pssh 0.2.2

data/assets/wssh.js

@@ -0,0 +1,134 @@
+/*
+WSSH Javascript Client
+
+Usage:
+
+var client = new WSSHClient();
+
+client.connect({
+    // Connection and authentication parameters
+    username: 'root',
+    hostname: 'localhost',
+    authentication_method: 'password', // can either be password or private_key
+    password: 'secretpassword', // do not provide when using private_key
+    key_passphrase: 'secretpassphrase', // *may* be provided if the private_key is encrypted
+
+    // Callbacks
+    onError: function(error) {
+        // Called upon an error
+        console.error(error);
+    },
+    onConnect: function() {
+        // Called after a successful connection to the server
+        console.debug('Connected!');
+
+        client.send('ls\n'); // You can send data back to the server by using WSSHClient.send()
+    },
+    onClose: function() {
+        // Called when the remote closes the connection
+        console.debug('Connection Reset By Peer');
+    },
+    onData: function(data) {
+        // Called when data is received from the server
+        console.debug('Received: ' + data);
+    }
+});
+
+*/
+
+function WSSHClient(uuid) {
+  this.uuid=uuid;
+};
+
+WSSHClient.prototype._generateEndpoint = function(options) {
+    if (window.location.protocol == 'https:') {
+        var protocol = 'wss://';
+    } else {
+        var protocol = 'ws://';
+    }
+    var endpoint = protocol + window.location.host +
+        '/socket?uuid=' + this.uuid; ///' + encodeURIComponent(options.hostname) + '/' +
+        //encodeURIComponent(options.username);
+    /*if (options.authentication_method == 'password') {
+        endpoint += '?password=' + encodeURIComponent(options.password);
+    } else if (options.authentication_method == 'private_key') {
+        endpoint += '?private_key=' + encodeURIComponent(options.private_key);
+        if (options.key_passphrase !== undefined)
+            endpoint += '&key_passphrase=' + encodeURIComponent(
+                options.key_passphrase);
+    }*/
+    return endpoint;
+};
+
+WSSHClient.prototype.startSocket = function() {
+
+    var ping;
+    var _self = this;
+    var connected = true;
+
+    if (window.WebSocket) {
+        this._connection = new WebSocket(this.endpoint);
+    }
+    else if (window.MozWebSocket) {
+        this._connection = MozWebSocket(this.endpoint);
+    }
+    else {
+        this.options.onError('WebSocket Not Supported');
+        return ;
+    }
+
+    this._connection.onopen = function() {
+        console.log("connected");
+        ping = window.setInterval(function() {
+          _self._connection.send('p');
+        }, 10000);
+        _self.options.onConnect();
+    };
+
+    this._connection.onmessage = function (evt) {
+        console.log(evt.data);
+        var data = JSON.parse(evt.data.toString());
+        if (data.error !== undefined) {
+            _self.options.onError(data.error);
+        } else if (data.close !== undefined) {
+          connected = false;
+        } else {
+            _self.options.onData(data.data);
+        }
+    };
+
+    this._connection.onclose = function(evt) {
+      if (connected) {
+        window.clearInterval(ping);
+        _self.reconnect();
+      } else {
+        _self.options.onClose();
+      }
+    };
+
+};
+
+WSSHClient.prototype.connect = function(options) {
+
+    this.endpoint = this._generateEndpoint(options);
+    this.options = options;
+
+    this.startSocket();
+
+};
+
+WSSHClient.prototype.send = function(data) {
+    this._connection.send('d' + data);
+};
+
+WSSHClient.prototype.start = function(width, height) {
+    this._connection.send('s' + width + ',' + height);
+};
+
+WSSHClient.prototype.resize = function(width, height) {
+    this._connection.send('r' + width + ',' + height);
+};
+
+WSSHClient.prototype.reconnect = function() {
+    this.startSocket();
+};

data/bin/pssh

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'pssh'
+
+Pssh::CLI.run(ARGV)
+

data/lib/pssh.rb

@@ -0,0 +1,114 @@
+require 'haml'
+require 'io/console'
+require 'json'
+require 'optparse'
+require 'pty'
+require 'readline'
+require 'tilt/haml'
+require 'thin'
+require 'rack/websocket'
+
+require 'pssh/cli'
+require 'pssh/client'
+require 'pssh/console'
+require 'pssh/socket'
+require 'pssh/version'
+require 'pssh/web_console'
+
+module Pssh
+
+  DEFAULT_IO_MODE = 'rw'
+  DEFAULT_SOCKET_PREFIX = '/tmp/pssh'
+  DEFAULT_PORT = 8022
+
+  class << self
+
+    attr_writer :io_mode
+    attr_writer :socket_prefix
+    attr_writer :command
+    attr_writer :open_sessions
+    attr_writer :port
+    attr_writer :prompt
+    attr_accessor :client
+    attr_accessor :socket
+    attr_accessor :pty
+    attr_accessor :web
+
+    def base_path
+      File.dirname(__FILE__) + "/.."
+    end
+
+    def port
+      @port ||= DEFAULT_PORT
+    end
+
+    def open_sessions
+      @open_sessions ||= {}
+    end
+
+    # Public: This sets whether the connecting user can just view or can
+    # also write to the screen. Values are 'rw, 'r', and 'w'.
+    #
+    # Returns a String.
+    def io_mode
+      @io_mode ||= DEFAULT_IO_MODE
+    end
+
+    # Public: This is the prefix that will be used to set up the socket for tmux or screen.
+    #
+    # Returns a String.
+    def socket_prefix
+      @socket_prefix ||= DEFAULT_SOCKET_PREFIX
+    end
+
+    # Public: This is the default socket path that will be used if one is not
+    # provided in the command line arguments.
+    #
+    # Returns a String.
+    def default_socket_path
+      @socket ||= "#{socket_prefix}-#{SecureRandom.uuid}"
+    end
+
+    # Public: This is the tool which we are going to use for our multiplexing. If
+    # we're currently in a tmux or screen session, that is the first option,
+    # then it checks if tmux or screen is installed, and then it resorts to
+    # a plain old shell.
+    #
+    # Returns a Symbol.
+    def command
+      @command ||=
+        (ENV['TMUX'] && :tmux) ||
+        (ENV['STY'] && :screen) ||
+        (`which tmux` && :tmux) ||
+        (`which screen` && :screen) ||
+        :shell
+    end
+
+    # Public: Allow configuring details of Pssh by making use of a block.
+    #
+    # Returns True.
+    def configure
+      yield self
+      true
+    end
+
+    # Public: This is the prompt character that shows up at the beginning of
+    # Pssh's console.
+    #
+    # Returns a String.
+    def prompt
+      @prompt ||= "\u26a1 "
+    end
+
+    # Public: Generates a random id for a session and stores it to a list.
+    #
+    # Returns a String.
+    def create_session(username=nil)
+      id = SecureRandom.uuid
+      self.open_sessions[id] = username
+      id
+    end
+
+  end
+
+end

data/lib/pssh/cli.rb

@@ -0,0 +1,60 @@
+module Pssh
+  class CLI
+
+    BANNER = <<-BANNER
+    Usage: pssh [options]
+
+    Description:
+
+      Remote pair programming made easy by allowing access via a web
+      browser.  Supports HTTP Basic Auth to handle users, and can be
+      combined with tmux, screen, or just a plain shell.
+
+    BANNER
+
+    def self.parse_options(args)
+      options = {}
+
+      @opts = OptionParser.new do |opts|
+        opts.banner = BANNER.gsub(/^ {4}/, '')
+
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on('-p PORT', '--port PORT', Integer, 'Set the port that Pssh will run on') do |port|
+          options[:port] = port.to_i
+        end
+
+        opts.on('-c PATH', '--command COMMAND', [:tmux, :screen, :shell], 'Set the tool that will be used to initialize the web session (tmux, screen, or shell)') do |command|
+          options[:command] = command
+        end
+
+        opts.on('-s PATH', '--socket PATH', String, 'Set the socket that will be used for connecting (/path/to/socket)') do |socket|
+          options[:socket] = socket
+        end
+
+        opts.on( '-h', '--help', 'Display this help.' ) do
+          puts opts
+          exit
+        end
+
+      end
+
+      @opts.parse!(args)
+
+      options
+    end
+
+    def self.run(args)
+      opts = parse_options(args)
+      Pssh.configure do |pssh|
+        opts.each do |k,v|
+          pssh.send :"#{k}=", v
+        end
+      end
+      Pssh::Client.start
+    end
+
+  end
+end
+

data/lib/pssh/client.rb

@@ -0,0 +1,30 @@
+module Pssh
+  class Client
+
+    def initialize
+      @pty = Pssh.pty = Pssh::Socket.new
+      @web = Pssh.web = Pssh::WebConsole.new
+      @app = Rack::Builder.new do
+        map "/assets/" do
+          run Rack::File.new "#{Pssh.base_path}/assets/"
+        end
+        map "/socket" do
+          run Pssh.pty
+        end
+        map "/" do
+          run Pssh.web
+        end
+      end
+      Thread.new do
+        @console = Console.new(pty: @pty, web: @web)
+      end
+      Thin::Logging.silent = true
+      Rack::Handler::Thin.run @app, Port: Pssh.port
+    end
+
+    def self.start
+      Pssh.client = @client = Client.new
+    end
+
+  end
+end

data/lib/pssh/console.rb

@@ -0,0 +1,81 @@
+module Pssh
+  class Console
+
+    COMMANDS = %w(list block unblock sessions kill-session exit).sort
+    BANNER = <<-BANNER
+      ------------------------------------------------------------------
+      help\t\tDisplays this help menu.
+      info\t\tDisplays current tmux settings and configuration.
+      list[ sessions]\tShow the currently open sessions.
+      kill-session[s]\tKill either all sessions or a specific by id.
+        --all\t\tKills all the open sessions.
+        'session id'\tKills only the session specified by the id.
+      exit\t\tCloses all active sessions and exits.
+      ------------------------------------------------------------------
+      Tip: Use tab-completion for commands and session ids.
+    BANNER
+
+    def initialize(opts = {})
+
+      @pty = opts[:pty]
+      @web = opts[:web]
+
+      begin
+        puts "[ pssh terminal ]"
+        puts "Service started on port #{Pssh.port}."
+        puts "Type 'help' for more information."
+
+        Readline.completion_append_character = " "
+        Readline.completion_proc = completion_proc
+
+        while command = Readline.readline(Pssh.prompt, true)
+          command.strip!
+          command.gsub!(/\s+/, ' ')
+          case command
+          when 'help'
+            puts BANNER.gsub(/^ {6}/,'')
+          when 'exit'
+            @pty.kill_all_sessions
+            Kernel.exit!
+          when 'info'
+            puts 'Current Configuration:'
+            if @pty.path
+              puts "Socket: #{@pty.path}"
+              puts "(Attach to this socket with `#{@pty.attach_cmd}`)"
+            else
+              puts 'Connections are made to a vanilla shell.'
+            end
+          when 'list sessions', 'list'
+            @pty.sessions.each do |k,v|
+              puts v[:user_string]
+            end
+          when /^kill-sessions?\s?(.*)$/
+            if $1 == '--all'
+              puts 'disconnecting all clients'
+              @pty.kill_all_sessions
+            else
+              puts "disconnecting #{$1}"
+              if @pty.sessions.keys.include?($1)
+                @pty.sessions[$1][:socket].close!
+              else
+                @pty.sessions.each do |k, sess|
+                  if sess[:username] == $1
+                    sess[:socket].close!
+                  end
+                end
+              end
+            end
+          end
+        end
+      rescue Exception => e
+        puts e.inspect
+        puts e.backtrace
+        retry
+      end
+    end
+
+    def completion_proc
+      @completion_proc ||= proc { |s| (COMMANDS + Pssh.open_sessions.keys + Pssh.open_sessions.values.uniq).grep( /^#{Regexp.escape(s)}/ ) }
+    end
+  end
+end

data/lib/pssh/socket.rb

@@ -0,0 +1,187 @@
+module Pssh
+  class Socket < Rack::WebSocket::Application
+
+    attr_accessor :sessions
+    attr_accessor :path
+    attr_accessor :attach_cmd
+
+    def initialize(opts={})
+      super
+
+      # set up empty variables
+      @sessions = {}
+      @killed_sessions = []
+      @existing_socket = false
+
+      self.send Pssh.command.to_sym
+    end
+
+    def tmux
+      if ENV['TMUX']
+        @path = ENV['TMUX'].split(',').first
+        @existing_socket = true
+        @command = "tmux -S #{@path} attach"
+      else
+        @path = Pssh.default_socket_path
+        @command = "tmux -S #{@path} new"
+      end
+      @attach_cmd = "tmux -S #{@path} attach"
+    end
+
+    def screen
+      if ENV['STY']
+        @path = ENV['STY']
+        @existing_socket = true
+        @command = "screen -S #{@path} -X multiuser on && screen -x #{@path}"
+      else
+        @path = Pssh.default_socket_path
+        @command = "screen -m -S #{@path}"
+      end
+      @attach_cmd = "screen -x #{@path}"
+    end
+
+    def shell
+      @path = nil
+      @command = 'sh'
+    end
+
+    def params(env)
+      Hash[env['QUERY_STRING'].split('&').map { |e| e.split '=' }]
+    end
+
+    def on_open(env)
+      uuid = @uuid = params(env)['uuid']
+      if @killed_sessions.include? uuid
+        # this session has been killed from the console and shouldn't be
+        # restarted
+        close_websocket and return
+      end
+      if @sessions[uuid]
+        @sessions[uuid][:active] = true
+      elsif Pssh.open_sessions.keys.include?(uuid)
+        user_string = Pssh.open_sessions[uuid] ? "#{Pssh.open_sessions[uuid]} (#{uuid})" : uuid
+        print "\n#{user_string} attached.\n#{Pssh.prompt}"
+        @sessions[uuid] = {
+          data: [],
+          username: Pssh.open_sessions[uuid],
+          user_string: user_string,
+          active: true,
+          started: false
+        }
+        Pssh.open_sessions.delete uuid
+      else
+        @sessions[uuid] = {socket: self}
+        self.close! and return
+      end
+      @sessions[uuid][:socket] = self
+    end
+
+    def on_close(env)
+      uuid = params(env)['uuid']
+      @sessions[uuid][:active] = false
+      Thread.new do
+        sleep 10
+        if @sessions[uuid][:active] == false
+          @sessions[uuid][:read].close
+          @sessions[uuid][:write].close
+          @sessions.delete uuid
+          print "\n#{user_string} detached.\n#{Pssh.prompt}"
+        end
+      end
+    end
+
+    def close_websocket
+      @sessions[@uuid][:socket].send_data({ close: true }.to_json) if @sessions[@uuid][:socket]
+      @sessions[@uuid][:read].close if @sessions[@uuid][:read]
+      @sessions[@uuid][:write].close if @sessions[@uuid][:write]
+      @sessions[@uuid][:thread].exit if @sessions[@uuid][:thread]
+      @sessions.delete @uuid
+      super
+    end
+
+    def kill_all_sessions
+      @sessions.each do |k,v|
+        v[:socket].close!
+      end
+    end
+
+    def close!
+      self.close_websocket
+      @killed_sessions << @uuid
+    end
+
+    # Internal: Sends a message to the tmux or screen display notifying of a
+    # new user that has connected.
+    #
+    # Returns nothing.
+    def send_display_message(uuid)
+      if @existing_socket
+        case Pssh.command.to_sym
+        when :tmux
+          `tmux -S #{@path} display-message "#{@sessions[uuid][:user_string]} has connected"`
+        when :screen
+          `screen -S #{@path} -X wall "#{@sessions[uuid][:user_string]} has connected"`
+        end
+      end
+    end
+
+    def clear_environment
+      ENV['TMUX'] = nil
+      ENV['STY'] = nil
+    end
+
+    def on_message(env, message)
+      uuid = params(env)['uuid']
+      return unless @sessions[uuid]
+      case message[0]
+      when 's'
+        unless @sessions[uuid][:started]
+          @sessions[uuid][:started] = true
+          @sessions[uuid][:thread] = Thread.new do
+            begin
+              if @sessions[uuid]
+                size = message[1..-1].split ','
+                send_display_message(uuid)
+                clear_environment
+                @sessions[uuid][:read], @sessions[uuid][:write], @sessions[uuid][:pid] = PTY.spawn(@command)
+                @sessions[uuid][:write].winsize = [size[1].to_i, size[0].to_i]
+
+                while(@sessions[uuid] && @sessions[uuid][:active]) do
+                  IO.select([@sessions[uuid][:read]])
+                  begin
+                    while (data = @sessions[uuid][:read].readpartial(2048)) do
+                      data.encode!('UTF-16', 'UTF-8', :invalid => :replace, :replace => '')
+                      data.encode!('UTF-8', 'UTF-16')
+                      if data.valid_encoding?
+                        @sessions[uuid][:socket].send_data({ data: data }.to_json)
+                      end
+                    end
+                  rescue Exception => e
+                    if @sessions[uuid]
+                      if e.is_a?(Errno::EAGAIN)
+                        retry
+                      else
+                        @sessions[uuid][:active] = false
+                      end
+                    end
+                  end
+                end
+              end
+
+            rescue Exception => e
+              puts e.inspect
+              puts e.backtrace
+              puts '---'
+              retry
+            end
+          end
+        end
+      when 'd'
+        @sessions[uuid][:write].write_nonblock message[1..-1] if Pssh.io_mode['w']
+      when 'r'
+        size = message[1..-1].split ','
+        @sessions[uuid][:write].winsize= [size[1].to_i, size[0].to_i]
+      end
+    end
+  end
+end