dynflow 0.2.0 → 0.3.0

data/lib/dynflow/future.rb

@@ -1,6 +1,6 @@
 module Dynflow
   class Future
-    Error            = Class.new StandardError
+    Error            = Class.new Dynflow::Error
     FutureAlreadySet = Class.new Error
     FutureFailed     = Class.new Error
     TimeOut          = Class.new Error

data/lib/dynflow/listeners/abstract.rb

@@ -8,6 +8,10 @@ module Dynflow
         @world  = Type! world, World
         @logger = world.logger
       end
+
+      def terminate(future = Future.new)
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/dynflow/listeners/serialization.rb

@@ -1,15 +1,45 @@
 module Dynflow
   module Listeners
     module Serialization
-      SocketMessage = Algebrick.type do
-        Execute      = type { fields request_id: Integer, execution_plan_uuid: String }
-        Confirmation = type do
-          variants Accepted = type { fields request_id: Integer },
-                   Failed   = type { fields request_id: Integer, error: String }
+      module Protocol
+
+        Job = Algebrick.type do
+          Event = type do
+            fields! execution_plan_id: String,
+                    step_id:           Fixnum,
+                    event:             Object
+          end
+
+          Execution = type do
+            fields! execution_plan_id: String
+          end
+
+          variants Event, Execution
         end
-        Done         = type { fields request_id: Integer, execution_plan_uuid: String }
 
-        variants Execute, Confirmation, Done
+        Message = Algebrick.type do
+          Request = type do
+            variants Do = type { fields request_id: Integer, job: Job }
+          end
+
+          Response = type do
+            variants Accepted = type { fields request_id: Integer },
+                     Failed   = type { fields request_id: Integer, error: String },
+                     Done     = type { fields request_id: Integer }
+          end
+
+          variants Request, Response
+        end
+
+        module Event
+          def to_hash
+            super.update event: Marshal.dump(event)
+          end
+
+          def self.product_from_hash(hash)
+            super(hash.merge 'event' => Marshal.load(hash.fetch('event')))
+          end
+        end
       end
 
       def dump(obj)
@@ -17,12 +47,16 @@ module Dynflow
       end
 
       def load(str)
-        SocketMessage.from_hash MultiJson.load(str)
+        Protocol::Message.from_hash MultiJson.load(str)
       end
 
       def send_message(io, message, barrier = nil)
         barrier.lock if barrier
         io.puts dump(message)
+        true
+      rescue SystemCallError => error
+        @logger.warn "message could not be sent #{message} because #{error}"
+        false
       ensure
         barrier.unlock if barrier
       end

data/lib/dynflow/listeners/socket.rb

@@ -5,7 +5,9 @@ module Dynflow
       include Listeners::Serialization
       include Algebrick::Matching
 
-      def initialize(world, socket_path)
+      Terminate = Algebrick.atom
+
+      def initialize(world, socket_path, interval = 1)
         super(world)
 
         File.delete socket_path if File.exist? socket_path
@@ -14,23 +16,35 @@ module Dynflow
 
         @clients         = []
         @client_barriers = {}
-        @loop            = Thread.new { loop { listen } }
+        @terminate       = false
+        @loop            = Thread.new do
+          Thread.current.abort_on_exception = true
+          catch(Terminate) { loop { listen(interval) } }
+          @terminate.resolve true
+        end
+      end
+
+      def terminate(future = Future.new)
+        raise 'multiple calls' if @terminate
+        @terminate = future
       end
 
       private
 
-      def listen
+      def listen(interval)
+        shutdown if @terminate
+
         ios                   = [@server, *@clients]
-        reads, writes, errors = IO.select(ios, [], ios)
-        reads.each do |readable|
+        reads, writes, errors = IO.select(ios, [], ios, interval)
+        Array(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)
+                  (on ~Protocol::Do do |(id, job)|
+                    execute_job(readable, id, job)
                   end),
                   (on NilClass.to_m do
                     remove_client readable
@@ -42,29 +56,36 @@ module Dynflow
         logger.fatal error
       end
 
-      def execute(readable, id, uuid)
+      def execute_job(readable, id, job)
         responded = false
         respond   = -> error = nil do
           unless responded
             responded = true
             send_message_to_client(readable, if error
                                                logger.error error
-                                               Failed[id, error.message]
+                                               Protocol::Failed[id, error.message]
                                              else
-                                               Accepted[id]
+                                               Protocol::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)
+        future = Future.new.do_then do |_|
+          if future.resolved?
+            respond.call
+            send_message_to_client readable, Protocol::Done[id]
+          else
+            respond.call future.value
+          end
+        end
+
+        match job,
+              (on ~Protocol::Execution do |(uuid)|
+                @world.execute(uuid, future)
+              end),
+              (on ~Protocol::Event do |(uuid, step_id, event)|
+                @world.event(uuid, step_id, event, future)
+              end)
         respond.call
       rescue Dynflow::Error => e
         respond.call e
@@ -83,6 +104,15 @@ module Dynflow
       def send_message_to_client(client, message)
         send_message client, message, @client_barriers[client]
       end
+
+      def shutdown
+        @clients.each { |c| c.shutdown :RDWR }
+        @server.close
+      rescue => e
+        @logger.error e
+      ensure
+        throw Terminate
+      end
     end
   end
 end

data/lib/dynflow/middleware.rb

@@ -0,0 +1,46 @@
+module Dynflow
+  class Middleware
+    require 'dynflow/middleware/register'
+    require 'dynflow/middleware/world'
+    require 'dynflow/middleware/action'
+    require 'dynflow/middleware/resolver'
+    require 'dynflow/middleware/stack'
+
+    include Algebrick::TypeCheck
+
+    def initialize(stack)
+      @stack = Type! stack, Stack
+    end
+
+    # call `pass` to get deeper with the call
+    def pass(*args)
+      @stack.pass(*args)
+    end
+
+    # to get the action object
+    def action
+      @stack.action or raise "the action is not available"
+    end
+
+    def run(*args)
+      pass(*args)
+    end
+
+    def plan(*args)
+      pass(*args)
+    end
+
+    def finalize(*args)
+      pass(*args)
+    end
+
+    def plan_phase(*args)
+      pass(*args)
+    end
+
+    def finalize_phase(*args)
+      pass(*args)
+    end
+
+  end
+end

data/lib/dynflow/middleware/action.rb

@@ -0,0 +1,9 @@
+module Dynflow
+  module Middleware::Action
+
+    def middleware
+      @middleware ||= Middleware::Register.new
+    end
+
+  end
+end

data/lib/dynflow/middleware/register.rb

@@ -0,0 +1,32 @@
+module Dynflow
+  class Middleware::Register
+    include Algebrick::TypeCheck
+
+    attr_reader :rules
+
+    def initialize
+      @rules = Hash.new do |h, k|
+        h[k] = { before:  [],
+                 after:   [],
+                 replace: [] }
+      end
+    end
+
+    def use(middleware_class, options = {})
+      unknown_options = options.keys - [:before, :after, :replace]
+      if unknown_options.any?
+        raise ArgumentError, "Unexpected options: #{unknown_options}"
+      end
+      @rules[middleware_class].merge!(options) do |key, old, new|
+        old + Array(new)
+      end
+    end
+
+    def merge!(register)
+      Type! register, Middleware::Register
+      register.rules.each do |klass, rules|
+        use(klass, rules)
+      end
+    end
+  end
+end

data/lib/dynflow/middleware/resolver.rb

@@ -0,0 +1,63 @@
+require 'tsort'
+
+module Dynflow
+  class Middleware::Resolver
+
+    include TSort
+    include Algebrick::TypeCheck
+
+    def initialize(register)
+      @register = Type! register, Middleware::Register
+    end
+
+    def result
+      @result ||= begin
+        @deps = normalize_rules(@register.rules)
+        self.tsort
+      end
+    end
+
+    private
+
+    # Takes eliminate :replace and :before rules.
+    # Returns hash, that maps middleware classes to their dependencies
+    def normalize_rules(rules)
+      deps          = Hash.new { |h, k| h[k] = [] }
+      substitutions = {}
+
+      # replace before with after on oposite direction and build the
+      # substitutions dictionary
+      rules.each do |middleware_class, middleware_rules|
+        deps[middleware_class].concat(middleware_rules[:after])
+        middleware_rules[:before].each do |dependent_class|
+          deps[dependent_class] << middleware_class
+        end
+        middleware_rules[:replace].each do |replaced|
+          substitutions[replaced] = middleware_class
+        end
+      end
+
+      # replace the middleware to be substituted
+      substitutions.each do |old, new|
+        deps[new].concat(deps[old])
+        deps.delete(old)
+      end
+
+      # ignore deps, that are not present in the stack
+      deps.each do |middleware_class, middleware_deps|
+        middleware_deps.reject! { |dep| !deps.has_key?(dep) }
+      end
+
+      return deps
+    end
+
+    def tsort_each_node(&block)
+      @deps.each_key(&block)
+    end
+
+    def tsort_each_child(node, &block)
+      @deps.fetch(node).each(&block)
+    end
+
+  end
+end

data/lib/dynflow/middleware/stack.rb

@@ -0,0 +1,29 @@
+module Dynflow
+  class Middleware::Stack
+    include Algebrick::TypeCheck
+
+    attr_reader :action, :middleware_class, :middleware
+
+    def self.build(middleware_classes, method, action, &block)
+      middleware_classes.reverse_each.reduce(block) do |stack, klass|
+        Middleware::Stack.new(stack, klass, method, action)
+      end
+    end
+
+    def initialize(next_stack, middleware_class, method, action)
+      @middleware_class = Child! middleware_class, Middleware
+      @middleware       = middleware_class.new self
+      @action           = Type! action, Dynflow::Action, NilClass
+      @method           = Match! method, :plan, :run, :finalize, :plan_phase, :finalize_phase
+      @next_stack       = Type! next_stack, Middleware::Stack, Proc
+    end
+
+    def call(*args)
+      @middleware.send @method, *args
+    end
+
+    def pass(*args)
+      @next_stack.call(*args)
+    end
+  end
+end

data/lib/dynflow/middleware/world.rb

@@ -0,0 +1,58 @@
+module Dynflow
+  class Middleware::World
+
+    include Algebrick::TypeCheck
+
+    def initialize
+      @register = Middleware::Register.new
+      clear_cache!
+    end
+
+    def use(*args)
+      clear_cache!
+      @register.use(*args)
+    end
+
+    def execute(method, action_or_class, *args, &block)
+      Match! method, :plan, :run, :finalize, :plan_phase, :finalize_phase
+      if Child? action_or_class, Dynflow::Action
+        action = nil
+        action_class = action_or_class
+      elsif Type? action_or_class, Dynflow::Action
+        action = action_or_class
+        action_class = action.action_class
+      else
+        Algebrick::TypeCheck.error action_or_class, 'is not instance or child class', Dynflow::Action
+      end
+
+      classes = middleware_classes(action_class)
+      stack   = Middleware::Stack.build(classes, method, action, &block)
+      stack.call(*args)
+    end
+
+    def clear_cache!
+      @middleware_classes_cache = {}
+    end
+
+    private
+
+    def cumulate_register(action_class, register = Middleware::Register.new)
+      register.merge!(@register)
+      unless action_class == Dynflow::Action
+        cumulate_register(action_class.superclass, register)
+      end
+      register.merge!(action_class.middleware)
+      return register
+    end
+
+    def middleware_classes(action_class)
+      unless @middleware_classes_cache.key?(action_class)
+        register = cumulate_register(action_class)
+        resolver = Dynflow::Middleware::Resolver.new(register)
+        @middleware_classes_cache[action_class] = resolver.result
+      end
+      return @middleware_classes_cache[action_class]
+    end
+
+  end
+end