Rewrite with rust and create a cargo package

.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false

.gitignore

@@ -1,2 +1,5 @@
 Gemfile.lock
+Cargo.lock
+target
 pkg/*
+**/*.o

.travis.yml

@@ -0,0 +1,5 @@
+language: rust
+rust:
+  - stable
+  - beta
+  - nightly

Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = 'hokaido'
+version = '0.0.10'
+authors = ['Hika Hibariya <[email protected]>']
+repository = 'https://github.com/idobata/hokaido'
+homepage = 'https://github.com/idobata/hokaido'
+license='MIT'
+description='Terminal sharing tool.'
+keywords = ['terminal', 'tool']
+
+[dependencies]
+docopt='0.6'
+env_logger = '0.3'
+libc='0.2.6'
+log = '0.3'
+nix='0.5.0'
+pty='0.1.6'
+pty-shell='0.1.3'
+rmp-serialize = '0.8'
+rustc-serialize='0.3'
+termios='0.2.0'
+clippy = {version = '0.0', optional = true}
+
+[features]
+default = []
+dev = ['clippy']

README.md

@@ -1,18 +1,34 @@
 # Hokaido
 
-## 1. Start server (Anywhere in internet)
+Hokaido is a character based terminal sharing tool. It's speedy and clear.
+
+## Installation
+
+``` sh
+$ cargo install hokaido
+```
+
+## How to use
+
+### 1. Start server
+
+Server is needed to relay communication between broadcaster and watchers.
 
 ``` sh
 $ hokaido server # on 203.0.113.10:4423
 ```
 
-## 2. Watch (Tokyo)
+### 2. Watch
+
+`watch` displays broadcaster's shell output.
 
 ``` sh
 $ hokaido watch --host 203.0.113.10
 ```
 
-## 3. Broadcast (Hokaido!)
+### 3. Broadcast
+
+`broadcast` invokes a new $SHELL and starts broadcasting its output.
 
 ``` sh
 $ hokaido broadcast --host 203.0.113.10

src/broadcast.rs

@@ -0,0 +1,158 @@
+use std::{env, error, fmt, io, process, result, thread};
+use std::net::TcpStream;
+use std::sync::mpsc::{channel, Sender};
+
+use pty;
+use pty_shell::{self, winsize, PtyShell};
+use libc;
+
+use message;
+
+#[derive(Debug)]
+pub enum Error {
+    Message(message::Error),
+    Pty(pty::Error),
+    PtyShell(pty_shell::Error),
+    Io(io::Error),
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Broadcast error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        match *self {
+            Error::Message(ref err) => Some(err),
+            Error::Pty(ref err) => Some(err),
+            Error::PtyShell(ref err) => Some(err),
+            Error::Io(ref err) => Some(err),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        error::Error::description(self).fmt(f)
+    }
+}
+
+impl From<message::Error> for Error {
+    fn from(err: message::Error) -> Error {
+        Error::Message(err)
+    }
+}
+
+impl From<pty::Error> for Error {
+    fn from(err: pty::Error) -> Error {
+        Error::Pty(err)
+    }
+}
+
+impl From<pty_shell::Error> for Error {
+    fn from(err: pty_shell::Error) -> Error {
+        Error::PtyShell(err)
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        Error::Io(err)
+    }
+}
+
+pub type Result<T> = result::Result<T, Error>;
+
+struct NotificationHandler {
+    stream: TcpStream,
+    sender: Sender<Option<message::Notification>>,
+}
+
+struct ShellHandler {
+    channel: Sender<Option<message::Notification>>,
+}
+
+impl pty_shell::PtyHandler for ShellHandler {
+    fn output(&mut self, data: &[u8]) {
+        let string = String::from_utf8_lossy(&data[..]).into_owned();
+        let _ = self.channel.send(Some(message::Notification::Output(string)));
+    }
+
+    fn resize(&mut self, size: &winsize::Winsize) {
+        let _ = self.channel.send(Some(build_winsize_notification(size)));
+    }
+
+    fn shutdown(&mut self) {
+        let _ = self.channel.send(None);
+    }
+}
+
+pub fn execute(host: String, port: i32, channel_name: String) -> Result<()> {
+    let mut stream = try!(TcpStream::connect(&format!("{}:{}", host, port)[..]));
+    let (sender, receiver) = channel();
+
+    try!(message::JoinRequest::Broadcast(channel_name.clone()).send(&mut stream));
+    try!(message::JoinResponse::receive(&stream));
+
+    NotificationHandler::spawn(&stream, &sender);
+
+    let child = try!(pty::fork());
+    try!(child.exec(env::var("SHELL").unwrap_or("bash".to_owned())));
+    try!(child.proxy(ShellHandler { channel: sender.clone() }));
+
+    let winsize = try!(winsize::from_fd(libc::STDIN_FILENO));
+    let _ = sender.send(Some(build_winsize_notification(&winsize)));
+
+    for message in receiver {
+        match message {
+            Some(notification) => try!(notification.send(&mut stream)),
+            None => break,
+        }
+    }
+
+    try!(child.wait());
+
+    Ok(())
+}
+
+impl NotificationHandler {
+    fn spawn(stream: &TcpStream, sender: &Sender<Option<message::Notification>>) {
+        let mut handler = NotificationHandler {
+            stream: stream.try_clone().unwrap(),
+            sender: sender.clone(),
+        };
+
+        thread::spawn(move || {
+            handler.process().unwrap_or_else(|e| {
+                println!("{:?}", e);
+                process::exit(1);
+            });
+        });
+    }
+
+    fn process(&mut self) -> Result<()> {
+        loop {
+            let notification = try!(message::Notification::receive(&self.stream));
+
+            match notification {
+                message::Notification::Closed(reason) => {
+                    println!("Broadcast has stopped: {}", reason);
+                    break;
+                }
+                message::Notification::WatcherJoined(_) => {
+                    let winsize = try!(winsize::from_fd(libc::STDIN_FILENO));
+                    let _ = self.sender.send(Some(build_winsize_notification(&winsize)));
+                }
+                _ => (),
+            }
+        }
+
+        let _ = self.sender.send(None);
+
+        Ok(())
+    }
+}
+
+fn build_winsize_notification(size: &winsize::Winsize) -> message::Notification {
+    message::Notification::Output(format!("\x1b[8;{};{}t", size.ws_row, size.ws_col))
+}

src/main.rs

@@ -0,0 +1,74 @@
+#![deny(missing_debug_implementations, missing_copy_implementations,
+        trivial_casts, trivial_numeric_casts,
+        unstable_features,
+        unused_import_braces, unused_qualifications)]
+#![cfg_attr(feature = "dev", allow(unstable_features))]
+#![cfg_attr(feature = "dev", feature(plugin))]
+#![cfg_attr(feature = "dev", plugin(clippy))]
+
+extern crate docopt;
+extern crate libc;
+extern crate nix;
+extern crate pty;
+extern crate pty_shell;
+extern crate rmp_serialize as msgpack;
+extern crate rustc_serialize;
+extern crate termios;
+
+#[macro_use]
+extern crate log;
+extern crate env_logger;
+
+mod message;
+mod broadcast;
+mod server;
+mod watch;
+
+use docopt::Docopt;
+
+static USAGE: &'static str = "
+Usage:
+  hokaido <command> [--host=<host>] [--port=<port>] [--channel=<channel>]
+  hokaido (-h | --help)
+  hokaido (-v | --version)
+
+Options:
+  -h --help            Show this screen.
+  -v --version         Show the version of hokaido.
+  --host=<host>        Server name  [default: 0.0.0.0].
+  --port=<port>        Server port  [default: 4423].
+  --channel=<channel>  Channel Name [default: default].
+";
+
+#[derive(RustcDecodable, Debug)]
+struct Args {
+    arg_command: Option<String>,
+    flag_host: String,
+    flag_port: i32,
+    flag_channel: String,
+    flag_version: bool,
+}
+
+fn main() {
+    let args: Args = Docopt::new(USAGE).and_then(|d| d.decode()).unwrap_or_else(|e| e.exit());
+
+    env_logger::init().unwrap();
+
+    match args.arg_command {
+        Some(command_name) => {
+            match command_name.as_ref() {
+                "broadcast" => broadcast::execute(args.flag_host, args.flag_port, args.flag_channel).unwrap_or_else(|e| panic!(e)),
+                "server" => server::execute(args.flag_host, args.flag_port).unwrap_or_else(|e| panic!(e)),
+                "watch" => watch::execute(args.flag_host, args.flag_port, args.flag_channel).unwrap_or_else(|e| panic!(e)),
+                _ => unreachable!(),
+            }
+        }
+        _ => {
+            if args.flag_version {
+                println!("{}", env!("CARGO_PKG_VERSION"));
+            } else {
+                unreachable!();
+            }
+        }
+    }
+}