dynflow 0.1.0 → 0.2.0

data/lib/dynflow/flows.rb

@@ -0,0 +1,13 @@
+require 'forwardable'
+
+module Dynflow
+  module Flows
+
+    require 'dynflow/flows/abstract'
+    require 'dynflow/flows/atom'
+    require 'dynflow/flows/abstract_composed'
+    require 'dynflow/flows/concurrence'
+    require 'dynflow/flows/sequence'
+
+  end
+end

data/lib/dynflow/flows/abstract.rb

@@ -0,0 +1,36 @@
+module Dynflow
+  module Flows
+
+    class Abstract < Serializable
+      include Algebrick::TypeCheck
+
+      def initialize
+        raise 'cannot instantiate Flows::Abstract'
+      end
+
+      def to_hash
+        { :class => self.class.name }
+      end
+
+      def empty?
+        self.size == 0
+      end
+
+      def size
+        raise NotImplementedError
+      end
+
+      def includes_step?(step_id)
+        self.all_step_ids.any? { |s| s == step_id }
+      end
+
+      def all_step_ids
+        raise NotImplementedError
+      end
+
+      def flatten!
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/dynflow/flows/abstract_composed.rb

@@ -0,0 +1,104 @@
+module Dynflow
+  module Flows
+    class AbstractComposed < Abstract
+
+      attr_reader :flows
+
+      def initialize(flows)
+        Type! flows, Array
+        flows.all? { |f| Type! f, Abstract }
+        @flows = flows
+      end
+
+      def to_hash
+        super.merge recursive_to_hash(:flows => flows)
+      end
+
+      def <<(v)
+        @flows << v
+        self
+      end
+
+      def [](*args)
+        @flows[*args]
+      end
+
+      def []=(*args)
+        @flows.[]=(*args)
+      end
+
+      def size
+        @flows.size
+      end
+
+      alias_method :sub_flows, :flows
+
+      # @return [Array<Integer>] all step_ids recursively in the flow
+      def all_step_ids
+        flows.map(&:all_step_ids).flatten
+      end
+
+      def add_and_resolve(dependency_graph, new_flow)
+        return if new_flow.empty?
+
+        satisfying_flows = find_satisfying_sub_flows(dependency_graph, new_flow)
+        add_to_sequence(satisfying_flows, new_flow)
+        flatten!
+      end
+
+      def flatten!
+        self.sub_flows.to_enum.with_index.reverse_each do |flow, i|
+          if flow.class == self.class
+            expand_steps(i)
+          elsif flow.is_a?(AbstractComposed) && flow.sub_flows.size == 1
+            self.sub_flows[i] = flow.sub_flows.first
+          end
+        end
+
+        self.sub_flows.map(&:flatten!)
+      end
+
+      protected
+
+      def self.new_from_hash(hash)
+        check_class_matching hash
+        new(hash[:flows].map { |flow_hash| from_hash(flow_hash) })
+      end
+
+      # adds the +new_flow+ in a way that it's in sequence with
+      # the +satisfying_flows+
+      def add_to_sequence(satisfying_flows, new_flow)
+        raise NotImplementedError
+      end
+
+      private
+
+      def find_satisfying_sub_flows(dependency_graph, new_flow)
+        satisfying_flows = Set.new
+        new_flow.all_step_ids.each do |step_id|
+          dependency_graph.required_step_ids(step_id).each do |required_step_id|
+            satisfying_flow = sub_flows.find do |flow|
+              flow.includes_step?(required_step_id)
+            end
+            if satisfying_flow
+              satisfying_flows << satisfying_flow
+              dependency_graph.mark_satisfied(step_id, required_step_id)
+            end
+          end
+        end
+
+        return satisfying_flows.to_a
+      end
+
+      def expand_steps(index)
+        expanded_step = self.sub_flows[index]
+        self.sub_flows.delete_at(index)
+        expanded_step.sub_flows.each do |flow|
+          self.sub_flows.insert(index, flow)
+          index += 1
+        end
+      end
+
+    end
+  end
+end

data/lib/dynflow/flows/atom.rb

@@ -0,0 +1,36 @@
+module Dynflow
+  module Flows
+    class Atom < Abstract
+
+      attr_reader :step_id
+
+      def to_hash
+        super.merge(:step_id => step_id)
+      end
+
+      def initialize(step_id)
+        @step_id = Type! step_id, Integer
+      end
+
+      def size
+        1
+      end
+
+      def all_step_ids
+        [step_id]
+      end
+
+      def flatten!
+        # nothing to do
+      end
+
+      protected
+
+      def self.new_from_hash(hash)
+        check_class_matching hash
+        new(hash[:step_id])
+      end
+
+    end
+  end
+end

data/lib/dynflow/flows/concurrence.rb

@@ -0,0 +1,28 @@
+module Dynflow
+  module Flows
+    class Concurrence < AbstractComposed
+
+      protected
+
+      def add_to_sequence(satisfying_flows, dependent_flow)
+        if satisfying_flows.empty?
+          self.sub_flows << dependent_flow
+          return
+        end
+        extracted_flow = extract_flows(satisfying_flows)
+        sequence       = Sequence.new([extracted_flow])
+
+        self.sub_flows << sequence
+        sequence << dependent_flow
+      end
+
+      def extract_flows(extracted_sub_flows)
+        extracted_sub_flows.each do |sub_flow|
+          self.sub_flows.delete(sub_flow)
+        end
+
+        return Concurrence.new(extracted_sub_flows)
+      end
+    end
+  end
+end

data/lib/dynflow/flows/sequence.rb

@@ -0,0 +1,13 @@
+module Dynflow
+  module Flows
+    class Sequence < AbstractComposed
+
+      protected
+
+      def add_to_sequence(satisfying_flows, dependent_flow)
+        # the flows are already in sequence, we don't need to do anything extra
+        self << dependent_flow
+      end
+    end
+  end
+end

data/lib/dynflow/future.rb

@@ -0,0 +1,173 @@
+module Dynflow
+  class Future
+    Error            = Class.new StandardError
+    FutureAlreadySet = Class.new Error
+    FutureFailed     = Class.new Error
+    TimeOut          = Class.new Error
+
+    # `#future` will become resolved to `true` when ``#countdown!`` is called `count` times
+    class CountDownLatch
+      attr_reader :future
+
+      def initialize(count, future = Future.new)
+        raise ArgumentError if count < 0
+        @count  = count
+        @lock   = Mutex.new
+        @future = future
+      end
+
+      def countdown!
+        @lock.synchronize do
+          @count -= 1 if @count > 0
+          @future.resolve true if @count == 0 && !@future.ready?
+        end
+      end
+
+      def count
+        @lock.synchronize { @count }
+      end
+    end
+
+    include Algebrick::TypeCheck
+    extend Algebrick::TypeCheck
+
+    def self.join(futures, result = Future.new)
+      countdown = CountDownLatch.new(futures.size, result)
+      futures.each do |future|
+        Type! future, Future
+        future.do_then { |_| countdown.countdown! }
+      end
+      result
+    end
+
+    def initialize(&task)
+      @lock     = Mutex.new
+      @value    = nil
+      @resolved = false
+      @failed   = false
+      @waiting  = []
+      @tasks    = []
+      do_then &task if task
+    end
+
+    def value(timeout = nil)
+      wait timeout
+      @lock.synchronize { @value }
+    end
+
+    def value!
+      value.tap { raise value if failed? }
+    end
+
+    def resolve(result)
+      set result, false
+    end
+
+    def fail(exception)
+      Type! exception, Exception, String
+      if exception.is_a? String
+        exception = FutureFailed.new(exception).tap { |e| e.set_backtrace caller }
+      end
+      set exception, true
+    end
+
+    def evaluate_to(&block)
+      resolve block.call
+    rescue => error
+      self.fail error
+    end
+
+    def evaluate_to!(&block)
+      evaluate_to &block
+      raise value if self.failed?
+    end
+
+    def do_then(&task)
+      call_task = @lock.synchronize do
+        @tasks << task unless _ready?
+        @resolved
+      end
+      task.call value if call_task
+      self
+    end
+
+    def set(value, failed)
+      @lock.synchronize do
+        raise FutureAlreadySet, "future already set to #{@value} cannot use #{value}" if _ready?
+        if failed
+          @failed = true
+        else
+          @resolved = true
+        end
+        @value = value
+        while (thread = @waiting.pop)
+          begin
+            thread.wakeup
+          rescue ThreadError
+            retry
+          end
+        end
+        !failed
+      end
+      @tasks.each { |t| t.call value }
+      self
+    end
+
+    def wait(timeout = nil)
+      @lock.synchronize do
+        unless _ready?
+          @waiting << Thread.current
+          clock.ping self, timeout, Thread.current, :expired if timeout
+          @lock.sleep
+          raise TimeOut unless _ready?
+        end
+      end
+      self
+    end
+
+    def ready?
+      @lock.synchronize { _ready? }
+    end
+
+    def resolved?
+      @lock.synchronize { @resolved }
+    end
+
+    def failed?
+      @lock.synchronize { @failed }
+    end
+
+    def tangle(future)
+      do_then { |v| future.set v, failed? }
+    end
+
+    # @api private
+    def expired(thread)
+      @lock.synchronize do
+        thread.wakeup if @waiting.delete(thread)
+      end
+    end
+
+    private
+
+    def _ready?
+      @resolved || @failed
+    end
+
+    @clock_barrier = Mutex.new
+
+    # @api private
+    def self.clock
+      @clock_barrier.synchronize do
+        # TODO remove global state and use world.clock, needs to be terminated in right order
+        @clock ||= Clock.new(::Logger.new($stderr)).tap do |clock|
+          at_exit { clock.ask(Clock::Terminate).wait }
+        end
+      end
+    end
+
+    def clock
+      self.class.clock
+    end
+  end
+end

data/lib/dynflow/listeners.rb

@@ -0,0 +1,7 @@
+module Dynflow
+  module Listeners
+    require 'dynflow/listeners/serialization'
+    require 'dynflow/listeners/abstract'
+    require 'dynflow/listeners/socket'
+  end
+end

data/lib/dynflow/listeners/abstract.rb

@@ -0,0 +1,13 @@
+module Dynflow
+  module Listeners
+    class Abstract
+      include Algebrick::TypeCheck
+      attr_reader :world, :logger
+
+      def initialize(world)
+        @world  = Type! world, World
+        @logger = world.logger
+      end
+    end
+  end
+end

data/lib/dynflow/listeners/serialization.rb

@@ -0,0 +1,41 @@
+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 }
+        end
+        Done         = type { fields request_id: Integer, execution_plan_uuid: String }
+
+        variants Execute, Confirmation, Done
+      end
+
+      def dump(obj)
+        MultiJson.dump(obj.to_hash)
+      end
+
+      def load(str)
+        SocketMessage.from_hash MultiJson.load(str)
+      end
+
+      def send_message(io, message, barrier = nil)
+        barrier.lock if barrier
+        io.puts dump(message)
+      ensure
+        barrier.unlock if barrier
+      end
+
+      def receive_message(io)
+        if (message = io.gets)
+          load(message)
+        else
+          nil
+        end
+      rescue IOError
+        nil
+      end
+    end
+  end
+end