sk-hoth 0.0.1 → 0.3.0

data/lib/hoth/transport/http.rb

@@ -0,0 +1,41 @@
+require 'net/http'
+
+module Hoth
+  module Transport
+    class Http < Base     
+      def call_remote_with(*params)
+        begin
+          handle_response post_payload(params)
+        rescue Exception => e
+          raise TransportError.wrap(e)
+        end
+      end
+      
+      def handle_response(response)
+        case response
+        when Net::HTTPSuccess
+          Hoth::Logger.debug "response.body: #{response.body}"
+          encoder.decode(response.body)["result"]
+        when Net::HTTPServerError
+          begin
+            Hoth::Logger.debug "response.body: #{response.body}"
+            raise encoder.decode(response.body)["error"]
+          rescue JSON::ParserError => jpe
+            raise TransportError.wrap(jpe)
+          end
+        when Net::HTTPRedirection, Net::HTTPClientError, Net::HTTPInformation, Net::HTTPUnknownResponse
+          raise NotImplementedError, "code: #{response.code}, message: #{response.body}"
+        end
+      end
+      
+      def post_payload(payload)
+        uri = URI.parse(self.endpoint.to_url)
+        return Net::HTTP.post_form(uri,
+          'name'   => self.name.to_s,
+          'params' => encoder.encode(payload)
+        )
+      end
+      
+    end
+  end
+end

data/lib/hoth/transport/http_hmac.rb

@@ -0,0 +1,37 @@
+require 'king_hmac'
+require 'net/http'
+module Hoth
+  module Transport
+    class HttpHmac < Http
+      attr_accessor :hmac_access_id, :hmac_secret
+      # just for testing request
+      attr_accessor :req
+      # Manually construct the HTTP request because it needs to be signed with
+      # hmac before.
+      # This function is more or less a copy of HTTP.post_form
+      # == Prerequisites
+      # you must set both instance variables: hmac_access_id, hmac_secret before
+      # the call can be made
+      # === Returns
+      # <Object>:. Net::HTTPResponse
+      def post_payload(payload)
+        raise TransportError, 'no hmac credentials set for hmac transport' unless hmac_access_id && hmac_secret
+        uri = URI.parse(self.endpoint.to_url)
+        # construct request object
+        self.req = Net::HTTP::Post.new(uri.path)
+        # add its form data
+        self.req.form_data = {'name'   => self.name.to_s,
+                         'params' => encoder.encode(payload) }
+        # ensure a date header is set, needed for hmac
+        self.req['Date'] = Time.now.httpdate if self.req['Date'].nil?
+        # sign request object => set Authorisation header
+        KingHmac::Auth.sign!(self.req, hmac_access_id, hmac_secret)
+        # go for it
+        return Net::HTTP.new(uri.host, uri.port).start {|http|
+          http.request(self.req)
+        }
+      end
+
+    end
+  end
+end

data/lib/hoth/transport/workling.rb

@@ -0,0 +1,23 @@
+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 Workling < Base
+      
+      def call_remote_with(*args)
+        topic      = SimplePublisher::Topic.new(:name => "#{self.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(encoder.encode(args))
+      end
+      
+    end
+    
+  end
+end

data/lib/hoth/transport.rb

@@ -0,0 +1,48 @@
+require 'hoth/transport/base'
+require 'hoth/transport/http'
+require 'hoth/transport/http_hmac'
+require 'hoth/transport/bert'
+require 'hoth/transport/workling'
+
+require 'hoth/encoding/json'
+require 'hoth/encoding/no_op'
+
+module Hoth
+  module Transport
+
+    POSSIBLE_TRANSPORTS = {
+      :json_via_http => {
+        :transport_class => Transport::Http,
+        :encoder => Encoding::Json
+      },
+      :http => :json_via_http,
+      :json_via_http_hmac => {
+        :transport_class => Transport::HttpHmac,
+        :encoder => Encoding::Json
+      },
+      :http_hmac => :json_via_http_hmac,
+      :workling => {
+        :transport_class => Transport::Workling
+      }
+    }
+
+    class <<self
+      def create(transport_name, service)
+        new_transport_with_encoding(transport_name, service)
+      end
+
+      def new_transport_with_encoding(transport_name, service)
+        if POSSIBLE_TRANSPORTS[transport_name.to_sym]
+          if POSSIBLE_TRANSPORTS[transport_name.to_sym].kind_of?(Hash)
+            POSSIBLE_TRANSPORTS[transport_name.to_sym][:transport_class].new(service, :encoder => POSSIBLE_TRANSPORTS[transport_name.to_sym][:encoder])
+          else
+            new_transport_with_encoding(POSSIBLE_TRANSPORTS[transport_name.to_sym], service)
+          end
+        else
+          raise TransportException.new("specified transport '#{transport_name}' does not exist, use one of these: #{POSSIBLE_TRANSPORTS.keys.join(", ")}")
+        end
+      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/lib/hoth.rb

@@ -0,0 +1,56 @@
+require 'singleton'
+
+require 'active_support/inflector'
+
+# must be loaded after alls transports and all encodings
+require 'hoth/transport'
+
+require 'hoth/service_definition'
+require 'hoth/service_module'
+require 'hoth/endpoint'
+require 'hoth/service'
+require 'hoth/modules'
+require 'hoth/service_registry'
+require 'hoth/services'
+
+require 'hoth/util/logger'
+
+require 'hoth/extension/core/exception'
+require 'hoth/exceptions'
+
+module Hoth
+  
+  class <<self
+    def init!
+      load_service_definition
+      load_module_definition
+      Logger.init_logging!
+    end
+  
+    def config_path
+      @config_path || "config/"
+    end
+    
+    def config_path=(config_path)
+      @config_path = config_path
+    end
+    
+    def load_service_definition
+      require File.join(config_path, "service_definition")
+    end
+
+    def load_module_definition
+      require File.join(config_path, "module_definition")
+    end
+    
+    def env
+      @env || ENV["HOTH_ENV"] || (Object.const_defined?("Rails") ? Rails.env.to_sym : :development)
+    end
+    
+    def env=(env)
+      @env = env.to_sym
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -2,36 +2,17 @@ require 'rubygems'
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'king_soa'
+require 'hoth'
 require 'spec'
 require 'spec/autorun'
 # for mocking web requests
 require 'webmock/rspec'
-require 'rack/test'
 include WebMock
 
+Hoth.env = "test"
 
-
-def local_service
-#         Rack::Builder.app do
-#      use KingSoa::Rack::Middleware
-#      run super
-#    end
-
-#    Rack::Builder.new do
-#    use KingSoa::Rack::Middleware
-#    app = proc do |env|
-#    [ 200, {'Content-Type' => 'text/plain'}, "b" ]
-#    end
-#    run app
-#    end.to_app
-#    def app
-#      Rack::Builder.new {
-#        # URLs starting with /account (logged in users) go to Rails
-#        map "/soa" do
-#          run KingSoa::Rack::Middleware.new
-#        end
-#      }.to_app
-#    end
-#    app.run
-end
+Spec::Matchers.define :string_matching do |regex|
+  match do |string|
+    string =~ regex
+  end
+end

data/spec/unit/encoding/json_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Encoding
+    
+    describe Json do
+      
+      it "should decode a JSON string" do
+        decoded_json = Json.decode '{"test":23}'
+        decoded_json.should ==({"test" => 23})
+      end
+      
+      it "should encode a JSON string" do
+        encoded_json = Json.encode({"test" => 23})
+        '{"test":23}'.should == encoded_json
+      end
+      
+      it "should know its ContentType" do
+        Json.content_type.should == "application/json"
+      end
+      
+    end
+    
+  end
+end

data/spec/unit/endpoint_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Hoth
+  
+  describe Endpoint do
+  
+    it "should have a port" do
+      endpoint = Endpoint.new { port 3000 }
+      endpoint.port.should == 3000
+    end
+  
+    it "should have a host name" do
+      endpoint = Endpoint.new { host "example.com" }
+      endpoint.host.should == "example.com"
+    end
+  
+    it "should have a transport name" do
+      endpoint = Endpoint.new { transport :json_via_http }
+      endpoint.transport.should == :json_via_http
+    end
+  
+    it "should should cast itself to URL string" do
+      endpoint = Endpoint.new { port 3000; host "example.com" }
+      endpoint.to_url.should == "http://example.com:3000/execute"
+    end
+    
+    it "should should know the deployment module this endpoint is associated to" do
+      endpoint = Endpoint.new { module_name "TestModule" }
+      endpoint.module_name.should == "TestModule"
+    end
+  
+  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/hoth_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Hoth do
+  
+  before(:each) do
+    @old_hoth_env = Hoth.env
+    Hoth.instance_variable_set "@env", nil
+  end
+  
+  after(:each) do
+    Hoth.env = @old_hoth_env
+  end
+  
+  it "should set the environment explicitly" do
+    Hoth.env = :test
+    Hoth.env.should == :test
+  end
+  
+  it "should default to :development if no environment is set" do
+    Hoth.env.should equal(:development)
+  end
+  
+  it "should return the Rails env if Rails is available" do
+    module Rails; end
+    Rails.should_receive(:env).and_return(:production)
+    Hoth.env.should equal(:production)
+    Object.send :remove_const, :Rails
+  end
+  
+end

data/spec/unit/providers/rack_provider_spec.rb

@@ -0,0 +1,49 @@
+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'))
+
+require 'rack/mock'
+
+module Hoth
+  module Providers
+    
+    describe RackProvider do
+      
+      it "should get transport and encoder based on called service" do
+        app = stub("ApplicationStub").as_null_object
+        middleware = Hoth::Providers::RackProvider.new(app)
+        
+        encoder = mock("EncoderMock")
+        encoder.should_receive(:decode).with("some_parameter").and_return(decoded_params = "some_parameter_decoded")
+        encoder.should_receive(:content_type).and_return("application/json")
+        
+        transport = mock("TransportMock")
+        transport.should_receive(:encoder).exactly(3).times.and_return(encoder)
+        
+        service = mock("ServiceMock")
+        service.should_receive(:transport).exactly(3).times.and_return(transport)
+        ServiceRegistry.should_receive(:locate_service).with("service_name").and_return(service)
+        
+        Hoth::Services.should_receive(:send).with("service_name", *decoded_params).and_return(service_result = "result")
+        encoder.should_receive(:encode).with({"result" => service_result}).and_return("result_encoded")
+        
+        mock_request = Rack::MockRequest.new(middleware)
+        mock_request.post("http://localhost/execute?name=service_name&params=some_parameter")
+      end
+      
+      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 be_a_kind_of(Array)
+        rack_response.last.first.should == "An error occuered! (RuntimeError)"
+      end
+      
+    end
+    
+  end
+end

data/spec/unit/service_definition_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Hoth
+  describe ServiceDefinition do
+  
+    it "should create a Service and add it to the registry instance" do
+      service_name = :my_service
+      
+      definition = ServiceDefinition.new
+      definition.service service_name do |some_params|
+        returns :nothing
+      end
+      
+      service = ServiceRegistry.locate_service(service_name)
+      service.should_not be(nil)
+      service.params_arity.should be(1)
+      service.return_nothing?.should be(true)
+    end
+  
+  end
+end

data/spec/unit/service_module_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module Hoth
+  
+  describe ServiceModule do
+  
+    it "should have a name" do
+      service_module = ServiceModule.new :name => :my_service_module
+      service_module.name.should equal(:my_service_module)
+    end
+  
+    it "should have an environment" do
+      service_module = ServiceModule.new(:name => "service_module_name")
+      block = Proc.new {}
+      service_module.env :test, &block
+      service_module[:test].should be_a(ServiceModule::Environment)
+    end
+  
+    it "should have multiple environments" do
+      service_module = ServiceModule.new(:name => "service_module_name")
+      block = Proc.new {}
+      service_module.env :test, :development, &block
+      service_module[:test].should be_a(ServiceModule::Environment)
+      service_module[:development].should be_a(ServiceModule::Environment)
+    end
+  
+    it "should be able to add services" do
+      service_module = ServiceModule.new(:name => "service_module_name")
+      block = Proc.new {}
+      
+      service_module.env :test, &block
+      
+      ServiceRegistry.should_receive(:locate_service).with(:service_name).and_return(service = mock("ServiceMock"))
+      service.should_receive(:module=).with(service_module)
+      service.should_receive(:via_endpoint).with(:special_endpoint)
+      
+      service_module.add_service("service_name", :via => :special_endpoint)
+    end
+  
+    describe ServiceModule::Environment do
+
+      it "should have an endpoint" do
+        endpoint_mock = mock("Endpoint", :null_object => true)
+      
+        endpoint_block = Proc.new do
+          endpoint :development do
+            host 'localhost'
+          end
+        end
+        
+        env = ServiceModule::Environment.new(&endpoint_block)      
+        env[:development].should_not be(nil)
+      end
+    
+    end
+  
+  end
+  
+end

data/spec/unit/service_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+class TestServiceImpl
+  def self.execute(param1, param2)
+  end
+end
+
+module Hoth
+  
+  describe Service do
+    
+    it "should define parameters and return values" do
+      service_block = Proc.new { |param_1, param_2, param_3| returns :some_data }
+
+      service = Service.new("TestService", &service_block)
+
+      service.params_arity.should be(3)
+      service.return_nothing?.should be(false)
+    end
+    
+    it "should know its service-impl class" do
+      service = Service.new("TestService") {}
+      service.impl_class
+    end
+    
+    it "should know that its service-impl class is not available" do
+      service = Service.new("TestServiceWithoutImplClass") {}
+      service.impl_class.should be(false)
+    end
+    
+    it "should know if it is local or not based on Impl-Class availability" do
+      service = Service.new("TestServiceWithoutImplClass") {}
+      service.is_local?.should be(false)
+
+      service = Service.new("test_service") {}
+      service.is_local?.should be(true)
+    end
+    
+    it "should execute the service stub locally if its impl-class was found" do
+      service = Service.new("test_service") { |p1, p2| returns :nothing }
+      
+      service.should_receive(:is_local?).and_return(true)
+      service.impl_class.should_receive(:execute).with(:arg1, :arg2)
+      
+      service.execute(:arg1, :arg2).should be(nil)
+    end
+  
+    it "should execute the service stub locally if its impl-class was found and return a value" do
+      service = Service.new("test_service") { |p1, p2| returns :value }
+      
+      service.should_receive(:is_local?).and_return(true)
+      service.impl_class.should_receive(:execute).with(:arg1, :arg2).and_return(result = mock("ResultMock"))
+      
+      service.execute(:arg1, :arg2).should be(result)
+    end
+  
+    it "should call the remote service if impl-class does not exist" do
+      service = Service.new("test_service_without_impl") { |p1, p2| returns :nothing }
+      
+      service.should_receive(:is_local?).and_return(false)
+      service.should_receive(:transport).and_return(transport = mock("TransportMock"))
+      transport.should_receive(:call_remote_with).with(:arg1, :arg2)
+      
+      service.execute(:arg1, :arg2)    
+    end
+  
+    it "should create transport instance based on endpoint" do
+      service = Service.new("test_service") { |p1, p2| returns :nothing }
+      service.should_receive(:endpoint).and_return(endpoint = mock("EndpointMock"))
+      endpoint.should_receive(:transport).and_return(:http)
+      Hoth::Transport.should_receive(:create).with(:http, service)
+      service.transport
+    end
+  
+  end
+  
+end

data/spec/unit/transport/base_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../',  'spec_helper'))
+
+module Hoth
+  module Transport
+    
+    describe "Base" do
+      
+      it "should initialize with service-delegate" do
+        service = mock("ServiceMock")
+        transport = Base.new(service)
+      end
+      
+      it "should use an NoOp encoder if no encoder class was given at all" do
+        service = mock("ServiceMock")
+        transport = Base.new(service)
+        transport.encoder.should == Encoding::NoOp
+      end
+      
+      it "should delegate calls to service-delegate" do
+        service = mock("ServiceMock")
+        service.should_receive(:name)
+        service.should_receive(:module)
+        service.should_receive(:endpoint)
+        service.should_receive(:params)
+        service.should_receive(:return_nothing?)
+        transport = Base.new(service)
+        
+        [:name, :module, :endpoint, :params, :return_nothing?].each do |method|
+          transport.send(method)
+        end
+      end
+      
+      it "should have an encoder" do
+        service = mock("ServiceMock")
+        encoder = mock("EncoderMock")
+        transport = Base.new(service, :encoder => encoder)
+        transport.encoder.should be(encoder)
+      end
+            
+    end
+    
+  end
+end