fix: Actually remove legacy server module

1 files changed, 0 insertions, 319 deletions

diff --git a/src/server_dev/auto/server.rs b/src/server_dev/auto/server.rs
deleted file mode 100644
index 164b271..0000000
--- a/src/server_dev/auto/server.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-use std::{
-  collections::HashMap,
-  error::Error,
-  io::{ErrorKind, Read, Write},
-  ops::Deref,
-  str::from_utf8,
-};
-
-use bytes::BytesMut;
-use mio::{
-  event::Event,
-  net::{TcpListener, TcpStream},
-  Events,
-  Interest,
-  Poll,
-  Registry,
-  Token,
-};
-
-use crate::{
-  config::get_config,
-  server::{
-    auto::cmd::{
-      property::{create_property_request_command, create_property_update_command},
-      room::create_room_id_redirect_command,
-      session::parse_session_initialization_command,
-    },
-    cmd::{
-      action::create_action_command,
-      buddy_list::create_buddy_list_notify_command,
-      property::parse_property_set_command,
-      text::{create_text_command, create_text_command_with_action},
-    },
-    parser::get_commands_from_buffer,
-  },
-};
-
-const SERVER: Token = Token(0);
-
-pub struct AutoServer {
-  pub clients:     HashMap<Token, String>,
-  pub connections: HashMap<Token, TcpStream>,
-  pub room_ids:    Vec<String>,
-}
-impl AutoServer {
-  pub fn listen(&mut self, addr: &str) -> Result<(), Box<dyn Error>> {
-    let mut server = TcpListener::bind(addr.parse().unwrap())?;
-    let mut poll = Poll::new()?;
-    let mut events = Events::with_capacity(1024);
-    let mut unique_token = Token(SERVER.0 + 1);
-
-    poll
-      .registry()
-      .register(&mut server, SERVER, Interest::READABLE)?;
-
-    debug!(
-      "AutoServer now listening on {}",
-      server.local_addr().unwrap()
-    );
-
-    loop {
-      poll.poll(&mut events, None)?;
-
-      for event in &events {
-        match event.token() {
-          SERVER => {
-            loop {
-              let (mut stream, address) = match server.accept() {
-                Ok((stream, address)) => (stream, address),
-                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
-                Err(e) => return Err(Box::new(e)),
-              };
-
-              let token = AutoServer::next(&mut unique_token);
-              poll.registry().register(
-                &mut stream,
-                token,
-                Interest::READABLE, //.add(Interest::WRITABLE),
-              )?;
-
-              self.connections.insert(token, stream);
-
-              debug!(
-                "registered peer with address '{}' as '{}'",
-                address, token.0
-              );
-            }
-          }
-          token => {
-            let done = self.process(poll.registry(), event, token)?;
-            if done {
-              self.connections.remove(&token);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  fn next(current: &mut Token) -> Token {
-    let next = current.0;
-    current.0 += 1;
-    Token(next)
-  }
-
-  fn broadcast(mut self, cmd: &[u8]) -> () {
-    self
-      .connections
-      .iter_mut()
-      .for_each(|c| c.1.write_all(cmd).unwrap());
-  }
-
-  fn process(
-    &mut self,
-    _registry: &Registry,
-    event: &Event,
-    token: Token,
-  ) -> Result<bool, Box<dyn Error>> {
-    if event.is_readable() {
-      let mut connection_closed = false;
-      let mut received_data = vec![0; 4096];
-      let mut bytes_read = 0;
-
-      let stream = self.connections.get_mut(&token).unwrap();
-
-      loop {
-        match stream.read(&mut received_data[bytes_read..]) {
-          Ok(0) => {
-            connection_closed = true;
-            break;
-          }
-          Ok(n) => {
-            bytes_read += n;
-            if bytes_read == received_data.len() {
-              received_data.resize(received_data.len() + 1024, 0);
-            }
-          }
-          Err(ref err) if err.kind() == ErrorKind::WouldBlock => break,
-          Err(ref err) if err.kind() == ErrorKind::Interrupted => continue,
-          Err(err) => return Err(Box::new(err)),
-        }
-      }
-
-      if bytes_read != 0 {
-        self.handle(&mut received_data[..bytes_read], token);
-      }
-      if connection_closed {
-        println!("de-registered peer with token '{}'", token.0);
-        return Ok(true);
-      }
-    }
-
-    Ok(false)
-  }
-
-  fn handle(&mut self, data: &[u8], token: Token) -> () {
-    // trace!("i am client: {:?}", self.clients.get(&token));
-    // debug!("{:?}", self.connections);
-    for cmd in get_commands_from_buffer(BytesMut::from(data)) {
-      debug!("received: {:?}", cmd);
-      match cmd.get(2).unwrap() {
-        10 => {
-          // PROPREQ
-          debug!("received property request command from client 'null'");
-          self
-            .connections
-            .get_mut(&token)
-            .unwrap()
-            .write_all(&create_property_update_command())
-            .unwrap();
-          debug!("sent property update command to client 'null'");
-        }
-        6 => {
-          // SESSINIT
-          let local_username = parse_session_initialization_command(cmd).username;
-          self.clients.insert(token, local_username.clone());
-          debug!(
-            "received session initialization command from client '{}'",
-            local_username,
-          );
-          self
-            .connections
-            .get_mut(&token)
-            .unwrap()
-            .write_all(&create_property_request_command())
-            .unwrap();
-          debug!(
-            "sent session initialization command to client '{}'",
-            local_username
-          );
-        }
-        15 => {
-          // PROPSET
-          let avatar = parse_property_set_command(cmd);
-          debug!(
-            "received property set command from client '{}': {}",
-            self.clients.get(&token).unwrap(),
-            avatar,
-          );
-          self
-            .connections
-            .get_mut(&token)
-            .unwrap()
-            .write_all(&create_text_command(
-              "WORLDSMASTER",
-              &get_config().unwrap().worldsmaster_greeting,
-            ))
-            .unwrap();
-          self
-            .connections
-            .get_mut(&token)
-            .unwrap()
-            .write_all(&create_action_command())
-            .unwrap();
-          debug!(
-            "sent session initialization command to client '{}'",
-            self.clients.get(&token).unwrap(),
-          );
-        }
-        29 => {
-          // BUDDYLISTUPDATE
-          let received_buddy = from_utf8(
-            cmd
-              .get(4..cmd.get(0).unwrap().to_owned() as usize - 1)
-              .unwrap(),
-          )
-          .unwrap();
-          debug!(
-            "received buddy list update command from client '{}': {}",
-            self.clients.get(&token).unwrap(),
-            received_buddy,
-          );
-          let buddies = vec![
-            "dosfox",
-            "Fallen_Angel",
-            "Internet_Man",
-            "Nexialist",
-            "SirGemini",
-            "SirGrandpa",
-            "Wirlaburla",
-          ];
-          if buddies.contains(&received_buddy) {
-            self
-              .connections
-              .get_mut(&token)
-              .unwrap()
-              .write_all(&create_buddy_list_notify_command(received_buddy))
-              .unwrap();
-            debug!(
-              "sent buddy list notify command to client '{}'",
-              self.clients.get(&token).unwrap(),
-            );
-          }
-        }
-        20 => {
-          // ROOMIDRQ
-          let room_name =
-            from_utf8(cmd.get(4..cmd.get(0).unwrap().to_owned() as usize).unwrap()).unwrap();
-          debug!(
-            "received room id request command from client '{}': {}",
-            self.clients.get(&token).unwrap(),
-            room_name,
-          );
-          let room_id;
-          if !self.room_ids.contains(&room_name.to_string()) {
-            self.room_ids.push(room_name.to_string());
-            room_id = self
-              .room_ids
-              .iter()
-              .position(|i| i == &room_name.to_string())
-              .unwrap();
-            trace!("inserted room '{}' as '{}'", room_name, room_id);
-          } else {
-            let position = self
-              .room_ids
-              .iter()
-              .position(|i| i == &room_name.to_string())
-              .unwrap();
-            trace!("found room '{}' as '{}'", room_name, position);
-            room_id = position;
-          }
-          trace!("room name: {}, room id: {}", room_name, room_id);
-          trace!("{:?}", self.room_ids);
-          self
-            .connections
-            .get_mut(&token)
-            .unwrap()
-            .write_all(&create_room_id_redirect_command(room_name, room_id))
-            .unwrap();
-        }
-        14 => {
-          // TEXT
-          let text =
-            from_utf8(cmd.get(6..cmd.get(0).unwrap().to_owned() as usize).unwrap()).unwrap();
-          let username = self.clients.get(&token).unwrap().clone();
-          debug!(
-            "received text command from client '{}': {}",
-            username,
-            format!("auto {}", text),
-          );
-          self.connections.iter_mut().for_each(|t| {
-            t.1
-              .write_all(&create_text_command(&username, text))
-              .unwrap()
-          });
-          debug!("broadcasted text command to clients");
-        }
-        7 => {
-          // SESSEXIT
-          debug!(
-            "received session exit command from client '{}'",
-            self.clients.get(&token).unwrap(),
-          );
-        }
-        _ => (),
-      }
-    }
-  }
-}