RubyGems - rhcp - Versions diffs - 0.1.2 - Mend

rhcp 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

data/Rakefile +116 -0
data/lib/rhcp/broker.rb +37 -0
data/lib/rhcp/client/command_param_stub.rb +51 -0
data/lib/rhcp/client/command_stub.rb +56 -0
data/lib/rhcp/client/http_broker.rb +86 -0
data/lib/rhcp/command.rb +120 -0
data/lib/rhcp/command_param.rb +93 -0
data/lib/rhcp/dispatching_broker.rb +25 -0
data/lib/rhcp/http_exporter.rb +157 -0
data/lib/rhcp/request.rb +93 -0
data/lib/rhcp/response.rb +62 -0
data/lib/rhcp/rhcp_exception.rb +6 -0
data/lib/rhcp.rb +47 -0
data/test/rhcp/broker_test.rb +29 -0
data/test/rhcp/client/command_param_stub_test.rb +73 -0
data/test/rhcp/client/command_stub_test.rb +40 -0
data/test/rhcp/command_param_test.rb +72 -0
data/test/rhcp/command_test.rb +136 -0
data/test/rhcp/dispatching_broker_test.rb +41 -0
data/test/rhcp/http_exporter_test.rb +113 -0
data/test/rhcp/http_registry_test.rb +73 -0
data/test/rhcp/http_test_server.rb +47 -0
data/test/rhcp/request_test.rb +124 -0
data/test/rhcp/response_test.rb +45 -0
metadata +87 -0

data/lib/rhcp/http_exporter.rb ADDED Viewed

@@ -0,0 +1,157 @@
+require 'webrick'
+require 'json'
+require 'net/http'
+require 'rhcp/broker'
+require 'rhcp/request'
+require 'rhcp/rhcp_exception'
+include WEBrick
+module RHCP
+  # TODO add some logging
+  # The +HttpExporter+ connects to the RHCP::Broker and exports all commands
+  # registered there via http, i.e. it servers requests to the URLs
+  #
+  #   /rhcp/get_commands
+  #   /rhcp/get_lookup_values
+  #   /rhcp/execute
+  #
+  # All data is transferred in JSON format.
+  class HttpExporter
+    DEFAULT_PORT = 42000
+    DEFAULT_PREFIX = "rhcp"
+    # by default, a new HttpExporter will create it's own +HTTPServer+
+    # on port 42000 - if you want to change this port, you can pass the port
+    # to use as +port+ option. If you want to use an existing +HTTPServer+
+    # instance, you can pass it as +server+ option instead.
+    #
+    # Also, you can specify the prefix for the rhcp URLs using the +prefix+
+    # option - otherwise, all
+    # rhcp actions will be exported at
+    #   /rhcp/get_commands
+    #   /rhcp/get_lookup_values
+    #   /rhcp/execute
+    # If you change this, please be aware that all clients that want to connect
+    # to this server need to be configured accordingly.
+    def initialize(broker, options = Hash.new())
+      @logger = RHCP::ModuleHelper::instance.logger
+      @broker = broker
+      # build your own server or use the on passed in as param
+      port = options.has_key?(:port) ? options[:port] : DEFAULT_PORT
+      if options.has_key?(:server)
+        @server = options[:server]
+        @logger.debug("using existing server #{@server}")
+      else
+        @logger.debug("opening own server on port #{port}")
+        @server = HTTPServer.new( :Port => port )
+      end
+      @url_prefix = options.has_key?(:prefix) ? options[:prefix] : DEFAULT_PREFIX
+      @server.mount_proc("/#{@url_prefix}/") {|req, res|
+        res.body = "<HTML>hello (again)</HTML>"
+        res['Content-Type'] = "text/html"
+      }
+      # TODO this path should probably be quite relative
+      @server.mount "/#{@url_prefix}/info", HTTPServlet::FileHandler, "docroot"
+      @server.mount "/#{@url_prefix}/get_commands", GetCommandsServlet, @broker
+      @server.mount "/#{@url_prefix}/get_lookup_values", GetLookupValuesServlet, @broker
+      @server.mount "/#{@url_prefix}/execute", ExecuteServlet, @broker
+      @logger.info("http exporter has been initialized - once started, it will listen on port '#{port}' for URLs starting with prefix '#{@url_prefix}'")
+    end
+    class BaseServlet < HTTPServlet::AbstractServlet
+      def initialize(server, broker)
+        super(server)
+        @broker = broker
+      end
+      def do_GET(req, res)
+        res['Content-Type'] = "application/json"
+        begin
+          #@logger.info("executing #{req}")
+          do_it(req, res)
+          #@logger.info("finished executing #{req}")
+        rescue RHCP::RhcpException => ex
+          # TODO define error format (should we send back a JSON-ified response object here?)
+          @logger.error("got an exception while executing request . #{ex}")
+          res.status = 500
+          res.body = [ ex.to_s ].to_json()
+          #puts ex
+          #puts ex.backtrace.join("\n")
+        end
+      end
+      # TODO is this a good idea?
+      def do_POST(req, res)
+        do_GET(req, res)
+      end
+    end
+    class GetCommandsServlet < BaseServlet
+      def do_it(req, res)
+        commands = @broker.get_command_list
+        puts "about to send back commands : #{commands.values.to_json()}"
+        res.body = commands.values.to_json()
+      end
+    end
+    class GetLookupValuesServlet < BaseServlet
+      def do_it(req, res)
+        partial_value = req.query.has_key?('partial') ? req.query['partial'] : ''
+        command = @broker.get_command(req.query['command'])
+        param = command.get_param(req.query['param'])
+        lookup_values = param.get_lookup_values(partial_value)
+        res.body = lookup_values.to_json()
+      end
+    end
+    class ExecuteServlet < BaseServlet
+      def do_it(req, res)
+        @logger.info("got an execute request : #{req}")
+        request = RHCP::Request.reconstruct_from_json(@broker, req.body)
+        response = request.execute()
+        @logger.debug("sending back response : #{response.to_json()}")
+        res.body = response.to_json()
+      end
+    end
+    def run
+      @server.start
+    end
+    def start
+      puts "about to start server..."
+      @thread = Thread.new {
+        puts "in thread; starting server..."
+        @server.start
+        puts "in thread: continuing..."
+      }
+    end
+    def stop
+      puts "about to stop server"
+      @server.stop
+      puts "thread stopped"
+      # TODO wait until after the server has ended - when this method exits, the server is still shutting down
+    end
+  end
+end

data/lib/rhcp/request.rb ADDED Viewed

@@ -0,0 +1,93 @@
+require 'rhcp/rhcp_exception'
+require 'rhcp/broker'
+require 'rubygems'
+require 'json'
+module RHCP
+  # This class represents a request made by a RHCP client to a RHCP server.
+  # It is passed as an argument to the method that should execute the requested
+  # command
+  class Request
+    attr_reader :command
+    attr_reader :param_values
+    # default constructor; will throw exceptions on invalid values
+    def initialize(command, param_values = {})
+      raise RHCP::RhcpException.new("command may not be null") if command == nil
+      # autobox the parameters if necessary
+      param_values.each do |k,v|
+        if ! v.instance_of?(Array)
+          param_values[k] = [ v ]
+        end
+      end
+      # check all param values for plausibility
+      param_values.each do |key,value|
+        command.get_param(key).check_param_is_valid(value)
+      end
+      # check that we've got all mandatory params
+      command.params.each do |name, param|
+        raise RHCP::RhcpException.new("missing mandatory parameter '#{name}'") if param.mandatory && ! param_values.has_key?(name)
+      end
+      @command = command
+      @param_values = param_values
+    end
+    # used to retrieve the value for the specified parameter
+    # returns either the value or an array of values if the parameter allows
+    # multiple values
+    def get_param_value(param_name)
+      raise "no such parameter : #{param_name}" unless @param_values.has_key?(param_name)
+      param = @command.get_param(param_name)
+      if (param.allows_multiple_values)
+        @param_values[param_name]
+      else
+        @param_values[param_name][0]
+      end
+    end
+    def has_param_value(param_name)
+      @param_values.has_key?(param_name)
+    end
+    # convenience method that executes the command that actually delegates to the
+    # command that's inside this request
+    def execute
+      @command.execute_request(self)
+    end
+    # reconstructs the request from it's JSON representation
+    # Since the JSON version of a request does hold the command name instead
+    # of the full command only, a broker is needed to lookup the command by
+    # it's name
+    #
+    # Params:
+    #   +broker+ is the broker to use for command lookup
+    #   +json_data+ is the JSON data that represents the request
+    def self.reconstruct_from_json(broker, json_data)
+      object = JSON.parse(json_data)
+      command = broker.get_command(object['command_name'])
+      self.new(command, object['param_values'])
+    end
+    # returns a JSON representation of this request.
+    def to_json(*args)
+      {
+        'command_name' => @command.name,
+        'param_values' => @param_values
+      }.to_json(*args)
+    end
+    def to_s
+      "#{@command.name} (#{@param_values})"
+    end
+  end
+end

data/lib/rhcp/response.rb ADDED Viewed

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'json'
+module RHCP
+  class Response
+    class Status
+      OK="ok"
+      ERROR="error"
+    end
+    # TODO these should be attr_reader's, but then we've got to solve json_create() differently
+    attr_accessor :status
+    attr_accessor :error_text
+    attr_accessor :error_detail
+    attr_accessor :data
+    # textual description of the result (optional)
+    attr_accessor :result_text
+    def initialize
+      @status = Status::OK
+      @error_text = ""
+      @error_detail = ""
+      @result_text = "";
+    end
+    def mark_as_error(text, detail="")
+      @status = Status::ERROR
+      @error_text = text
+      @error_detail = detail
+    end
+    def set_payload(data)
+      @data = data
+    end
+    def self.reconstruct_from_json(json_data)
+      object = JSON.parse(json_data)
+      instance = self.new()
+      instance.status = object["status"]
+      instance.error_text = object["error_text"]
+      instance.error_detail = object["error_detail"]
+      instance.set_payload(object["data"])
+      instance.result_text = object['result_text']
+      instance
+    end
+    def to_json(*args)
+      {
+        'status' => @status,
+        'error_text' => @error_text,
+        'error_detail' => @error_detail,
+        'data' => @data,   # TODO what about JSONinification of data? (probably data should be JSON-ish data only, i.e. no special objects)
+        'result_text' => @result_text
+      }.to_json(*args)
+    end
+  end
+end

data/lib/rhcp/rhcp_exception.rb ADDED Viewed

@@ -0,0 +1,6 @@
+module RHCP
+  class RhcpException < Exception
+  end
+end

data/lib/rhcp.rb ADDED Viewed

@@ -0,0 +1,47 @@
+require 'singleton'
+require 'logger'
+require 'rhcp/broker'
+require 'rhcp/command'
+require 'rhcp/command_param'
+require 'rhcp/dispatching_broker'
+require 'rhcp/http_exporter'
+require 'rhcp/request'
+require 'rhcp/response'
+require 'rhcp/rhcp_exception'
+require 'rhcp/client/http_broker'
+require 'rhcp/client/command_stub'
+require 'rhcp/client/command_param_stub'
+module RHCP #:nodoc:
+  class Version
+    include Singleton
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 2
+    def Version.to_s
+      [ MAJOR, MINOR, TINY ].join(".")
+    end
+  end
+  class ModuleHelper
+    include Singleton
+    attr_accessor :logger
+    def initialize()
+      # TODO do we really want to log to STDOUT per default?
+      # TODO check the whole package for correct usage of loggers
+      @logger = Logger.new(STDOUT)
+    end
+  end
+end

data/test/rhcp/broker_test.rb ADDED Viewed

@@ -0,0 +1,29 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'test/unit'
+require 'rhcp'
+class BrokerTest < Test::Unit::TestCase
+  def test_register_commands
+    broker = RHCP::Broker.new()
+    assert_not_nil broker
+    commands = broker.get_command_list
+    assert_not_nil commands
+    assert_equal 0, commands.size
+    command = RHCP::Command.new("test", "a test command", lambda {})
+    broker.register_command(command)
+    commands = broker.get_command_list
+    assert_equal 1, commands.size
+    assert_equal command, commands["test"]
+  end
+  def test_register_duplicate
+    broker = RHCP::Broker.new()
+    broker.register_command RHCP::Command.new("test", "a test command", lambda {})
+    assert_raise(RHCP::RhcpException) { broker.register_command RHCP::Command.new("test", "a command with the same name", lambda {}) }
+  end
+end

data/test/rhcp/client/command_param_stub_test.rb ADDED Viewed

@@ -0,0 +1,73 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'test/unit'
+require 'rhcp/client/command_param_stub'
+require 'rhcp/command_param'
+class CommandParamStubTest < Test::Unit::TestCase
+  def param_lookup
+    ["foo", "bar", "baz"]
+  end
+  def setup
+    @p = RHCP::CommandParam.new("test", "this param is used for testing purposes only",
+      :mandatory => true,
+      :allows_multiple_values => true,
+      :lookup_method => self.method(:param_lookup),
+      :is_default_param => true
+    )
+  end
+  def test_json
+    json = @p.to_json
+    puts "json : >>#{json}<<"
+    p2 = RHCP::Client::CommandParamStub.reconstruct_from_json(json)
+    assert_not_nil p2
+    assert_instance_of RHCP::Client::CommandParamStub, p2
+    assert_equal @p.name, p2.name
+    assert_equal @p.description, p2.description
+    assert_equal @p.allows_multiple_values, p2.allows_multiple_values
+    assert_equal @p.has_lookup_values, p2.has_lookup_values
+    assert_equal @p.is_default_param, p2.is_default_param
+    assert_equal @p.mandatory, p2.mandatory
+    json_hash = JSON.parse(json)
+    p3 = RHCP::Client::CommandParamStub.reconstruct_from_json(json_hash)
+    assert_instance_of RHCP::Client::CommandParamStub, p3
+    assert_equal @p.name, p3.name
+    assert_equal @p.description, p3.description
+    assert_equal @p.allows_multiple_values, p3.allows_multiple_values
+  end
+  # when a param is "stubbed", it should be possible to inject a method
+  # for retrieving the lookup values
+  def test_stubbing
+    json = @p.to_json
+    stub = RHCP::Client::CommandParamStub.reconstruct_from_json(json)
+    stub.get_lookup_values_block = lambda {
+      |partial_value|
+      [ "mascarpone", "limoncello" ]
+    }
+    lookup_values = stub.get_lookup_values()
+    assert_equal [ "mascarpone", "limoncello" ], lookup_values
+  end
+  def test_stubbing_without_lookup_values
+    p = RHCP::CommandParam.new("test", "without lookup values",
+      :mandatory => true,
+      :allows_multiple_values => true,
+      :is_default_param => true
+    )
+    stub = RHCP::Client::CommandParamStub.reconstruct_from_json(p.to_json())
+    has_been_invoked = false
+    stub.get_lookup_values_block = lambda {
+      |partial_value|
+      has_been_invoked = true
+    }
+    stub.get_lookup_values()
+    assert_equal false, has_been_invoked
+  end
+end

data/test/rhcp/client/command_stub_test.rb ADDED Viewed

@@ -0,0 +1,40 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'rubygems'
+require 'json'
+require 'test/unit'
+require 'rhcp'
+require 'rhcp'
+require 'rhcp'
+class CommandStubTest < Test::Unit::TestCase
+  def command_method(request, response)
+    first_param = request.get_param_value("first_param")
+    puts "just testing : #{first_param}"
+    first_param.reverse
+  end
+  def test_json
+    c = RHCP::Command.new("test", "a command for testing", self.method(:command_method))
+    c.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    json = c.to_json
+    puts "JSON : >>#{JSON.pretty_generate(c)}<<"
+    assert_not_nil json
+    c2 = RHCP::Client::CommandStub.reconstruct_from_json(json)
+    assert_not_nil c2
+    assert_instance_of RHCP::Client::CommandStub, c2
+    assert_equal c.name, c2.name
+    assert_equal c.description, c2.description
+    assert_equal c.params.size, c2.params.size
+    json_hash = JSON.parse(json)
+    c3 = RHCP::Client::CommandStub.reconstruct_from_json(json_hash)
+    assert_instance_of RHCP::Client::CommandStub, c3
+    assert_equal c.name, c3.name
+    assert_equal c.description, c3.description
+    assert_equal c.params.size, c3.params.size
+  end
+end

data/test/rhcp/command_param_test.rb ADDED Viewed

@@ -0,0 +1,72 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+require 'test/unit'
+require 'rhcp/command_param'
+class CommandParamTest < Test::Unit::TestCase
+  def param_lookup
+    ["foo", "bar", "baz"]
+  end
+  def test_creation
+    param = RHCP::CommandParam.new("test", "this param is used for testing purposes only")
+    assert_not_nil param, "a param should not be nil after creation"
+    assert_equal false, param.mandatory, "by default, params should not be mandatory"
+    assert_equal false, param.has_lookup_values, "by default, a param does not have lookup values"
+    assert_equal false, param.allows_multiple_values, "by default, a param should not allow multiple values"
+    assert_equal false, param.is_default_param
+  end
+  def test_options
+    param = RHCP::CommandParam.new("test", "this param is used for testing purposes only",
+      :mandatory => true,
+      :allows_multiple_values => true,
+      :lookup_method => self.method(:param_lookup),
+      :is_default_param => true
+    )
+    assert_not_nil param, "a param should not be nil after creation"
+    assert_equal true, param.mandatory
+    assert_equal true, param.allows_multiple_values
+    assert_equal true, param.has_lookup_values
+    assert_equal true, param.is_default_param
+  end
+  def test_lookup_values
+    param = RHCP::CommandParam.new("lookup_test", "testing if lookup values are working",
+      :lookup_method => self.method(:param_lookup)
+    )
+    assert_not_nil param
+    assert_equal param_lookup(), param.get_lookup_values()
+  end
+  def test_partial_lookup_values
+    param = RHCP::CommandParam.new("lookup_test", "testing if partial lookup values are working",
+      :lookup_method => self.method(:param_lookup)
+    )
+    assert_not_nil param
+    assert_equal ["bar", "baz"], param.get_lookup_values("ba")
+  end
+  def test_get_lookup_values_without_lookup
+    param = RHCP::CommandParam.new("lookup_test", "testing if partial lookup values are working")
+    assert_not_nil param
+    assert_equal [], param.get_lookup_values()
+  end
+  def test_check_param_is_valid
+    param = RHCP::CommandParam.new("validity_test", "testing if valid values are valid")
+    assert_not_nil param
+    assert param.check_param_is_valid([ "bla" ])
+    assert_raise(RHCP::RhcpException) { param.check_param_is_valid [ "bla", "blubb" ] }
+  end
+  # values that aren't part of the lookup values are invalid
+  def test_check_param_is_valid_lookup_values
+    param = RHCP::CommandParam.new("lookup_test", "testing if partial lookup values are working",
+      :lookup_method => self.method(:param_lookup)
+    )
+    assert_raise(RHCP::RhcpException) { param.check_param_is_valid(["zaphod"]) }
+  end
+end