dynflow 0.1.0 → 0.2.0

data/lib/dynflow/listeners/socket.rb

@@ -0,0 +1,88 @@
+module Dynflow
+  module Listeners
+    class Socket < Abstract
+      # TODO terminate when exiting
+      include Listeners::Serialization
+      include Algebrick::Matching
+
+      def initialize(world, socket_path)
+        super(world)
+
+        File.delete socket_path if File.exist? socket_path
+        @server = UNIXServer.new socket_path
+        File.chmod(0600, socket_path)
+
+        @clients         = []
+        @client_barriers = {}
+        @loop            = Thread.new { loop { listen } }
+      end
+
+      private
+
+      def listen
+        ios                   = [@server, *@clients]
+        reads, writes, errors = IO.select(ios, [], ios)
+        reads.each do |readable|
+          if readable == @server
+            add_client @server.accept
+            logger.info 'Client connected.'
+
+          else
+            match message = receive_message(readable),
+                  (on ~Execute do |(id, uuid)|
+                    execute(readable, id, uuid)
+                  end),
+                  (on NilClass.to_m do
+                    remove_client readable
+                    logger.info 'Client disconnected.'
+                  end)
+          end
+        end
+      rescue => error
+        logger.fatal error
+      end
+
+      def execute(readable, id, uuid)
+        responded = false
+        respond   = -> error = nil do
+          unless responded
+            responded = true
+            send_message_to_client(readable, if error
+                                               logger.error error
+                                               Failed[id, error.message]
+                                             else
+                                               Accepted[id]
+                                             end)
+          end
+        end
+
+        @world.execute(uuid,
+                       f = Future.new do |_|
+                         if f.resolved?
+                           respond.call
+                           send_message_to_client readable, Done[id, uuid]
+                         else
+                           respond.call f.value
+                         end
+                       end)
+        respond.call
+      rescue Dynflow::Error => e
+        respond.call e
+      end
+
+      def add_client(client)
+        @clients << client
+        @client_barriers[client] = Mutex.new
+      end
+
+      def remove_client(client)
+        @clients.delete client
+        @client_barriers.delete client
+      end
+
+      def send_message_to_client(client, message)
+        send_message client, message, @client_barriers[client]
+      end
+    end
+  end
+end

data/lib/dynflow/logger_adapters.rb

@@ -0,0 +1,8 @@
+module Dynflow
+  module LoggerAdapters
+    require 'dynflow/logger_adapters/formatters'
+    require 'dynflow/logger_adapters/abstract'
+    require 'dynflow/logger_adapters/simple'
+    require 'dynflow/logger_adapters/delegator'
+  end
+end

data/lib/dynflow/logger_adapters/abstract.rb

@@ -0,0 +1,30 @@
+module Dynflow
+  module LoggerAdapters
+    class Abstract
+
+      # @returns [#fatal, #error, #warn, #info, #debug] logger object for logging errors from action execution
+      def action_logger
+        raise NotImplementedError
+      end
+
+      # @returns [#fatal, #error, #warn, #info, #debug] logger object for logging Dynflow errors
+      def dynflow_logger
+        raise NotImplementedError
+      end
+
+      def level
+        raise NotImplementedError
+      end
+
+      def level=(v)
+        raise NotImplementedError
+      end
+
+      private
+
+      def apply_formatters(base, formatters)
+        formatters.reduce(base) { |base, formatter| formatter.new(base) }
+      end
+    end
+  end
+end

data/lib/dynflow/logger_adapters/delegator.rb

@@ -0,0 +1,13 @@
+module Dynflow
+  module LoggerAdapters
+    class Delegator < Abstract
+
+      attr_reader :action_logger, :dynflow_logger
+
+      def initialize(action_logger, dynflow_logger, formatters = [Formatters::Exception])
+        @action_logger  = apply_formatters action_logger, formatters
+        @dynflow_logger = apply_formatters dynflow_logger, formatters
+      end
+    end
+  end
+end

data/lib/dynflow/logger_adapters/formatters.rb

@@ -0,0 +1,8 @@
+module Dynflow
+  module LoggerAdapters
+    module Formatters
+      require 'dynflow/logger_adapters/formatters/abstract'
+      require 'dynflow/logger_adapters/formatters/exception'
+    end
+  end
+end

data/lib/dynflow/logger_adapters/formatters/abstract.rb

@@ -0,0 +1,33 @@
+module Dynflow
+  module LoggerAdapters
+    module Formatters
+      class Abstract
+        def initialize(base)
+          @base = base
+        end
+
+        [:fatal, :error, :warn, :info, :debug].each do |method|
+          define_method method do |message, &block|
+            if block
+              @base.send method, &-> { format(block.call) }
+            else
+              @base.send method, format(message)
+            end
+          end
+        end
+
+        def level=(v)
+          @base.level = v
+        end
+
+        def level
+          @base.level
+        end
+
+        def format(message)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/dynflow/logger_adapters/formatters/exception.rb

@@ -0,0 +1,15 @@
+module Dynflow
+  module LoggerAdapters
+    module Formatters
+      class Exception < Abstract
+        def format(message)
+          if ::Exception === message
+            "#{message.message} (#{message.class})\n#{message.backtrace.join("\n")}"
+          else
+            message
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynflow/logger_adapters/simple.rb

@@ -0,0 +1,59 @@
+require 'English'
+
+module Dynflow
+  module LoggerAdapters
+    class Simple < Abstract
+      require 'logger'
+
+      attr_reader :logger, :action_logger, :dynflow_logger
+
+      def initialize(output = $stdout, level = Logger::DEBUG, formatters = [Formatters::Exception])
+        @logger           = Logger.new(output)
+        @logger.level     = level
+        @logger.formatter = method(:formatter).to_proc
+        @action_logger    = apply_formatters ProgNameWrapper.new(@logger, ' action'), formatters
+        @dynflow_logger   = apply_formatters ProgNameWrapper.new(@logger, 'dynflow'), formatters
+      end
+
+      def level
+        @logger.level
+      end
+
+      def level=(v)
+        @logger.level = v
+      end
+
+      private
+
+      def formatter(severity, datetime, prog_name, msg)
+        format "[%s #%d] %5s -- %s%s\n",
+               datetime.strftime('%Y-%m-%d %H:%M:%S.%L'),
+               $PID,
+               severity,
+               (prog_name ? prog_name + ': ' : ''),
+               msg.to_s
+      end
+
+      class ProgNameWrapper
+        def initialize(logger, prog_name)
+          @logger    = logger
+          @prog_name = prog_name
+        end
+
+        { fatal: 4, error: 3, warn: 2, info: 1, debug: 0 }.each do |method, level|
+          define_method method do |message, &block|
+            @logger.add level, message, @prog_name, &block
+          end
+        end
+
+        def level=(v)
+          @logger.level = v
+        end
+
+        def level
+          @logger.level
+        end
+      end
+    end
+  end
+end

data/lib/dynflow/micro_actor.rb

@@ -0,0 +1,102 @@
+module Dynflow
+  class MicroActor
+    include Algebrick::TypeCheck
+    include Algebrick::Matching
+
+    attr_reader :logger, :initialized
+
+    Terminate = Algebrick.atom
+
+    def initialize(logger, *args)
+      @logger      = logger
+      @initialized = Future.new
+      @thread      = Thread.new { run *args }
+      Thread.pass until @mailbox
+    end
+
+    def <<(message)
+      raise 'actor terminated' if terminated?
+      @mailbox << [message, nil]
+      self
+    end
+
+    def ask(message, future = Future.new)
+      future.fail Dynflow::Error.new('actor terminated') if terminated?
+      @mailbox << [message, future]
+      future
+    end
+
+    def stopped?
+      @terminated.ready?
+    end
+
+    private
+
+    def delayed_initialize(*args)
+    end
+
+    def termination
+      terminate!
+    end
+
+    def terminating?
+      @terminated
+    end
+
+    def terminated?
+      terminating? && @terminated.ready?
+    end
+
+    def terminate!
+      raise unless Thread.current == @thread
+      @terminated.resolve true
+      throw Terminate
+    end
+
+    def on_message(message)
+      raise NotImplementedError
+    end
+
+    def receive
+      message, future = @mailbox.pop
+      #logger.debug "#{self.class} received:\n  #{message}"
+      if message == Terminate
+        # TODO do not use this future to store in @terminated use one added to Terminate message
+        if terminating?
+          @terminated.do_then { future.resolve true } if future
+        else
+          @terminated = (future || Future.new)
+          termination
+        end
+      else
+        on_envelope message, future
+      end
+    rescue => error
+      logger.fatal error
+    end
+
+    def on_envelope(message, future)
+      if future
+        future.evaluate_to { on_message message }
+      else
+        on_message message
+      end
+      if future && future.failed?
+        logger.error future.value
+      end
+    end
+
+    def run(*args)
+      Thread.current.abort_on_exception = true
+
+      @mailbox    = Queue.new
+      @terminated = nil
+
+      delayed_initialize(*args)
+      Thread.pass until @initialized
+      @initialized.resolve true
+
+      catch(Terminate) { loop { receive } }
+    end
+  end
+end

data/lib/dynflow/persistence.rb

@@ -0,0 +1,53 @@
+require 'dynflow/persistence_adapters'
+
+module Dynflow
+
+  class Persistence
+
+    attr_reader :adapter
+
+    def initialize(world, persistence_adapter)
+      @world   = world
+      @adapter = persistence_adapter
+    end
+
+    def load_action(step)
+      attributes = adapter.
+          load_action(step.execution_plan_id, step.action_id).
+          update(step: step)
+      return Action.from_hash(attributes,
+                              step.phase,
+                              step,
+                              step.world)
+    end
+
+    def save_action(execution_plan_id, action)
+      adapter.save_action(execution_plan_id, action.id, action.to_hash)
+    end
+
+    def find_execution_plans(options)
+      adapter.find_execution_plans(options).map do |execution_plan_hash|
+        ExecutionPlan.new_from_hash(execution_plan_hash, @world)
+      end
+    end
+
+    def load_execution_plan(id)
+      execution_plan_hash = adapter.load_execution_plan(id)
+      ExecutionPlan.new_from_hash(execution_plan_hash, @world)
+    end
+
+    def save_execution_plan(execution_plan)
+      adapter.save_execution_plan(execution_plan.id, execution_plan.to_hash)
+    end
+
+    def load_step(execution_plan_id, step_id, world)
+      step_hash = adapter.load_step(execution_plan_id, step_id)
+      ExecutionPlan::Steps::Abstract.from_hash(step_hash, execution_plan_id, world)
+    end
+
+    def save_step(step)
+      adapter.save_step(step.execution_plan_id, step.id, step.to_hash)
+    end
+
+  end
+end

data/lib/dynflow/persistence_adapters.rb

@@ -0,0 +1,6 @@
+module Dynflow
+  module PersistenceAdapters
+    require 'dynflow/persistence_adapters/abstract'
+    require 'dynflow/persistence_adapters/sequel'
+  end
+end

data/lib/dynflow/persistence_adapters/abstract.rb

@@ -0,0 +1,56 @@
+module Dynflow
+  module PersistenceAdapters
+    class Abstract
+      def pagination?
+        false
+      end
+
+      def filtering_by
+        []
+      end
+
+      def ordering_by
+        []
+      end
+
+      # @option options [Integer] page index of the page (starting at 0)
+      # @option options [Integer] per_page the number of the items on page
+      # @option options [Symbol] order_by name of the column to use for ordering
+      # @option options [true, false] desc set to true if order should be descending
+      # @option options [Hash{ Symbol => Object,Array<object> }] filters hash represents
+      #   set of allowed values for a given key representing column
+      def find_execution_plans(options = {})
+        raise NotImplementedError
+      end
+
+      def load_execution_plan(execution_plan_id)
+        raise NotImplementedError
+      end
+
+      def save_execution_plan(execution_plan_id, value)
+        raise NotImplementedError
+      end
+
+      def load_step(execution_plan_id, step_id)
+        raise NotImplementedError
+      end
+
+      def save_step(execution_plan_id, step_id, value)
+        raise NotImplementedError
+      end
+
+      def load_action(execution_plan_id, action_id)
+        raise NotImplementedError
+      end
+
+      def save_action(execution_plan_id, action_id, value)
+        raise NotImplementedError
+      end
+
+      # for debug purposes
+      def to_hash
+        raise NotImplementedError
+      end
+    end
+  end
+end