rvt 0.9.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40c0eb5241121c94ef06e819351e3622dec19f87
+  data.tar.gz: 33f5a3b57e0f16bddda6cf8568d0a126403fd9e9
+SHA512:
+  metadata.gz: 473f3b32b24b91a76f45a46b19f557b0f96a3bb8f5ec3040bf2d1a09f265d662d3952875a8aec3cf45e045bb3683c7e6c8d9229382cd063399627c0ab5033344
+  data.tar.gz: 8decfdb59c9293d84bac29d98fe546d3da4ef8e944d76c688e158e3284db8a6289933113c3aaed683f02c94c3d7e1451b720e9888e30c1a6711ecde5e7b9f85d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Genadi Samokovarov, Guillermo Iguaran
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,25 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'socket'
+require 'active_support/core_ext/string/strip'
+require 'rake/testtask'
+
+EXPANDED_CWD = File.expand_path(File.dirname(__FILE__))
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+# Just ignore this if rake is not runned from the current directory, as is the
+# case with docker's container. BUNDLE_GEMFILE won't do for our case, since the
+# Gemfile references gemspec.
+Bundler::GemHelper.install_tasks if defined? Bundler::GemHelper
+
+task default: :test

data/app/assets/javascripts/rvt/application.js

@@ -0,0 +1 @@
+//= require_tree .

data/app/assets/javascripts/rvt/console_sessions.js

@@ -0,0 +1,182 @@
+//= require rvt
+
+var AJAXTransport = (function(RVT) {
+
+  var inherits = RVT.inherits;
+  var EventEmitter = RVT.EventEmitter;
+
+  var FORM_MIME_TYPE = 'application/x-www-form-urlencoded; charset=utf-8';
+
+  var AJAXTransport = function(options) {
+    EventEmitter.call(this);
+    options || (options = {});
+
+    this.url = (typeof options.url === 'string') ? {
+      input: options.url,
+      pendingOutput: options.url,
+      configuration: options.url
+    } : options.url;
+
+    this.uid = options.uid;
+    this.pendingInput  = '';
+
+    this.initializeEventHandlers();
+  };
+
+  inherits(AJAXTransport, EventEmitter);
+
+  // Initializes the default event handlers.
+  AJAXTransport.prototype.initializeEventHandlers = function() {
+    this.on('input', this.sendInput);
+    this.on('configuration', this.sendConfiguration);
+    this.once('initialization', function(cols, rows) {
+      this.emit('configuration', cols, rows);
+      this.pollForPendingOutput();
+    });
+  };
+
+  // Shorthand for creating XHR requests.
+  AJAXTransport.prototype.createRequest = function(method, url, options) {
+    options || (options = {});
+
+    var params = '';
+
+    if (typeof options.form === 'object') {
+      var content = [], form = options.form;
+
+      for (var key in form) {
+        var value = form[key];
+        content.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
+      }
+
+      params = content.join('&');
+      if (method === 'GET' ? '?' : '') params = '?' + params;
+    }
+
+    var request = new XMLHttpRequest;
+    request.open(method, method === 'GET' ? url + params : url);
+
+    if (params && method != 'GET') {
+      request.setRequestHeader('Content-Type', FORM_MIME_TYPE);
+      request.data = params;
+    }
+
+    return request;
+  };
+
+  AJAXTransport.prototype.pollForPendingOutput = function() {
+    var request = this.createRequest('GET', this.url.pendingOutput, {
+      form: { uid: this.uid }
+    });
+
+    var self = this;
+    request.onreadystatechange = function() {
+      if (request.readyState === XMLHttpRequest.DONE) {
+        if (request.status === 200) {
+          self.emit('pendingOutput', request.responseText);
+          self.pollForPendingOutput();
+        } else {
+          self.emit('disconnect', request);
+        }
+      }
+    };
+
+    request.send(null);
+  };
+
+  // Send the input to the server.
+  //
+  // Each key press is encoded to an intermediate format, before it is sent to
+  // the server.
+  //
+  // RVT#keysPressed is an alias for RVT#sendInput.
+  AJAXTransport.prototype.sendInput = function(input) {
+    input || (input = '');
+
+    if (this.disconnected) return;
+    if (this.sendingInput) return this.pendingInput += input;
+
+    // Indicate that we are starting to send input.
+    this.sendingInput = true;
+
+    var request = this.createRequest('PUT', this.url.input, {
+      form: { input: this.pendingInput + input, uid: this.uid }
+    });
+
+    // Clear the pending input.
+    this.pendingInput = '';
+
+    var self = this;
+    request.onreadystatechange = function() {
+      if (request.readyState === XMLHttpRequest.DONE) {
+        self.sendingInput = false;
+        if (self.pendingInput) self.sendInput();
+      }
+    };
+
+    request.send(request.data);
+  };
+
+  // Send the terminal configuration to the server.
+  //
+  // Right now by configuration, we understand the terminal widht and terminal
+  // height.
+  //
+  // RVT#resized is an alias for RVT#sendconfiguration.
+  AJAXTransport.prototype.sendConfiguration = function(cols, rows) {
+    if (this.disconnected) return;
+
+    var request = this.createRequest('PUT', this.url.configuration, {
+      form: { width: cols, height: rows, uid: this.uid }
+    });
+
+    // Just send the configuration and don't care about any output.
+    request.send(request.data);
+  };
+
+  return AJAXTransport;
+
+}).call(this, RVT);
+
+window.addEventListener('load', function() {
+  var geometry = calculateFitScreenGeometry();
+  config.terminal.cols = geometry[0];
+  config.terminal.rows = geometry[1];
+
+  var terminal = window.terminal = new RVT.Terminal(config.terminal);
+
+  terminal.on('data', function(data) {
+    transport.emit('input', data);
+  });
+
+  var transport = new AJAXTransport(config.transport);
+
+  transport.on('pendingOutput', function(response) {
+    var json = JSON.parse(response);
+    if (json.output) terminal.write(json.output);
+  });
+
+  transport.on('disconnect', function() {
+    terminal.destroy();
+  });
+
+  transport.emit('initialization', terminal.cols, terminal.rows);
+
+  // Utilities
+  // ---------
+
+  function calculateFitScreenGeometry() {
+    // Currently, resizing term.js is broken. E.g. opening vi causes it to go
+    // back to 80x24 and fail with off-by-one error. Other stuff, like chip8
+    // are rendered incorrectly and so on.
+    //
+    // To work around it, create a temporary terminal, just so we can get the
+    // best dimensions for the screen.
+    var temporary = new RVT.Terminal;
+    try {
+      return temporary.fitScreen();
+    } finally {
+      temporary.destroy();
+    }
+  }
+});

data/app/assets/stylesheets/rvt/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/assets/stylesheets/rvt/console_sessions.css.erb

@@ -0,0 +1,6 @@
+<% RVT.config.style.instance_eval do %>
+  body { color: <%= colors.foreground %>; background: <%= colors.background %>; margin: 0; padding: 0; }
+
+  .terminal { float: left; overflow: hidden; font: <%= font %>; }
+  .terminal-cursor { color: <%= colors.background %>; background: <%= colors.foreground %>; }
+<% end %>

data/app/controllers/rvt/application_controller.rb

@@ -0,0 +1,13 @@
+module RVT
+  class ApplicationController < ActionController::Base
+    before_action :prevent_unauthorized_requests!
+
+    private
+
+    def prevent_unauthorized_requests!
+      unless request.remote_ip.in?(RVT.config.whitelisted_ips)
+        render nothing: true, status: :unauthorized
+      end
+    end
+  end
+end

data/app/controllers/rvt/console_sessions_controller.rb

@@ -0,0 +1,47 @@
+require_dependency 'rvt/application_controller'
+
+module RVT
+  class ConsoleSessionsController < ApplicationController
+    rescue_from ConsoleSession::Unavailable do |exception|
+      render json: exception, status: :gone
+    end
+
+    rescue_from ConsoleSession::Invalid do |exception|
+      render json: exception, status: :unprocessable_entity
+    end
+
+    rescue_from ConsoleSession::Unauthorized do |exception|
+      render json: exception, status: :unauthorized
+    end
+
+    def index
+      @console_session = ConsoleSession.create
+    end
+
+    def input
+      @console_session = ConsoleSession.find_by_pid_and_uid(params[:id], params[:uid])
+      @console_session.send_input(console_session_params[:input])
+
+      render nothing: true
+    end
+
+    def configuration
+      @console_session = ConsoleSession.find_by_pid_and_uid(params[:id], params[:uid])
+      @console_session.configure(console_session_params)
+
+      render nothing: true
+    end
+
+    def pending_output
+      @console_session = ConsoleSession.find_by_pid_and_uid(params[:id], params[:uid])
+
+      render json: { output: @console_session.pending_output }
+    end
+
+    private
+
+    def console_session_params
+      params.permit(:id, :uid, :input, :width, :height)
+    end
+  end
+end

data/app/models/rvt/console_session.rb

@@ -0,0 +1,109 @@
+module RVT
+  # Manage and persist (in memory) RVT::Slave instances.
+  class ConsoleSession
+    include ActiveModel::Model
+
+    # In-memory storage for the console sessions. Session preservation is
+    # troubled on servers with multiple workers and threads.
+    INMEMORY_STORAGE = {}
+
+    # Base error class for ConsoleSession specific exceptions.
+    #
+    # Provides #to_json implementation, so all subclasses are JSON
+    # serializable.
+    class Error < StandardError
+      def as_json(*)
+        { error: to_s }
+      end
+    end
+
+    # Raised when trying to find a session that is no longer in the in-memory
+    # session storage or when the slave process exited.
+    Unavailable = Class.new(Error)
+
+    # Raised when an operation transition to an invalid state.
+    Invalid = Class.new(Error)
+
+    # Raised when a request doesn't know the slave process uid.
+    Unauthorized = Class.new(Error)
+
+    class << self
+      # Finds a session by its pid.
+      #
+      # Raises RVT::ConsoleSession::Expired if there is no such session.
+      def find(pid)
+        INMEMORY_STORAGE[pid.to_i] or raise Unavailable, 'Session unavailable'
+      end
+
+      # Finds a session by its pid.
+      #
+      # Raises RVT::ConsoleSession::Expired if there is no such session.
+      # Raises RVT::ConsoleSession::Unauthorized if uid doesn't match.
+      def find_by_pid_and_uid(pid, uid)
+        find(pid).tap do |console_session|
+          raise Unauthorized if console_session.uid != uid
+        end
+      end
+
+      # Creates an already persisted consolse session.
+      #
+      # Use this method if you need to persist a session, without providing it
+      # any input.
+      def create
+        new.persist
+      end
+    end
+
+    def initialize
+      @slave = Slave.new
+    end
+
+    # Explicitly persist the model in the in-memory storage.
+    def persist
+      INMEMORY_STORAGE[pid] = self
+    end
+
+    # Returns true if the current session is persisted in the in-memory storage.
+    def persisted?
+      self == INMEMORY_STORAGE[pid]
+    end
+
+    # Returns an Enumerable of all key attributes if any is set, regardless if
+    # the object is persisted or not.
+    def to_key
+      [pid] if persisted?
+    end
+
+    private
+
+    def delegate_and_call_slave_method(name, *args, &block)
+      # Cache the delegated method, so we don't have to hit #method_missing
+      # on every call.
+      define_singleton_method(name) do |*inner_args, &inner_block|
+        begin
+          @slave.public_send(name, *inner_args, &inner_block)
+        rescue ArgumentError => exc
+          raise Invalid, exc
+        rescue Slave::Closed => exc
+          raise Unavailable, exc
+        end
+      end
+
+      # Now call the method, since that's our most common use case. Delegate
+      # the method and than call it.
+      public_send(name, *args, &block)
+    end
+
+    def method_missing(name, *args, &block)
+      if @slave.respond_to?(name)
+        delegate_and_call_slave_method(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      @slave.respond_to?(name) or super
+    end
+  end
+end

data/app/views/layouts/rvt/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>RVT</title>
+
+    <%= stylesheet_link_tag    'rvt/application', media: 'all' %>
+    <%= javascript_include_tag 'rvt/application' %>
+    <%= csrf_meta_tags %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>