king_soa 0.0.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,64 @@
+= KingSoa
+
+Creating a SOA requires a centralized location to define all services within the
+SOA. Furthermore you want to know where those services live.
+
+== Tech details
+
+the soa registry is keeping a bunch of service objects which know where a method
+lives. Methods are classes with an self.perform method and can be located local,
+remote(http) or beeing put onto a queue
+
+
+
+== Install
+
+    gem install king_soa
+
+== Define services
+
+=== Low Level
+
+You can define services anywhere in your app and add them to the service
+registry.
+Be aware that the registry is a singleton, so that the rack middleware and your
+app are seeing the same :
+    # create the service
+     service = KingSoa::Service.new(:name=>:increment_usage,
+                                    :url=>'http://localhost:4567',
+                                    :auth_key=>'12345')
+     # register
+     KingSoa::Registry << service
+
+     # somewhere in your app just call your service method
+     KingSoa.increment_usage(12)
+
+A service name is always required. If the service is to be called remotely you
+must add a url and an auth_key.
+The transport is done via http calls, so to make it secure you should either use
+https in public or hide the servers somwhere on your farm.
+
+== Integration
+
+=== Rails
+
+
+=== Sinatra
+
+Take a look at spec/server/app where you can see a minimal sinatra implementation
+The base is just:
+    require 'king_soa'
+    use KingSoa::Rack::Middleware
+    
+ 
+== 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) 2010 Georg Leciejewski. See LICENSE for details.

data/lib/king_soa/rack/middleware.rb

@@ -0,0 +1,47 @@
+module KingSoa::Rack
+  class Middleware
+
+    def initialize(app)
+      @app = app
+    end
+
+    # Takes incoming soa requests and calls the passed in method with given params
+    def call(env)
+#      Hoth::Logger.debug "env: #{env.inspect}"
+      if env["PATH_INFO"] =~ /^\/soa/
+        begin
+          req = Rack::Request.new(env)
+          # find service
+          service = KingSoa.find(req.params["name"])
+          # authenticate
+          authenticated?(service, req.params["auth_key"])
+          # perform method with decoded  params
+          result = service.perform(*service.decode( req.params["params"] ))
+          # encode result
+          encoded_result = service.encode({"result" => result})
+          # and return
+          [ 200,
+            {'Content-Type' => 'application/json',
+             'Content-Length' => "#{encoded_result.length}"},
+            [encoded_result] ]
+        rescue Exception => e
+          #Hoth::Logger.debug "e: #{e.message}"
+          if service
+            encoded_error = service.encode({"error" => e})
+            [500, {'Content-Type' => 'application/json', 'Content-Length' => "#{encoded_error.length}"}, [encoded_error]]
+          else
+            encoded_error = {"error" => "An error occurred! (#{e.message})"}.to_json
+            [500, {'Content-Type' => "application/json", 'Content-Length' => "#{encoded_error.length}"}, [encoded_error]]
+          end
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+    def authenticated?(service, key)
+      raise "Please provide a valid authentication key" unless service.auth_key == key
+    end
+
+  end
+end

data/lib/king_soa/registry.rb

@@ -0,0 +1,55 @@
+module KingSoa
+  class Registry
+    include Singleton
+
+    ############################################################################
+    # Class methods .. only use those since we are in a Singleton
+    ############################################################################
+
+    # Get a method by a given name
+    def self.[](service_name)
+      instance[service_name]
+    end
+    # add a service
+    def self.<<(service)
+      instance << service
+    end
+    # Return an array of defined services
+    def self.services
+      instance.services
+    end
+
+    # find a group of services identified by starting with the same string
+    #
+    def group(name)
+      instance.group(name)
+    end
+    ############################################################################
+    # Instance methods - not directly accessible => Singleton
+    ############################################################################
+
+    # returns all available methods
+    def services
+      @services ||= []
+    end
+
+    # Add a new method onto the stack
+    def <<(service)
+      (services || []) << service
+    end
+
+    # Get a method by a given name
+    def [](service_name)
+      name = service_name.to_sym
+      services.detect {|s| s.name == name }
+    end
+
+    def group(service_name)
+      name = service_name.to_sym
+#      srvs = []
+      services.collect {|s| s.name[/^#{name}/] }
+    end
+
+
+  end
+end

data/lib/king_soa/service.rb

@@ -0,0 +1,88 @@
+module KingSoa
+  class Service
+    # endpoint url
+    attr_accessor :debug, :name, :auth_key, :queue
+    attr_reader :request
+    
+    def initialize(opts)
+      self.name = opts[:name].to_sym
+      self.url = opts[:url] if opts[:url]      
+      self.queue = opts[:queue] if opts[:queue]
+      self.auth_key = opts[:auth_key] if opts[:auth_key]
+    end
+
+    def call_remote(*args)
+      set_request_opts(args)
+      resp_code = @request.perform
+      case resp_code
+      when 200
+        return self.decode(@request.response_body)["result"]
+      else
+        return self.decode(@request.response_body)["error"]
+      end
+    end
+
+    def perform(*args)
+      result = local_class ? local_class.send(:perform, *args) : call_remote(*args)
+      return result
+    end
+    
+
+    def local_class
+      @local_class ||= begin
+                        "#{self.name.to_s.camelize}".constantize
+                      rescue NameError => e        # no local implementation
+                        false
+                      end
+    end
+
+    def request
+      @request ||= Typhoeus::Easy.new
+    end
+
+    def set_request_opts(args)
+      request.url         = url
+      request.method      = :post
+      request.timeout     = 100 # milliseconds
+      request.params      = params(args)
+      request.user_agent  = 'KingSoa'
+      request.follow_location = true      
+      request.verbose     = 1 if debug      
+    end
+
+    # Url receiving the request
+    # TODO. if not present try to grab from endpoint
+    def url
+      @url
+    end
+    def url=(url)
+      @url = "#{url}/soa"
+    end
+
+     # The params for each soa request consisnt of two values:
+    # name => the name of the method to call
+    # params => the parameters for the method
+    # ==== Parameter
+    # params<Hash|Array|String>:: will be json encoded
+    # === Returns
+    # <Hash{String=>String}>:: params added to the POST body
+    def params(payload)
+      { 'name'   => name.to_s,
+        'params' => encode(payload),
+        'auth_key'=> auth_key }
+    end
+
+    def encode(string)
+      string.to_json
+    end
+
+    def decode(string)
+      begin
+        JSON.parse(string)
+      rescue JSON::ParserError => e
+        raise e
+      end
+    end
+
+  end
+end

data/lib/king_soa.rb

@@ -0,0 +1,56 @@
+require 'singleton'
+require 'json'
+require 'typhoeus'
+require 'active_support/inflector'
+
+require 'king_soa/registry'
+require 'king_soa/service'
+require 'king_soa/rack/middleware'
+
+# Define available services.
+#
+# service:
+#   name: sign_document
+#   url: "https://msg.salesking.eu"
+#   auth: 'a-long-random-string'
+#   queue: a-queue-name
+#
+#
+# method: save_signed_document
+# url: "https://www.salesking.eu/soa"
+#
+#
+# after defining your services you can call each of them with
+# <tt>Hoth::Services.service_name(params)</tt>
+#
+#     KingSoa.sign_document(counter)
+#     current_number = Hoth::Services.value_of_counter(counter)
+#     created_account = Hoth::Services.create_account(account)
+#
+module KingSoa
+  
+  class << self
+
+    def init_from_hash(services)
+      # create service
+      
+    end
+    
+    # Locate service by a given name
+    # ==== Params
+    # service<String|Symbol>:: the name to lookup
+    def find(service)
+      Registry[service]
+    end
+
+    # this is where the services get called
+    def method_missing(meth, *args, &blk) # :nodoc:
+      if service = Registry[meth]
+        service.execute(*args)
+      else
+        super
+      end
+    end
+  end
+
+end

data/spec/king_soa/rack/middleware_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe KingSoa::Rack::Middleware do
+  include Rack::Test::Methods
+
+  before(:each) do
+    @service = KingSoa::Service.new(:url=>'localhost', :name=>'a_method')
+    KingSoa::Registry << @service
+  end
+
+  it "should be able to handle exceptions" do
+    app = stub("ApplicationStub").as_null_object
+    middleware = KingSoa::Rack::Middleware.new(app)
+    env = {"PATH_INFO" => "/soa", "name" => 'a_method'}
+
+    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 == "{\"error\":\"An error occurred! (Missing rack.input)\"}"
+  end
+
+  xit "says hello" do
+    app = stub("ApplicationStub").as_null_object
+        middleware = Hoth::Providers::RackProvider.new(app)
+
+    get '/soa', :name=>'a_method', :params=> "#{{:number=>1}.to_json}"
+    last_response.should == 'ads'#be_ok
+    last_response.body.should == 'Hello World'
+  end
+
+#  def app
+#    dummy_app = lambda { |env| puts "in dummy"; [200, {}, ""] }
+#    KingSoa::Rack::Middleware.new(dummy_app)
+#  end
+
+end

data/spec/king_soa/registry_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe KingSoa::Registry do
+  before(:each) do
+
+  end
+
+  it "should return empty services" do
+    reg = KingSoa::Registry.new
+    reg.services.should == []
+  end
+
+  it "should add service" do
+    reg = KingSoa::Registry.new
+    s = KingSoa::Service.new(:url=>'http://localhost')
+    reg << s
+    reg.services.should == [s]
+  end
+
+  it "should return a service by name" do
+    reg = KingSoa::Registry.new
+    s = KingSoa::Service.new(:name=>:save_document, :url=>'http://localhost')
+    reg << s
+    reg[:save_document].should == s
+  end
+
+
+end

data/spec/king_soa/service_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe KingSoa::Service do
+  before(:each) do
+  end
+
+  it "should init" do
+    
+  end
+end
+
+describe KingSoa::Service, 'local request' do
+
+  it "should call service" do
+    s = KingSoa::Service.new(:name=>:local_soa_class)
+    res = s.perform(1,2,3)
+    res.should == [1,2,3]
+  end
+end
+
+# needs the local testserver !!!
+# ruby spec/server/app
+describe KingSoa::Service, 'remote request' do
+
+  it "should call a service remote" do
+    s = KingSoa::Service.new(:name=>:soa_test_service, :url=>'http://localhost:4567', :auth_key=>'12345')
+    s.perform(1,2,3).should == [1,2,3]
+  end
+
+  it "should call a service remote and return auth error" do
+    s = KingSoa::Service.new(:name=>:soa_test_service, :url=>'http://localhost:4567', :auth_key=>'wrong')
+    s.perform(1,2,3).should == "Please provide a valid authentication key"
+  end
+
+  it "should call a service remote and return auth error" do
+    s = KingSoa::Service.new(:name=>:wrong_service, :url=>'http://localhost:4567', :auth_key=>'12345')
+    s.perform(1,2,3).should == "An error occurred! (undefined method `auth_key' for nil:NilClass)"
+  end
+end
+
+
+class LocalSoaClass
+  def self.perform(param1, param2, param3)
+    return [param1, param2, param3]
+  end
+end

data/spec/server/app.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'sinatra'
+require "#{File.dirname(__FILE__)}/../../lib/king_soa"
+
+use KingSoa::Rack::Middleware
+
+
+###################################################
+# method to kill this server instance
+#'/die'
+#######################################
+# Somewhere in you app
+#
+# setup test registry
+service = KingSoa::Service.new(:name=>'soa_test_service', :auth_key=>'12345')
+KingSoa::Registry << service
+
+# the class beeing called localy
+class SoaTestService
+
+  def self.perform(param1, param2, param3)
+    return [param1, param2, param3]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'king_soa'
+require 'spec'
+require 'spec/autorun'
+# for mocking web requests
+require 'webmock/rspec'
+require 'rack/test'
+include WebMock
+
+
+
+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

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: king_soa
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Georg Leciejewski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-08 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: typhoeus
+  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: json
+  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: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+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: gl@salesking.eu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- README.rdoc
+- lib/king_soa.rb
+- lib/king_soa/rack/middleware.rb
+- lib/king_soa/registry.rb
+- lib/king_soa/service.rb
+- spec/king_soa/rack/middleware_spec.rb
+- spec/king_soa/registry_spec.rb
+- spec/king_soa/service_spec.rb
+- spec/server/app.rb
+- spec/spec_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/salesking/king_soa
+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 by SalesKing
+test_files: 
+- spec/spec_helper.rb
+- spec/king_soa/registry_spec.rb
+- spec/king_soa/service_spec.rb
+- spec/king_soa/rack/middleware_spec.rb
+- spec/server/app.rb