startback-websocket 0.14.0 → 0.14.3

data/lib/startback/event/agent.rb

@@ -1,84 +0,0 @@
-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
-        @context = nil
-        install_listeners
-      end
-      attr_reader :engine
-      attr_accessor :context
-      protected :context=
-
-    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_data|
-          event = engine.factor_event(event_data)
-          with_context(event.context).call(event)
-        end
-      end
-
-      # Synchronously listen to a specific event.
-      #
-      # See Bus#listen
-      def sync(exchange, queue)
-        bus.listen(exchange, queue) do |event_data|
-          event = engine.factor_event(event_data)
-          with_context(event.context).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
-
-      def with_context(context)
-        dup.tap{|a| a.send(:context=, context) }
-      end
-
-      def operation_world(op)
-        super(op).merge(context: context)
-      end
-
-    end # class Agent
-  end # class Event
-end # module Starback

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

@@ -1,162 +0,0 @@
-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|
-              stop_errors(self, "listen") do
-                (listener || bl).call(body)
-              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/bunny.rb

@@ -1 +0,0 @@
-require_relative 'bunny/async'

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

@@ -1,45 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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/memory.rb

@@ -1,2 +0,0 @@
-require_relative 'memory/sync'
-require_relative 'memory/async'

data/lib/startback/event/bus.rb

@@ -1,100 +0,0 @@
-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

@@ -1,94 +0,0 @@
-require 'rack'
-require 'startback'
-module Startback
-  class Event
-    #
-    # This class is the starting point of event handling in
-    # Startback. It holds a Bus instance to which emitters
-    # and listeners can connect.
-    #
-    # The Engine exposes a rack app (.rack_app) with a /healthcheck webservice.
-    # It is supposed to be mounted to a webserver such as puma.
-    #
-    # This class goes hand in hand with the `startback:engine`
-    # docker image. It can be extended by subclasses to override
-    # the following methods:
-    #
-    #   - 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)
-    #   - rack_app if you want to customize the API running
-    #
-    class Engine
-      include Support::Robustness
-
-      DEFAULT_OPTIONS = {
-
-      }
-
-      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
-        @bus ||= ::Startback::Event::Bus.new
-      end
-
-      def connect
-        log(:info, self, "Connecting to the bus now!")
-        bus.connect
-      end
-
-      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
-
-      def rack_app
-        engine = self
-        Rack::Builder.new do
-          use Startback::Web::CatchAll
-
-          map '/health-check' do
-            health = Startback::Web::HealthCheck.new {
-              engine.on_health_check
-            }
-            run(health)
-          end
-        end
-      end
-
-    end # class Engine
-  end # class Event
-end # module Startback

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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,47 +0,0 @@
-module Startback
-  #
-  # An Event occuring a given context and having a type and attached data.
-  #
-  # Event instances have String types that are by default unrelated to ruby
-  # classes. Also, this Event class has a `json` information contract that
-  # allows dumping & reloading them easily. A context or context_factory may
-  # be provided in dress world to reload the event context from data, but
-  # that logic is opaque to this class.
-  #
-  # This class is intended to be subclassed if a more specific event protocol
-  # is wanted.
-  #
-  class Event
-
-    def initialize(type, data, context = nil)
-      @type = type.to_s
-      @data = OpenStruct.new(data)
-      @context = context
-    end
-    attr_reader :context, :type, :data
-
-    def self.json(src, context)
-      return src if src.is_a?(Event)
-
-      parsed = JSON.parse(src)
-      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)
-      h = {
-        type: self.type,
-        data: data.to_h
-      }
-      h[:context] = context if context
-      h.to_json(*args, &bl)
-    end
-
-  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/ext/date_time.rb

@@ -1,9 +0,0 @@
-class DateTime
-
-  # Makes sure that DateTime are exported with ISO8601
-  # conventions when using to_json and to_csv
-  def to_s(*args)
-    iso8601
-  end
-
-end

data/lib/startback/ext/time.rb

@@ -1,9 +0,0 @@
-class Time
-
-  # Makes sure that Time are exported with ISO8601
-  # conventions when using to_json and to_csv
-  def to_s(*args)
-    iso8601
-  end
-
-end

data/lib/startback/model.rb

@@ -1,6 +0,0 @@
-module Startback
-  class Model
-    include Support::DataObject
-
-  end # class Model
-end # module Startback

data/lib/startback/operation/error_operation.rb

@@ -1,19 +0,0 @@
-module Startback
-  class Operation
-    class ErrorOperation < Operation
-
-      def initialize(details)
-        @details = details
-      end
-      attr_reader :details
-
-      def call
-      end
-
-      def bind(world)
-        self
-      end
-
-    end # class ErrorOperation
-  end # class Operation
-end # module Startback

data/lib/startback/operation/multi_operation.rb

@@ -1,28 +0,0 @@
-module Startback
-  class Operation
-    class MultiOperation < Operation
-
-      def initialize(ops = [])
-        @ops = ops
-      end
-      attr_reader :ops
-
-      def size
-        ops.size
-      end
-
-      def +(other)
-        MultiOperation.new(@ops + Array(other))
-      end
-
-      def bind(world)
-        MultiOperation.new(ops.map{|op| op.bind(world) })
-      end
-
-      def call
-        ops.map{|op| op.call }
-      end
-
-    end # class MultiOperation
-  end # class Operation
-end # module Startback