rhcp 0.1.9 → 0.2.14

data/lib/rhcp/command_param.rb

@@ -23,6 +23,8 @@ module RHCP
     attr_reader :allows_multiple_values    
     # "true" if this parameter is the default parameter for the enclosing command
     attr_reader :is_default_param
+    # the key to a context value that is used for filling this parameter
+    attr_reader :autofill_context_key
 
     # creates a new command parameter
     # options is a hash, possibly holding the following values (all optional)
@@ -34,19 +36,44 @@ module RHCP
       @name = name
       @description = description
 
+      # TODO add default value for optional params
+      # TODO also, it should be possible to allow extra values for params with lookups
       @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
+      @autofill_context_key = options[:autofill_context_key] || nil
+    end
+
+    # searches the context for a values that can be auto-filled
+    # if a value is found in the context, it is returned
+    # if this parameter cannot be filled from the context, nil is returned
+    def find_value_in_context(context)
+      result = nil
+      if @autofill_context_key != nil
+        if context.cookies.has_key?(@autofill_context_key)
+          result = context.cookies[@autofill_context_key]
+        end
+      end
+      result
     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 = "")
+    # with "partial_value"    
+    def get_lookup_values(request, partial_value = "")
       if @has_lookup_values
-        @lookup_value_block.call().grep(/^#{partial_value}/)
+        # TODO mix other_params and context
+        $logger.debug "get_lookup_values for '#{request.command.name}'; request : #{request}"
+        values = []
+        if @lookup_value_block.arity == 1 or @lookup_value_block.arity == -1
+          values = @lookup_value_block.call(request)
+        else
+          values = @lookup_value_block.call()
+        end
+        
+        values.grep(/^#{partial_value}/)
       else
         []
       end
@@ -56,7 +83,7 @@ module RHCP
     # 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)
+    def check_param_is_valid(request, possible_value)
 
       # formal check : single-value params against multi-value params
       if ((! @allows_multiple_values) && (possible_value.size > 1))
@@ -66,7 +93,7 @@ module RHCP
       # check against lookup values
       if @has_lookup_values
         possible_value.each do |value|
-          if ! get_lookup_values().include?(value)
+          if ! get_lookup_values(request).include?(value)
             raise RHCP::RhcpException.new("invalid value '#{value}' for parameter '#{@name}'")
           end
         end
@@ -84,7 +111,8 @@ module RHCP
         'allows_multiple_values' => @allows_multiple_values,
         'has_lookup_values' => @has_lookup_values,
         'is_default_param' => @is_default_param,
-        'mandatory' => @mandatory
+        'mandatory' => @mandatory,
+        'autofill_context_key' => @autofill_context_key
       }.to_json(*args)
     end        
 

data/lib/rhcp/context.rb

@@ -0,0 +1,43 @@
+module RHCP
+  
+  # The context class is used for transporting both the context hash and some
+  # other client state like the parameter values that have been collected during
+  # user input. It should be sent with all rhcp remote calls and should generally
+  # be treated as optional.
+  class Context
+    
+    # hash holding context information; similar to HTTP cookies
+    # TODO should we actually use cookies for transporting this info?
+    attr_accessor :cookies
+    
+    def initialize(cookies = {})
+      @cookies = cookies
+    end       
+    
+    def to_json(*args)
+      {
+        'cookies' => @cookies,
+      }.to_json(*args)
+    end  
+    
+    def self.reconstruct_from_json(json_data)
+      $logger.debug "reconstructing context from json : >>#{json_data}<<"
+      object = JSON.parse(json_data)
+      instance = self.new()
+      instance.cookies = object['cookies'] 
+      
+      instance
+    end
+
+    def to_s
+      result = "<Context cookies:"
+      @cookies.each do |k,v|
+        result += " '#{k}'='#{v}'"
+      end
+      result += ">"
+      result
+    end
+    
+  end
+
+end

data/lib/rhcp/dispatching_broker.rb

@@ -3,23 +3,47 @@ require 'rhcp/broker'
 
 module RHCP
 
-  class DispatchingBroker < RHCP::Broker
+  class DispatchingBroker < Broker
     def initialize
-      @known_commands = Hash.new()
+      @brokers = []
     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
+      @brokers << new_broker
+      # TODO this is not a good way of handling duplicate detection since the broker has been added to the list already
+      get_command_list()
+    end
+
+    def get_broker_for_command_name(command_name, context)
+      result = nil
+      @brokers.each do |broker|
+        broker.get_command_list(context).each do |name, command|
+          if name == command_name
+            result = broker
+          end
+        end
       end
+      raise RHCP::RhcpException.new("no broker found that offers command '#{command_name}'") if result == nil
+      result
     end
-    
+
+    # returns a list of all known commands
+    def get_command_list(context = RHCP::Context.new())
+      result = {}
+      @brokers.each do |broker|
+        broker.get_command_list(context).each do |name, command|
+          raise RHCP::RhcpException.new("duplicate command: '#{name}' has already been defined.") if result.has_key?(name)
+          result[name] = command
+        end
+      end
+      result
+    end
+
+    def execute(request)
+      broker = get_broker_for_command_name(request.command.name, request.context)
+      broker.execute(request)
+    end
+
   end
   
 end

data/lib/rhcp/http_exporter.rb

@@ -13,7 +13,7 @@ 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
+  # registered there via http
   # 
   #   /rhcp/get_commands
   #   /rhcp/get_lookup_values
@@ -62,6 +62,7 @@ module RHCP
       # TODO this path should probably be quite relative
       @server.mount "/#{@url_prefix}/info", HTTPServlet::FileHandler, "docroot"
       @server.mount "/#{@url_prefix}/info2", HTTPServlet::FileHandler, "qooxdoo_rhcp/build"
+      
       @server.mount "/#{@url_prefix}/get_commands", GetCommandsServlet, @broker
       @server.mount "/#{@url_prefix}/get_lookup_values", GetLookupValuesServlet, @broker
       @server.mount "/#{@url_prefix}/execute", ExecuteServlet, @broker
@@ -76,18 +77,28 @@ module RHCP
       end
       
       def do_GET(req, res)
-        res['Content-Type'] = "application/json"        
+        res['Content-Type'] = "application/json"
+        @broker = RHCP::Client::ContextAwareBroker.new(@broker)
+        Thread.current['broker'] = @broker
         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}")
+          @logger.debug("executing #{req}")
+        
+          begin
+            pre_flight_command = @broker.get_command("pre_flight_init")
+            request = RHCP::Request.new(pre_flight_command, {}, @broker.context)
+            response = @broker.execute(request)
+          rescue RHCP::RhcpException
+            @logger.warn("no pre_flight command defined")
+          end
+          do_it(req, res)          
+        rescue Exception => ex
+          @logger.error("got an exception while executing request . #{ex}\n#{ex.backtrace.join("\n")}")
+          
+          response = RHCP::Response.new()
+          response.mark_as_error(ex.to_s, ex.backtrace.join("\n"))
+
           res.status = 500
-          res.body = [ ex.to_s ].to_json()
-          #puts ex
-          #puts ex.backtrace.join("\n")
+          res.body = response.to_json()
         end
       end
       
@@ -101,8 +112,13 @@ module RHCP
     class GetCommandsServlet < BaseServlet      
       
       def do_it(req, res)
-        commands = @broker.get_command_list
-        puts "about to send back commands : #{commands.values.to_json()}"
+        context = req.body == nil ?
+          RHCP::Context.new() :
+          RHCP::Context.reconstruct_from_json(req.body)
+          
+        commands = @broker.get_command_list(context)
+        #puts "about to send back commands : #{commands.values.to_json()}"
+        @logger.info("/get_commands returns #{commands.values.size()} commands.")
         res.body = commands.values.to_json()
       end
     end
@@ -110,10 +126,23 @@ module RHCP
     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)
+        request = RHCP::Request.reconstruct_from_json(@broker, req.body)
+        
+        #command = @broker.get_command(req.query['command'])
+        #param = command.get_param(req.query['param'])
+        
+        #partial_value = req.query.has_key?('partial') ? req.query['partial'] : ''
+        
+        req_params = {}
+        if req.query_string != nil
+          req.query_string.split("&").each do |param_string|
+            (key, value) = param_string.split("=")
+            req_params[key] = value
+          end
+        end
+        $logger.debug("get_lookup_values for #{req_params['command']}")
+        lookup_values = @broker.get_lookup_values(request, req_params['param'])
+        
         res.body = lookup_values.to_json()
       end
       
@@ -126,9 +155,13 @@ module RHCP
         # TODO filter "nocache" parameters from query string
         request = RHCP::Request.reconstruct_from_json(@broker, req.body)
 
-        response = request.execute()
+        @logger.debug "http exporter delegating to next broker : #{@broker.class.to_s}"
+        response = @broker.execute(request)
+        
+        response.set_context(@broker.context.cookies)
         
         @logger.debug("sending back response : #{response.to_json()}")
+        puts "response : #{response.to_json()}"
         res.body = response.to_json()
       end
       

data/lib/rhcp/logging_broker.rb

@@ -0,0 +1,85 @@
+require 'rhcp/broker'
+
+module RHCP
+
+  class LoggingBroker < Broker
+
+    def initialize(wrapped_broker)
+      super()
+      @wrapped_broker = wrapped_broker
+      @logger = RHCP::ModuleHelper::instance.logger
+    end
+
+    def get_command_list(context = RHCP::Context.new())
+      @wrapped_broker.get_command_list(context)
+    end
+
+    def register_command(command)
+      @wrapped_broker.register_command(command)
+    end
+
+    def clear
+      @wrapped_broker.clear()
+    end
+    
+    def get_blacklisted_commands
+      [ "log_to_jabber", "log_to_jabber_detail", "on_host", "hostname" ]
+    end
+    
+    
+    # TODO would be nice if this helper method would be accessible from inside vop plugins
+    def var_name(name)
+      self.class.to_s + "." + name
+    end
+    
+    def execute(request)
+      blacklisted = get_blacklisted_commands.include?(request.command.name)
+      if not blacklisted and request.context.cookies.has_key?('__loggingbroker.blacklisted_commands') then
+        blacklisted = request.context.cookies['__loggingbroker.blacklisted_commands'].split(',').include?(request.command.name)
+      end
+  
+      command = get_command(request.command.name, request.context)
+      mode = command.is_read_only ? 'r/o' : 'r/w'
+  
+      is_new_request = Thread.current[var_name("request_id")] == nil
+      if is_new_request
+        Thread.current[var_name("request_id")] = Time.now().to_i.to_s + '_' + request.command.name
+        Thread.current[var_name("stack")] = []
+        Thread.current[var_name("id_stack")] = []
+      end
+      
+      Thread.current[var_name("stack")] << command.name
+      
+      level = Thread.current[var_name("stack")].size()
+      
+      unless blacklisted    
+        #$logger.info ">> #{command.name} (#{mode}) : #{Thread.current[var_name("stack")].join(" -> ")}"
+        start_ts = Time.now()
+        log_request_start(Thread.current[var_name("request_id")], level, mode, Thread.current[var_name("stack")], request, start_ts)
+      end
+      
+      response = @wrapped_broker.execute(request)
+      
+      unless blacklisted
+        stop_ts = Time.now()
+        duration = stop_ts.to_i - start_ts.to_i
+        
+        log_request_stop(Thread.current[var_name("request_id")], level, mode, Thread.current[var_name("stack")], request, response, duration)
+      end
+      
+      Thread.current[var_name("stack")].pop
+      
+      response
+    end
+
+    def log_request_start(request_id, level, mode, current_stack, request, start_ts)
+      $logger.debug("> #{request_id} #{level} [#{mode}] #{current_stack.join('.')} #{request}")
+    end
+    
+    def log_request_stop(request_id, level, mode, current_stack, request, response, duration)
+      $logger.debug("< #{request_id} #{level} [#{mode}] #{current_stack.join('.')} #{request}")
+    end
+
+  end
+
+end

data/lib/rhcp/memcached_broker.rb

@@ -0,0 +1,120 @@
+require 'rhcp/broker'
+require 'memcache'
+
+module RHCP
+
+  class MemcachedBroker < Broker
+
+    def initialize(wrapped_broker, memcached_server = "127.0.0.1:11211", expiration_seconds = 3600)
+      super()
+      @wrapped_broker = wrapped_broker
+      
+      @cache = MemCache.new(
+        [memcached_server]
+      )
+      @expiry_seconds = expiration_seconds
+    end
+
+    # TODO would be nice if we could turn the caching on and off through commands
+    
+    def get_command_list(context = RHCP::Context.new())
+      @wrapped_broker.get_command_list(context)
+    end
+
+    def register_command(command)
+      @wrapped_broker.register_command(command)
+    end
+
+    def clear
+      @wrapped_broker.clear()
+    end
+    
+    def get_lookup_values(request, param_name)
+      sorted_param_values = []
+      request.param_values.keys.sort.each do |key|
+        sorted_param_values << request.param_values[key]
+      end
+      cache_key = 'lookup_' + request.command.name + '_' + sorted_param_values.join('|')
+
+      result = nil
+      if ((request.context == nil) or (not request.context.cookies.has_key?('__caching.disable')))
+        result = @cache.get(cache_key)
+      end
+      
+      if result == nil then
+        result = @wrapped_broker.get_lookup_values(request, param_name)
+        @cache.add(cache_key, result, @expiry_seconds)
+      end
+
+      result
+    end
+    
+    def execute(request)
+      command = get_command(request.command.name, request.context)
+  
+      result = nil
+  
+      # construct the cache key out of the command name and all parameter values
+      sorted_param_values = []
+      request.param_values.keys.sort.each do |key|
+        sorted_param_values << request.param_values[key]
+      end
+      cache_key = request.command.name + '_' + sorted_param_values.join('|')
+  
+      should_read_from_cache = 
+        (command.is_read_only) &&
+        ( (not command.result_hints.has_key?(:cache)) || (command.result_hints[:cache]) ) &&
+        ((request.context == nil) or (not request.context.cookies.has_key?('__caching.disable')))
+  
+      if should_read_from_cache
+        cached_response_json = @cache.get(cache_key)
+        if cached_response_json
+          #cached_response = JSON.parse(cached_response_json)
+          cached_response = RHCP::Response.reconstruct_from_json(cached_response_json)
+          $logger.debug("got data from cache for #{cache_key}")
+          cached_data = cached_response.data
+          
+          # TODO why don't we just throw back the response?
+          response = RHCP::Response.new()          
+          response.data = cached_data
+          response.status = RHCP::Response::Status::OK
+          
+          # all context that has been sent with the request should be sent back
+          response.context = request.context.cookies
+          
+          # also, we want to add all context that has been returned by the cached response
+          if cached_response.context != nil then
+            if response.context == nil then
+              response.context = {}
+            end
+            $logger.debug("merging in context from cached response : #{cached_response.context}")
+            cached_response.context.each do |k,v|
+              response.context[k] = v
+            end
+          end
+          
+          response.created_at = cached_response.created_at 
+          
+          result = cached_data
+        else
+  
+        end
+      end
+  
+      if result == nil
+        response = @wrapped_broker.execute(request)
+  
+        # TODO we might want to store the result in memcached nevertheless
+        if should_read_from_cache
+          # TODO do we want to cache failed command executions as well?
+          $logger.debug("storing data in cache for : #{cache_key}")
+          @cache.add(cache_key, response.to_json, @expiry_seconds)
+        end
+      end
+  
+      response
+    end
+  
+  end
+    
+end