king_soa 0.0.1 → 0.0.2

data/lib/king_soa/rack/middleware.rb

@@ -13,24 +13,28 @@ module KingSoa::Rack
           req = Rack::Request.new(env)
           # find service
           service = KingSoa.find(req.params["name"])
+          #  TODO rescue service class not found
+          raise "The service: #{req.params["name"]} could not be found" unless service
           # authenticate
-          authenticated?(service, req.params["auth_key"])
-          # perform method with decoded  params
-          result = service.perform(*service.decode( req.params["params"] ))
+          authenticated?(service, req.params["auth"])
+          # perform method with decoded params
+          result = service.perform(*service.decode( req.params["args"] ))
           # encode result
           encoded_result = service.encode({"result" => result})
           # and return
-          [ 200,
-            {'Content-Type' => 'application/json',
-             'Content-Length' => "#{encoded_result.length}"},
-            [encoded_result] ]
+          [
+            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
+            encoded_error = {"error" => "An error occurred => #{e.message}"}.to_json
             [500, {'Content-Type' => "application/json", 'Content-Length' => "#{encoded_error.length}"}, [encoded_error]]
           end
         end
@@ -39,8 +43,9 @@ module KingSoa::Rack
       end
     end
 
+    # TODO raise and rescue specific error
     def authenticated?(service, key)
-      raise "Please provide a valid authentication key" unless service.auth_key == key
+      raise "Please provide a valid authentication key" unless service.auth == key
     end
 
   end

data/lib/king_soa/service.rb

@@ -1,16 +1,18 @@
 module KingSoa
   class Service
     # endpoint url
-    attr_accessor :debug, :name, :auth_key, :queue
+    attr_accessor :debug, :name, :auth, :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]
+      self.auth = opts[:auth] if opts[:auth]
     end
 
+    # Call a service living somewhere in the soa universe. This is done by
+    # making a POST request to the url
     def call_remote(*args)
       set_request_opts(args)
       resp_code = @request.perform
@@ -22,20 +24,40 @@ module KingSoa
       end
     end
 
-    def perform(*args)
-      result = local_class ? local_class.send(:perform, *args) : call_remote(*args)
-      return result
+    # A queued method MUST have an associated resque worker running and the soa
+    # class MUST have the @queue attribute for redis set
+    def add_to_queue(*args)
+      # use low level resque method since class might not be local available for Resque.enqueue
+      Resque::Job.create(queue, local_class_name, *args)
     end
-    
+
+    # Call a method: remote over http, local or put a job onto a queue
+    # === Parameter
+    # args:: whatever arguments the service methods recieves. Those are later json
+    # encoded for remote or queued methods
+    def perform(*args)
+      if queue
+        add_to_queue(*args)
+        return nil
+      else
+        result = local_class ? local_class.send(:perform, *args) : call_remote(*args)
+        return result
+      end
+    end    
 
     def local_class
       @local_class ||= begin
-                        "#{self.name.to_s.camelize}".constantize
+                        local_class_name.constantize
                       rescue NameError => e        # no local implementation
                         false
                       end
     end
 
+    # Return the classname infered from service name
+    def local_class_name
+      self.name.to_s.camelize
+    end
+
     def request
       @request ||= Typhoeus::Easy.new
     end
@@ -59,17 +81,20 @@ module KingSoa
       @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
+    # The params for each soa request consist of following values:
+    #    name => the name of the method to call
+    #    args => the arguments for the soa class method
+    #    auth => an authentication key. something like a api key or pass. To make
+    # it really secure you MUST use https or do not expose your soa endpoints
+    #
     # ==== Parameter
-    # params<Hash|Array|String>:: will be json encoded
+    # payload<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 }
+      { 'name'    => name.to_s,
+        'args'    => encode(payload),
+        'auth'    => auth }
     end
 
     def encode(string)

data/lib/king_soa.rb

@@ -1,4 +1,5 @@
 require 'singleton'
+require 'resque'
 require 'json'
 require 'typhoeus'
 require 'active_support/inflector'
@@ -21,7 +22,8 @@ require 'king_soa/rack/middleware'
 #
 #
 # after defining your services you can call each of them with
-# <tt>Hoth::Services.service_name(params)</tt>
+#
+# <tt>KingSoa.service_name(args)</tt>
 #
 #     KingSoa.sign_document(counter)
 #     current_number = Hoth::Services.value_of_counter(counter)
@@ -32,12 +34,11 @@ module KingSoa
   class << self
 
     def init_from_hash(services)
-      # create service
-      
+      # create service      
     end
     
     # Locate service by a given name
-    # ==== Params
+    # ==== Parameter
     # service<String|Symbol>:: the name to lookup
     def find(service)
       Registry[service]
@@ -46,7 +47,7 @@ module KingSoa
     # this is where the services get called
     def method_missing(meth, *args, &blk) # :nodoc:
       if service = Registry[meth]
-        service.execute(*args)
+        service.perform(*args)
       else
         super
       end

data/spec/king_soa/rack/middleware_spec.rb

@@ -8,7 +8,7 @@ describe KingSoa::Rack::Middleware do
     KingSoa::Registry << @service
   end
 
-  it "should be able to handle exceptions" do
+  it "should handle exceptions" do
     app = stub("ApplicationStub").as_null_object
     middleware = KingSoa::Rack::Middleware.new(app)
     env = {"PATH_INFO" => "/soa", "name" => 'a_method'}
@@ -19,18 +19,10 @@ describe KingSoa::Rack::Middleware do
     rack_response.last.first.should == "{\"error\":\"An error occurred! (Missing rack.input)\"}"
   end
 
-  xit "says hello" do
+  xit "should handle result" 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'
+    middleware = KingSoa::Rack::Middleware.new(app)
+    env = {"PATH_INFO" => "/soa"}
+#    KingSoa.should_receive(:find).and_return(@service)
   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

@@ -2,26 +2,23 @@ require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 describe KingSoa::Registry do
   before(:each) do
-
+    @reg = KingSoa::Registry
   end
 
   it "should return empty services" do
-    reg = KingSoa::Registry.new
-    reg.services.should == []
+    @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]
+  it "should add service" do    
+    s = KingSoa::Service.new(:name=>'process_documents')
+    @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
+    @reg << s
+    @reg[:save_document].should == s
   end
 
 

data/spec/king_soa/service_spec.rb

@@ -13,34 +13,40 @@ 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]
+    s.perform(1,2,3).should == [1,2,3]
+  end
+end
+
+describe KingSoa::Service, 'queued' do
+
+  it "should call queue" do
+    s = KingSoa::Service.new(:name=>:local_soa_class, :queue=>:test_queue)
+    s.perform(1,2,3).should be_nil
   end
 end
 
-# needs the local testserver !!!
-# ruby spec/server/app
 describe KingSoa::Service, 'remote request' do
 
+  before :all do
+    start_test_server
+  end
+
+  after :all do
+    stop_test_server
+  end
+
   it "should call a service remote" do
-    s = KingSoa::Service.new(:name=>:soa_test_service, :url=>'http://localhost:4567', :auth_key=>'12345')
+    s = KingSoa::Service.new(:name=>:soa_test_service, :url=>test_url, :auth=>'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 = KingSoa::Service.new(:name=>:soa_test_service, :url=>test_url, :auth=>'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]
+    s = KingSoa::Service.new(:name=>:wrong_service, :url=>test_url, :auth=>'12345')
+    s.perform(1,2,3).should include("The service: wrong_service could not be found")
   end
 end

data/spec/server/app.rb

@@ -1,26 +1,29 @@
 #!/usr/bin/env ruby
 require 'rubygems'
 require 'sinatra'
-require "#{File.dirname(__FILE__)}/../../lib/king_soa"
+# change since we want the files in here not from installed gem
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require "king_soa"
 
+# this grabs all /soa requests
 use KingSoa::Rack::Middleware
 
+#  method to kill this server instance
+get '/die' do
+  exit!
+end
 
-###################################################
-# method to kill this server instance
-#'/die'
 #######################################
-# Somewhere in you app
+# Somewhere in you app define services
 #
 # setup test registry
-service = KingSoa::Service.new(:name=>'soa_test_service', :auth_key=>'12345')
+service = KingSoa::Service.new(:name=>'soa_test_service', :auth => '12345')
 KingSoa::Registry << service
 
-# the class beeing called localy
+# the local soa class beeing called
 class SoaTestService
-
   def self.perform(param1, param2, param3)
     return [param1, param2, param3]
   end
-
 end

data/spec/spec_helper.rb

@@ -5,33 +5,35 @@ $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
+# for starting the test sinatra server
+require 'open3'
 
+def test_url
+  'http://localhost:4567'
+end
 
+# Start a local test sinatra app receiving the real requests .. no mocking here
+# the server could also be started manually with:
+#   ruby spec/server/app
+def start_test_server(wait_time=1)
+  # start sinatra test server
+  Dir.chdir(File.dirname(__FILE__) + '/server/') do
+    @in, @rackup, @err = Open3.popen3("ruby app.rb")
+  end
+  sleep wait_time # ensure the server is up
+end
 
-def local_service
-#         Rack::Builder.app do
-#      use KingSoa::Rack::Middleware
-#      run super
-#    end
+def stop_test_server
+  Typhoeus::Request.get( "#{test_url}/die")
+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
+################################################################################
+# Local soa classes called in specs
+################################################################################
+
+class LocalSoaClass
+  def self.perform(param1, param2, param3)
+    return [param1, param2, param3]
+  end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Georg Leciejewski
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-08 00:00:00 +02:00
+date: 2010-05-09 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,7 +55,7 @@ dependencies:
   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.
+  SOA. KingSoa takes care of keeping services in a service registry and knows how to call them.
 
 email: gl@salesking.eu
 executables: []
@@ -106,7 +106,7 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Registry and deployment description abstraction for SOA-Services by SalesKing
+summary: Abstraction layer for SOA-Services
 test_files: 
 - spec/spec_helper.rb
 - spec/king_soa/registry_spec.rb