startback 0.11.5 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa9e440ddba682a1c59c98a5635b0febafe08222e9cee2de68d3262c6da6d8d4
-  data.tar.gz: '09a4748015aa374687c4016341d7f6a699d80718da7f9b4a6449294d69cf7897'
+  metadata.gz: 67ffd7abceaf1b4e048cc8f02f668b682ea81f62fc7de5228a9f0d12abab1df8
+  data.tar.gz: 1eb075bdec30a569726bc3f2a74c1ce427aef8ff0c3cbcee401a61c034e71ca6
 SHA512:
-  metadata.gz: 6f832ba94f865dfd66c372fcf19623c68f43c76019623fd49da96e88fa2c7355bc78916ae98f3ae32de7e4deb0f08d9ade5d7eb2b3fa9f9bebb5544c0de698d4
-  data.tar.gz: 6ec4e88b7f2bc2ffd58d6e0cddb5bfffc5411149b71a97d1a51e7195105bd907568b45afec40f47916c17dbc45dfe81a5e6432781fa821dbdb2b1ba47f614c86
+  metadata.gz: 8cb4d6f1302a34cab267c836c1e0d81c54267607de7f24d350183ff05a79af7cc216a6f34bc96c0e1204f71cca1de744fde448590e99bd96a1ab45c15c8ceddf
+  data.tar.gz: fecf573e39eb04317d756414349d94092f24a07210629a55347191ef74ec94fcc8079f8a4f38b6c58bf94be5c59fbd79a90a168a4925819ce771269ccae6e3da

data/lib/startback/event/agent.rb

@@ -1,7 +1,70 @@
 module Startback
   class Event
+    #
+    # An agent listen to specific events and react with its
+    # `call` method.
+    #
+    # This class is intended to be subclasses and the following
+    # methods overriden:
+    #
+    #   - install_listeners that installs sync and async listeners
+    #   - call to create a context and implement reaction behavior
+    #
     class Agent
       include Support::OperationRunner
+      include Support::Robustness
+
+      def initialize(engine)
+        @engine = engine
+        install_listeners
+      end
+      attr_reader :engine
+
+    protected
+
+      # Installs the various event handlers by calling `sync`
+      # and `async` methods.
+      #
+      # This method is intended to be overriden.
+      def install_listeners
+      end
+
+      # Returns the underlying bus
+      def bus
+        engine.bus
+      end
+
+      # Asynchronously listen to a specific event.
+      #
+      # See Bus#listen
+      def async(exchange, queue)
+        bus.async.listen(exchange, queue) do |event|
+          dup.call(event)
+        end
+      end
+
+      # Synchronously listen to a specific event.
+      #
+      # See Bus#listen
+      def sync(exchange, queue)
+        bus.listen(exchange, queue) do |event|
+          dup.call(event)
+        end
+      end
+
+      # Reacts to a specific event.
+      #
+      # This method must be implemented by subclasses and raises
+      # an error by default.
+      def call(event = nil)
+        log(:fatal, {
+          op: self.class,
+          op_data: event,
+          error: %Q{Unexpected call to Startback::Event::Agent#call},
+          backtrace: caller
+        })
+        raise NotImplementedError
+      end
 
     end # class Agent
   end # class Event

data/lib/startback/event/bus/bunny/async.rb

@@ -0,0 +1,165 @@
+require 'bunny'
+module Startback
+  class Event
+    class Bus
+      module Bunny
+        #
+        # Asynchronous implementation of the bus abstraction, on top of RabbitMQ
+        # and using the 'bunny' gem (you need to include it in your Gemfile
+        # yourself: it is NOT a startback official dependency).
+        #
+        # This bus implementation emits events by dumping them to RabbitMQ using
+        # the event type as exchange name. Listeners may use the `processor`
+        # parameter to specify the queue name ; otherwise a default "main" queue
+        # is used.
+        #
+        # Examples:
+        #
+        #     # Connects to RabbitMQ using all default options
+        #     #
+        #     # Uses the STARTBACK_BUS_BUNNY_ASYNC_URL environment variable for
+        #     # connection URL if present.
+        #     Startback::Bus::Bunny::Async.new
+        #
+        #     # Connects to RabbitMQ using a specific URL
+        #     Startback::Bus::Bunny::Async.new("amqp://rabbituser:rabbitpass@192.168.17.17")
+        #     Startback::Bus::Bunny::Async.new(url: "amqp://rabbituser:rabbitpass@192.168.17.17")
+        #
+        #     # Connects to RabbitMQ using specific connection options. See Bunny's own
+        #     # documentation
+        #     Startback::Bus::Bunny::Async.new({
+        #       connection_options: {
+        #         host: "192.168.17.17"
+        #       }
+        #     })
+        #
+        class Async
+          include Support::Robustness
+
+          CHANNEL_KEY = 'Startback::Bus::Bunny::Async::ChannelKey'
+
+          DEFAULT_OPTIONS = {
+            # (optional) The URL to use for connecting to RabbitMQ.
+            url: ENV['STARTBACK_BUS_BUNNY_ASYNC_URL'],
+
+            # (optional) The options has to pass to ::Bunny constructor
+            connection_options: nil,
+
+            # (optional) The options to use for the emitter/listener fanout
+            fanout_options: {},
+
+            # (optional) The options to use for the listener queue
+            queue_options: {},
+
+            # (optional) Default event factory to use, if any
+            event_factory: nil,
+
+            # (optional) A default context to use for general logging
+            context: nil,
+
+            # (optional) Size of consumer pool
+            consumer_pool_size: 1,
+
+            # (optional) Whether the program must be aborted on consumption
+            # error
+            abort_on_exception: true,
+
+            # (optional) Whether connection occurs immediately,
+            # or on demand later
+            autoconnect: false
+          }
+
+          # Creates a bus instance, using the various options provided to
+          # fine-tune behavior.
+          def initialize(options = {})
+            options = { url: options } if options.is_a?(String)
+            @options = DEFAULT_OPTIONS.merge(options)
+            connect if @options[:autoconnect]
+          end
+          attr_reader :options
+
+          def connect
+            disconnect
+            conn = options[:connection_options] || options[:url]
+            try_max_times(10) do
+              @bunny = ::Bunny.new(conn)
+              @bunny.start
+              channel # make sure we already create the channel
+              log(:info, {op: "#{self.class.name}#connect", op_data: conn}, options[:context])
+            end
+          end
+
+          def disconnect
+            if channel = Thread.current[CHANNEL_KEY]
+              channel.close
+              Thread.current[CHANNEL_KEY] = nil
+            end
+            @bunny.close if @bunny
+          end
+
+          def channel
+            unless @bunny
+              raise Startback::Errors::Error, "Please connect your bus first, or use autoconnect: true"
+            end
+
+            Thread.current[CHANNEL_KEY] ||= @bunny.create_channel(
+              nil,
+              consumer_pool_size, # consumer_pool_size
+              abort_on_exception? # consumer_pool_abort_on_exception
+            )
+          end
+
+          def emit(event)
+            stop_errors(self, "emit", event.context) do
+              fanout = channel.fanout(event.type.to_s, fanout_options)
+              fanout.publish(event.to_json)
+            end
+          end
+
+          def listen(type, processor = nil, listener = nil, &bl)
+            raise ArgumentError, "A listener must be provided" unless listener || bl
+
+            fanout = channel.fanout(type.to_s, fanout_options)
+            queue = channel.queue((processor || "main").to_s, queue_options)
+            queue.bind(fanout)
+            queue.subscribe do |delivery_info, properties, body|
+              event = stop_errors(self, "listen") do
+                factor_event(body)
+              end
+              stop_errors(self, "listen", event.context) do
+                (listener || bl).call(event)
+              end
+            end
+          end
+
+        protected
+
+          def consumer_pool_size
+            options[:consumer_pool_size]
+          end
+
+          def abort_on_exception?
+            options[:abort_on_exception]
+          end
+
+          def fanout_options
+            options[:fanout_options]
+          end
+
+          def queue_options
+            options[:queue_options]
+          end
+
+          def factor_event(body)
+            if options[:event_factory]
+              options[:event_factory].call(body)
+            else
+              Event.json(body, options)
+            end
+          end
+
+        end # class Async
+      end # module Bunny
+    end # class Bus
+  end # class Event
+end # module Startback

data/lib/startback/event/bus/memory/async.rb

@@ -0,0 +1,45 @@
+module Startback
+  class Event
+    class Bus
+      module Memory
+        #
+        # Asynchronous implementation of the Bus abstraction, for use between
+        # components sharing the same process.
+        #
+        # This implementation actually calls listeners synchronously (it mays)
+        # but hides error raised by them. See Bus::Bunny::Async for another
+        # implementation that is truly asynchronous and relies on RabbitMQ.
+        #
+        class Async
+          include Support::Robustness
+
+          DEFAULT_OPTIONS = {
+          }
+
+          def initialize(options = {})
+            @options = DEFAULT_OPTIONS.merge(options)
+            @listeners = {}
+          end
+
+          def connect
+          end
+
+          def emit(event)
+            (@listeners[event.type.to_s] || []).each do |l|
+              stop_errors(self, "emit", event) {
+                l.call(event)
+              }
+            end
+          end
+
+          def listen(type, processor = nil, listener = nil, &bl)
+            raise ArgumentError, "A listener must be provided" unless listener || bl
+            @listeners[type.to_s] ||= []
+            @listeners[type.to_s] << (listener || bl)
+          end
+
+        end # class Sync
+      end # module Memory
+    end # class Bus
+  end # class Event
+end # module Startback

data/lib/startback/event/bus/memory/sync.rb

@@ -0,0 +1,35 @@
+module Startback
+  class Event
+    class Bus
+      module Memory
+        #
+        # Synchronous implementation of the Bus abstraction, for use between
+        # components sharing the same process.
+        #
+        class Sync
+          include Support::Robustness
+
+          def initialize
+            @listeners = {}
+          end
+
+          def connect
+          end
+
+          def emit(event)
+            (@listeners[event.type.to_s] || []).each do |l|
+              l.call(event)
+            end
+          end
+
+          def listen(type, processor = nil, listener = nil, &bl)
+            raise ArgumentError, "A listener must be provided" unless listener || bl
+            @listeners[type.to_s] ||= []
+            @listeners[type.to_s] << (listener || bl)
+          end
+
+        end # class Sync
+      end # module Memory
+    end # class Bus
+  end # class Event
+end # module Startback

data/lib/startback/event/bus.rb

@@ -0,0 +1,100 @@
+module Startback
+  class Event
+    #
+    # Sync and async bus abstraction allowing to register listeners and
+    # emitting events towards them.
+    #
+    # This bus actually decorates two busses, one in synchronous and the
+    # other one is asynchronous (optional).
+    #
+    # * A synchronous bus MUST call the listeners as part of emitting
+    #   process, and MUST re-raise any error occuring during that process.
+    #   See, e.g. Startback::Bus::Memory::Sync
+    #
+    # * An asynchronous bus MAY call the listeners later, but MUST hide
+    #   errors to the emitter.
+    #   See, e.g. Startback::Bus::Memory::Async
+    #
+    # This bus facade emits events to both sync and async busses (if any),
+    # and listen on the sync one by default.
+    #
+    # For emitters:
+    #
+    #     # This will synchronously call every listeners who `listen`
+    #     # on the synchronous bus (& reraise exceptions) then call
+    #     # (possibly later) all listeners who `listen` on the
+    #     # asynchronous bus if any (& hide exceptions).
+    #     bus.emit(event)
+    #
+    #     # This only reaches sync listeners
+    #     bus.sync.emit(event)
+    #
+    #     # This only reaches async listeners (an async bus must be set)
+    #     bus.async.emit(event)
+    #
+    # Please note that there is currently no way to reach sync listeners
+    # without having to implement error handling on the emitter side.
+    #
+    # For listeners:
+    #
+    #     # This will listen synchronously and make the emitter fail if
+    #     # anything goes wrong with the callback:
+    #     bus.listen(event_type) do |event|
+    #       ...
+    #     end
+    #
+    #     # It is a shortcut for:
+    #     bus.sync.listen(event_type) do |event| ... end
+    #
+    #     This will listen asynchronously and could not make the emitter
+    #     fail if something goes wrong with the callback.
+    #     bus.async.listen(event_type) do |event|
+    #       ...
+    #     end
+    #
+    # Feel free to access the sync and async busses directly for specific
+    # cases though.
+    #
+    class Bus
+      include Support::Robustness
+
+      def initialize(sync = Memory::Sync.new, async = nil)
+        @sync = sync
+        @async = async
+      end
+      attr_reader :sync, :async
+
+      def connect
+        sync.connect if sync
+        async.connect if async
+      end
+
+      # Emits a particular event to the listeners.
+      #
+      # @arg event an event, should be an Event instance (through duck
+      #      typing is allowed)
+      def emit(event)
+        monitor({
+          op: "Startback::Bus#emit",
+          op_data: {
+            event: { type: event.type }
+          }
+        }, event.context) do
+          sync.emit(event)
+          async.emit(event) if async
+        end
+      end
+
+      # Registers `listener` as being interested in receiving events of
+      # a specific type.
+      #
+      # @arg type: Symbol, the type of event the listener is interested in.
+      # @arg listener: Proc, the listener itself.
+      def listen(type, processor = nil, listener = nil, &bl)
+        sync.listen(type, processor, listener, &bl)
+      end
+
+    end # class Bus
+  end # class Event
+end # module Startback
+require_relative 'bus/memory'

data/lib/startback/event/engine.rb

@@ -4,10 +4,10 @@ require 'startback'
 module Startback
   class Event
     #
-    # This class runs an infinite loop using ServerEngine.
-    # It is intended to be used to run jobs that listen to
-    # a Startback Bus instance without having the main process
-    # terminating immediately.
+    # This class is the starting point of event handling in
+    # Startback. It holds a Bus instance to which emitters
+    # and listeners can connect, and the possibility for the
+    # the listening part to start an infinite loop (ServerEngine).
     #
     # The Engine automatically runs a Webrick small webapp
     # with a /healthcheck webservice. The class can be extended
@@ -15,86 +15,157 @@ module Startback
     # checks.
     #
     # This class goes hand in hand with the `startback:engine`
-    # docker image.
+    # docker image. It can be extended by subclasses to override
+    # the following methods:
     #
-    # Example:
-    #
-    #     # Dockerfile
-    #     FROM enspirit/startback:engine-0.11
-    #
-    #     # engine.rb
-    #     require 'startback/event/engine'
-    #     Startback::Event::Engine.run
+    #   - bus to use something else than a simple memory bus
+    #   - on_health_check to check specific health conditions
+    #   - create_agents to instantiate all listening agents
+    #     (unless auto_create_agents is used)
     #
     class Engine
+      include Support::Robustness
 
       DEFAULT_OPTIONS = {
-        daemonize: false,
-        worker_type: 'process',
-        workers: 1
+
+        # To be passed to ServerEngine
+        server_engine: {}
+
       }
 
-      def initialize
-        require 'serverengine'
+      def initialize(options = {}, context = Context.new)
+        @options = DEFAULT_OPTIONS.merge(options)
+        @context = context
+      end
+      attr_reader :options, :context
+
+      class << self
+        def auto_create_agents?
+          !!@auto_create_agents
+        end
+
+        # Register a base class which will be used to discover
+        # the agents to start when the engine is ran.
+        def auto_create_agents(base_class = nil)
+          @auto_create_agents ||= base_class
+          @auto_create_agents
+        end
       end
 
+      # This method is executed on health check and can be
+      # overriden by subclasses to perform specific checks.
       def on_health_check
         "Ok"
       end
 
+      def bus
+        ::Startback::Event::Bus.new
+      end
+
+      def connect
+        log(:info, self, "Connecting to the bus now!")
+        bus.connect
+      end
+
       def run(options = {})
-        options = DEFAULT_OPTIONS.merge(options)
-        health = Engine.build_health_check(self)
-        worker = Engine.build_worker(health)
-        se = ServerEngine.create(nil, worker, options)
-        se.run
-        se
+        connect
+
+        log(:info, self, "Running agents and server engine!")
+        create_agents
+        Runner.new(self, options[:server_engine] || {}).run
       end
 
-      class << self
-        def run(*args, &bl)
-          new.run(*args, &bl)
+      def create_agents
+        return unless parent = self.class.auto_create_agents
+
+        ObjectSpace
+          .each_object(Class)
+          .select { |klass| klass < parent }
+          .each { |klass| klass.new(self) }
+      end
+
+      class Runner
+
+        DEFAULT_SERVER_ENGINE_OPTIONS = {
+          daemonize: false,
+          worker_type: 'process',
+          workers: 1
+        }
+
+        def initialize(engine, options = {})
+          raise ArgumentError if engine.nil?
+
+          @engine = engine
+          @options = DEFAULT_SERVER_ENGINE_OPTIONS.merge(options)
+          require 'serverengine'
         end
+        attr_reader :engine, :options
 
-        def build_health_check(engine)
-          Rack::Builder.new do
-            map '/health-check' do
-              health = Startback::Web::HealthCheck.new {
-                engine.on_health_check
-              }
-              run(health)
-            end
-          end
+        def run(options = {})
+          health = self.class.build_health_check(engine)
+          worker = self.class.build_worker(engine, health)
+          se = ServerEngine.create(nil, worker, options)
+          se.run
+          se
         end
 
-        def build_worker(health)
-          Module.new do
-            include Support::Env
+        class << self
+          def run(*args, &bl)
+            new.run(*args, &bl)
+          end
 
-            def initialize
-              @stop_flag = ServerEngine::BlockingFlag.new
+          def build_health_check(engine)
+            Rack::Builder.new do
+              map '/health-check' do
+                health = Startback::Web::HealthCheck.new {
+                  engine.on_health_check
+                }
+                run(health)
+              end
             end
+          end
 
-            define_method(:health) do
-              health
-            end
+          def build_worker(engine, health)
+            Module.new do
+              include Support::Env
 
-            def run
-              until @stop_flag.set?
-                Rack::Handler::WEBrick.run(health, {
-                  :Port => env('STARTBACK_ENGINE_PORT', '3000').to_i,
-                  :Host => env('STARTBACK_ENGINE_LISTEN', '0.0.0.0')
-                })
+              def initialize
+                @stop_flag = ServerEngine::BlockingFlag.new
+              end
+
+              define_method(:health) do
+                health
+              end
+
+              define_method(:engine) do
+                engine
               end
-            end
 
-            def stop
-              @stop_flag.set!
-              Rack::Handler::WEBrick.shutdown
+              def run
+                ran = false
+                until @stop_flag.set?
+                  if ran
+                    engine.send(:log, :warn, engine, "Restarting internal loop")
+                  else
+                    engine.send(:log, :info, engine, "Starting internal loop")
+                  end
+                  Rack::Handler::WEBrick.run(health, {
+                    :Port => env('STARTBACK_ENGINE_PORT', '3000').to_i,
+                    :Host => env('STARTBACK_ENGINE_LISTEN', '0.0.0.0')
+                  })
+                  ran = true
+                end
+              end
+
+              def stop
+                engine.send(:log, :info, engine, "Stopping internal loop")
+                @stop_flag.set!
+                Rack::Handler::WEBrick.shutdown
+              end
             end
           end
-        end
-      end # class << self
+        end # class << self
+      end # class Runner
     end # class Engine
   end # class Event
 end # module Startback

data/lib/startback/event.rb

@@ -42,4 +42,5 @@ module Startback
   end # class Event
 end # module Startback
 require_relative 'event/agent'
+require_relative 'event/bus'
 require_relative 'event/engine'

data/lib/startback/support/robustness.rb

@@ -107,8 +107,6 @@ module Startback
         }
         Tools.info(args, op_took: took)
         result
-      rescue => ex
-        raise
       end
 
       # Executes the block without letting errors propagate.

data/lib/startback/version.rb

@@ -1,8 +1,8 @@
 module Startback
   module Version
     MAJOR = 0
-    MINOR = 11
-    TINY  = 5
+    MINOR = 12
+    TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"
 end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'startback'
-require 'startback/bus'
+require 'startback/event'
 require 'startback/support/fake_logger'
 require 'rack/test'
 

data/spec/unit/event/bus/memory/test_async.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Startback
+  class Event
+    describe Bus::Memory do
+
+      subject{
+        Bus::Memory::Async.new
+      }
+
+      it 'allows emiting an receiving' do
+        seen = nil
+        subject.listen("user_changed") do |evt|
+          seen = evt
+        end
+        subject.emit(Event.new("user_changed", {id: 12}))
+        expect(seen).to be_a(Event)
+        expect(seen.type).to eql("user_changed")
+        expect(seen.data.to_h).to eql({id: 12})
+      end
+
+      it 'allows mixin Symbol vs. String for event type' do
+        seen = nil
+        subject.listen(:user_changed) do |evt|
+          seen = evt
+        end
+        subject.emit(Event.new(:user_changed, {id: 12}))
+        expect(seen).to be_a(Event)
+        expect(seen.type).to eql("user_changed")
+        expect(seen.data.to_h).to eql({id: 12})
+      end
+
+      it 'does not raise errors synchronously' do
+        subject.listen("user_changed") do |evt|
+          raise "An error occured"
+        end
+        expect {
+          subject.emit(Event.new("user_changed", {id: 12}))
+        }.not_to raise_error
+      end
+
+    end
+  end
+end

data/spec/unit/event/bus/memory/test_sync.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Startback
+  class Event
+    describe Bus::Memory do
+
+      subject{
+        Bus::Memory::Sync.new
+      }
+
+      it 'allows emiting an receiving' do
+        seen = nil
+        subject.listen("user_changed") do |evt|
+          seen = evt
+        end
+        subject.emit(Event.new("user_changed", {id: 12}))
+        expect(seen).to be_a(Event)
+        expect(seen.type).to eql("user_changed")
+        expect(seen.data.to_h).to eql({id: 12})
+      end
+
+      it 'allows mixin Symbol vs. String for event type' do
+        seen = nil
+        subject.listen(:user_changed) do |evt|
+          seen = evt
+        end
+        subject.emit(Event.new(:user_changed, {id: 12}))
+        expect(seen).to be_a(Event)
+        expect(seen.type).to eql("user_changed")
+        expect(seen.data.to_h).to eql({id: 12})
+      end
+
+      it 'raises emit errors synchronously' do
+        subject.listen("user_changed") do |evt|
+          raise "An error occured"
+        end
+        expect {
+          subject.emit(Event.new("user_changed", {id: 12}))
+        }.to raise_error("An error occured")
+      end
+
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: startback
 version: !ruby/object:Gem::Version
-  version: 0.11.5
+  version: 0.12.0
 platform: ruby
 authors:
 - Bernard Lambeau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-05-18 00:00:00.000000000 Z
+date: 2022-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -385,12 +385,6 @@ files:
 - lib/startback/audit/prometheus.rb
 - lib/startback/audit/shared.rb
 - lib/startback/audit/trailer.rb
-- lib/startback/bus.rb
-- lib/startback/bus/bunny.rb
-- lib/startback/bus/bunny/async.rb
-- lib/startback/bus/memory.rb
-- lib/startback/bus/memory/async.rb
-- lib/startback/bus/memory/sync.rb
 - lib/startback/caching/entity_cache.rb
 - lib/startback/caching/no_store.rb
 - lib/startback/caching/store.rb
@@ -399,6 +393,12 @@ files:
 - lib/startback/errors.rb
 - lib/startback/event.rb
 - lib/startback/event/agent.rb
+- lib/startback/event/bus.rb
+- lib/startback/event/bus/bunny.rb
+- lib/startback/event/bus/bunny/async.rb
+- lib/startback/event/bus/memory.rb
+- lib/startback/event/bus/memory/async.rb
+- lib/startback/event/bus/memory/sync.rb
 - lib/startback/event/engine.rb
 - lib/startback/ext.rb
 - lib/startback/ext/date_time.rb
@@ -431,13 +431,13 @@ files:
 - spec/spec_helper.rb
 - spec/unit/audit/test_prometheus.rb
 - spec/unit/audit/test_trailer.rb
-- spec/unit/bus/memory/test_async.rb
-- spec/unit/bus/memory/test_sync.rb
 - spec/unit/caching/test_entity_cache.rb
 - spec/unit/context/test_abstraction_factory.rb
 - spec/unit/context/test_dup.rb
 - spec/unit/context/test_h_factory.rb
 - spec/unit/context/test_middleware.rb
+- spec/unit/event/bus/memory/test_async.rb
+- spec/unit/event/bus/memory/test_sync.rb
 - spec/unit/support/hooks/test_after_hook.rb
 - spec/unit/support/hooks/test_before_hook.rb
 - spec/unit/support/operation_runner/test_around_run.rb

data/lib/startback/bus/bunny/async.rb

@@ -1,123 +0,0 @@
-require 'bunny'
-module Startback
-  class Bus
-    module Bunny
-      #
-      # Asynchronous implementation of the bus abstraction, on top of RabbitMQ
-      # and using the 'bunny' gem (you need to include it in your Gemfile
-      # yourself: it is NOT a startback official dependency).
-      #
-      # This bus implementation emits events by dumping them to RabbitMQ using
-      # the event type as exchange name. Listeners may use the `processor`
-      # parameter to specify the queue name ; otherwise a default "main" queue
-      # is used.
-      #
-      # Examples:
-      #
-      #     # Connects to RabbitMQ using all default options
-      #     #
-      #     # Uses the STARTBACK_BUS_BUNNY_ASYNC_URL environment variable for
-      #     # connection URL if present.
-      #     Startback::Bus::Bunny::Async.new
-      #
-      #     # Connects to RabbitMQ using a specific URL
-      #     Startback::Bus::Bunny::Async.new("amqp://rabbituser:rabbitpass@192.168.17.17")
-      #     Startback::Bus::Bunny::Async.new(url: "amqp://rabbituser:rabbitpass@192.168.17.17")
-      #
-      #     # Connects to RabbitMQ using specific connection options. See Bunny's own
-      #     # documentation
-      #     Startback::Bus::Bunny::Async.new({
-      #       connection_options: {
-      #         host: "192.168.17.17"
-      #       }
-      #     })
-      #
-      class Async
-        include Support::Robustness
-
-        CHANNEL_KEY = 'Startback::Bus::Bunny::Async::ChannelKey'
-
-        DEFAULT_OPTIONS = {
-          # (optional) The URL to use for connecting to RabbitMQ.
-          url: ENV['STARTBACK_BUS_BUNNY_ASYNC_URL'],
-
-          # (optional) The options has to pass to ::Bunny constructor
-          connection_options: nil,
-
-          # (optional) The options to use for the emitter/listener fanout
-          fanout_options: {},
-
-          # (optional) The options to use for the listener queue
-          queue_options: {},
-
-          # (optional) Default event factory to use, if any
-          event_factory: nil,
-
-          # (optional) A default context to use for general logging
-          context: nil
-        }
-
-        # Creates a bus instance, using the various options provided to
-        # fine-tune behavior.
-        def initialize(options = {})
-          options = { url: options } if options.is_a?(String)
-          @options = DEFAULT_OPTIONS.merge(options)
-          retried = 0
-          conn = options[:connection_options] || options[:url]
-          try_max_times(10) do
-            @bunny = ::Bunny.new(conn)
-            @bunny.start
-            channel
-            log(:info, {op: "#{self.class.name}#connect", op_data: conn}, options[:context])
-          end
-        end
-        attr_reader :options
-
-        def channel
-          Thread.current[CHANNEL_KEY] ||= @bunny.create_channel
-        end
-
-        def emit(event)
-          stop_errors(self, "emit", event.context) do
-            fanout = channel.fanout(event.type.to_s, fanout_options)
-            fanout.publish(event.to_json)
-          end
-        end
-
-        def listen(type, processor = nil, listener = nil, &bl)
-          raise ArgumentError, "A listener must be provided" unless listener || bl
-          fanout = channel.fanout(type.to_s, fanout_options)
-          queue = channel.queue((processor || "main").to_s, queue_options)
-          queue.bind(fanout)
-          queue.subscribe do |delivery_info, properties, body|
-            event = stop_errors(self, "listen") do
-              factor_event(body)
-            end
-            stop_errors(self, "listen", event.context) do
-              (listener || bl).call(event)
-            end
-          end
-        end
-
-      protected
-
-        def fanout_options
-          options[:fanout_options]
-        end
-
-        def queue_options
-          options[:queue_options]
-        end
-
-        def factor_event(body)
-          if options[:event_factory]
-            options[:event_factory].call(body)
-          else
-            Event.json(body, options)
-          end
-        end
-
-      end # class Async
-    end # module Bunny
-  end # class Bus
-end # module Klaro

data/lib/startback/bus/memory/async.rb

@@ -1,40 +0,0 @@
-module Startback
-  class Bus
-    module Memory
-      #
-      # Asynchronous implementation of the Bus abstraction, for use between
-      # components sharing the same process.
-      #
-      # This implementation actually calls listeners synchronously (it mays)
-      # but hides error raised by them. See Bus::Bunny::Async for another
-      # implementation that is truly asynchronous and relies on RabbitMQ.
-      #
-      class Async
-        include Support::Robustness
-
-        DEFAULT_OPTIONS = {
-        }
-
-        def initialize(options = {})
-          @options = DEFAULT_OPTIONS.merge(options)
-          @listeners = {}
-        end
-
-        def emit(event)
-          (@listeners[event.type.to_s] || []).each do |l|
-            stop_errors(self, "emit", event) {
-              l.call(event)
-            }
-          end
-        end
-
-        def listen(type, processor = nil, listener = nil, &bl)
-          raise ArgumentError, "A listener must be provided" unless listener || bl
-          @listeners[type.to_s] ||= []
-          @listeners[type.to_s] << (listener || bl)
-        end
-
-      end # class Sync
-    end # module Memory
-  end # class Bus
-end # module Klaro

data/lib/startback/bus/memory/sync.rb

@@ -1,30 +0,0 @@
-module Startback
-  class Bus
-    module Memory
-      #
-      # Synchronous implementation of the Bus abstraction, for use between
-      # components sharing the same process.
-      #
-      class Sync
-        include Support::Robustness
-
-        def initialize
-          @listeners = {}
-        end
-
-        def emit(event)
-          (@listeners[event.type.to_s] || []).each do |l|
-            l.call(event)
-          end
-        end
-
-        def listen(type, processor = nil, listener = nil, &bl)
-          raise ArgumentError, "A listener must be provided" unless listener || bl
-          @listeners[type.to_s] ||= []
-          @listeners[type.to_s] << (listener || bl)
-        end
-
-      end # class Sync
-    end # module Memory
-  end # class Bus
-end # module Klaro

data/lib/startback/bus.rb

@@ -1,94 +0,0 @@
-require 'startback/event'
-module Startback
-  #
-  # Sync and async bus abstraction allowing to register listeners and
-  # emitting events towards them.
-  #
-  # This bus actually decorates two busses, one in synchronous and the
-  # other one is asynchronous (optional).
-  #
-  # * A synchronous bus MUST call the listeners as part of emitting
-  #   process, and MUST re-raise any error occuring during that process.
-  #   See, e.g. Startback::Bus::Memory::Sync
-  #  
-  # * An asynchronous bus MAY call the listeners later, but MUST hide
-  #   errors to the emitter.
-  #   See, e.g. Startback::Bus::Memory::Async
-  #
-  # This bus facade emits events to both sync and async busses (if any),
-  # and listen on the sync one by default.
-  #
-  # For emitters:
-  #
-  #     # This will synchronously call every listeners who `listen`
-  #     # on the synchronous bus (& reraise exceptions) then call
-  #     # (possibly later) all listeners who `listen` on the
-  #     # asynchronous bus if any (& hide exceptions).
-  #     bus.emit(event)
-  #
-  #     # This only reaches sync listeners
-  #     bus.sync.emit(event) 
-  #
-  #     # This only reaches async listeners (an async bus must be set)
-  #     bus.async.emit(event)
-  #
-  # Please note that there is currently no way to reach sync listeners
-  # without having to implement error handling on the emitter side. 
-  #
-  # For listeners:
-  #
-  #     # This will listen synchronously and make the emitter fail if
-  #     # anything goes wrong with the callback:
-  #     bus.listen(event_type) do |event|
-  #       ...
-  #     end
-  #
-  #     # It is a shortcut for:
-  #     bus.sync.listen(event_type) do |event| ... end 
-  #
-  #     This will listen asynchronously and could not make the emitter
-  #     fail if something goes wrong with the callback.
-  #     bus.async.listen(event_type) do |event|
-  #       ...
-  #     end
-  #
-  # Feel free to access the sync and async busses directly for specific
-  # cases though.
-  #
-  class Bus
-    include Support::Robustness
-
-    def initialize(sync = Memory::Sync.new, async = nil)
-      @sync = sync
-      @async = async
-    end
-    attr_reader :sync, :async
-
-    # Emits a particular event to the listeners.
-    #
-    # @arg event an event, should be an Event instance (through duck
-    #      typing is allowed)
-    def emit(event)
-      monitor({
-        op: "Startback::Bus#emit",
-        op_data: {
-          event: { type: event.type }
-        }
-      }, event.context) do
-        sync.emit(event)
-        async.emit(event) if async
-      end
-    end
-
-    # Registers `listener` as being interested in receiving events of
-    # a specific type.
-    #
-    # @arg type: Symbol, the type of event the listener is interested in.
-    # @arg listener: Proc, the listener itself. 
-    def listen(type, processor = nil, listener = nil, &bl)
-      sync.listen(type, processor, listener, &bl)
-    end
-
-  end # class Bus
-end # module Klaro
-require_relative 'bus/memory'

data/spec/unit/bus/memory/test_async.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-module Startback
-  describe Bus::Memory do
-
-    subject{
-      Bus::Memory::Async.new
-    }
-
-    it 'allows emiting an receiving' do
-      seen = nil
-      subject.listen("user_changed") do |evt|
-        seen = evt
-      end
-      subject.emit(Event.new("user_changed", {id: 12}))
-      expect(seen).to be_a(Event)
-      expect(seen.type).to eql("user_changed")
-      expect(seen.data.to_h).to eql({id: 12})      
-    end
-
-    it 'allows mixin Symbol vs. String for event type' do
-      seen = nil
-      subject.listen(:user_changed) do |evt|
-        seen = evt
-      end
-      subject.emit(Event.new(:user_changed, {id: 12}))
-      expect(seen).to be_a(Event)
-      expect(seen.type).to eql("user_changed")
-      expect(seen.data.to_h).to eql({id: 12})      
-    end
-
-    it 'does not raise errors synchronously' do
-      subject.listen("user_changed") do |evt|
-        raise "An error occured"
-      end
-      expect {
-        subject.emit(Event.new("user_changed", {id: 12}))
-      }.not_to raise_error
-    end
-
-  end
-end

data/spec/unit/bus/memory/test_sync.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-module Startback
-  describe Bus::Memory do
-
-    subject{
-      Bus::Memory::Sync.new
-    }
-
-    it 'allows emiting an receiving' do
-      seen = nil
-      subject.listen("user_changed") do |evt|
-        seen = evt
-      end
-      subject.emit(Event.new("user_changed", {id: 12}))
-      expect(seen).to be_a(Event)
-      expect(seen.type).to eql("user_changed")
-      expect(seen.data.to_h).to eql({id: 12})      
-    end
-
-    it 'allows mixin Symbol vs. String for event type' do
-      seen = nil
-      subject.listen(:user_changed) do |evt|
-        seen = evt
-      end
-      subject.emit(Event.new(:user_changed, {id: 12}))
-      expect(seen).to be_a(Event)
-      expect(seen.type).to eql("user_changed")
-      expect(seen.data.to_h).to eql({id: 12})      
-    end
-
-    it 'raises emit errors synchronously' do
-      subject.listen("user_changed") do |evt|
-        raise "An error occured"
-      end
-      expect {
-        subject.emit(Event.new("user_changed", {id: 12}))
-      }.to raise_error("An error occured")
-    end
-
-  end
-end