base2020/src/net/server.rs

use super::*;
use anyhow::{Context, Error, Result};
use futures::{channel::mpsc::*, future::try_join, lock::Mutex, prelude::*};
use serde_json::json;
use std::sync::Arc;
use stream::iter;

pub async fn greet<T>(sink: &mut T) -> Result<()>
where
    T: Sink<ServerMessage, Error = Error> + Unpin,
{
    let mut greeting = iter(vec![
        ServerMessage::Meta {
            m: Meta {
                version: "Unstable",
                helo: Some("Dedicated base2020 server".into()),
            },
        },
        ServerMessage::SetState { u: Some(0), s: json!({}) },
    ])
    .map(Ok);

    sink.send_all(&mut greeting)
        .await
        .context("Greeting client")
}

pub struct Server {
}

#[derive(Clone)]
pub struct Handle {
    server: Arc<Mutex<Server>>,
}

impl Server {
    pub fn create() -> Handle {
        Handle {
            server: Arc::new(Mutex::new(Server {
            })),
        }
    }

    pub fn process_message(&mut self, player: usize, msg: ClientMessage) {
        debug!("Client#{} message: {:?}", player, &msg);
    }
}
where
{

pub async fn run_client(
    handle: Handle,
    source: &mut (impl Stream<Item = Result<ClientMessage, Error>> + Send + Unpin),
    mut sink: &mut (impl Sink<ServerMessage, Error = Error> + Send + Unpin),
) -> Result<()> {
    let output_task = async {
        greet(&mut sink).await?;
        Ok::<(), Error>(())
    };

    let input_task = async {
        loop {
            match source.next().await {
                Some(Ok(msg)) => handle.server.lock().await.process_message(0, msg),
                Some(Err(error)) => return Err(error),
                None => break Ok(()),
            }
        }
    };
    try_join(output_task, input_task).await.map(|((), ())| ())
}