rhcp 0.1.9 → 0.2.14

data/lib/rhcp.rb

@@ -10,8 +10,10 @@ require 'rhcp/request'
 require 'rhcp/response'
 require 'rhcp/rhcp_exception'
 require 'rhcp/client/http_broker'
+require 'rhcp/client/context_aware_broker'
 require 'rhcp/client/command_stub'
 require 'rhcp/client/command_param_stub'
+require 'rhcp/logging_broker'
 
 module RHCP #:nodoc:
   
@@ -20,8 +22,8 @@ module RHCP #:nodoc:
     include Singleton
     
     MAJOR = 0
-    MINOR = 1
-    TINY  = 9
+    MINOR = 2
+    TINY  = 14
 
     def Version.to_s
       [ MAJOR, MINOR, TINY ].join(".")
@@ -45,3 +47,5 @@ module RHCP #:nodoc:
   end
   
 end
+
+$logger = Logger.new(STDOUT)

data/lib/rhcp/broker.rb

@@ -1,3 +1,5 @@
+require 'rhcp/context'
+
 module RHCP
 
   # Applications register the commands they are implementing at a broker.
@@ -6,24 +8,17 @@ module RHCP
   class Broker
     
     attr_reader :name
+    attr_reader :known_commands
     
     def initialize(name = "")
       # command_name => command
       @known_commands = Hash.new()
       @name = name
     end  
-
-    # returns a list of all known commands
-    def get_command_list()
-      @known_commands
-    end  
-
-    # returns the specified command object
-    def get_command(command_name)
-      raise RHCP::RhcpException.new("no such command : #{command_name}") unless @known_commands.has_key?(command_name)
-      get_command_list[command_name]
-    end
     
+    ################################################################################################
+    # public server interface
+
     # registers a new command - this method should be called by the application
     # providing the command
     def register_command(command)
@@ -31,10 +26,72 @@ module RHCP
       @known_commands[command.name] = command
     end
     
+    def unregister_command(name)
+      raise RHCP::RhcpException.new("no command found with name '#{name}'") unless @known_commands.has_key?(name)
+      @known_commands.delete name
+    end
+    
     # removes all commands that have been registered previously
     def clear
       @known_commands = Hash.new()
     end
 
+    ################################################################################################
+    # public client interface
+    
+    # returns a list of all known commands
+    def get_command_list(context = RHCP::Context.new())
+      result = {}
+      @known_commands.each do |name, command|
+        if command.is_enabled?(context)
+          result[name] = command
+        end
+      end
+      result
+    end  
+    
+    def execute(request)
+      command = get_command(request.command.name, request.context)
+      command.execute_request(request)
+    end
+    
+    ################################################################################################
+    # the following methods are basically helper methods for going through the
+    # data returned by get_command_list()
+    # 
+    # there should be no need to override these in descendant brokers
+
+    # returns the specified command object
+    def get_command(command_name, context=RHCP::Context.new())
+      commands = get_command_list(context)
+      
+      raise RHCP::RhcpException.new("no such command : #{command_name}") unless commands.has_key?(command_name)
+      commands[command_name]
+    end
+    
+    # returns a list of all mandatory parameters for the specified command
+    def get_mandatory_params(command_name, context=RHCP::Context.new())
+      command = get_command(command_name, context)
+      command.get_mandatory_params(context)
+    end
+    
+    # fetches lookup values for the parameter specified by command_name/param_name
+    # might evaluate the values that have already been collected and the current
+    # context
+    def get_lookup_values(request, param_name)
+      command = get_command(request.command.name, request.context)
+      command.get_param(param_name).get_lookup_values(request)
+    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(request, param_name, possible_value)
+      command = get_command(request.command.name, request.context)
+      param = command.get_param(param_name)
+      param.check_param_is_valid(request, possible_value)
+    end
+
   end
 end

data/lib/rhcp/client/command_param_stub.rb

@@ -31,13 +31,14 @@ module RHCP
             :allows_multiple_values => object['allows_multiple_values'],
             :has_lookup_values => object['has_lookup_values'],
             :is_default_param => object['is_default_param'],
-            :mandatory => object['mandatory']
+            :mandatory => object['mandatory'],
+            :autofill_context_key => object['autofill_context_key']
           }
           self.new(*args)
         end
         
-        def remote_get_lookup_values(partial_value = "")
-          @get_lookup_values_block.call(partial_value)
+        def remote_get_lookup_values(context = RHCP::Context.new())
+          @get_lookup_values_block.call(context)
         end
         
       end      

data/lib/rhcp/client/context_aware_broker.rb

@@ -0,0 +1,78 @@
+module RHCP
+
+  module Client
+
+    # a broker decorator that keeps track of the current context
+    class ContextAwareBroker
+
+      attr_accessor :context
+
+      def initialize(wrapped_broker)
+        @wrapped_broker = wrapped_broker
+        @context = RHCP::Context.new()
+      end
+
+      def register_command(command)
+        @wrapped_broker.register_command command
+      end
+
+      def clear
+        @wrapped_broker.clear()
+      end
+
+      def get_command_list(context=@context)
+        @wrapped_broker.get_command_list(context)
+      end
+
+      def give_the_request_some_context_rico(request)
+        # TODO think about the errors of your ways, son...
+        @context.cookies.each do |k,v|
+          request.context.cookies[k] = v
+        end
+        new_request = RHCP::Request.new(request.command, request.param_values, request.context)
+        #$logger.debug("+++ wrapped own request  : #{new_request}")
+        new_request
+      end
+
+      def execute(request)
+        #$logger.debug("+++ ContextAwareBroker.execute (#{request.command.name}, #{request.param_values}, #{request.context}) +++")
+
+        new_request = give_the_request_some_context_rico(request)
+        response = @wrapped_broker.execute(new_request)
+
+        # store context received with response
+        if response.context != nil
+          # TODO it would be nice if we could delete cookies as well
+          response.context.each do |key,value|
+            @context.cookies[key] = value
+            $logger.debug "storing value '#{value}' for key '#{key}' in context"
+          end
+        end
+
+        response
+      end
+
+      def get_command(command_name, context=@context)
+        @wrapped_broker.get_command(command_name, context)
+      end
+
+      def get_mandatory_params(command_name, context=@context)
+        command = get_command(command_name)
+        command.get_mandatory_params(context)
+      end
+
+      def get_lookup_values(request, param_name)
+        request_with_context = give_the_request_some_context_rico(request)
+        @wrapped_broker.get_lookup_values(request_with_context, param_name)
+      end
+
+      def check_param_is_valid(request, param_name, possible_value)
+        request_with_context = give_the_request_some_context_rico(request)
+        @wrapped_broker.check_param_is_valid(request_with_context, param_name, possible_value)
+      end
+
+    end
+
+  end
+
+end

data/lib/rhcp/client/http_broker.rb

@@ -11,7 +11,7 @@ module RHCP
     
       # This is an implementation of a RHCP broker that retrieves it's data via
       # http from a remote broker. Since it implements the same interface as RHCP::Broker,
-      # clients can use it exactly as if they were talking with the broker itself.
+      # clients can use it exactly as if they were talking to the broker itself.
       class HttpBroker < Broker
 
         def initialize(url)
@@ -19,7 +19,26 @@ module RHCP
           @url = url
           @logger = RHCP::ModuleHelper.instance.logger
           @logger.debug "connecting to #{@url}"
-          res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/") }
+          
+#          req = Net::HTTP::Get.new("/rhcp")
+#          if params.has_key?("user") && params.has_key?("password") then
+#            req.basic_auth params["user"], params["password"]
+#          elsif uri.user != nil then
+#            req.basic_auth uri.user, uri.password
+#          end      
+#          
+#          http = Net::HTTP.new(uri.host, uri.port)
+#          #http.set_debug_output($stderr)
+#          @op.log_to_jabber_detail("message" => "HTTP_START #{uri} : #{req}")
+#          response = http.request(req)
+          
+          res = Net::HTTP.new(@url.host, @url.port).start { |http|
+            if @url.user != nil then
+              @logger.debug "using basic auth data: #{@url.user} / #{@url.password}"
+              http.basic_auth @url.user, @url.password
+            end
+            http.get("/rhcp/") 
+          }
           if (res.code == "200")
             @logger.info "connected to '#{@url}' successfully."
           else
@@ -29,9 +48,9 @@ module RHCP
         end
 
         # returns a list of all known commands
-        # TODO add caching for commands
-        def get_command_list()
-          res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/get_commands") }   
+        def get_command_list(context = RHCP::Context.new())          
+          # TODO CONTEXT include context
+          res = Net::HTTP.new(@url.host, @url.port).start { |http| http.post("/rhcp/get_commands", context.to_json) }   
           if (res.code != "200")
             raise RHCP::RhcpException.new("could not retrieve command list from remote server : http status #{res.code} (#{res.message})")
           end
@@ -60,13 +79,14 @@ module RHCP
             }
             
             # inject appropriate blocks for all params
-            command.params.each do |name, param|
+            command.params.each do |param|
               param.get_lookup_values_block = lambda {
-                |partial_value|
-                @logger.debug("getting lookup values for param #{name} of command #{command.name} using #{@url}")
+                |request|
+                @logger.debug("getting lookup values for param #{param.name} of command #{command.name} using #{@url}")
                 # TODO add caching for lookup values
+                $logger.debug("request : #{request}")
                 res = Net::HTTP.new(@url.host, @url.port).start { |http| 
-                  http.get("/rhcp/get_lookup_values?command=#{command.name}&param=#{name}") 
+                  http.post("/rhcp/get_lookup_values?command=#{command.name}&param=#{param.name}", request.to_json)
                 }   
                 if (res.code != "200")
                   raise RHCP::RhcpException.new("could not retrieve lookup values from remote server : http status #{res.code} (#{res.message})")

data/lib/rhcp/command.rb

@@ -3,7 +3,6 @@ module RHCP
   require 'rubygems'
   require 'json'
   
-  #require 'rhcp/rhcp'
   require 'rhcp/response'
   
   # This class represents a single RHCP command, i.e. a functionality that
@@ -16,32 +15,41 @@ module RHCP
     attr_reader :name
 
     # textual description of what this command is doing
-    attr_reader :description
-
+    attr_accessor :description
+    
     # the parameters supported by this command
     attr_reader :params
 
     # the block that should be executed if this command is invoked
-    attr_reader :block
+    attr_accessor :block
     
     # the parameter that is the default param for this command; might be nil
     attr_reader :default_param
     
     # "true" if this command returns data, but does not modify anything.
     attr_reader :is_read_only
+
+    # an array of context keys that enable this command
+    # 
+    # if at least one of the listed keys is found in the context, the command
+    # is enabled, otherwise not. if no keys are listed, the command is enabled
+    # by default
+    attr_accessor :enabled_through_context_keys
     
     # hints about how the result of this command might be displayed
     attr_accessor :result_hints
 
-    def initialize(name, description, block)
+    def initialize(name, description, block = nil)
       @logger = RHCP::ModuleHelper.instance().logger
       
       @name = name
       @description = description
-      @block = block
-      @params = Hash.new()
+      @block = block unless block == nil
+      @params = Array.new()
+      
       @default_param = nil
       @is_read_only = false
+      @enabled_through_context_keys = nil
       # TODO formalize this! (we need rules how clients should react, otherwise this will be a mess)
       # TODO in some cases, the display_type could also be guessed from the response, I guess
       @result_hints = {
@@ -51,10 +59,30 @@ module RHCP
       }
     end
 
+    def is_enabled?(context = RHCP::Context.new())
+      result = true
+
+      if @enabled_through_context_keys != nil
+        result = false
+        @enabled_through_context_keys.each do |key|
+          if context.cookies.keys.select { |element| element == key }.size() > 0
+            @logger.debug "enabling command #{@name} because of context key #{key}"
+            result = true
+            break
+          end
+        end
+      end
+
+      result
+    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
+      existing_params = @params.select do |param|
+        param.name == new_param.name
+      end
+      raise "duplicate parameter name '#{new_param.name}'" if existing_params.size > 0
+      @params << 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")
@@ -76,32 +104,108 @@ module RHCP
     # 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]
+      existing_params = @params.select do |param|
+        param.name == param_name
+      end
+      
+      # there shouldn't be none
+      raise RHCP::RhcpException.new("no such parameter : #{param_name}") unless existing_params.size > 0
+      
+      # there can be only one
+      raise RHCP::RhcpException.new("BUG: duplicate parameters found") if existing_params.size > 1
+      
+      existing_params.first
+    end
+
+    # returns an array of all mandatory params for this command
+    # mandatory parameters that are auto-filled through the context are
+    # filtered out
+    def get_mandatory_params(context = RHCP::Context.new())
+      @params.select do |param| 
+        param.mandatory &&
+        ! param.find_value_in_context(context)
+      end
     end
 
     # invokes this command
     def execute_request(request)
       @logger.debug "gonna execute request >>#{request}<<"
-      response = RHCP::Response.new()      
+      
+      response = RHCP::Response.new()
+      # check all param values for plausibility
+      request.param_values.each do |key,value|
+        get_param(key).check_param_is_valid(request, value)
+      end
+
+      # check that we've got all mandatory params
+      @params.each do |param|
+        if param.mandatory && ! request.param_values.has_key?(param.name)
+          raise RHCP::RhcpException.new("missing mandatory parameter '#{param.name}' for command '#{self.name}'")
+        end
+      end
+      
       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
+      rescue Exception => ex
         response.mark_as_error(ex.to_s, ex.backtrace.join("\n"))
       end
+
+      # the command has been executed, so we should clear the store of collected param values
+      #request.context.collected_values = {}
       
       fire_post_exec_event(request, response)
       
       response
     end
     
-    def execute(param_values = {})
-      req = RHCP::Request.new(self, param_values)
+    def execute(param_values = {}, context = RHCP::Context.new())
+      req = RHCP::Request.new(self, param_values, context)
       execute_request(req)
     end
     
+    def add_as_instance_method(the_instance, additional_param_values = {})
+      rhcp_command = self
+      command_name = rhcp_command.name
+  
+      already_defined = the_instance.methods.select { |m| m == command_name }.size() > 0
+      if already_defined
+        the_instance.class.send(:remove_method, command_name.to_sym)
+      end
+      the_instance.class.send(:define_method, command_name.to_sym) do |*args|
+        # args is an array - but we need the (optional) hash on index 0
+        param_values = {}
+        if args.length > 0
+          $logger.debug("args: #{args}")
+          param_values = args.first
+        end
+  
+        # we need to carry along the context
+        the_broker = Thread.current['broker']
+        
+        param_values.merge! additional_param_values
+  
+        #param_values["host"] = @hostname if self.class.to_s == "HostController"
+        
+        request = RHCP::Request.new(rhcp_command, param_values, the_broker.context)
+        
+        response = the_broker.execute(request)
+  
+        if (response.status != RHCP::Response::Status::OK) then
+          # TODO actually, it would be nice if we could log the details into a file and show only the message
+          filtered_error_detail = response.error_detail.split("\n").select do |line|
+            /lib\/plugins\//.match(line)
+          end.join("\n")
+          
+          $logger.error("#{response.error_text}\n#{response.error_detail}")
+          #$logger.error("#{response.error_text}")
+          raise RuntimeError.new(response.error_text)
+        end
+        response.data
+      end
+    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
@@ -111,9 +215,10 @@ module RHCP
       {
         'name' => @name,
         'description' => @description,
-        'params' => @params.values,
+        'params' => @params,
         'read_only' => @is_read_only,
-        'result_hints' => @result_hints
+        'result_hints' => @result_hints,
+        'enabled_through_context_keys' => @enabled_through_context_keys
       }.to_json(*args)
     end