rhcp 0.2.17 → 0.2.18

data/lib/rhcp.rb

@@ -23,7 +23,7 @@ module RHCP #:nodoc:
     
     MAJOR = 0
     MINOR = 2
-    TINY  = 17
+    TINY  = 18
 
     def Version.to_s
       [ MAJOR, MINOR, TINY ].join(".")

data/lib/rhcp/client/context_aware_broker.rb

@@ -23,7 +23,11 @@ module RHCP
       def get_command_list(context=@context)
         @wrapped_broker.get_command_list(context)
       end
-
+      
+      def known_commands
+        @wrapped_broker.known_commands
+      end               
+      
       def give_the_request_some_context_rico(request)
         # TODO think about the errors of your ways, son...
         @context.cookies.each do |k,v|

data/lib/rhcp/command.rb

@@ -32,6 +32,8 @@ module RHCP
     # "true" if this command returns data, but does not modify anything.
     attr_reader :is_read_only
 
+    attr_reader :accepts_extra_params
+    
     # an array of context keys that enable this command
     # 
     # if at least one of the listed keys is found in the context, the command
@@ -56,6 +58,9 @@ module RHCP
       @default_param = nil
       @is_read_only = false
       @enabled_through_context_keys = nil
+      
+      @accepts_extra_params = false
+      
       # 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 = {
@@ -106,6 +111,11 @@ module RHCP
       @is_read_only = true
       self
     end
+    
+    def accept_extra_params()
+      @accepts_extra_params = true
+      self
+    end
 
     # returns the specified CommandParam
     # or throws an RhcpException if the parameter does not exist
@@ -115,7 +125,7 @@ module RHCP
       end
       
       # there shouldn't be none
-      raise RHCP::RhcpException.new("no such parameter : #{param_name}") unless existing_params.size > 0
+      raise RHCP::RhcpException.new("undefined parameter '#{param_name}' in '#{self.name}'") unless existing_params.size > 0
       
       # there can be only one
       raise RHCP::RhcpException.new("BUG: duplicate parameters found") if existing_params.size > 1
@@ -140,8 +150,14 @@ module RHCP
       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)
+      begin
+        request.param_values.each do |key,value|
+          get_param(key).check_param_is_valid(request, value)
+        end
+      rescue Exception => ex
+        if (/undefined\sparameter/.match(ex.message))
+          raise RHCP::RhcpException.new(ex.message) unless @accepts_extra_params 
+        end
       end
 
       # check that we've got all mandatory params

data/lib/rhcp/context.rb

@@ -9,9 +9,12 @@ module RHCP
     # hash holding context information; similar to HTTP cookies
     # TODO should we actually use cookies for transporting this info?
     attr_accessor :cookies
+    attr_accessor :request_context_id
     
-    def initialize(cookies = {})
+    def initialize(cookies = {}, request_context_id = nil)
       @cookies = cookies
+      @request_context_id = request_context_id
+      @request_counter = 0
     end       
     
     # def to_json(*args)
@@ -29,6 +32,10 @@ module RHCP
       # instance
     # end
 
+    def incr_and_get_request_counter()
+      @request_counter += 1
+    end
+    
     def to_s
       result = "<Context with #{@cookies.size} cookies>"
       # @cookies.each do |k,v|

data/lib/rhcp/request.rb

@@ -14,6 +14,7 @@ module RHCP
     attr_reader :command
     attr_reader :param_values
     attr_reader :context
+    attr_reader :request_count
 
     # default constructor; will throw exceptions on invalid values
     def initialize(command, some_param_values = {}, context = RHCP::Context.new())
@@ -23,7 +24,8 @@ module RHCP
       @logger.debug "initializing request #{command.name} with params #{param_values}"
 
       @context = context
-
+      @request_count = @context.incr_and_get_request_counter()
+        
       command.params.each do |param|
         
         value_from_context = param.find_value_in_context(context)
@@ -119,7 +121,8 @@ module RHCP
       {
         :command_name => @command.name,
         :param_values => @param_values,
-        :context => @context
+        :context => @context,
+        :request_count => @request_count
       }
     end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rhcp
 version: !ruby/object:Gem::Version 
-  hash: 53
+  hash: 51
   prerelease: false
   segments: 
   - 0
   - 2
-  - 17
-  version: 0.2.17
+  - 18
+  version: 0.2.18
 platform: ruby
 authors: 
 - Philipp Traeder
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-07 00:00:00 +01:00
+date: 2012-01-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,7 +59,6 @@ files:
 - lib/rhcp/broker.rb
 - lib/rhcp/context.rb
 - lib/rhcp/command.rb
-- lib/rhcp/memcached_broker.rb
 - test/rhcp/test_base.rb
 - test/rhcp/command_param_test.rb
 - test/rhcp/context_aware_broker_test.rb

data/lib/rhcp/memcached_broker.rb

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