ruby_robot 0.1.9

data/lib/ruby_robot/ruby_robot.proto

@@ -0,0 +1,53 @@
+//
+// gRPC service definition for the RubyRobot.
+//
+syntax = "proto3";
+
+import "google/protobuf/empty.proto";
+
+option java_multiple_files = true;
+option java_package = "net.avilla.netflix.studio.robot";
+option java_outer_classname = "RobotProto";
+option objc_class_prefix = "RBT";
+
+package RubyRobot;
+
+//
+// Service definitions
+//
+service RubyRobot {
+  rpc Left(google.protobuf.Empty)   returns (RubyRobotResponse)     {}
+  rpc Move(google.protobuf.Empty)   returns (RubyRobotResponse)     {}
+  rpc Place(RubyRobotRequest)       returns (RubyRobotResponse)     {}
+  rpc Remove(google.protobuf.Empty) returns (google.protobuf.Empty) {}
+  rpc Report(google.protobuf.Empty) returns (RubyRobotResponse)     {}
+  rpc Right(google.protobuf.Empty)  returns (RubyRobotResponse)     {}
+}
+
+//
+// Message type definitions
+//
+message RubyRobotRequest {
+  int32 x = 1;
+  int32 y = 2;
+  enum Direction {
+    // Clockwise from NORTH
+    NORTH=0;
+    EAST =1;
+    SOUTH=2;
+    WEST =3;
+  } 
+  Direction direction = 3;
+}
+
+message RubyRobotError {
+  int32 error    = 1;
+  string message = 2;
+}
+
+message RubyRobotResponse {
+  oneof response {
+    RubyRobotRequest current_state = 1;
+    RubyRobotError   error   = 2;
+  }
+}

data/lib/ruby_robot/schema_loader.rb

@@ -0,0 +1,10 @@
+module RubyRobot
+  module SchemaLoader
+
+    def load_schema(name)
+      schema_path = File.join(File.dirname(__FILE__), '..', '..', 'json_schema', "#{name}.schema.json")
+      schema = JSON.load(File.new(schema_path))
+    end
+
+  end
+end

data/lib/ruby_robot/shell.rb

@@ -0,0 +1,204 @@
+#
+# Behold: I stand on the shoulders of giants...rossmeissl@github.com 
+# is the _(wo?)man_
+#
+require 'bombshell'
+require 'logger'
+
+module RubyRobot
+class Shell < ::Bombshell::Environment
+  include ::Bombshell::Shell
+
+  prompt_with 'ILoveNetflixStudio'
+
+  attr_reader :logger
+
+  def initialize
+    @logger = Logger.new(STDOUT)
+    @logger.formatter = proc { |severity, datetime, progname, msg|
+      "#{msg}\n"
+    }
+  end
+
+  #
+  # Place a robot
+  #
+  def PLACE(x, y, direction)
+    # Save state in case place is called w/ invalid coords
+    orig_robot = @robot
+    orig_tabletop = @tabletop
+    # TODO: What happens when place is called > 1x per session?
+    # Answer under time crunch: just replace the Robot and Tabletop
+    @robot = Robot.new(direction)
+    @tabletop = NetflixTabletop.new
+    begin
+      @tabletop.place(@robot, x: x, y: y)
+      true
+    rescue
+      @robot = orig_robot
+      @tabletop = orig_tabletop
+      @logger.info $!
+      false
+    end
+  end
+
+  def MOVE
+    return if @robot.nil?
+    @robot.move
+  end
+
+  def LEFT
+    return if @robot.nil?
+    @robot.left
+  end
+
+  def RIGHT
+    return if @robot.nil?
+    @robot.right
+  end
+
+  def REPORT(to_stderr=true)
+    return nil if @robot.nil?
+    @logger.info(@robot.report) if to_stderr
+    @robot.report
+  end
+
+  # Exit Bombshell
+  alias :QUIT   :quit
+end
+end
+
+#
+# Monkeypatch Irb to allow no-arg uppercase methods
+#
+module IRB
+class Irb
+    # Evaluates input for this session.
+    def eval_input
+      @scanner.set_prompt do
+        |ltype, indent, continue, line_no|
+        if ltype
+          f = @context.prompt_s
+        elsif continue
+          f = @context.prompt_c
+        elsif indent > 0
+          f = @context.prompt_n
+        else
+          f = @context.prompt_i
+        end
+        f = "" unless f
+        if @context.prompting?
+          @context.io.prompt = p = prompt(f, ltype, indent, line_no)
+        else
+          @context.io.prompt = p = ""
+        end
+        if @context.auto_indent_mode
+          unless ltype
+            ind = prompt(@context.prompt_i, ltype, indent, line_no)[/.*\z/].size +
+              indent * 2 - p.size
+            ind += 2 if continue
+            @context.io.prompt = p + " " * ind if ind > 0
+          end
+        end
+      end
+
+      @scanner.set_input(@context.io) do
+        signal_status(:IN_INPUT) do
+          if l = @context.io.gets
+            #
+            # Begin monkeypatch: turn uppercase constants into
+            # method calls
+            #
+            if [:MOVE,:LEFT,:RIGHT,:REPORT,:REMOVE,:QUIT].include?(l.strip.to_sym)
+              l = "#{l.strip}()\n"
+            end
+            #
+            # End monkeypatch
+            #
+            print l if @context.verbose?
+          else
+            if @context.ignore_eof? and @context.io.readable_after_eof?
+              l = "\n"
+              if @context.verbose?
+                printf "Use \"exit\" to leave %s\n", @context.ap_name
+              end
+            else
+              print "\n"
+            end
+          end
+          l
+        end
+      end
+
+      @scanner.each_top_level_statement do |line, line_no|
+        signal_status(:IN_EVAL) do
+          begin
+            line.untaint
+            @context.evaluate(line, line_no)
+            output_value if @context.echo?
+            exc = nil
+          rescue Interrupt => exc
+          rescue SystemExit, SignalException
+            raise
+          rescue Exception => exc
+          end
+          if exc
+            print exc.class, ": ", exc, "\n"
+            if exc.backtrace && exc.backtrace[0] =~ /irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
+                !(SyntaxError === exc)
+              irb_bug = true
+            else
+              irb_bug = false
+            end
+
+            messages = []
+            lasts = []
+            levels = 0
+            if exc.backtrace
+              for m in exc.backtrace
+                m = @context.workspace.filter_backtrace(m) unless irb_bug
+                if m
+                  if messages.size < @context.back_trace_limit
+                    messages.push "\tfrom "+m
+                  else
+                    lasts.push "\tfrom "+m
+                    if lasts.size > @context.back_trace_limit
+                      lasts.shift
+                      levels += 1
+                    end
+                  end
+                end
+              end
+            end
+            print messages.join("\n"), "\n"
+            unless lasts.empty?
+              printf "... %d levels...\n", levels if levels > 0
+              print lasts.join("\n"), "\n"
+            end
+            print "Maybe IRB bug!\n" if irb_bug
+          end
+          if $SAFE > 2
+            abort "Error: irb does not work for $SAFE level higher than 2"
+          end
+        end
+      end
+    end
+end
+end
+
+#
+# Map these constants to symbols so the shell
+# will pass them through
+#
+module Bombshell
+module Shell
+  NORTH=:north
+  SOUTH=:south
+  EAST=:east
+  WEST=:west
+end
+end
+# Tell shell not to show lower-case 'quit' method; it is aliased
+# to #QUIT along w/ all the other upper-case methods.
+::Bombshell::Shell::Commands::HIDE << :quit
+::Bombshell::Shell::Commands::HIDE << :logger

data/lib/ruby_robot/tabletop.rb

@@ -0,0 +1,120 @@
+#
+# This class is a tabletop which is essentially a 2D
+# array even though Ruby doesn't support 2D arrays
+# like in other languages.
+#
+# As per the API instructions, (0,0) is considered
+# to be the SOUTH WEST most corner.
+#
+module RubyRobot
+class Tabletop
+  attr_reader :width, :height
+
+  def initialize(width, height)
+    # Store position of each piece
+    @width = width
+    @height = height
+    # Actually, this probably isn't necessary
+    # @playing_field = Array.new(@width) { Array.new(@height) }
+    # Hash with keys as the robot object and values are x/y coords
+    @robots = {}
+  end
+
+  def width_range
+    # Exclude width since positions are 0-based
+    (0...@width)
+  end
+
+  def height_range
+    # Exclude height since positions are 0-based
+    (0...@height)
+  end
+
+  def calculate_position(orig_position, direction_sym)
+    case direction_sym
+    # These are clockwise from north
+    when :north then orig_position[:y] += 1
+    when :east  then orig_position[:x] += 1
+    when :south then orig_position[:y] -= 1
+    when :west  then orig_position[:x] -= 1
+    end
+    orig_position
+  end
+
+  #
+  # Return hash of x/y coords for a placed
+  # Robot, else raise PlacementError.  Position state doesn't
+  # mean much to a Robot, by itself: only in 
+  # relation to a Tabletop.
+  #
+  def position(robot)
+    raise PlacementError.new "Robot is not on this table" unless placed?(robot)
+    @robots[robot]
+  end
+
+  #
+  # Can the Robot move in the specified direction
+  # w/o falling off?  Even though direction is a
+  # property of a specific Robot, pass it in here.
+  #
+  # Later this could be extended to support multiple
+  # Robots on a Tabletop.  In that case, this and 
+  # #move would need to be synchronized...
+  #
+  def move?(robot, direction_sym)
+    raise PlacementError.new "Robot is not on this table" unless placed?(robot)
+    possible_position = calculate_position(@robots[robot].clone, direction_sym)
+
+    # Is current_position on the board?
+    # Check in range (0..width).include?(x) and (0..height).include?(y)
+    return false if 
+      !width_range.include?(possible_position[:x]) or 
+      !height_range.include?(possible_position[:y])
+    true
+  end
+
+  #
+  # Move the robot in the specified direction.
+  #
+  def move(robot, direction_sym)
+    raise PlacementError.new "Robot is not on this table" unless placed?(robot)
+    new_position = calculate_position(@robots[robot].clone, direction_sym)
+    # Move the robot by placing it at its new location
+    place(robot, **new_position)
+  end
+
+  #
+  # Is this robot on this Tabletop?
+  #
+  def placed?(robot)
+    @robots.keys.include?(robot)
+  end
+
+  #
+  # NYI: Implement for multiple Robots per Tabletop
+  #
+  def place?(robot, direction_sym)
+    true
+  end
+
+  #
+  # Place a robot on this board
+  #
+  def place(robot, x:0, y:0)
+    raise PlacementError.new "Coordinates (#{x},#{y}) are not on this board" if 
+      !width_range.include?(x) || !height_range.include?(y)
+    # @playing_field[x][y] = robot
+    @robots[robot] = {x: x, y: y}
+    robot.place(self)
+  end
+
+  #
+  # Human-readable dump of Tabletop, with
+  # 2D array index {x:0,y:0} in the lower-left
+  # corner of the output.
+  #
+  def inspect
+    @playing_field
+  end
+end
+end

data/lib/ruby_robot/version.rb

@@ -0,0 +1,3 @@
+module RubyRobot
+  VERSION = "0.1.9"
+end

data/lib/ruby_robot/webapp.rb

@@ -0,0 +1,263 @@
+require 'sinatra/base'
+require 'sinatra/swagger-exposer/swagger-exposer'
+require 'ruby_robot'
+require 'json-schema'
+require 'json'
+
+module RubyRobot
+
+#
+# SwaggerExposer turns out to have a few drawbacks; it doesn't support
+# specifying enumerated string types.
+#
+USE_SWAGGER_EXPOSER=false
+
+#
+# Simple Sinatra webapp that supports:
+#
+# Run HTTP GET on /swagger.json to fetch a static JSON OpenAPI description 
+# for this webapp (suitable for use with swagger.io's GUI).
+#
+class Webapp < Sinatra::Base
+  include ::RubyRobot::SchemaLoader
+
+  set :public_folder, File.expand_path(File.join(File.dirname(__FILE__), '..', 'public'))
+  enable :static
+
+  # Tell sinatra to listen on all interfaces if it detects 
+  # it is running on a docker container...otherwise it
+  # will just bind to the loopback interface which can't be
+  # exposed from the container.
+  set :bind, '0.0.0.0' if File.exist?('/.dockerenv')
+
+  REPORT_EXAMPLE_OBJ = {x:1,y:1,direction: :NORTH}
+  REPORT_EXAMPLE = REPORT_EXAMPLE_OBJ.to_json
+
+  ERR_PLACEMENT_MSG = 'Robot is not currently placed'
+
+  def request_schema
+    @@request_schema ||= schema = load_schema('request')
+  end
+
+  def response_schema
+    @@response_schema ||= schema = load_schema('response')
+  end
+
+  def max_error_message_length
+    # Grab from the schema
+    (response_schema['definitions']['Error']['properties']['message']['maxLength'] || 1024)
+  end
+
+if USE_SWAGGER_EXPOSER
+  register Sinatra::SwaggerExposer 
+  #
+  # Swagger general info
+  #
+  general_info(
+    {
+      version: ::RubyRobot::VERSION,
+      title: 'RubyRobot',
+      description: 'Web interface to RubyRobot API',
+    }
+  )
+
+  #
+  # Swagger types
+  #
+  type 'Error', {
+    :required => [:code, :message],
+    :properties => {
+      :code => {
+        :type => Integer,
+        :example => 400,
+        :description => 'The error code',
+      },
+      :message => {
+        :type => String,
+        :example => ERR_PLACEMENT_MSG,
+        :description => 'The error message',
+      }
+    }
+  }
+
+  type 'Report', {
+    required: [:x, :y, :direction],
+    properties: {
+      x: {
+        type: Integer,
+        example: 0
+      },
+      y: {
+        type: Integer,
+        example: 0
+      },
+      direction: {
+        type: String,
+        example: "NORTH"
+      }
+    }
+  }
+end # if USE_SWAGGER_EXPOSER
+
+  #
+  # "Normal" sinatra/ruby code.
+  #
+  def robot
+    @@robot ||= proc { 
+      rr = ::RubyRobot::Shell.new
+      # In the webapp, don't log the REPORT messages to stdout
+      rr.logger.formatter = proc { |severity, datetime, progname, msg| "" }
+      rr
+    }.call
+  end
+
+  def not_placed_error
+    [400, {code: 400, message: ERR_PLACEMENT_MSG}.to_json]
+  end
+
+  def formatted_report
+    r = robot.REPORT(false)
+    if !r.nil?
+      r[:direction] = r[:direction].upcase unless r[:direction].nil?
+    end
+    r
+  end
+
+  def position_report
+    # Pass along the report, but the direction needs to be upcased to
+    # comply w/ the JSON schema for the web API 
+    [200, formatted_report.to_json]
+  end
+
+if USE_SWAGGER_EXPOSER
+  endpoint_description 'Place the robot'
+  endpoint_parameter :body, "Robot placement specification object", :body, true, 'Report', {
+    example: REPORT_EXAMPLE_OBJ
+  } 
+  endpoint_response 200, 'Report', 'Successful placement'
+  endpoint_response 400, 'Error', ERR_PLACEMENT_MSG
+  endpoint_tags 'Robot'
+end # if USE_SWAGGER_EXPOSER
+  post '/place' do 
+    content_type :json
+    request_params = nil
+    result = nil
+    begin
+      # Parse JSON args
+      request.body.rewind
+      request_params = JSON.parse(request.body.read)
+      # Validate input against JSON schema
+      json_schema_errors = JSON::Validator.fully_validate(request_schema, request_params)
+      body_json = {code: 400, message: "Bad request: #{json_schema_errors.join('; ')}"[0...max_error_message_length] }.to_json
+      body body_json
+      return [400, body_json] unless json_schema_errors.empty?
+      # Call robot#PLACE: inputs have already been validated by the JSON schema
+      robot.PLACE(request_params['x'], request_params['y'], (request_params['direction']))
+      body_json = formatted_report.to_json
+      body body_json
+      [200, body_json]
+    rescue
+      # TODO: log failing request details to enterprise logging...
+      # STDERR.puts $!
+      body_json = {code: 400, message: "Bad request (#{$!})"[0...max_error_message_length]}.to_json
+      body body_json
+      [400, body_json]
+    end
+  end
+
+if USE_SWAGGER_EXPOSER
+  endpoint_description 'Move the robot'
+  endpoint_response 200, 'Report', REPORT_EXAMPLE
+  endpoint_response 400, 'Error', ERR_PLACEMENT_MSG
+  endpoint_tags 'Robot'
+end # if USE_SWAGGER_EXPOSER
+  post '/move' do 
+    content_type :json
+    if robot.REPORT.nil?
+      not_placed_error
+    else
+      robot.MOVE
+      position_report
+    end
+  end
+
+if USE_SWAGGER_EXPOSER
+  endpoint_description 'Turn the robot left'
+  endpoint_response 200, 'Report', REPORT_EXAMPLE
+  endpoint_response 400, 'Error', ERR_PLACEMENT_MSG
+  endpoint_tags 'Robot'
+end # if USE_SWAGGER_EXPOSER
+  post '/left' do
+    content_type :json
+    if robot.REPORT.nil?
+      not_placed_error
+    else
+      robot.LEFT
+      position_report
+    end
+  end
+
+if USE_SWAGGER_EXPOSER
+  endpoint_description 'Turn the robot right'
+  endpoint_response 200, 'Report', REPORT_EXAMPLE
+  endpoint_response 400, 'Error', ERR_PLACEMENT_MSG
+  endpoint_tags 'Robot'
+end # if USE_SWAGGER_EXPOSER
+  post '/right' do
+    content_type :json
+    if robot.REPORT.nil?
+      not_placed_error
+    else
+      robot.RIGHT
+      position_report
+    end
+  end
+
+if USE_SWAGGER_EXPOSER
+  endpoint_description "Report the robot's position and orientation"
+  endpoint_response 200, 'Report', REPORT_EXAMPLE
+  endpoint_response 400, 'Error', ERR_PLACEMENT_MSG
+  endpoint_tags 'Robot'
+end # if USE_SWAGGER_EXPOSER
+  get '/report' do
+    content_type :json
+    if robot.REPORT.nil?
+      not_placed_error
+    else
+      position_report
+    end
+  end
+
+if !USE_SWAGGER_EXPOSER
+  get '/' do
+    redirect '/index.html'
+  end
+end
+
+  post '/remove' do
+    @@robot = nil
+    [200]
+  end
+
+  #
+  # For now, just validate the response for POST /place to show 
+  # responses can be validated within a Sinatra URL handler.
+  #
+  after '/place' do
+    # Validate response
+    begin
+      obj = JSON.parse(body.first)
+      unless JSON::Validator.validate(response_schema, obj)
+        # TODO: Enteprise logging
+        # Print out the failing constraints
+        STDERR.puts JSON::Validator.fully_validate(response_schema, obj)
+        STDERR.puts "Return value doesn't match response.schema.json: #{body.first}"
+      end
+    rescue
+      # TODO: Enterprise logging here...
+      STDERR.puts "Error (#{$!}) parsing JSON: '#{body}'"
+    end
+    # STDERR.puts "Failed validation" if JSON::Validator.validate(@response_schema, obj)
+  end
+end
+end