startback 0.11.5 → 0.12.2

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,162 @@ 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
+        @context.engine = self
+      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
+
+      def factor_event(event_data)
+        Event.json(event_data, context)
+      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/ext/context.rb

@@ -0,0 +1,5 @@
+module Startback
+  class Context
+    attr_accessor :engine
+  end # class Context
+end # module Startback

data/lib/startback/event/ext/operation.rb

@@ -0,0 +1,13 @@
+module Startback
+  class Operation
+
+    def self.emits(type, &bl)
+      after_call do
+        event_data = instance_exec(&bl)
+        event = type.new(type.to_s, event_data, context)
+        context.engine.bus.emit(event)
+      end
+    end
+
+  end # class Operation
+end # module Startback

data/lib/startback/event.rb

@@ -20,14 +20,11 @@ module Startback
     end
     attr_reader :context, :type, :data
 
-    def self.json(src, world = {})
+    def self.json(src, context)
       parsed = JSON.parse(src)
-      context = if world[:context]
-        world[:context]
-      elsif world[:context_factory]
-        world[:context_factory].call(parsed)
-      end
-      Event.new(parsed['type'], parsed['data'], context)
+      klass = Kernel.const_get(parsed['type'])
+      context = context.fork(parsed['context']) if context
+      klass.new(parsed['type'], parsed['data'], context)
     end
 
     def to_json(*args, &bl)
@@ -41,5 +38,8 @@ module Startback
 
   end # class Event
 end # module Startback
+require_relative 'event/ext/context'
+require_relative 'event/ext/operation'
 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  = 2
   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'
 
@@ -10,3 +10,28 @@ end
 RSpec.configure do |c|
   c.include SpecHelpers
 end
+
+class SubContext < Startback::Context
+  attr_accessor :foo
+  h_factory do |c,h|
+    c.foo = h["foo"]
+  end
+  h_dump do |h|
+    h.merge!("foo" => foo)
+  end
+end
+
+class SubContext
+  attr_accessor :bar
+  h_factory do |c,h|
+    c.bar = h["bar"]
+  end
+  h_dump do |h|
+    h.merge!("bar" => bar)
+  end
+end
+
+class User
+  class Changed < Startback::Event
+  end
+end

data/spec/unit/context/test_dup.rb

@@ -3,12 +3,8 @@ require 'spec_helper'
 module Startback
   describe Context, "dup" do
 
-    class Subcontext < Context
-      attr_accessor :foo
-    end
-
     let(:context) {
-      Subcontext.new.tap{|s| s.foo = "bar" }
+      SubContext.new.tap{|s| s.foo = "bar" }
     }
 
     class ContextRelatedAbstraction
@@ -27,7 +23,7 @@ module Startback
         expect(x).not_to be(context)
       }
       expect(seen).to be(got)
-      expect(got).to be_a(Subcontext)
+      expect(got).to be_a(SubContext)
       expect(got).not_to be(context)
       expect(got.foo).to eql("bar")
     end
@@ -43,4 +39,4 @@ module Startback
     end
 
   end
-end
+end

data/spec/unit/context/test_fork.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module Startback
+  describe Context, "fork" do
+
+    it 'is a simple dup without args' do
+      context = SubContext.new
+      context.foo = ['hello']
+
+      forked = context.fork
+      puts "Forked: #{forked.inspect}"
+      expect(fork).not_to be(context)
+      expect(forked.foo).to eql(['hello'])
+      expect(forked.foo).to be(context.foo)
+    end
+
+    it 'yields the context if a block is provided' do
+      context = SubContext.new
+
+      seen = false
+      context.fork({ 'foo' => 'hello' }) do |forked|
+        expect(fork).not_to be(context)
+        expect(forked.foo).to eql('hello')
+        seen = true
+      end
+      expect(seen).to eql(true)
+    end
+
+    it 'uses the factory on the hash provided' do
+      context = SubContext.new
+
+      forked = context.fork({ 'foo' => 'hello' })
+      expect(fork).not_to be(context)
+      expect(forked.foo).to eql('hello')
+    end
+
+  end
+end

data/spec/unit/context/test_h_factory.rb

@@ -7,26 +7,6 @@ module Startback
       expect(Context.new.to_json).to eql("{}")
     end
 
-    class SubContext < Context
-      attr_accessor :foo
-      h_factory do |c,h|
-        c.foo = h["foo"]
-      end
-      h_dump do |h|
-        h.merge!("foo" => foo)
-      end
-    end
-
-    class SubContext
-      attr_accessor :bar
-      h_factory do |c,h|
-        c.bar = h["bar"]
-      end
-      h_dump do |h|
-        h.merge!("bar" => bar)
-      end
-    end
-
     it 'allows installing factories' do
       expect(Context.h_factories).to be_empty
       expect(SubContext.h_factories.size).to eql(2)

data/spec/unit/context/test_middleware.rb

@@ -10,18 +10,18 @@ module Startback
       include Rack::Test::Methods
 
       def app
-        opts = middleware_options
+        build_args = self.build_args
         Rack::Builder.new do
-          use Middleware, opts
+          use Middleware, *build_args
           run ->(env){
-            ctx = env[Startback::Context::Middleware::RACK_ENV_KEY] 
+            ctx = env[Startback::Context::Middleware::RACK_ENV_KEY]
             [200, {}, ctx.class.to_s]
           }
         end
       end
 
-      context 'when used without option' do
-        let(:middleware_options){ nil }
+      context 'when used without context' do
+        let(:build_args){ [] }
 
         it 'sets the default context class' do
           get '/'
@@ -31,9 +31,7 @@ module Startback
       end
 
       context 'when specifying the context class' do
-        let(:middleware_options){{
-          context_class: MyContextSubClass
-        }}
+        let(:build_args){ [MyContextSubClass.new] }
 
         it 'sets the default context class' do
           get '/'

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

data/spec/unit/test_event.rb

@@ -4,7 +4,7 @@ module Startback
   describe Event do
 
     subject{
-      Event.new("user_changed", { "foo" => "bar" })
+      Event.new("User::Changed", { "foo" => "bar" })
     }
 
     it 'presents an ostruct on top of its data' do
@@ -15,7 +15,7 @@ module Startback
 
       JSON_SRC = <<-JSON.gsub(/\s+/, "")
         {
-          "type": "user_changed",
+          "type": "User::Changed",
           "data": {
             "foo": "bar"
           }
@@ -27,10 +27,10 @@ module Startback
       end
 
       it 'has a to_json that dumps the context if any' do
-        evt = Event.new("user_changed", { "foo" => "bar" }, { "baz": "context" })
+        evt = Event.new("User::Changed", { "foo" => "bar" }, { "baz": "context" })
         expect(evt.to_json).to eql(<<-JSON.gsub(/\s+/, ""))
           {
-            "type": "user_changed",
+            "type": "User::Changed",
             "data": {
               "foo": "bar"
             },
@@ -43,26 +43,19 @@ module Startback
 
 
       it 'has a json class method that works as expected' do
-        evt = Event.json(JSON_SRC)
+        evt = Event.json(JSON_SRC, nil)
         expect(evt).to be_a(Event)
-        expect(evt.type).to eql("user_changed")
+        expect(evt.type).to eql("User::Changed")
         expect(evt.data).to eql(subject.data)
       end
 
-      it 'accepts an explicit context in the world' do
-        evt = Event.json(JSON_SRC, context: 12)
-        expect(evt.context).to eql(12)
+      it 'accepts an explicit context as second argument' do
+        c = SubContext.new.tap{|x| x.foo = 'hello' }
+        evt = Event.json(JSON_SRC, c)
+        expect(evt.context).not_to be(c)
+        expect(evt.context).to be_a(SubContext)
+        expect(evt.context.foo).to eql('hello')
       end
-
-      it 'accepts an context factory in the world' do
-        cf = ->(arg) {
-          expect(arg).to eql(JSON.parse(JSON_SRC))
-          12
-        }
-        evt = Event.json(JSON_SRC, context_factory: cf)
-        expect(evt.context).to eql(12)
-      end
-
     end
 
   end

data/spec/unit/web/test_catch_all.rb

@@ -53,7 +53,7 @@ module Startback
 
         def app
           Rack::Builder.new do
-            use Context::Middleware, context_class: MyContextWithErrorHandler
+            use Context::Middleware, MyContextWithErrorHandler.new
             use CatchAll
             run ->(env){ raise AnError, "Hello error" }
           end