Code shared from the Rust Playground

playground.rs

use std::sync::Arc;

use tokio::prelude::*;
use tokio::net::TcpStream;
use tokio::sync::mpsc;

struct Message {
    buf: Vec<u8>,
}

pub struct PubSubSocket {
    socket: TcpStream,
    tx_sender: mpsc::UnboundedSender<Message>,
    tx_receiver: mpsc::UnboundedReceiver<Message>,
}
impl PubSubSocket {
    // TODO: make channel bounded in size (needs to be configurable)
    pub fn new(socket: TcpStream) -> Arc<Self> {
        let (tx_sender, tx_receiver) = mpsc::unbounded_channel();
        let socket_ptr = Arc::new(PubSubSocket {
            socket,
            tx_sender,
            tx_receiver,
        });

        let cloned_ptr = socket_ptr.clone();

        tokio::spawn(tx_receiver
            .map_err(|e| eprintln!("error in pubsub send queue: {}", e))
            .for_each(move |m|
                tokio::io::write_all(&cloned_ptr.socket, m.buf)
                    .map(|_| ())
                    .map_err(|e| eprintln!("write error: {}", e))));

        socket_ptr
    }
}