hoodoo 1.0.5 → 1.1.0

data/lib/hoodoo/services/middleware/amqp_log_writer.rb

@@ -13,33 +13,33 @@ module Hoodoo; module Services
   class Middleware
 
     # Log writer which sends structured messages to an AMQP-based queue via
-    # the AlchemyAMQ gems. A Hoodoo::Logger::FastWriter subclass, since though
-    # talking to the queue might be comparatively slow, Alchemy itself uses an
-    # asynchronous Thread for this so there's no need to add another one for
-    # this logger.
+    # the Alchemy Flux gem. A Hoodoo::Logger::FastWriter subclass, since though
+    # talking to the queue might be comparatively slow, Flux uses Event Machine
+    # for this so there's no need to add another Thread for this logger.
     #
-    # See also Hoodoo::Logger and Hoodoo::Services::Middleware::AMQPLogMessage.
+    # See also Hoodoo::Logger.
     #
     class AMQPLogWriter < Hoodoo::Logger::FastWriter
 
       # Create an AMQP logger instance.
       #
-      # +alchemy+::    The Alchemy endpoint to use for sending messages to the
-      #                AMQP-based queue.
+      # +alchemy+::     The Alchemy endpoint to use for sending messages to the
+      #                 AMQP-based queue.
       #
-      # +queue_name+:: The queue name (as a String) to use. Optional. If
-      #                omitted, reads +ENV[ 'AMQ_LOGGING_ENDPOINT' ]+ or if
-      #                that is unset, defaults to +platform.logging+.
+      # +routing_key+:: The routing key (as a String) to use. Optional. If
+      #                 omitted, reads +ENV[ 'AMQ_LOGGING_ENDPOINT' ]+ or if
+      #                 that is unset, defaults to +platform.logging+.
       #
       # If you're running with Rack on top of Alchemy, then the +call+ method's
-      # +env+ parameter containing the Rack environment should have a key of
-      # +rack.alchemy+ or +alchemy+ with a value that can be assigned to the
-      # +alchemy+ parameter. The logger will then use the active Alchemy
-      # service to send messages to its configured named queue.
+      # +env+ parameter containing the Rack environment _MUST_ have a key of
+      # +alchemy.service+ with a value that's the AlchemyFlux::Service instance
+      # handling queue communication. This is assigned to the +alchemy+
+      # parameter. The logger will then use this active Alchemy service to send
+      # messages to its configured routing key.
       #
-      def initialize( alchemy, queue_name = nil )
-        @alchemy    = alchemy
-        @queue_name = queue_name || ENV[ 'AMQ_LOGGING_ENDPOINT' ] || 'platform.logging'
+      def initialize( alchemy, routing_key = nil )
+        @alchemy     = alchemy
+        @routing_key = routing_key || ENV[ 'AMQ_LOGGING_ENDPOINT' ] || 'platform.logging'
       end
 
       # Custom implementation of the Hoodoo::Logger::WriterMixin#report
@@ -63,19 +63,15 @@ module Hoodoo; module Services
       #                    the log payload.
       #
       def report( level, component, code, data )
-        return if @alchemy.nil? || defined?( Hoodoo::Services::Middleware::AMQPLogMessage ).nil?
+        return if @alchemy.nil?
 
         # Take care with Symbol keys in 'data' vs string keys in e.g. 'Session'.
 
         data[ :id ] ||= Hoodoo::UUID.generate()
 
-        interaction_id = data[ :interaction_id ]
-        session        = data[ :session ] || {}
+        session = data[ :session ] || {}
+        message = Hoodoo::Services::Middleware::AMQPLogMessage.new( {
 
-        caller_id      = session[ 'caller_id' ]
-        identity       = ( session[ 'identity' ] || {} ).to_h
-
-        message = Hoodoo::Services::Middleware::AMQPLogMessage.new(
           :id             => data[ :id ],
           :level          => level,
           :component      => component,
@@ -84,34 +80,13 @@ module Hoodoo; module Services
 
           :data           => data,
 
-          :interaction_id => interaction_id,
-          :caller_id      => caller_id,
-          :identity       => identity,
-
-          :routing_key    => @queue_name,
-        )
+          :interaction_id => data[ :interaction_id ],
+          :caller_id      => session[ 'caller_id' ],
+          :identity       => ( session[ 'identity' ] || {} ).to_h
 
-        # Broken services can attempt to log invalid datatypes such as
-        # BigDecimal, which Msgpack can't serialize. At the time of writing,
-        # Alchemy AMQ would thus encounter a serialization exception *within
-        # its EventMachine sending loop*, so in a different *native* thread.
-        # This exception could not be caught by Ruby / Hoodoo in "this"
-        # native thread, so instead the uncaught exception kills the service.
-        # Although Alchemy could catch that itself, there is no way for it to
-        # report the failure to Hoodoo in a way that a log reporting caller
-        # could understand; it's async and in the wrong native thread anyway.
-        #
-        # Solution: In non-production environments only (due to the potential
-        # performance hit), manually serialize the message before sending it.
-        # If this call blows up, the Hoodoo exception handler will catch it
-        # and report the result as a properly formed 500, including the
-        # Msgpack (or other exception) details on exactly what was wrong.
-        #
-        unless Hoodoo::Services::Middleware.environment.production?
-          message.serialize()
-        end
+        } ).to_h()
 
-        @alchemy.send_message( message )
+        @alchemy.send_message_to_queue( @routing_key, message )
       end
     end
 

data/lib/hoodoo/services/middleware/middleware.rb

@@ -53,7 +53,7 @@ module Hoodoo; module Services
   #
   # The middleware adds a STDERR stream writer logger by default and an AMQP
   # log writer on the first Rack +call+ should the Rack environment provide an
-  # Alchemy endpoint (see the AlchemyAMQ gem).
+  # Alchemy endpoint (see the Alchemy Flux gem).
   #
   class Middleware
 
@@ -211,10 +211,37 @@ module Hoodoo; module Services
     # Are we running on the queue, else (implied) a local HTTP server?
     #
     def self.on_queue?
-      q = ENV[ 'AMQ_ENDPOINT' ]
+      q = ENV[ 'AMQ_URI' ]
       q.nil? == false && q.empty? == false
     end
 
+    # Return a service 'name' derived from the service's collection of
+    # declared resources. The name will be the same across any instances of
+    # the service that implement the same resources. This can be used for
+    # e.g. AMQP-based queue-named operations, that want to target the same
+    # resource collection regardless of instance.
+    #
+    # This method will not work unless the middleware has parsed the set
+    # of service interface declarations (during instance initialisation).
+    # If a least one middleware instance has already been created, it is
+    # safe to call.
+    #
+    def self.service_name
+      @@service_name
+    end
+
+    # For a given resource name and version, return the _de_ _facto_ routing
+    # path based on version and name with no modifications.
+    #
+    # +resource+::    Resource name for the endpoint, e.g. +:Purchase+.
+    #                 String or symbol.
+    #
+    # +version+::     Implemented version of the endpoint. Integer.
+    #
+    def self.de_facto_path_for( resource, version )
+      "/#{ version }/#{ resource }"
+    end
+
     # Access the middleware's logging instance. Call +report+ on this to make
     # structured log entries. See Hoodoo::Logger::WriterMixin#report along
     # with Hoodoo::Logger for other calls you can use.
@@ -338,7 +365,8 @@ module Hoodoo; module Services
     # of the endpoints.
     #
     def self.flush_services_for_test
-      @@services = []
+      @@services     = []
+      @@service_name = nil
 
       ObjectSpace.each_object( self ) do | middleware_instance |
         discoverer = middleware_instance.instance_variable_get( '@discoverer' )
@@ -383,7 +411,8 @@ module Hoodoo; module Services
       # actions          Set of symbols naming allowed actions
       # implementation   Hoodoo::Services::Implementation subclass *instance* to
       #                  use on match
-
+      #
+      #
       @@services = service_container.component_interfaces.map do | interface |
 
         if interface.nil? || interface.endpoint.nil? || interface.implementation.nil?
@@ -395,6 +424,13 @@ module Hoodoo; module Services
         #
         interfaces_have_public_methods() unless interface.public_actions.empty?
 
+        # There are two routes to an implementation - one via the custom path
+        # given through its 'endpoint' declaration, the other a de facto path
+        # determined from the unmodified version and resource name. Both lead
+        # to the same implementation instance.
+        #
+        implementation_instance = interface.implementation.new
+
         # Regexp explanation:
         #
         # Match "/", the version text, "/", the endpoint text, then either
@@ -402,17 +438,34 @@ module Hoodoo; module Services
         # everything else. Match data index 1 will be whatever character (if
         # any) followed after the endpoint ("/" or ".") while index 2 contains
         # everything else.
+        #
+        custom_path   = "/v#{ interface.version }/#{ interface.endpoint }"
+        custom_regexp = /\/v#{ interface.version }\/#{ interface.endpoint }(\.|\/|$)(.*)/
+
+        # Same as above, but for the de facto routing.
+        #
+        de_facto_path   = self.class.de_facto_path_for( interface.resource, interface.version )
+        de_facto_regexp = /\/#{ interface.version }\/#{ interface.resource }(\.|\/|$)(.*)/
 
         Hoodoo::Services::Discovery::ForLocal.new(
           :resource                => interface.resource,
           :version                 => interface.version,
-          :base_path               => "/v#{ interface.version }/#{ interface.endpoint }",
-          :routing_regexp          => /\/v#{ interface.version }\/#{ interface.endpoint }(\.|\/|$)(.*)/,
+          :base_path               => custom_path,
+          :routing_regexp          => custom_regexp,
+          :de_facto_base_path      => de_facto_path,
+          :de_facto_routing_regexp => de_facto_regexp,
           :interface_class         => interface,
-          :implementation_instance => interface.implementation.new
+          :implementation_instance => implementation_instance
         )
+
       end
 
+      # Determine the service name from the resources above then announce
+      # the whole collection to any interested discovery engines.
+
+      sorted_resources = @@services.map() { | service | service.resource }.sort()
+      @@service_name   = "service.#{ sorted_resources.join( '_' ) }"
+
       announce_presence_of( @@services )
     end
 
@@ -972,7 +1025,8 @@ module Hoodoo; module Services
     # +env+:: Rack 'env' parameter from e.g. Rack's invocation of #call.
     #
     def enable_alchemy_logging_from( env )
-      alchemy = env[ 'rack.alchemy' ]
+      alchemy = env[ 'alchemy.service' ]
+
       unless alchemy.nil? || defined?( @@alchemy )
         @@alchemy = alchemy
         self.class.send( :add_queue_logging, @@alchemy ) unless @@alchemy.nil?
@@ -1343,22 +1397,13 @@ module Hoodoo; module Services
       end
     end
 
-    # Announce the presence of the service endpoints to known interested
-    # parties.
+    # Announce the presence of the local resource endpoints in this service
+    # to known interested parties.
     #
     # ONLY CALL AS PART OF INSTANCE CREATION (from #initialize).
     #
-    # +services+:: Array of Hashes describing service information.
-    #
-    # Hash keys/values are as follows:
-    #
-    # +regexp+::         A regular expression for a URI path which, if matched,
-    #                    means that this service endpoint is being called.
-    # +path+::           The endpoint path that the regexp would match, with
-    #                    leading "/" (e.g. "/v1/products")
-    # +interface+::      The Interface subclass for this endpoint.
-    # +implementation+:: The Implementation subclass instance for this
-    #                    endpoint.
+    # +services+:: Array of Hoodoo::Services::Discovery::ForLocal instances
+    #              describing available resources in this local service.
     #
     def announce_presence_of( services )
 
@@ -1370,7 +1415,7 @@ module Hoodoo; module Services
       #
       # A class variable is wrong, as entirely new instances of the service
       # middleware might be stood up in one process and could potentially
-      # be handling different services. This is typically only the case for
+      # be handling different resources. This is typically only the case for
       # running tests, but *might* happen elsewhere too. In any event, we
       # don't want announcements in one instance to pollute the discovery
       # data in another (especially the records of which services were
@@ -1378,14 +1423,15 @@ module Hoodoo; module Services
 
       if self.class.on_queue?
 
-        @discoverer ||= Hoodoo::Services::Discovery::ByConsul.new
+        @discoverer ||= Hoodoo::Services::Discovery::ByFlux.new
 
         services.each do | service |
           interface = service.interface_class
 
           @discoverer.announce(
             interface.resource,
-            interface.version
+            interface.version,
+            { :services => services }
           )
         end
 
@@ -1584,12 +1630,16 @@ module Hoodoo; module Services
       # then there's no matching endpoint; badly routed request; 404. If we
       # find many, raise an exception and rely on the exception handler to
       # send back a 500.
+      #
+      # We try the custom routing path first, then the de facto path, then
+      # give up if neither match.
 
       uri_path = CGI.unescape( interaction.rack_request.path() )
 
       selected_path_data = nil
       selected_services  = @@services.select do | service_data |
-        path_data = process_uri_path( uri_path, service_data.routing_regexp )
+        path_data = process_uri_path( uri_path, service_data.routing_regexp ) ||
+                    process_uri_path( uri_path, service_data.de_facto_routing_regexp )
 
         if path_data.nil?
           false

data/lib/hoodoo/services/services/service.rb

@@ -102,7 +102,7 @@ module Hoodoo; module Services
     # +env+:: Rack environment (ignored).
     #
     def call( env )
-      raise "Hoodoo::Services::Implementation subclasses should only be called through the middleware - add 'use Hoodoo::Services::Middleware' to (e.g.) config.ru"
+      raise "Hoodoo::Services::Service subclasses should only be called through the middleware - add 'use Hoodoo::Services::Middleware' to (e.g.) config.ru"
     end
 
   protected
@@ -126,7 +126,7 @@ module Hoodoo; module Services
       #
       classes.each do | klass |
         unless klass < Hoodoo::Services::Interface
-          raise "Hoodoo::Services::Implementation::comprised_of expects Hoodoo::Services::Interface subclasses only - got '#{ klass }'"
+          raise "Hoodoo::Services::Service::comprised_of expects Hoodoo::Services::Interface subclasses only - got '#{ klass }'"
         end
       end
 

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.0.5'
+  VERSION = '1.1.0'
 
 end

data/spec/services/discovery/discoverers/by_flux_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe Hoodoo::Services::Discovery::ByFlux do
+
+  after :all do
+    Hoodoo::Services::Middleware.flush_services_for_test()
+  end
+
+  context 'without a mocked service name it' do
+    before :each do
+      @d = described_class.new
+      allow( Hoodoo::Services::Middleware ).to receive( :service_name ).and_return( 'service.Version' )
+    end
+
+    it 'announces' do
+      result = @d.announce( 'Version', '2' ) # Intentional string use
+
+      expect( result ).to be_a( Hoodoo::Services::Discovery::ForAMQP )
+      expect( result.resource ).to eq( :Version )
+      expect( result.version ).to eq( 2 )
+      expect( result.routing_path ).to eq( '/2/Version')
+    end
+
+    it 'discovers local' do
+               @d.announce( :Version,   2  )
+      result = @d.discover( 'Version', '2' )
+
+      expect( result ).to be_a( Hoodoo::Services::Discovery::ForAMQP )
+      expect( result.resource ).to eq( :Version )
+      expect( result.version ).to eq( 2 )
+      expect( result.routing_path ).to eq( '/2/Version')
+    end
+
+    it 'discovers remote' do
+      result = @d.discover( 'External', 1 )
+
+      expect( result ).to be_a( Hoodoo::Services::Discovery::ForAMQP )
+      expect( result.resource ).to eq( :External )
+      expect( result.version ).to eq( 1 )
+      expect( result.routing_path ).to eq( '/1/External')
+    end
+  end
+
+  context 'with a real service list it' do
+
+    class FluxDiscovererImplementationA < Hoodoo::Services::Implementation; end
+    class FluxDiscovererImplementationB < Hoodoo::Services::Implementation; end
+    class FluxDiscovererImplementationC < Hoodoo::Services::Implementation; end
+
+    class FluxDiscovererInterfaceA < Hoodoo::Services::Interface
+      interface :InterfaceA do
+        endpoint :a_interfaces, FluxDiscovererImplementationA
+        version 1
+      end
+    end
+
+    class FluxDiscovererInterfaceB < Hoodoo::Services::Interface
+      interface :InterfaceB do
+        endpoint :b_interfaces, FluxDiscovererImplementationA
+        version 2
+      end
+    end
+
+    class FluxDiscovererInterfaceC < Hoodoo::Services::Interface
+      interface :InterfaceC do
+        endpoint :c_interfaces, FluxDiscovererImplementationA
+        version 3
+      end
+    end
+
+    # Intentionally not in alphabetical order, to check for reordering in
+    # service name / queue name environment variable later.
+    #
+    class FluxDiscovererService < Hoodoo::Services::Service
+      comprised_of FluxDiscovererInterfaceB,
+                   FluxDiscovererInterfaceA,
+                   FluxDiscovererInterfaceC
+    end
+
+    before :each do
+      Hoodoo::Services::Middleware.flush_services_for_test()
+      @d = described_class.new
+    end
+
+    it 'announces and sets environment variables' do
+      ENV.delete( 'ALCHEMY_SERVICE_NAME'   )
+      ENV.delete( 'ALCHEMY_RESOURCE_PATHS' )
+
+      expect_any_instance_of( Hoodoo::Services::Middleware ).to receive( :announce_presence_of ) do | instance, services |
+        result = @d.announce( :InterfaceA, '1', { :services => services } )
+
+        expect( result ).to be_a( Hoodoo::Services::Discovery::ForAMQP )
+        expect( result.resource ).to eq( :InterfaceA )
+        expect( result.version ).to eq( 1 )
+        expect( result.routing_path ).to eq( '/1/InterfaceA')
+      end
+
+      Hoodoo::Services::Middleware.new( FluxDiscovererService.new )
+
+      expect( ENV[ 'ALCHEMY_SERVICE_NAME'   ] ).to eq( 'service.InterfaceA_InterfaceB_InterfaceC' )
+      expect( ENV[ 'ALCHEMY_RESOURCE_PATHS' ].split( ',' ) ).to match_array(
+        %w{ /v1/a_interfaces /1/InterfaceA /v2/b_interfaces /2/InterfaceB /v3/c_interfaces /3/InterfaceC }
+      )
+    end
+
+    it 'discovers local' do
+      expect_any_instance_of( Hoodoo::Services::Middleware ).to receive( :announce_presence_of ) do | instance, services |
+                 @d.announce( :InterfaceC,   3, { :services => services } )
+        result = @d.discover( 'InterfaceC', '3' )
+
+        expect( result ).to be_a( Hoodoo::Services::Discovery::ForAMQP )
+        expect( result.resource ).to eq( :InterfaceC )
+        expect( result.version ).to eq( 3 )
+        expect( result.routing_path ).to eq( '/3/InterfaceC')
+      end
+
+      Hoodoo::Services::Middleware.new( FluxDiscovererService.new )
+    end
+
+    it 'discovers remote' do
+      expect_any_instance_of( Hoodoo::Services::Middleware ).to receive( :announce_presence_of ) do | instance, services |
+        result = @d.discover( 'External', 1 )
+
+        expect( result ).to be_a( Hoodoo::Services::Discovery::ForAMQP )
+        expect( result.resource ).to eq( :External )
+        expect( result.version ).to eq( 1 )
+        expect( result.routing_path ).to eq( '/1/External')
+      end
+
+      Hoodoo::Services::Middleware.new( FluxDiscovererService.new )
+    end
+
+  end
+end