rhcp 0.1.2 → 0.1.3

data/lib/rhcp/command.rb

@@ -1,120 +0,0 @@
-module RHCP
-
-  require 'rubygems'
-  require 'json'
-  
-  #require 'rhcp/rhcp'
-  require 'rhcp/response'
-  
-  # This class represents a single RHCP command, i.e. a functionality that
-  # should be exposed to clients.
-  class Command
-    
-    # TODO add read_write/read_only marker
-    
-    # TODO add metadata about the command's result (display type ("table"), column order etc.)
-    
-    # a unique name for this command
-    attr_reader :name
-
-    # textual description of what this command is doing
-    attr_reader :description
-
-    # the parameters supported by this command
-    attr_reader :params
-
-    # the block that should be executed if this command is invoked
-    attr_reader :block
-    
-    # the parameter that is the default param for this command; might be nil
-    attr_reader :default_param
-
-    def initialize(name, description, block)
-      @logger = RHCP::ModuleHelper.instance().logger
-      
-      @name = name
-      @description = description
-      @block = block
-      @params = Hash.new()
-      @default_param = nil
-    end
-
-    # adds a new parameter and returns the command
-    def add_param(new_param)
-      raise "duplicate parameter name '#{new_param.name}'" if @params.has_key?(new_param.name)
-      @params[new_param.name] = new_param
-      if new_param.is_default_param
-        if @default_param != nil
-          raise RHCP::RhcpException.new("there can be only one default parameter per command, and the parameter '#{@default_param.name}' has already been marked as default")
-        end
-        @default_param = new_param
-      end
-      self
-    end
-
-    # returns the specified CommandParam
-    # or throws an RhcpException if the parameter does not exist
-    def get_param(param_name)
-      raise RHCP::RhcpException.new("no such parameter : #{param_name}") unless @params.has_key?(param_name)
-      @params[param_name]
-    end
-
-    # invokes this command
-    def execute_request(request)
-      @logger.debug "gonna execute request >>#{request}<<"
-      response = RHCP::Response.new()      
-      begin
-        # TODO redirect the block's output (both Logger and STDOUT/STDERR) and send it back with the response
-        result = block.call(request, response)
-        response.set_payload(result)
-      rescue => ex
-        response.mark_as_error(ex.to_s, ex.backtrace.join("\n"))
-      end
-      
-      fire_post_exec_event(request, response)
-      
-      response
-    end
-    
-    def execute(param_values = {})
-      req = RHCP::Request.new(self, param_values)
-      execute_request(req)
-    end
-    
-    
-    # we do not serialize the block (no sense in this) nor the default param
-    # when the command is unmarshalled as stub, the default param will be set again
-    # automatically ba add_param(), and the block will be replaced by the block
-    # that does the remote invocation
-    def to_json(*args)
-      {
-        'name' => @name,
-        'description' => @description,
-        'params' => @params.values
-      }.to_json(*args)
-    end
-    
-    # TODO think about moving this and the whole command thing to the broker
-    def Command.register_post_exec_listener(block)        
-      @@listener = [] unless defined?(@@listener)
-      @@listener << block
-    end
-    
-    def Command.clear_post_exec_listeners()
-      @@listener = []
-    end
-    
-    def fire_post_exec_event(request, response)
-      return unless defined? @@listener
-      @@listener.each do |listener|
-        begin
-          listener.call(request, response)
-        rescue => ex
-          @logger.warn "a post-exec listener failed with the following message : #{ex}"
-        end
-      end
-    end
-
-  end
-
-end

data/lib/rhcp/command_param.rb

@@ -1,93 +0,0 @@
-require 'rubygems'
-require 'json'
-
-require 'rhcp/rhcp_exception'
-
-module RHCP
-
-  # This class represents a single parameter that can be specified for
-  # a certain command. It is used by the server side to define which
-  # commands are available for clients.
-  class CommandParam
-
-    # a unique name for this parameter
-    attr_reader :name
-    # a textual description of this parameter's meaning
-    attr_reader :description
-    # "true" if the command can not be invoked without this parameter
-    attr_reader :mandatory
-    # "true" if there are lookup values available for this parameter
-    attr_reader :has_lookup_values
-    # "true" if this parameter might be specified multiple times, resulting
-    # in a list of values for this parameter
-    attr_reader :allows_multiple_values    
-    # "true" if this parameter is the default parameter for the enclosing command
-    attr_reader :is_default_param
-
-    # creates a new command parameter
-    # options is a hash, possibly holding the following values (all optional)
-    #   :mandatory                true if the parameter is necessary for this command
-    #   :allows_multiple_values   true if this parameter might be specified multiple times
-    #   :lookup_method            a block that returns an array of lookup values valid for this param
-    #   :is_default_param         true if this parameter is the default param for the enclosing command
-    def initialize(name, description, options = Hash.new)
-      @name = name
-      @description = description
-
-      @mandatory = options[:mandatory] || false
-      @lookup_value_block = options[:lookup_method]     
-      @has_lookup_values = @lookup_value_block != nil
-      @allows_multiple_values = options[:allows_multiple_values] || false
-      @is_default_param = options[:is_default_param] || false
-    end
-
-    # returns lookup values for this parameter
-    # if "partial_value" is specified, only those values are returned that start
-    # with "partial_value"
-    def get_lookup_values(partial_value = "")
-      if @has_lookup_values
-        @lookup_value_block.call().grep(/^#{partial_value}/)
-      else
-        []
-      end
-    end
-
-    # throws an exception if +possible_value+ is not a valid value for this parameter
-    # returns true otherwise
-    # note that this methods expects +possible_value+ to be an array since all param values
-    # are specified as arrays
-    def check_param_is_valid(possible_value)
-
-      # formal check : single-value params against multi-value params
-      if ((! @allows_multiple_values) && (possible_value.size > 1))
-        raise RHCP::RhcpException.new("multiple values specified for single-value parameter '#{@name}'")
-      end
-
-      # check against lookup values
-      if @has_lookup_values
-        possible_value.each do |value|
-          if ! get_lookup_values().include?(value)
-            raise RHCP::RhcpException.new("invalid value '#{value}' for parameter '#{@name}'")
-          end
-        end
-      end
-
-      true
-    end
-    
-    # we do not serialize the lookup_method (it couldn't be invoked remotely
-    # anyway)
-    def to_json(*args)
-      {
-        'name' => @name,
-        'description' => @description,
-        'allows_multiple_values' => @allows_multiple_values,
-        'has_lookup_values' => @has_lookup_values,
-        'is_default_param' => @is_default_param,
-        'mandatory' => @mandatory
-      }.to_json(*args)
-    end        
-
-  end
-
-end  

data/lib/rhcp/dispatching_broker.rb

@@ -1,25 +0,0 @@
-require 'rhcp/rhcp_exception'
-require 'rhcp/broker'
-
-module RHCP
-
-  class DispatchingBroker < RHCP::Broker
-    def initialize
-      @known_commands = Hash.new()
-    end
-    
-    # returns a list of all known commands
-    def get_command_list()
-      @known_commands
-    end  
-
-    def add_broker(new_broker)
-      new_broker.get_command_list.each do |name, command|
-        raise RHCP::RhcpException.new("duplicate command: '#{name}' has already been defined.") if @known_commands.has_key?(name)
-        @known_commands[name] = command
-      end
-    end
-    
-  end
-  
-end

data/lib/rhcp/http_exporter.rb

@@ -1,157 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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