rhcp 0.1.2 → 0.1.3

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.1.2 / 2008-12-07
+
+* initial version
+
+  * nothing to snothing to see here....
+

data/Manifest.txt

@@ -0,0 +1,4 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile

data/README.txt

@@ -0,0 +1,48 @@
+= RHCP
+
+* http://rhcp.rubyforge.org
+
+== DESCRIPTION:
+
+RHCP is a protocol designed for building up a command-metadata-based communication infrastructure making it easier for application developers to export commands in applications to generic clients.
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -20,7 +20,7 @@ Rake::TestTask.new() { |t|
   t.libs << "lib"
   t.libs << "test"
   t.libs << "test/rhcp"
-  t.test_files = FileList['test/rhcp/*_test.rb']
+  t.test_files = FileList['test/rhcp/**/*_test.rb']
   t.verbose = true
 }
 
@@ -114,3 +114,12 @@ Rake::GemPackageTask.new(spec) do |p|
   p.need_tar = true
   p.need_zip = true
 end
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.new('rhcp', PKG_VERSION) do |p|
+  # p.rubyforge_name = 'rhcp' # if different than lowercase project name
+  p.developer('Philipp T.', 'philipp@hitchhackers.net')
+end
+

metadata

@@ -1,87 +1,69 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: rhcp
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
-date: 2008-12-07 00:00:00 +01:00
-summary: Library for exporting parts of your application using the rhcp protocol
-require_paths: 
-- lib
-email: philipp@hitchhackers.net
-homepage: http://hitchhackers.net/projects/rhcp
-rubyforge_project: rhcp
-description: The rhcp protocol allows you to register commands along with their parameter descriptions and some metadata that can then be executed by rhcp clients.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.1.3
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: |+
-  
-      This is the initial release of rhcp - hope you'll like it.
-      Feel free to send me feedback to rhcp at hitchhackers dot net.
-  
 authors: 
-- Philipp Traeder
-files: 
-- Rakefile
-- lib/rhcp
-- lib/rhcp/client
-- lib/rhcp/client/http_broker.rb
-- lib/rhcp/client/command_param_stub.rb
-- lib/rhcp/client/command_stub.rb
-- lib/rhcp/command.rb
-- lib/rhcp/command_param.rb
-- lib/rhcp/response.rb
-- lib/rhcp/dispatching_broker.rb
-- lib/rhcp/broker.rb
-- lib/rhcp/http_exporter.rb
-- lib/rhcp/request.rb
-- lib/rhcp/rhcp_exception.rb
-- lib/rhcp.rb
-- test/rhcp
-- test/rhcp/client
-- test/rhcp/client/command_param_stub_test.rb
-- test/rhcp/client/command_stub_test.rb
-- test/rhcp/command_param_test.rb
-- test/rhcp/command_test.rb
-- test/rhcp/response_test.rb
-- test/rhcp/dispatching_broker_test.rb
-- test/rhcp/broker_test.rb
-- test/rhcp/http_test_server.rb
-- test/rhcp/http_exporter_test.rb
-- test/rhcp/http_registry_test.rb
-- test/rhcp/request_test.rb
-test_files: 
-- test/rhcp/client/command_param_stub_test.rb
-- test/rhcp/client/command_stub_test.rb
-- test/rhcp/command_param_test.rb
-- test/rhcp/command_test.rb
-- test/rhcp/response_test.rb
-- test/rhcp/dispatching_broker_test.rb
-- test/rhcp/broker_test.rb
-- test/rhcp/http_test_server.rb
-- test/rhcp/http_exporter_test.rb
-- test/rhcp/http_registry_test.rb
-- test/rhcp/request_test.rb
-rdoc_options: []
-
-extra_rdoc_files: []
+- Philipp T.
+autorequire: 
+bindir: bin
+cert_chain: []
 
+date: 2009-01-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: RHCP is a protocol designed for building up a command-metadata-based communication infrastructure making it easier for application developers to export commands in applications to generic clients.
+email: 
+- philipp@hitchhackers.net
 executables: []
 
 extensions: []
 
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+has_rdoc: true
+homepage: http://rhcp.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: rhcp
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: RHCP is a protocol designed for building up a command-metadata-based communication infrastructure making it easier for application developers to export commands in applications to generic clients.
+test_files: []
 

data/lib/rhcp.rb

@@ -1,47 +0,0 @@
-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/lib/rhcp/broker.rb

@@ -1,37 +0,0 @@
-module RHCP
-
-  # Applications register the commands they are implementing at a broker.
-  # The broker holds the list of commands and is the central entry point for
-  # all code that wants to export/publish these commands  
-  class Broker
-    
-    def initialize
-      # command_name => command
-      @known_commands = Hash.new()
-    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
-    
-    # registers a new command - this method should be called by the application
-    # providing the command
-    def register_command(command)
-      raise RHCP::RhcpException.new("duplicate command name : #{command.name}") if @known_commands.has_key?(command.name)
-      @known_commands[command.name] = command
-    end
-    
-    # removes all commands that have been registered previously
-    def clear
-      @known_commands = Hash.new()
-    end
-
-  end
-end

data/lib/rhcp/client/command_param_stub.rb

@@ -1,51 +0,0 @@
-require 'rhcp/command_param'
-
-module RHCP
-  
-  module Client
-    
-      # This is a proxy representing a remote CommandParam - see
-      # RHCP::CommandParam for details
-      class CommandParamStub < RHCP::CommandParam
-        
-        # the block that should be executed when +get_lookup_values()+ is called
-        # on this CommandParamStub
-        attr_accessor :get_lookup_values_block
-        
-        # when constructing a CommandParamStub, the +:lookup_method+ option is 
-        # set to +remote_get_lookup_values+ so that a method can be injected
-        # from outside that will retrieve the lookup values (using the
-        # +get_lookup_values_block+ property).
-        def initialize(name, description, options)
-          # we don't need to stub anything if the method does not have lookup values
-          if (options[:has_lookup_values])
-            options[:lookup_method] = self.method(:remote_get_lookup_values)
-          end
-          super(name, description, options)
-        end
-        
-        def self.reconstruct_from_json(json_data)
-          object = json_data.instance_of?(Hash) ? json_data : JSON.parse(json_data)
-          args = object.values_at('name', 'description')
-          args << {
-            :allows_multiple_values => object['allows_multiple_values'],
-            :has_lookup_values => object['has_lookup_values'],
-            :is_default_param => object['is_default_param'],
-            :mandatory => object['mandatory']
-          }
-          self.new(*args)
-        end
-        
-        def remote_get_lookup_values(partial_value = "")
-          @get_lookup_values_block.call(partial_value)
-        end
-        
-      end      
-
-  end
-  
-end
-
- 
-
-

data/lib/rhcp/client/command_stub.rb

@@ -1,56 +0,0 @@
-require 'rhcp/command'
-require 'rhcp/client/command_param_stub'
-require 'rubygems'
-require 'json'
-
-
-module RHCP
-  
-  module Client
-    
-      # This is a stub that represents a remote RHCP::Command.
-      # Instances of this class will live in a client that uses one of the brokers
-      # from the RHCP::Client package. The interesting aspect about this stub is
-      # that the execute method is modified so that it does not execute the
-      # command directly, but can be modified from outside (by setting the
-      # +execute_block+ property) so that broker classes can inject their
-      # remote invocation logic.
-      class CommandStub < RHCP::Command
-        
-        attr_accessor :execute_block
-        
-        # constructs a new instance
-        # should not be invoked directly, but is called from +reconstruct_from_json+
-        def initialize(name, description)
-          super(name, description, lambda {})
-        end
-        
-        # builds a CommandStub out of some json data (either serialized as string
-        # or already unpacked into a ruby-hash)
-        # all nested params are unmarshalled as RHCP::CommandParamStub instances
-        # so that we are able to inject the logic for invoking get_lookup_values
-        # remotely
-        def self.reconstruct_from_json(json_data)
-          object = json_data.instance_of?(Hash) ? json_data : JSON.parse(json_data)
-          args = object.values_at('name', 'description')
-          instance = self.new(*args)
-          object['params'].each do |p|
-            param = RHCP::Client::CommandParamStub.reconstruct_from_json(p)
-            instance.add_param(param)
-          end
-          instance
-        end        
-        
-        # we don't want to execute the command block as the normal RHCP::Command
-        # does, but rather want to call the block injected by the registry that
-        # has created this stub.
-        def execute_request(request)
-          @execute_block.call(request)
-        end
-      end      
-      
-    end
-    
-end
-
-

data/lib/rhcp/client/http_broker.rb

@@ -1,86 +0,0 @@
-#require 'rhcp/rhcp'
-require 'rhcp/broker'
-require 'rhcp/rhcp_exception'
-require 'rhcp/client/command_stub'
-require 'net/http'
-require 'json'
-
-module RHCP
-  
-  module Client
-    
-      # 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.
-      # TODO shouldn't this descent from Broker?
-      class HttpBroker
-
-        def initialize(url)
-          # TODO should this really be an URL? or just a host name?
-          @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/") }
-          if (res.code == "200")
-            @logger.info "connected to '#{@url}' successfully."
-          else
-            @logger.error "cannot connect to '#{@url}' : got http status code #{res.code}"
-            raise RHCP::RhcpException.new("could not connect to '#{@url}' : got http status code #{res.code} (#{res.message})");
-          end
-        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") }   
-          if (res.code != "200")
-            raise RHCP::RhcpException.new("could not retrieve command list from remote server : http status #{res.code} (#{res.message})")
-          end
-          
-          @logger.debug "raw response : >>#{res.body}<<"
-
-          # the commands are transferred as array => convert into hash
-          command_array = JSON.parse(res.body)
-          commands = Hash.new()
-          command_array.each do |command_string|
-            command = RHCP::Client::CommandStub.reconstruct_from_json(command_string)
-            commands[command.name] = command
-            # and inject the block for executing over http
-            command.execute_block = lambda {
-              |req|
-              @logger.debug("executing command #{command.name} via http using #{@url}")
-              
-              res = Net::HTTP.new(@url.host, @url.port).start { |http| http.post("/rhcp/execute", req.to_json()) }
-              if (res.code != "200")
-                raise RHCP::RhcpException.new("could not execute command using remote server : http status #{res.code} (#{res.message})")
-              end
-              
-              json_response = RHCP::Response.reconstruct_from_json(res.body)
-              @logger.debug "json response : #{json_response}"
-              json_response
-            }
-            
-            # inject appropriate blocks for all params
-            command.params.each do |name, param|
-              param.get_lookup_values_block = lambda {
-                |partial_value|
-                @logger.debug("getting lookup values for param #{name} of command #{command.name} using #{@url}")
-                # TODO add caching for lookup values
-                res = Net::HTTP.new(@url.host, @url.port).start { |http| 
-                  http.get("/rhcp/get_lookup_values?command=#{command.name}&param=#{name}") 
-                }   
-                if (res.code != "200")
-                  raise RHCP::RhcpException.new("could not retrieve lookup values from remote server : http status #{res.code} (#{res.message})")
-                end
-                JSON.parse(res.body)
-              }
-            end
-          end
-          commands
-        end
-
-      end
-
-    end
-    
-end