hoth 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Dirk Breuer
+
+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/README.rdoc

@@ -0,0 +1,18 @@
+= hoth
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Dirk Breuer. See LICENSE for details.

data/lib/hoth.rb

@@ -0,0 +1,23 @@
+require 'singleton'
+
+require 'active_support/inflector'
+
+require 'hoth/transport/hoth_transport'
+require 'hoth/transport/json_transport'
+require 'hoth/transport/bert_transport'
+require 'hoth/transport/workling_transport'
+
+require 'hoth/definition'
+require 'hoth/deployment_module'
+require 'hoth/endpoint'
+require 'hoth/service'
+require 'hoth/service_deployment'
+require 'hoth/service_registry'
+require 'hoth/services'
+
+require 'hoth/util/logger'
+
+require 'hoth/extension/core/exception'
+require 'hoth/exceptions'
+
+Hoth::Logger.init_logging!

data/lib/hoth/definition.rb

@@ -0,0 +1,7 @@
+module Hoth
+  class Definition
+    def service(service_name, options = {})
+      service = ServiceRegistry.add_service(Service.new(service_name, options))
+    end
+  end
+end

data/lib/hoth/deployment_module.rb

@@ -0,0 +1,41 @@
+module Hoth
+  class DeploymentModule
+    attr_accessor :name, :environments
+
+    class Environment
+      attr_accessor :endpoint, :deployment_options
+      
+      def initialize(attributes = {})
+        @endpoint           = attributes[:endpoint]
+        @deployment_options = attributes[:deployment_options]
+      end
+      
+      def propagate_module_name_to_endpoint(module_name)
+        @endpoint.module_name = module_name
+      end
+    end
+    
+    def initialize(attributes = {})
+      @environments = {}
+      @name = attributes[:name]
+    end
+    
+    def env(*options)
+      attributes = Hash === options.last ? options.pop : {}
+      options.each do |env_name|
+        @environments[env_name.to_sym] = Environment.new(attributes)
+        @environments[env_name.to_sym].propagate_module_name_to_endpoint(@name)
+      end
+      self
+    end
+    
+    def [](env_name)
+      @environments[env_name.to_sym]
+    end
+    
+    def path(path = nil)
+      path.nil? ? @path : @path = path
+    end
+
+  end
+end

data/lib/hoth/endpoint.rb

@@ -0,0 +1,25 @@
+module Hoth
+  class Endpoint
+    attr_accessor :host, :port, :module_name, :transport_type
+
+    def initialize(attributes)
+      @host           = attributes[:host]
+      @port           = attributes[:port]
+      @module_name    = attributes[:module_name]
+      @transport_type = attributes[:transport_type]
+    end
+
+    def ==(endpoint)
+      self.host == endpoint.host &&
+        self.port == endpoint.port
+    end
+
+    def to_url
+      "http://#{@host}:#{@port}/execute"
+    end
+    
+    def is_local?
+      ENV["LOCAL"] == "true" ? true : false # make dynamic
+    end
+  end
+end

data/lib/hoth/exceptions.rb

@@ -0,0 +1,13 @@
+module Hoth
+  class HothException < StandardError
+    attr_reader :original
+    def self.wrap(original)
+      wrapped = new("#{original.class} says: #{original.message}")
+      wrapped.set_backtrace original.backtrace
+      wrapped.instance_variable_set :@original, original
+      wrapped
+    end
+  end
+
+  class TransportError < HothException; end
+end

data/lib/hoth/extension/core/exception.rb

@@ -0,0 +1,15 @@
+class Exception
+  def to_json(*a)
+    {
+      'json_class'   => self.class.name,
+      'message'      => self.message,
+      'backtrace'    => self.backtrace
+    }.to_json(*a)
+  end
+  
+  def self.json_create(hash)
+    exception = new(hash["message"])
+    exception.set_backtrace hash['backtrace']
+    exception
+  end
+end

data/lib/hoth/providers/bertrpc_provider.rb

@@ -0,0 +1,35 @@
+require 'ernie'
+
+module Hoth
+  module Providers
+    class BertRPCProvider
+      
+      def self.create_ernie_definition
+        Ernie.log "Possible Service implementations: #{Object.constants.grep(/.*Impl$/).inspect}"
+        Object.constants.grep(/.*Impl$/).each do |impl_class_name|
+          if impl_class = Object.const_get(impl_class_name) #&& impl_class.respond_to?(:execute)
+            Ernie.log "Service implementation was loaded! (#{impl_class.inspect})"
+            if impl_class.respond_to?(:execute)
+              service_name = impl_class_name.gsub("Impl", "").underscore.to_sym
+              mod(service_name) do
+                fun(:execute) do |*args|
+                  return_value = begin
+                    Hoth::Transport::BertTransport::TuplePreparer.prepare(Hoth::Services.send(service_name, *args))
+                  rescue Exception => e
+                    Ernie.log %Q{An Exception occured: #{e.message} -- #{e.backtrace.join("\n\t")}}
+                    false
+                  end
+                end
+              end
+            else
+              Ernie.log "Implementation wasn't applicatable. :execute method is missing!"
+            end
+          else
+            Ernie.log "Service implementation was not loaded! (#{impl_class_name.inspect})"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hoth/providers/rack_provider.rb

@@ -0,0 +1,33 @@
+require 'rack/request'
+require 'json'
+
+module Hoth
+  module Providers
+    class RackProvider
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env["PATH_INFO"] =~ /^\/execute/
+          begin
+            req = Rack::Request.new(env)
+
+            service_name   = req.params["name"]
+            service_params = req.params["params"]
+            json_payload   = JSON({"result" => Hoth::Services.send(service_name, service_params)})
+          
+            [200, {'Content-Type' => 'application/json', 'Content-Length' => "#{json_payload.length}"}, json_payload]
+          rescue Exception => e
+            json_payload = JSON({'error' => e})
+            [500, {'Content-Type' => 'application/json', 'Content-Length' => "#{json_payload.length}"}, json_payload]
+          end
+        else
+          @app.call(env)
+        end
+      end
+
+    end
+  end
+end

data/lib/hoth/service.rb

@@ -0,0 +1,36 @@
+module Hoth
+  class Service
+    attr_accessor :name, :endpoint, :params, :return_value
+    
+    def initialize(name, args = {})
+      @name         = name
+      @endpoint     = ServiceDeployment.module(args[:endpoint])[Services.env].endpoint
+      @params       = args[:params]
+      @return_value = args[:returns]
+    end
+    
+    def transport
+      @transport ||= "hoth/transport/#{endpoint.transport_type}_transport".camelize.constantize.new(self)
+    end
+    
+    def service_impl_class
+      @service_impl_class_name ||= "#{self.name.to_s.camelize}Impl"
+      # in Rails development environment we cannot cache the class constant, because it gets unloaded, so you get 
+      # an "A copy of xxxImpl has been removed from the module tree but is still active!" error from ActiveSupport dependency mechanism
+      # TODO: Try to solve this problem
+      # TODO: get rid of these Rails dependencies
+      @service_impl_class_name.constantize
+    end
+    
+    def execute(*args)
+      if self.endpoint.is_local?
+        decoded_params = transport.decode_params(*args)
+        Hoth::Logger.debug "decoded_params: #{decoded_params.inspect}"
+        result = service_impl_class.send(:execute, *decoded_params)
+        return return_value ? result : nil
+      else
+        transport.call_remote_with(*args)
+      end
+    end
+  end
+end

data/lib/hoth/service_deployment.rb

@@ -0,0 +1,27 @@
+module Hoth
+  class ServiceDeployment
+    include Singleton
+
+    attr_reader :deployment_modules
+
+    def self.define(&block)
+      instance.instance_eval(&block)
+    end
+
+    def self.module(module_name)
+      instance.deployment_modules[module_name]
+    end
+
+    def service_module(module_name, &block)
+      deployment_module = DeploymentModule.new(:name => module_name)
+      deployment_module.instance_eval(&block)
+      @deployment_modules[module_name] = deployment_module
+    end
+
+    private
+
+      def initialize
+        @deployment_modules = {}
+      end
+  end
+end

data/lib/hoth/service_registry.rb

@@ -0,0 +1,27 @@
+module Hoth
+  class ServiceRegistry
+    include Singleton
+    
+    def self.add_service(service)
+      instance.add_service(service)
+    end
+    
+    def self.locate_service(service_name)
+      instance.locate_service(service_name)
+    end
+    
+    def add_service(service)
+      @registry[service.name] = service
+    end
+    
+    def locate_service(service_name)
+      @registry[service_name]
+    end
+    
+    private
+    
+      def initialize
+        @registry = {}
+      end
+  end
+end

data/lib/hoth/services.rb

@@ -0,0 +1,23 @@
+module Hoth
+  class Services
+    def self.define(&block)
+      (@definition || Definition.new).instance_eval(&block)
+    end
+    
+    class <<self
+      attr_writer :env
+      
+      def env
+        @env.to_sym
+      end
+      
+      def method_missing(meth, *args, &blk)
+        if _service = ServiceRegistry.locate_service(meth)
+          _service.execute(*args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/hoth/transport/amqp_transport.rb

@@ -0,0 +1,7 @@
+module Hoth
+  module Transport
+    class AmqpTransport
+      
+    end
+  end
+end

data/lib/hoth/transport/bert_transport.rb

@@ -0,0 +1,87 @@
+require 'bert'
+require 'bertrpc'
+
+module Hoth
+  module Transport
+    class BertTransport < HothTransport
+      
+      class TuplePreparer
+        def self.prepare(obj)
+          case obj
+          when Array
+            obj.collect { |o| prepare o }
+          when Hash
+            obj.each { |k,v| obj[k] = prepare(v) }
+          else
+            ruby2tuple obj
+          end
+        end
+        
+        def self.ruby2tuple(ruby)
+          if ruby.respond_to? :to_serialize
+            tuple = t[ruby.class.name.underscore, {}]
+            ruby.to_serialize.each do |field|
+              tuple.last[field] = prepare(ruby.send(field))
+            end
+            tuple
+          else
+            ruby
+          end
+        end
+      end
+      
+      class Deserializer
+        def self.deserialize(data)
+          case data
+          when BERT::Tuple
+            tuple2ruby data
+          when Array
+            data.collect { |o| deserialize o }
+          when Hash
+            data.each { |k,v| data[k] = deserialize(v) }
+          else
+            data
+          end
+        end
+        
+        def self.tuple2ruby(tuple)
+          case tuple
+          when BERT::Tuple
+            begin
+              ruby_class = tuple.first.camelize.constantize
+              ruby_obj = ruby_class.new({})
+              ruby_obj.to_serialize.each do |field|
+                ruby_obj.send("#{field}=", deserialize(tuple.last[field]))
+              end
+              
+              ruby_obj
+            rescue NameError => e
+              puts %Q{An Exception occured: #{e.message} -- #{e.backtrace.join("\n\t")}}
+              tuple
+            end
+          else
+            puts "Was not anything we could decode!"
+            tuple
+          end
+        end
+      end
+      
+      def call_remote_with(*args)
+        bert_service = BERTRPC::Service.new(self.endpoint.host, self.endpoint.port)
+        
+        response = bert_service.call.send(self.name).execute(*TuplePreparer.prepare(args))
+        
+        if self.return_value
+          return Deserializer.deserialize(response)
+        else
+          return true
+        end
+      end
+      
+      def decode_params(params)
+        Deserializer.deserialize(params)
+      end
+      
+    end
+  end
+end

data/lib/hoth/transport/hoth_transport.rb

@@ -0,0 +1,16 @@
+require 'forwardable'
+
+module Hoth
+  module Transport
+    class HothTransport
+      extend Forwardable
+      
+      def_delegators :@service_delegate, :name, :endpoint, :params, :return_value
+      
+      def initialize(service_delegate)
+        @service_delegate = service_delegate
+      end
+      
+    end
+  end
+end

data/lib/hoth/transport/json_transport.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'net/http'
+
+module Hoth
+  module Transport
+    class JsonTransport < HothTransport     
+      def call_remote_with(*args)
+        response = Net::HTTP.post_form(
+          URI.parse(self.endpoint.to_url),
+          { 'name' => self.name.to_s, 'params' => "#{args.to_json}" }
+        )
+        
+        if return_value
+          case response
+          when Net::HTTPSuccess
+            Hoth::Logger.debug "response.body: #{response.body}"
+            JSON(response.body)["result"]
+          when Net::HTTPServerError
+            begin
+              raise JSON(response.body)["error"]
+            rescue JSON::ParserError => jpe
+              raise TransportError.wrap(jpe)
+            end
+          when Net::HTTPRedirection, Net::HTTPClientError, Net::HTTPInformation, Net::HTTPUnknownResponse
+            #TODO Handle redirects(3xx) and http errors(4xx), http information(1xx), unknown responses(xxx)
+            raise NotImplementedError, "HTTP code: #{response.code}, message: #{response.message}"
+          end
+        else
+          response.is_a?(Net::HTTPSuccess)
+        end
+      end
+      
+      def decode_params(params)
+        Hoth::Logger.debug "Original params before decode: #{params.inspect}"
+        JSON.parse(params)
+      rescue JSON::ParserError => jpe
+        raise TransportError.wrap(jpe)
+      end
+      
+    end
+  end
+end

data/lib/hoth/transport/workling_transport.rb

@@ -0,0 +1,27 @@
+begin
+  require 'simple_publisher'
+rescue LoadError
+  STDERR.puts "You need the simple_publisher gem if you want to use Workling/Starling transport."
+end
+
+module Hoth
+  module Transport
+    
+    class WorklingTransport < HothTransport
+      
+      def call_remote_with(*args)
+        topic      = SimplePublisher::Topic.new(:name => "#{endpoint.module_name.to_s.underscore}_subscribers__#{name.to_s.underscore}")
+        connection = SimplePublisher::StarlingConnection.new(:host => endpoint.host, :port => endpoint.port)
+
+        publisher = SimplePublisher::Publisher.new(:topic => topic, :connection => connection)
+        publisher.publish(args)
+      end
+      
+      def decode_params(*params)
+        params
+      end
+      
+    end
+    
+  end
+end

data/lib/hoth/util/logger.rb

@@ -0,0 +1,46 @@
+module Hoth
+  class Logger
+    class <<self
+      
+      def log_provider=(log_provider)
+        @log_provider = log_provider
+      end
+      
+      def init_logging!
+        Hoth::Logger.log_provider = if Object.const_defined?("Rails")
+          Rails.logger
+        else
+          require 'logger'
+          ::Logger.new("/tmp/hoth.log")
+        end
+      end
+      
+      def debug(msg)
+        log_provider.debug msg
+      end
+      
+      def info(msg)
+        log_provider.info msg
+      end
+      
+      def warn(msg)
+        log_provider.warn msg
+      end
+      
+      def error(msg)
+        log_provider.error msg
+      end
+      
+      def fatal(msg)
+        log_provider.fatal msg
+      end
+      
+      private
+      
+        def log_provider
+          @log_provider || init_logging!
+        end
+    end
+        
+  end
+end

data/spec/hoth_spec.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'hoth'
+require 'spec'
+require 'spec/autorun'
+
+Hoth::Services.env = "test"
+
+Spec::Matchers.define :string_matching do |regex|
+  match do |string|
+    string =~ regex
+  end
+end

data/spec/unit/definition_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Hoth::Definition do
+  
+  it "should create a Service and add it to the registry instance" do
+    service_name = :my_service
+    service_options = {
+      :params   => [:some_params],
+      :returns  => nil,
+      :endpoint => :my_service_module
+    }
+
+    service = mock("ServiceMock")
+    Hoth::Service.should_receive(:new).with(service_name, service_options).and_return(service)
+    Hoth::ServiceRegistry.should_receive(:add_service).with(service)
+    
+    definition = Hoth::Definition.new
+    definition.service service_name, service_options
+  end
+  
+end

data/spec/unit/deployment_module_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Hoth::DeploymentModule do
+  
+  it "should have a name" do
+    deployment_module = Hoth::DeploymentModule.new :name => :my_service_module
+    deployment_module.name.should equal(:my_service_module)
+  end
+  
+  it "should have an environment" do
+    deployment_module = Hoth::DeploymentModule.new(:name => "deployment_module_name")
+    
+    env_specific_options = {:endpoint => endpoint = mock("EndpointMock"), :deployment_options => "deployment_options"}
+    endpoint.should_receive(:module_name=).with("deployment_module_name").exactly(3).times
+    deployment_module.env :test, env_specific_options
+    deployment_module[:test].should be_a(Hoth::DeploymentModule::Environment)
+
+    deployment_module.env :staging, :production, env_specific_options
+    deployment_module[:staging].should be_a(Hoth::DeploymentModule::Environment)
+    deployment_module[:production].should be_a(Hoth::DeploymentModule::Environment)
+    
+    [:test, :staging, :production].each do |environment|
+      deployment_module[environment].endpoint.should == endpoint
+      deployment_module[environment].deployment_options.should == "deployment_options"
+    end
+  end
+  
+  it "should have a path pointing to the service root" do
+    deployment_module = Hoth::DeploymentModule.new
+    deployment_module.path "services_dir/my_service"
+    deployment_module.path.should == "services_dir/my_service"
+  end
+
+  describe Hoth::DeploymentModule::Environment do
+    it "should have an endpoint" do
+      endpoint_mock = mock("Hoth::Endpoint", :null_object => true)
+      
+      env = Hoth::DeploymentModule::Environment.new(:endpoint => endpoint_mock)
+      env.endpoint.should equal(endpoint_mock)
+    end
+
+    it "should have deployment options" do
+      some_options = {:server_instances => 5}
+      
+      env = Hoth::DeploymentModule::Environment.new(:deployment_options => some_options)
+      env.deployment_options.should equal(some_options)
+    end
+    
+    it "should set propagate the module_name of the enclosing DeploymentModule to its endpoint" do
+      endpoint = mock("Hoth::Endpoint", :null_object => true)
+      endpoint.should_receive(:module_name=).with("deployment_module_name")
+      
+      env = Hoth::DeploymentModule::Environment.new(:endpoint => endpoint)
+      env.propagate_module_name_to_endpoint("deployment_module_name")
+    end
+  end
+  
+end

data/spec/unit/endpoint_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Hoth::Endpoint do
+  
+  it "should have a port" do
+    endpoint = Hoth::Endpoint.new(:port => 3000)
+    endpoint.port.should == 3000
+  end
+  
+  it "should have a host name" do
+    endpoint = Hoth::Endpoint.new(:host => "example.com")
+    endpoint.host.should == "example.com"
+  end
+  
+  it "should have a transport type" do
+    endpoint = Hoth::Endpoint.new(:transport_type => :json)
+    endpoint.transport_type.should == :json
+  end
+  
+  it "should should cast itself to URL string" do
+    endpoint = Hoth::Endpoint.new(:port => 3000, :host => "example.com")
+    endpoint.to_url.should == "http://example.com:3000/execute"
+  end
+  
+  it "should compare to another endpoint" do
+    json_endpoint = Hoth::Endpoint.new(
+      :port => 3000,
+      :host => "example.com",
+      :transport_type => :json
+    )
+
+    bert_endpoint = Hoth::Endpoint.new(
+      :port => 3000,
+      :host => "example.com",
+      :transport_type => :bert
+    )
+    
+    json_endpoint.should equal(json_endpoint)
+    json_endpoint.should_not equal(bert_endpoint)
+  end
+  
+  it "should know if it is local or not" do
+    endpoint = Hoth::Endpoint.new({})
+    endpoint.is_local?.should_not be(nil)
+  end
+  
+  it "should should know the deployment module this endpoint is associated to" do
+    endpoint = Hoth::Endpoint.new(:module_name => "TestModule")
+    endpoint.module_name.should == "TestModule"
+  end
+  
+end

data/spec/unit/extension/core/exception_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../',  'spec_helper'))
+
+describe Exception do
+  
+  it "should be able to create json with empty backtrace" do
+    e = Exception.new "message"
+    e.to_json.should == "{\"json_class\":\"Exception\",\"message\":\"message\",\"backtrace\":null}"
+  end
+  
+  it "should be able to create json with backtrace" do
+    e = Exception.new "message"
+    e.set_backtrace ["back", "trace"]
+    e.to_json.should == "{\"json_class\":\"Exception\",\"message\":\"message\",\"backtrace\":[\"back\",\"trace\"]}"
+  end
+  
+  it "should be able to deserialize exception from json" do
+    e = Exception.new "message"
+    e.set_backtrace ["back", "trace"]
+    deserialized = JSON(e.to_json)
+    deserialized.message.should == "message"
+    deserialized.backtrace.should == ["back", "trace"]
+  end
+  
+  it "should be able to serialize and deserialize descendants of the Exception class" do
+    class ExceptionSpec <  Exception; end
+    e = ExceptionSpec.new "message"
+    e.set_backtrace ["back", "trace"]
+    deserialized = JSON(e.to_json)
+    deserialized.message.should == "message"
+    deserialized.backtrace.should == ["back", "trace"]
+    deserialized.should be_a ExceptionSpec
+  end
+  
+end

data/spec/unit/providers/rack_provider_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../',  'lib', 'hoth', 'providers', 'rack_provider'))
+
+describe Hoth::Providers::RackProvider do
+  it "should be able to handle exceptions" do
+    app = stub("ApplicationStub").as_null_object
+    middleware = Hoth::Providers::RackProvider.new app
+    env = {"PATH_INFO" => "/execute/some_method", "other_params" => nil}
+    Rack::Request.should_receive(:new).and_raise(RuntimeError)
+    
+    rack_response = middleware.call env
+    rack_response.first.should == 500 #status code
+    rack_response.last.should match('json_class')
+    rack_response.last.should match('RuntimeError')
+  end
+end

data/spec/unit/service_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+class TestServiceImpl
+  def self.execute(param1, param2)
+    
+  end
+end
+
+describe Hoth::Service do
+  
+  before(:each) do
+    Hoth::ServiceDeployment.should_receive(:module).
+                            and_return({:test => stub(:endpoint => stub("Endpoint"))})
+    
+    @service = Hoth::Service.new("TestService",
+      :endpoint => "test_module",
+      :params   => ["parameter", "another_parameter"],
+      :returns  => [:some_data]
+    )
+  end
+  
+  it "should have a name and an endpoint based ob the deployment definition" do
+    Hoth::ServiceDeployment.should_receive(:module).
+                            with("test_module").
+                            and_return({:test => mock("DeploymentModule", :endpoint => stub("Endpoint"))})
+    
+    service = Hoth::Service.new("TestService", :endpoint => "test_module")
+    service.name.should == "TestService"
+  end
+  
+  it "should define parameters and return values" do
+    Hoth::ServiceDeployment.should_receive(:module).
+                            and_return({:test => stub(:endpoint => stub("Endpoint"))})
+    
+    service = Hoth::Service.new("TestService",
+      :endpoint => "test_module",
+      :params   => ["parameter", "another_parameter"],
+      :returns  => [:some_data]
+    )
+    
+    service.params.should == ["parameter", "another_parameter"]
+    service.return_value.should == [:some_data]
+  end
+  
+  it "should execute the service stub locally based on the endpoint" do
+    @service.should_receive(:endpoint).and_return(mock("Endpoint", :is_local? => true))
+    transport_mock = mock("HothTranport")
+    transport_mock.should_receive(:decode_params).
+                   with(:arg1, :arg2).
+                   and_return([:decoded_arg1, :decoded_arg2])
+                   
+    @service.should_receive(:transport).and_return(transport_mock)
+    
+    @service.execute(:arg1, :arg2)
+  end
+  
+  it "should execute the service stub via transport based on the endpoint" do
+    
+  end
+  
+  it "should create transport instance based on endpoint" do
+    
+  end
+  
+end

data/spec/unit/transport/workling_transport_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Transport
+    
+    describe "WorklingTransport" do
+      
+      it "should send publish a message via SimplePublisher" do
+        endpoint = mock("EndpointMock")
+        endpoint.should_receive(:module_name).and_return("TestServiceModule")
+        endpoint.should_receive(:host).and_return("localhost")
+        endpoint.should_receive(:port).and_return("22122")
+        
+        service = mock("ServiceMock")
+        service.should_receive(:name).and_return("TestService")
+        service.should_receive(:endpoint).any_number_of_times.and_return(endpoint)
+        
+        SimplePublisher::Topic.should_receive(:new).with(:name => "test_service_module_subscribers__test_service").and_return(topic = mock("Topic"))
+        
+        SimplePublisher::StarlingConnection.should_receive(:new).with(:host => "localhost", :port => "22122").and_return(connection = mock("Connection"))
+        
+        SimplePublisher::Publisher.should_receive(:new).with(
+          :topic => topic,
+          :connection => connection
+        ).and_return(publisher = mock("PublisherMock"))
+
+        uid = "GC-123546"
+        email_address = "test@example.com"
+
+        publisher.should_receive(:publish).with([uid, email_address])
+        
+        transport = WorklingTransport.new(service)
+        transport.call_remote_with(uid, email_address)
+      end
+      
+      it "should decode params from a message wrapper" do
+        params_as_message = ["uid"]
+        
+        transport = WorklingTransport.new(mock("ServiceMock"))
+        transport.decode_params(*params_as_message).should == ["uid"]
+      end
+      
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification 
+name: hoth
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- pkw.de Development
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bertrpc
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: |
+  Creating a SOA requires a centralized location to define all services within the
+  SOA. Furthermore you want to know where to deploy those services.
+
+email: dev@pkw.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- README.rdoc
+- lib/hoth.rb
+- lib/hoth/definition.rb
+- lib/hoth/deployment_module.rb
+- lib/hoth/endpoint.rb
+- lib/hoth/exceptions.rb
+- lib/hoth/extension/core/exception.rb
+- lib/hoth/providers/bertrpc_provider.rb
+- lib/hoth/providers/rack_provider.rb
+- lib/hoth/service.rb
+- lib/hoth/service_deployment.rb
+- lib/hoth/service_registry.rb
+- lib/hoth/services.rb
+- lib/hoth/transport/amqp_transport.rb
+- lib/hoth/transport/bert_transport.rb
+- lib/hoth/transport/hoth_transport.rb
+- lib/hoth/transport/json_transport.rb
+- lib/hoth/transport/workling_transport.rb
+- lib/hoth/util/logger.rb
+- spec/hoth_spec.rb
+- spec/spec_helper.rb
+- spec/unit/definition_spec.rb
+- spec/unit/deployment_module_spec.rb
+- spec/unit/endpoint_spec.rb
+- spec/unit/extension/core/exception_spec.rb
+- spec/unit/providers/rack_provider_spec.rb
+- spec/unit/service_spec.rb
+- spec/unit/transport/workling_transport_spec.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/pkwde/hoth
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Registry and deployment description abstraction for SOA-Services
+test_files: 
+- spec/hoth_spec.rb
+- spec/spec_helper.rb
+- spec/unit/definition_spec.rb
+- spec/unit/deployment_module_spec.rb
+- spec/unit/endpoint_spec.rb
+- spec/unit/extension/core/exception_spec.rb
+- spec/unit/providers/rack_provider_spec.rb
+- spec/unit/service_spec.rb
+- spec/unit/transport/workling_transport_spec.rb