startback-websocket 0.14.0 → 0.14.1

data/lib/startback/operation.rb

@@ -1,78 +0,0 @@
-module Startback
-  #
-  # High-level Operation abstraction, that is a piece of code that executes
-  # on demand and (generally) changes the state of the software system.
-  #
-  # An operation is basically an object that respond to `call`, but that
-  # executes within a given world (see `bind`). It also has before and
-  # after hooks that allows specifying what needs to be done before invoking
-  # call and after having invoked it. All this protocol is actually under
-  # the responsibility of an `OperationRunner`. Operations should not be
-  # called manually by third-party code.
-  #
-  # Example:
-  #
-  #     class SayHello < Startback::Operation
-  #
-  #       before_call do
-  #         # e.g. check_some_permissions
-  #       end
-  #
-  #       def call
-  #         puts "Hello"
-  #       end
-  #
-  #       after_call do
-  #         # e.g. log and/or emit something on a bus
-  #       end
-  #
-  #     end
-  #
-  class Operation
-    extend Support::TransactionPolicy
-    include Errors
-    include Support::OperationRunner
-    include Support::Hooks.new(:call)
-
-    attr_accessor :world
-    protected :world=
-
-    def initialize(input = {})
-      @input = input
-    end
-    attr_reader :input
-
-    def bind(world)
-      return self unless world
-      self.world = world
-      self
-    end
-
-    def method_missing(name, *args, &bl)
-      return super unless args.empty? and bl.nil?
-      return super unless world
-      world.fetch(name){ super }
-    end
-
-    def respond_to?(name, *args)
-      super || (world && world.has_key?(name))
-    end
-
-    def with_context(ctx = nil)
-      old_world = self.world
-      self.world = self.world.merge(context: ctx || old_world.context.dup)
-      result = ctx ? yield : yield(self.world.context)
-      self.world = old_world
-      result
-    end
-
-  protected
-
-    def operation_world(op)
-      self.world
-    end
-
-  end # class Operation
-end # module Startback
-require_relative 'operation/error_operation'
-require_relative 'operation/multi_operation'

data/lib/startback/services.rb

@@ -1,11 +0,0 @@
-module Startback
-  class Services
-    include Startback::Errors
-
-    def initialize(context)
-      @context = context
-    end
-    attr_reader :context
-
-  end # class Services
-end # module Startback

data/lib/startback/support/data_object.rb

@@ -1,71 +0,0 @@
-module Startback
-  module Support
-    module DataObject
-
-      def initialize(data = {})
-        @_data = data.dup.freeze
-      end
-
-      attr_writer :_data
-      protected :_data=
-
-      def method_missing(name, *args, &bl)
-        return super unless args.empty? && bl.nil?
-        return super unless pair = _data_key_for(name)
-
-        pair.last ? !!@_data[pair.first] : @_data[pair.first]
-      end
-
-      def [](name)
-        return nil unless pair = _data_key_for(name, false, false)
-
-        @_data[pair.first]
-      end
-
-      def respond_to?(name)
-        super || !_data_key_for(name).nil?
-      end
-
-      def to_data
-        @_data
-      end
-      alias :to_h :to_data
-
-      def to_json(*args, &bl)
-        to_data.to_json(*args, &bl)
-      end
-
-    private
-
-      def _data_key_for(key, try_camelize = _data_allow_camelize, try_query = _data_allow_query)
-        if @_data.key?(key)
-          [key, false]
-        elsif @_data.key?(key.to_s)
-          [key.to_s, false]
-        elsif key.is_a?(String) && @_data.key?(key.to_sym)
-          [key.to_sym, false]
-        elsif try_camelize
-          cam = key.to_s.gsub(/_([a-z])/){ $1.upcase }.to_sym
-          _data_key_for(cam, false, true)
-        elsif try_query && key.to_s =~ /\?$/
-          got = _data_key_for(key[0...-1].to_sym, false, false)
-          got ? [got.first, true] : _data_key_not_found(key)
-        else
-          _data_key_not_found(key)
-        end
-      end
-
-      def _data_allow_camelize
-        true
-      end
-
-      def _data_allow_query
-        true
-      end
-
-      def _data_key_not_found(key)
-        nil
-      end
-    end # module DataObject
-  end # module Support
-end # module Startback

data/lib/startback/support/env.rb

@@ -1,41 +0,0 @@
-module Startback
-  module Support
-    # This method provides the `env` and `env!` methods that
-    # help querying environment variables easily.
-    module Env
-
-      # Returns an environment variable or raise an error if
-      # not set.
-      #
-      # The result is always a String with no leading/trailing
-      # spaces.
-      #
-      # If a block is given, the environment variable is yield
-      # and the result of the block returned.
-      def env!(key, default = nil, &bl)
-        v = ENV[key].to_s.strip
-        raise Startback::Error, "Missing ENV var `#{key}`" if v.empty?
-
-        env(key, default, &bl)
-      end
-      module_function :env!
-
-      # Returns an environment variable or the default value
-      # passed as second argument.
-      #
-      # The result is always a String with no leading/trailing
-      # spaces.
-      #
-      # If a block is given, the environment variable is yield
-      # and the result of the block returned.
-      def env(key, default = nil, &bl)
-        v = ENV[key].to_s.strip
-        v = v.empty? ? default : v
-        v = bl.call(v) if bl && v
-        v
-      end
-      module_function :env
-
-    end # module Env
-  end # module Support
-end # module Startback

data/lib/startback/support/fake_logger.rb

@@ -1,18 +0,0 @@
-module Startback
-  module Support
-    class FakeLogger < Logger
-
-      def initialize(*args)
-        @last_msg = nil
-      end
-      attr_reader :last_msg
-
-      [:debug, :info, :warn, :error, :fatal].each do |meth|
-        define_method(meth) do |msg|
-          @last_msg = msg
-        end        
-      end
-
-    end # class Logger
-  end # module Support
-end # module Startback

data/lib/startback/support/hooks.rb

@@ -1,48 +0,0 @@
-module Startback
-  module Support
-    class Hooks < Module
-
-      def initialize(suffix)
-        @suffix = suffix
-        define_method :"before_#{suffix}" do
-          self.class.__befores.each do |bl|
-            instance_exec(&bl)
-          end
-        end
-        define_method :"after_#{suffix}" do
-          self.class.__afters.each do |bl|
-            instance_exec(&bl)
-          end
-        end
-      end
-      attr_reader :suffix
-
-      def included(by)
-        by.instance_eval %Q{
-          def __befores(create = false)
-            if create
-              @__befores ||= (superclass.respond_to?(:__befores, false) ? superclass.__befores.dup : [])
-            end
-            @__befores || (superclass.respond_to?(:__befores, false) ? superclass.__befores : [])
-          end
-
-          def __afters(create = false)
-            if create
-              @__afters ||= (superclass.respond_to?(:__afters, false) ? superclass.__afters.dup : [])
-            end
-            @__afters || (superclass.respond_to?(:__afters, false) ? superclass.__afters : [])
-          end
-
-          def before_#{suffix}(&bl)
-            __befores(true) << bl
-          end
-
-          def after_#{suffix}(&bl)
-            __afters(true) << bl
-          end
-        }
-      end
-
-    end # class Hooks
-  end # module Support
-end # module Startback

data/lib/startback/support/log_formatter.rb

@@ -1,34 +0,0 @@
-module Startback
-  module Support
-    class LogFormatter
-
-      def call(severity, time, progname, msg)
-        msg = { message: msg } if msg.is_a?(String)
-        msg = { error: msg } if msg.is_a?(Exception)
-        {
-          severity: severity,
-          time: time
-        }.merge(msg)
-         .merge(error: error_to_json(msg[:error], severity))
-         .compact
-         .to_json << "\n"
-      end
-
-      def error_to_json(error, severity = nil)
-        return error if error.nil?
-        return error if error.is_a?(String)
-        return error.to_s unless error.is_a?(Exception)
-
-        backtrace = error.backtrace[0..25] if severity == "FATAL"
-        causes = error.causes.map{|c| error_to_json(c) } if error.respond_to?(:causes)
-        causes = nil if causes && causes.empty?
-        {
-          message: error.message,
-          backtrace: backtrace,
-          causes: causes
-        }.compact
-      end
-
-    end # class LogFormatter
-  end # module Support
-end # module Startback

data/lib/startback/support/logger.rb

@@ -1,34 +0,0 @@
-module Startback
-  module Support
-    #
-    # A Logger extension that sends info and debug messages to STDOUT
-    # and other messages to STDERR. This is not configurable.
-    #
-    class Logger < ::Logger
-
-      def initialize
-        super(STDOUT)
-        @err_logger = ::Logger.new(STDERR)
-      end
-
-      def self.level=(level)
-        super.tap{
-          @err_logger.level = level
-        }
-      end
-
-      def warn(*args, &bl)
-        @err_logger.warn(*args, &bl)
-      end
-
-      def error(*args, &bl)
-        @err_logger.error(*args, &bl)
-      end
-
-      def fatal(*args, &bl)
-        @err_logger.fatal(*args, &bl)
-      end
-
-    end # class Logger
-  end # module Support
-end # module Startback

data/lib/startback/support/operation_runner.rb

@@ -1,150 +0,0 @@
-module Startback
-  module Support
-    #
-    # Support module for high-level architectural components that
-    # execute operations as part of their logic, see e.g. Web::Api.
-    #
-    # This module contributes a `run` instance method that allows
-    # binding an operation with a world, and executing it while
-    # supporting around runners.
-    #
-    # Example:
-    #
-    #     class HighLevelComponent
-    #       include Startback::Support::OperationRunner
-    #
-    #       def some_method
-    #         # Runs the operation passed after some binding
-    #         run SomeOperation.new
-    #       end
-    #
-    #     protected
-    #
-    #       # Overriden to inject some extra world
-    #       def operation_world(op)
-    #         super(op).merge({ hello: "world" })
-    #       end
-    #
-    #       # Execute this around op
-    #       around_run do |op, then_block|
-    #         puts "About to run #{op.inspect}"
-    #         then_block.call
-    #       end
-    #
-    #       # SomeClass#call will be called with the operation
-    #       # as first parameter and a block as continuation
-    #       around_run SomeClass.new
-    #
-    #     end
-    #
-    module OperationRunner
-
-      # Contributes the hook DSL methods to classes that include
-      # the OperationRunner module
-      module ClassMethods
-
-        # Registers a callable to be executed around operation running.
-        #
-        # In its block form, the callable is `instance_exec`uted on the
-        # runner instance, with the operation passed as first parameter
-        # and a then_block callable as second parameter (continuation):
-        #
-        #     around_run do |op,then_block|
-        #       # do whatever you want with the op (already bounded)
-        #       puts op.inspect
-        #
-        #       # do not forget to call the continuation block
-        #       then_block.call
-        #     end
-        #
-        # With a parameter responding to `#call`, the latter is invoked
-        # with the operation as parameter and a block as continuation:
-        #
-        #     class Arounder
-        #
-        #       def call(op)
-        #         # do whatever you want with the op (already bounded)
-        #         puts op.inspect
-        #
-        #         # do not forget to call the continuation block
-        #         yield
-        #       end
-        #
-        #     end
-        #
-        def around_run(arounder = nil, &bl)
-          raise ArgumentError, "Arg or block required" unless arounder || bl
-          arounds(true) << [arounder || bl, arounder.nil?]
-        end
-
-      private
-
-        def arounds(create = false)
-          if create
-            @arounds ||= superclass.respond_to?(:arounds, true) \
-                       ? superclass.send(:arounds, true).dup \
-                       : []
-          end
-          @arounds || (superclass.respond_to?(:arounds, true) ? superclass.send(:arounds, true) : [])
-        end
-
-      end
-
-      # When included by a class/module, install the DSL methods
-      def self.included(by)
-        by.extend(ClassMethods)
-      end
-
-      # Runs `operation`, taking care of binding it and executing
-      # hooks.
-      #
-      # This method is NOT intended to be overriden. Use hooks and
-      # `operation_world` to impact default behavior.
-      def run(operation)
-        op_world = operation_world(operation)
-        op_bound = operation.bind(op_world)
-        _run_befores(op_bound)
-        r = _run_with_arounds(op_bound, self.class.send(:arounds))
-        _run_afters(op_bound)
-        r
-      end
-
-    protected
-
-      # Returns the world to use to bind an operation.
-      #
-      # The default implementation returns an empty hash. This is
-      # intended to be overriden by classes including this module.
-      def operation_world(op)
-        {}
-      end
-
-    private
-
-      def _run_befores(op_bound)
-        op_bound.before_call if op_bound.respond_to?(:before_call, true)
-      end
-
-      def _run_with_arounds(operation, arounds = [])
-        if arounds.empty?
-          operation.call
-        else
-          arounder, iexec = arounds.first
-          after_first = ->() {
-            _run_with_arounds(operation, arounds[1..-1])
-          }
-          if iexec
-            self.instance_exec(operation, after_first, &arounder)
-          else
-            arounder.call(self, operation, &after_first)
-          end
-        end
-      end
-
-      def _run_afters(op_bound)
-        op_bound.after_call if op_bound.respond_to?(:after_call, true)
-      end
-
-    end # module OperationRunner
-  end # module Support
-end # module Startback

data/lib/startback/support/robustness.rb

@@ -1,157 +0,0 @@
-module Startback
-  module Support
-    #
-    # This module provides helper methods for robustness of a software design.
-    #
-    # It is included by main Startback abstractions, and can be included by
-    # specific software components who needs fine-tuning of monitoring, logging
-    # and error handling.
-    #
-    # All public methods here follow the following free args parameters:
-    #
-    # 1. First (& second) argument(s) form the log message.
-    #
-    #    A full log message is a Hash having :op (required), :op_took (optional),
-    #    and :op_data (optional) keys.
-    #
-    #    If a String (or two) are used instead, a log message will be built taking
-    #    the former as the executer (a class or instance) and the second as a method.
-    #    `{ op: "executer#method" }`
-    #
-    # 2. The second (or third) argument should be a Logger instance, a Context,
-    #    or an instance knowing its context. The best logger is extracted from it
-    #    and used for actual logging.
-    #
-    # Examples:
-    #
-    #     log(:info, op: "hello", op_data: {foo: 12})    => logged as such on STDOUT
-    #     log(:info, "A simple message")                 => { op: "A simple message" } on STDOUT
-    #     log(:info, Startback, "hello")                 => { op: "Startback#hello"  } on STDOUT
-    #     log(:info, Event.new, "hello")                 => { op: "Event#hello" }      on STDOUT
-    #     log(:info, Event.new, "hello", "hello world")  => { op: "Event#hello", op_data: { message: "hello world" } } on STDOUT
-    #     log(:info, self, context)                      => { op: "..." } on context's logger or STDOUT
-    #     log(:info, self, event)                        => { op: "..." } on event context's logger or STDOUT
-    #     ...
-    #
-    module Robustness
-
-      # Included to avoid poluting the space of the including
-      # classes.
-      module Tools
-
-        def default_logger
-          @@default_logger ||= begin
-            l = ::Logger.new(STDOUT)
-            l.formatter = LogFormatter.new
-            l.warn(op: "#{self}", op_data: { msg: "Using default logger to STDOUT" })
-            @@default_logger = l
-          end
-          @@default_logger
-        end
-        module_function :default_logger
-
-        def logger_for(arg)
-          return arg if arg.is_a?(::Logger)
-          return arg.logger if arg.is_a?(Context) && arg.logger
-          return logger_for(arg.context) if arg.respond_to?(:context, false)
-          default_logger
-        end
-        module_function :logger_for
-
-        def parse_args(log_msg, method = nil, context = nil, extra = nil)
-          method, context, extra = nil, method, context unless method.is_a?(String)
-          context, extra = nil, context if context.is_a?(Hash) || context.is_a?(String) && extra.nil?
-          extra = { op_data: { message: extra } } if extra.is_a?(String)
-          logger = logger_for(context) || logger_for(log_msg)
-          log_msg = if log_msg.is_a?(Hash)
-            log_msg.dup
-          elsif log_msg.is_a?(String)
-            log_msg = { op: "#{log_msg}#{method.nil? ? '' : '#'+method.to_s}" }
-          elsif log_msg.is_a?(Exception)
-            log_msg = { error: log_msg }
-          else
-            log_msg = log_msg.class unless log_msg.is_a?(Module)
-            log_msg = { op: "#{log_msg.name}##{method}" }
-          end
-          log_msg.merge!(extra) if extra
-          [ log_msg, logger ]
-        end
-        module_function :parse_args
-
-        [:debug, :info, :warn, :error, :fatal].each do |meth|
-          define_method(meth) do |args, extra = nil, &bl|
-            act_args = (args + [extra]).compact
-            log_msg, logger = parse_args(*act_args)
-            logger.send(meth, log_msg)
-          end
-          module_function(meth)
-        end
-
-      end # module Tools
-
-      # Logs a specific message with a given severity.
-      #
-      # Severity can be :debug, :info, :warn, :error or :fatal.
-      # The args must follow module's conventions, see above.
-      def log(severity, *args)
-        Tools.send(severity, args)
-      end
-
-      # Calls the block and monitors then log its execution time.
-      #
-      # The args must follow module's conventions, see above.
-      def monitor(*args, &bl)
-        result = nil
-        took = Benchmark.realtime {
-          result = bl.call
-        }
-        Tools.info(args, op_took: took)
-        result
-      end
-
-      # Executes the block without letting errors propagate.
-      # Errors are logged, though. Nothing is logged if everything
-      # goes fine.
-      #
-      # The args must follow module's conventions, see above.
-      def stop_errors(*args, &bl)
-        result = nil
-        took = Benchmark.realtime {
-          result = bl.call
-        }
-        result
-      rescue => ex
-        Tools.fatal(args, op_took: took, error: ex)
-        nil
-      end
-
-      # Tries executing the block up to `n` times, until an attempt
-      # succeeds (then returning the result). Logs the first and last
-      # fatal error, if any.
-      #
-      # The args must follow module's conventions, see above.
-      def try_max_times(n, *args, &bl)
-        retried = 0
-        took = 0
-        begin
-          result = nil
-          took += Benchmark.realtime {
-            result = bl.call
-          }
-          result
-        rescue => ex
-          Tools.error(args + [{op_took: took, error: ex}]) if retried == 0
-          retried += 1
-          if retried < n
-            sleep(retried)
-            retry
-          else
-            Tools.fatal(args + [{op_took: took, error: ex}])
-            raise
-          end
-        end
-      end
-
-    end # module Robustness
-  end # module Support
-end # module Startback

data/lib/startback/support/transaction_manager.rb

@@ -1,25 +0,0 @@
-module Startback
-  module Support
-    class TransactionManager
-
-      def initialize(db, method = :transaction)
-        @db = db
-        @method = method
-      end
-
-      def call(runner, op, &then_block)
-        raise ArgumentError, "A block is required" unless then_block
-
-        before = (op.class.transaction_policy == :before_call)
-        if before
-          @db.send(@method) do
-            then_block.call
-          end
-        else
-          then_block.call
-        end
-      end
-
-    end # class TransactionManager
-  end # module Support
-end # module Startback