rvt 0.9.9

data/app/views/rvt/console_sessions/index.html.erb

@@ -0,0 +1,17 @@
+<script>
+  var config = {
+    terminal: {
+      colors: <%= raw RVT.config.style.colors.to_json %>
+    },
+
+    transport: {
+      url: {
+        input: "<%= rvt.input_console_session_path(@console_session) %>",
+        pendingOutput: "<%= rvt.pending_output_console_session_path(@console_session) %>",
+        configuration: "<%= rvt.configuration_console_session_path(@console_session) %>"
+      },
+
+      uid: "<%= @console_session.uid %>"
+    }
+  };
+</script>

data/config/routes.rb

@@ -0,0 +1,11 @@
+RVT::Engine.routes.draw do
+  root to: 'console_sessions#index'
+
+  resources :console_sessions do
+    member do
+      put :input
+      get :pending_output
+      put :configuration
+    end
+  end
+end

data/lib/assets/javascripts/rvt.js

@@ -0,0 +1,41 @@
+//= require term
+
+;(function(BaseTerminal) {
+
+  // Expose the main RVT namespace.
+  var RVT = this.RVT = {};
+
+  // Follow term.js example and expose inherits and EventEmitter.
+  var inherits = RVT.inherits = BaseTerminal.inherits;
+  var EventEmitter = RVT.EventEmitter = BaseTerminal.EventEmitter;
+
+  var Terminal = RVT.Terminal = function(options) {
+    if (typeof options === 'number') {
+      return BaseTerminal.apply(this, arguments);
+    }
+
+    BaseTerminal.call(this, options || (options = {}));
+
+    this.open();
+
+    if (!(options.rows || options.cols) || !options.geometry) {
+      this.fitScreen();
+    }
+  };
+
+  // Make RVT.Terminal inherit from BaseTerminal (term.js).
+  inherits(Terminal, BaseTerminal);
+
+  Terminal.prototype.fitScreen = function() {
+    var width  = Math.floor(this.element.clientWidth / this.cols);
+    var height = Math.floor(this.element.clientHeight / this.rows);
+
+    var rows = Math.floor(window.innerHeight / height);
+    var cols = Math.floor(this.parent.clientWidth / width);
+
+    this.resize(cols, rows);
+
+    return [cols, rows];
+  };
+
+}).call(this, Terminal);

data/lib/rvt.rb

@@ -0,0 +1,21 @@
+require 'active_support/lazy_load_hooks'
+require 'active_support/inflector'
+
+require 'rvt/colors'
+require 'rvt/engine'
+require 'rvt/slave'
+
+module RVT
+  # Shortcut for +RVT::Engine.config.rvt+.
+  def self.config
+    Engine.config.rvt
+  end
+
+  ActiveSupport.run_load_hooks(:rvt, self)
+end
+
+# Inflect the name as an acronym to help Rails auto loading find constants
+# under +RVT::+ instead of +Rvt::+.
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym 'RVT'
+end

data/lib/rvt/colors.rb

@@ -0,0 +1,87 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module RVT
+  # = Colors
+  #
+  # Manages the creation and serialization of terminal color themes.
+  #
+  # Colors is a subclass of +Array+ and it stores a collection of CSS color
+  # values, to be used from the client-side terminal.
+  #
+  # You can specify 8 or 16 colors and additional +background+ and +foreground+
+  # colors. If not explicitly specified, +background+ and +foreground+ are
+  # considered to be the first and the last of the given colors.
+  class Colors < Array
+    class << self
+      # Registry of color themes mapped to a name.
+      #
+      # Don't manually alter the registry. Use RVT::Colors.register_theme
+      # for adding entries.
+      def themes
+        @@themes ||= {}.with_indifferent_access
+      end
+
+      # Register a color theme into the color themes registry.
+      #
+      # Registration maps a name and Colors instance.
+      #
+      # If a block is given, it would be yielded with a new Colors instance to
+      # populate the theme colors in.
+      #
+      # If a Colors instance is already instantiated it can be passed directly
+      # as the second (_colors_) argument. In this case, if a block is given,
+      # it won't be executed.
+      def register_theme(name, colors = nil)
+        themes[name] = colors || new.tap { |c| yield c }
+      end
+
+      # The default colors theme.
+      def default
+        self[:light]
+      end
+
+      # Shortcut for RVT::Colors.themes#[].
+      def [](name)
+        themes[name]
+      end
+    end
+
+    alias :add :<<
+
+    # Background color getter and setter.
+    #
+    # If called without arguments it acts like a getter. Otherwise it acts like
+    # a setter.
+    #
+    # The default background color will be the first entry in the colors theme.
+    def background(value = nil)
+      @background   = value unless value.nil?
+      @background ||= self.first
+    end
+
+    alias :background= :background
+
+    # Foreground color getter and setter.
+    #
+    # If called without arguments it acts like a getter. Otherwise it acts like
+    # a setter.
+    #
+    # The default foreground color will be the last entry in the colors theme.
+    def foreground(value = nil)
+      @foreground   = value unless value.nil?
+      @foreground ||= self.last
+    end
+
+    alias :foreground= :foreground
+
+    def as_json(*)
+      (dup << background << foreground).to_a
+    end
+  end
+end
+
+require 'rvt/colors/light'
+require 'rvt/colors/monokai'
+require 'rvt/colors/solarized'
+require 'rvt/colors/tango'
+require 'rvt/colors/xterm'

data/lib/rvt/colors/light.rb

@@ -0,0 +1,24 @@
+module RVT
+  Colors.register_theme(:light) do |c|
+    c.add '#000000'
+    c.add '#cd0000'
+    c.add '#00cd00'
+    c.add '#cdcd00'
+    c.add '#0000ee'
+    c.add '#cd00cd'
+    c.add '#00cdcd'
+    c.add '#e5e5e5'
+
+    c.add '#7f7f7f'
+    c.add '#ff0000'
+    c.add '#00ff00'
+    c.add '#ffff00'
+    c.add '#5c5cff'
+    c.add '#ff00ff'
+    c.add '#00ffff'
+    c.add '#ffffff'
+
+    c.background '#ffffff'
+    c.foreground '#000000'
+  end
+end

data/lib/rvt/colors/monokai.rb

@@ -0,0 +1,24 @@
+module RVT
+  Colors.register_theme(:monokai) do |c|
+    c.add '#1c1d19'
+    c.add '#d01b24'
+    c.add '#a7d32C'
+    c.add '#d8cf67'
+    c.add '#61b8d0'
+    c.add '#695abb'
+    c.add '#d53864'
+    c.add '#fefffe'
+
+    c.add '#1c1d19'
+    c.add '#d12a24'
+    c.add '#a7d32c'
+    c.add '#d8cf67'
+    c.add '#61b8d0'
+    c.add '#695abb'
+    c.add '#d53864'
+    c.add '#fefffe'
+
+    c.background '#1c1d19'
+    c.foreground '#fefffe'
+  end
+end

data/lib/rvt/colors/solarized.rb

@@ -0,0 +1,47 @@
+module RVT
+  Colors.register_theme(:solarized_dark) do |c|
+    c.add '#073642'
+    c.add '#dc322f'
+    c.add '#859900'
+    c.add '#b58900'
+    c.add '#268bd2'
+    c.add '#d33682'
+    c.add '#2aa198'
+    c.add '#eee8d5'
+
+    c.add '#002b36'
+    c.add '#cb4b16'
+    c.add '#586e75'
+    c.add '#657b83'
+    c.add '#839496'
+    c.add '#6c71c4'
+    c.add '#93a1a1'
+    c.add '#fdf6e3'
+
+    c.background '#002b36'
+    c.foreground '#657b83'
+  end
+
+  Colors.register_theme(:solarized_light) do |c|
+    c.add '#073642'
+    c.add '#dc322f'
+    c.add '#859900'
+    c.add '#b58900'
+    c.add '#268bd2'
+    c.add '#d33682'
+    c.add '#2aa198'
+    c.add '#eee8d5'
+
+    c.add '#002b36'
+    c.add '#cb4b16'
+    c.add '#586e75'
+    c.add '#657b83'
+    c.add '#839496'
+    c.add '#6c71c4'
+    c.add '#93a1a1'
+    c.add '#fdf6e3'
+
+    c.background '#fdf6e3'
+    c.foreground '#657b83'
+  end
+end

data/lib/rvt/colors/tango.rb

@@ -0,0 +1,24 @@
+module RVT
+  Colors.register_theme(:tango) do |c|
+    c.add '#2e3436'
+    c.add '#cc0000'
+    c.add '#4e9a06'
+    c.add '#c4a000'
+    c.add '#3465a4'
+    c.add '#75507b'
+    c.add '#06989a'
+    c.add '#d3d7cf'
+
+    c.add '#555753'
+    c.add '#ef2929'
+    c.add '#8ae234'
+    c.add '#fce94f'
+    c.add '#729fcf'
+    c.add '#ad7fa8'
+    c.add '#34e2e2'
+    c.add '#eeeeec'
+
+    c.background '#2e3436'
+    c.foreground '#eeeeec'
+  end
+end

data/lib/rvt/colors/xterm.rb

@@ -0,0 +1,24 @@
+module RVT
+  Colors.register_theme(:xterm) do |c|
+    c.add '#000000'
+    c.add '#cd0000'
+    c.add '#00cd00'
+    c.add '#cdcd00'
+    c.add '#0000ee'
+    c.add '#cd00cd'
+    c.add '#00cdcd'
+    c.add '#e5e5e5'
+
+    c.add '#7f7f7f'
+    c.add '#ff0000'
+    c.add '#00ff00'
+    c.add '#ffff00'
+    c.add '#5c5cff'
+    c.add '#ff00ff'
+    c.add '#00ffff'
+    c.add '#ffffff'
+
+    c.background '#000000'
+    c.foreground '#ffffff'
+  end
+end

data/lib/rvt/engine.rb

@@ -0,0 +1,85 @@
+require 'ipaddr'
+require 'active_support/core_ext/numeric/time'
+require 'rails/engine'
+
+require 'active_model'
+require 'sprockets/rails'
+
+module RVT
+  class Engine < ::Rails::Engine
+    isolate_namespace RVT
+
+    config.rvt = ActiveSupport::OrderedOptions.new.tap do |c|
+      c.automount          = true
+      c.command            = nil
+      c.default_mount_path = '/console'
+      c.timeout            = 0.seconds
+      c.term               = 'xterm-color'
+      c.whitelisted_ips    = ['127.0.0.1', '::1']
+
+      c.style = ActiveSupport::OrderedOptions.new.tap do |s|
+        s.colors = 'light'
+        s.font   = 'large Menlo, DejaVu Sans Mono, Liberation Mono, monospace'
+      end
+    end
+
+    initializer 'rvt.add_default_route' do |app|
+      # While we don't need the route in the test environment, we define it
+      # there as well, so we can easily test it.
+      if config.rvt.automount && (Rails.env.development? || Rails.env.test?)
+        app.routes.append do
+          mount RVT::Engine => app.config.rvt.default_mount_path
+        end
+      end
+    end
+
+    initializer 'rvt.process_whitelisted_ips' do
+      config.rvt.tap do |c|
+        # Ensure that it is an array of IPAddr instances and it is defaulted to
+        # 127.0.0.1 if not present. Only unique entries are left in the end.
+        c.whitelisted_ips = Array(c.whitelisted_ips).map { |ip|
+          if ip.is_a?(IPAddr)
+            ip
+          else
+            IPAddr.new(ip.presence || '127.0.0.1')
+          end
+        }.uniq
+
+        # IPAddr instances can cover whole networks, so simplify the #include?
+        # check for the most common case.
+        def (c.whitelisted_ips).include?(ip)
+          if ip.is_a?(IPAddr)
+            super
+          else
+            any? { |net| net.include?(ip.to_s) }
+          end
+        end
+      end
+    end
+
+    initializer 'rvt.process_command' do
+      config.rvt.tap do |c|
+        # +Rails.root+ is not available while we set the default values of the
+        # other options. Default it during initialization.
+
+        # Not all people created their Rails 4 applications with the Rails 4
+        # generator, so bin/rails may not be available.
+        if c.command.blank?
+          local_rails = Rails.root.join('bin/rails')
+          c.command = "#{local_rails.executable? ? local_rails : 'rails'} console"
+        end
+      end
+    end
+
+    initializer 'rvt.process_colors' do
+      config.rvt.style.tap do |c|
+        case colors = c.colors
+        when Symbol, String
+          c.colors = Colors[colors] || Colors.default
+        else
+          c.colors = Colors.new(colors)
+        end
+      end
+    end
+  end
+end

data/lib/rvt/slave.rb

@@ -0,0 +1,147 @@
+module RVT
+  # = Slave\ Process\ Wrapper
+  #
+  # Creates and communicates with slave processes.
+  #
+  # The communication happens through an input with attached psuedo-terminal.
+  # All of the communication is done in asynchronous way, meaning that when you
+  # send input to the process, you have get the output by polling for it.
+  class Slave
+    # Different OS' and platforms raises different errors when trying to read
+    # on output end of a closed process.
+    READING_ON_CLOSED_END_ERRORS = [ Errno::EIO, EOFError ]
+
+    # Raised when trying to read from a closed (exited) process.
+    Closed = Class.new(IOError)
+
+    # The slave process id.
+    attr_reader :pid
+
+    # Unique identifier for each slave process.
+    attr_reader :uid
+
+    def initialize(command = RVT.config.command, options = {})
+      # Windows doesn't have PTY, requiring it at the top level will fail the
+      # whole program execution.
+      require 'pty'
+      require 'io/console'
+
+      @uid = SecureRandom.hex(16)
+
+      using_term(options[:term] || RVT.config.term) do
+        @output, @input, @pid = PTY.spawn(command.to_s)
+      end
+
+      configure(options)
+    end
+
+    # Configure the psuedo terminal properties.
+    #
+    # Options:
+    #   :width  The width of the terminal in number of columns.
+    #   :height The height of the terminal in number of rows.
+    #
+    # If any of the width or height is missing (or zero), the terminal size
+    # won't be set.
+    def configure(options = {})
+      dimentions = options.values_at(:height, :width).collect(&:to_i)
+      @input.winsize = dimentions unless dimentions.any?(&:zero?)
+    end
+
+    # Sends input to the slave process STDIN.
+    #
+    # Returns immediately.
+    def send_input(input)
+      raise ArgumentError if input.nil? or input.try(:empty?)
+      input.each_char { |char| @input.putc(char) }
+    end
+
+    # Returns whether the slave process has any pending output in +wait+
+    # seconds.
+    #
+    # By default, the +timeout+ follows +config.rvt.timeout+. Usually,
+    # it is zero, making the response immediate.
+    def pending_output?(timeout = RVT.config.timeout)
+      # JRuby's select won't automatically coerce ActiveSupport::Duration.
+      !!IO.select([@output], [], [], timeout.to_i)
+    end
+
+    # Gets the pending output of the process.
+    #
+    # The pending output is read in an non blocking way by chunks, in the size
+    # of +chunk_len+. By default, +chunk_len+ is 49152 bytes.
+    #
+    # Returns +nil+, if there is no pending output at the moment. Otherwise,
+    # returns the output that hasn't been read since the last invocation.
+    #
+    # Raises Errno:EIO on closed output stream. This can happen if the
+    # underlying process exits.
+    def pending_output(chunk_len = 49152)
+      # Returns nil if there is no pending output.
+      return unless pending_output?
+
+      pending = String.new
+      while chunk = @output.read_nonblock(chunk_len)
+        pending << chunk
+      end
+      pending.force_encoding('UTF-8')
+    rescue IO::WaitReadable
+      pending.force_encoding('UTF-8')
+    rescue
+      raise Closed if READING_ON_CLOSED_END_ERRORS.any? { |exc| $!.is_a?(exc) }
+    end
+
+    # Dispose the underlying process, sending +SIGTERM+.
+    #
+    # After the process is disposed, it is detached from the parent to prevent
+    # zombies.
+    #
+    # If the process is already disposed an Errno::ESRCH will be raised and
+    # handled internally. If you want to handle Errno::ESRCH yourself, pass
+    # +{raise: true}+ as options.
+    #
+    # Returns a thread, which can be used to wait for the process termination.
+    def dispose(options = {})
+      dispose_with(:SIGTERM, options)
+    end
+
+    # Dispose the underlying process, sending +SIGKILL+.
+    #
+    # After the process is disposed, it is detached from the parent to prevent
+    # zombies.
+    #
+    # If the process is already disposed an Errno::ESRCH will be raised and
+    # handled internally. If you want to handle Errno::ESRCH yourself, pass
+    # +{raise: true}+ as options.
+    #
+    # Returns a thread, which can be used to wait for the process termination.
+    def dispose!(options = {})
+      dispose_with(:SIGKILL, options)
+    end
+
+    private
+
+    LOCK = Mutex.new
+
+    def using_term(term)
+      if term.nil?
+        yield
+      else
+        LOCK.synchronize do
+          begin
+            (previous_term, ENV['TERM'] = ENV['TERM'], term) and yield
+          ensure
+            ENV['TERM'] = previous_term
+          end
+        end
+      end
+    end
+
+    def dispose_with(signal, options = {})
+      Process.kill(signal, @pid)
+      Process.detach(@pid)
+    rescue Errno::ESRCH
+      raise if options[:raise]
+    end
+  end
+end