startback-jobs 0.14.0 → 0.14.1

data/lib/startback/caching/no_store.rb

@@ -1,28 +0,0 @@
-module Startback
-  module Caching
-    #
-    # Caching store implementation that caches nothing at all.
-    #
-    class NoStore
-
-      def initialize
-      end
-
-      def exist?(key)
-        false
-      end
-
-      def get(key)
-        nil
-      end
-
-      def set(key, value, ttl)
-        value
-      end
-
-      def delete(key)
-      end
-
-    end # class NoStore
-  end # module Caching
-end # module Startback

data/lib/startback/caching/store.rb

@@ -1,34 +0,0 @@
-module Startback
-  module Caching
-    #
-    # Caching store specification & dummy implementation.
-    #
-    # This class should not be used in real project, as it implements
-    # See the 'cache' gem that provides conforming implementations.
-    #
-    class Store
-
-      def initialize
-        @saved = {}
-      end
-      attr_reader :saved
-
-      def exist?(key)
-        saved.has_key?(key)
-      end
-
-      def get(key)
-        saved[key]
-      end
-
-      def set(key, value, ttl)
-        saved[key] = value
-      end
-
-      def delete(key)
-        saved.delete(key)
-      end
-
-    end # class Store
-  end # module Caching
-end # module Startback

data/lib/startback/context/h_factory.rb

@@ -1,43 +0,0 @@
-module Startback
-  class Context
-    module HFactory
-
-      def h(hash)
-        h_factor!(self.new, hash)
-      end
-
-      def h_factor!(context, hash)
-        h_factories.each do |f|
-          f.call(context, hash)
-        end
-        context
-      end
-
-      def h_factories
-        @h_factories ||= []
-      end
-
-      def h_factory(&factory)
-        h_factories << factory
-      end
-
-      ###
-
-      def h_dump!(context, hash = {})
-        h_dumpers.each do |d|
-          context.instance_exec(hash, &d)
-        end
-        hash
-      end
-
-      def h_dumpers
-        @h_dumpers ||= []
-      end
-
-      def h_dump(&dumper)
-        h_dumpers << dumper
-      end
-
-    end # module HFactory
-  end # class Context
-end # module Startback

data/lib/startback/context/middleware.rb

@@ -1,53 +0,0 @@
-module Startback
-  class Context
-    #
-    # Rack middleware that installs a particular context instance
-    # on the Rack environment.
-    #
-    # Examples:
-    #
-    #     # Use the default context class
-    #     Rack::Builder.new do
-    #       use Startback::Context::Middleware
-    #
-    #       run ->(env){
-    #         ctx = env[Startback::Context::Middleware::RACK_ENV_KEY]
-    #         ctx.is_a?(Startback::Context) # => true
-    #       }
-    #     end
-    #
-    #     # Use a user defined context class
-    #     Rack::Builder.new do
-    #       use Startback::Context::Middleware, MyContextClass.new
-    #
-    #       run ->(env){
-    #         ctx = env[Startback::Context::Middleware::RACK_ENV_KEY]
-    #         ctx.is_a?(MyContextClass)     # => true (your subclass)
-    #         ctx.is_a?(Startback::Context) # => true (required!)
-    #       }
-    #     end
-    #
-    class Middleware
-
-      RACK_ENV_KEY = 'SAMBACK_CONTEXT'
-
-      def initialize(app, context = Context.new)
-        @app = app
-        @context = context
-      end
-      attr_reader :context
-
-      def call(env)
-        env[RACK_ENV_KEY] ||= context.dup.tap{|c|
-          c.original_rack_env = env.dup
-        }
-        @app.call(env)
-      end
-
-      def self.context(env)
-        env[RACK_ENV_KEY]
-      end
-
-    end # class Middleware
-  end # class Context
-end # module Startback

data/lib/startback/context.rb

@@ -1,122 +0,0 @@
-module Startback
-  #
-  # Defines an execution context for Startback applications, and provides
-  # a cached factory for related abstractions (see `factor`), and an
-  # extensible world, statically and dynamically.
-  #
-  # In web application, an instance of a context can be set on the Rack
-  # environment, using Context::Middleware.
-  #
-  # This class SHOULD be subclassed for application required extensions
-  # to prevent touching the global Startback state itself.
-  #
-  # Also, for event handling in distributed architectures, a Context should
-  # be dumpable and reloadable to JSON. An `h` information contract if provided
-  # for that. Subclasses may contribute to the dumping and reloading process
-  # through the `h_dump` and `h_factory` methods
-  #
-  #     module MyApp
-  #       class Context < Startback::Context
-  #
-  #         attr_accessor :foo
-  #
-  #         h_dump do |h|
-  #           h.merge!("foo" => foo)
-  #         end
-  #
-  #         h_factor do |c,h|
-  #           c.foo = h["foo"]
-  #         end
-  #
-  #       end
-  #     end
-  #
-  class Context
-    attr_accessor :original_rack_env
-
-    # An error handler can be provided on the Context class. The latter
-    # MUST expose an API similar to ruby's Logger class. It can be a logger
-    # instance, simply.
-    #
-    # Fatal errors catched by Web::CatchAll are sent on `error_handler#fatal`
-    #
-    # Deprecated, use the logger below instead.
-    attr_accessor :error_handler
-
-    # A logger can be provided on the context, and will be used for everything
-    # related to logging, audit trailing and robustness. The logger receives
-    # object following the log & trail conventions of Startback, and must
-    # convert them to wathever log format is necessary.
-    attr_accessor :logger
-
-    require_relative 'context/h_factory'
-    extend(Context::HFactory)
-
-    def initialize
-      super
-      yield(self) if block_given?
-    end
-
-    attr_writer :_world
-    protected :_world=
-
-    def self.world(who, &block)
-      @_world ||= Support::World.new
-      @_world = @_world.factory(who, &block)
-    end
-
-    def self.factor_world(context)
-      @_world ||= Support::World.new
-      @_world.with_scope(context)
-    end
-
-    def world
-      @_world ||= self.class.factor_world(self)
-    end
-
-    def with_world(world)
-      dup do |ctx|
-        ctx._world = self.world.with(world)
-      end
-    end
-
-    # Factors an instance of `clazz`, which must be a Context-related
-    # abstraction (i.e. its constructor takes the context as last parameters).
-    #
-    # Factored abstractions are cached for a given context & arguments.
-    def factor(clazz, *args)
-      @factored ||= {}
-      key = args.empty? ? clazz : [clazz] + args
-      @factored[key] ||= clazz.new(*(args << self))
-    end
-
-    def clean_factored!
-      @factored = {}
-    end
-    private :clean_factored!
-
-    def to_h
-      self.class.h_dump!(self)
-    end
-
-    def to_json(*args, &bl)
-      to_h.to_json(*args, &bl)
-    end
-
-    def fork(h = nil)
-      dup.tap{|duped|
-        self.class.h_factor!(duped, h) if h
-        yield(duped) if block_given?
-      }
-    end
-
-    def dup
-      super.tap{|c|
-        c.send(:clean_factored!)
-        yield(c) if block_given?
-      }
-    end
-
-  end # class Context
-end # module Startback
-require_relative 'context/middleware'

data/lib/startback/errors.rb

@@ -1,197 +0,0 @@
-module Startback
-  module Errors
-
-    class Error < StandardError
-      def initialize(message = nil, causes = nil)
-        super(message)
-        @causes = Array(causes)
-      end
-      attr_reader :causes
-
-      class << self
-        def status(code = nil)
-          if code.nil?
-            @code || (superclass.respond_to?(:status) ? superclass.status : 500)
-          else
-            @code = code || @code
-          end
-        end
-
-        def keep_error(keep = nil)
-          @keep_error = keep unless keep.nil?
-          @keep_error
-        end
-      end
-
-      def message
-        msg = super
-        return msg unless msg == self.class.name
-        parts = self.class.name.split('::').last.gsub(/[A-Z]/){|x|
-          " #{x.downcase}"
-        }.strip.split(" ")
-        parts = parts[0...-1] unless self.class.keep_error
-        parts.join(" ").capitalize
-      end
-
-      def has_causes?
-        causes && !causes.empty?
-      end
-
-      def cause
-        causes&.first
-      end
-    end
-
-    class BadRequestError < Error
-      status 400
-    end
-
-      class UnauthorizedError < BadRequestError
-        status 401
-      end
-
-      class ForbiddenError < BadRequestError
-        status 403
-      end
-
-      class NotFoundError < BadRequestError
-        status 404
-      end
-
-      class MethodNotAllowedError < BadRequestError
-        status 405
-      end
-
-      class NotAcceptableError < BadRequestError
-        status 406
-      end
-
-      class ConflictError < BadRequestError
-        status 409
-      end
-
-      class GoneError < BadRequestError
-        status 410
-      end
-
-      class PreconditionFailedError < BadRequestError
-        status 412
-      end
-
-      class UnsupportedMediaTypeError < BadRequestError
-        status 415
-      end
-
-      class ExpectationFailedError < BadRequestError
-        status 417
-      end
-
-      class LockedError < BadRequestError
-        status 423
-      end
-
-      class PreconditionRequiredError < BadRequestError
-        status 428
-      end
-
-    class InternalServerError < Error
-      status 500
-      keep_error(true)
-    end
-
-      class NotImplementedError < InternalServerError
-        status 501
-      end
-
-    ### Helper methods
-
-      def bad_request_error!(msg = nil)
-        raise Startback::Errors::BadRequestError, msg
-      end
-      module_function :bad_request_error!
-
-      def unauthorized_error!(msg = nil)
-        raise Startback::Errors::UnauthorizedError, msg
-      end
-      module_function :unauthorized_error!
-
-      def forbidden_error!(msg = nil)
-        raise Startback::Errors::ForbiddenError, msg
-      end
-      module_function :forbidden_error!
-
-      def not_found_error!(msg = nil)
-        raise Startback::Errors::NotFoundError, "#{msg} not found"
-      end
-      module_function :not_found_error!
-
-      def method_not_allowed_error!(msg = nil)
-        raise Startback::Errors::MethodNotAllowedError, msg
-      end
-      module_function :method_not_allowed_error!
-
-      def not_acceptable_error!(msg = nil)
-        raise Startback::Errors::NotAcceptableError, msg
-      end
-      module_function :not_acceptable_error!
-
-      def conflict_error!(msg = nil)
-        raise Startback::Errors::ConflictError, msg
-      end
-      module_function :conflict_error!
-
-      def gone_error!(msg = nil)
-        raise Startback::Errors::GoneError, msg
-      end
-      module_function :gone_error!
-
-      def precondition_failed_error!(msg = nil)
-        raise Startback::Errors::PreconditionFailedError, msg
-      end
-      module_function :precondition_failed_error!
-
-      def unsupported_media_type_error!(media)
-        raise Startback::Errors::UnsupportedMediaTypeError, "Unable to use `#{media}` as input data"
-      end
-      module_function :unsupported_media_type_error!
-
-      def expectation_failed_error!(msg = nil)
-        raise Startback::Errors::ExpectationFailedError, msg
-      end
-      module_function :expectation_failed_error!
-
-      def locked_error!(msg = nil)
-        raise Startback::Errors::LockedError, msg
-      end
-      module_function :locked_error!
-
-      def precondition_required_error!(msg = nil)
-        raise Startback::Errors::PreconditionRequiredError, msg
-      end
-      module_function :precondition_required_error!
-
-      def internal_server_error!(msg = nil)
-        raise Startback::Errors::InternalServerError, msg
-      end
-      module_function :internal_server_error!
-
-      def not_implemented_error!(msg = nil)
-        raise Startback::Errors::NotImplementedError, msg
-      end
-      module_function :not_implemented_error!
-
-  # Aliases
-
-      def user_error!(msg = nil)
-        raise Startback::Errors::BadRequestError, msg
-      end
-      module_function :user_error!
-
-      def server_error!(msg = nil)
-        raise Startback::Errors::InternalServerError, msg
-      end
-      module_function :server_error!
-
-  end # module Errors
-  include Errors
-end # module Startback

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