dynflow 0.7.9 → 0.8.0

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OTk4YWEzYzI4ZGUxYmEzYmRiZmYwZGUwN2I3ZjgzY2NlNmNjMDQ2OA==
-  data.tar.gz: !binary |-
-    OTFjZmY1OGE4MDI3MmIwY2YyYTIwYjZiOWI1YjljMTNiN2JhN2FhMA==
-SHA512:
-  metadata.gz: !binary |-
-    ZGRlZGI5Njc4ZDA4ZmFkNzMxMTdkMGM0M2E5Y2ZlNjljYjUxNzc5MDY0ZWY5
-    MWJmNWQzYjZjOGVhMTM2ODRiZjZlM2JkMTZhY2MwMzUwNDM4M2FlN2VmZjA3
-    ODIwODIzYjdkZGE2NGI1NGYzNzEzODQ4OTdjOWQyMTc0ZTI5YmQ=
-  data.tar.gz: !binary |-
-    OTllZWM0M2U2M2ZiN2I1MjA0MTQzM2ZlYzdiNzUxMzZjMTg2Mzg5ODRiOTcw
-    MWQwNTdmMjYxN2Q3ZWFlOGRmOTVmZjJhNjIyYTNlMjZiNWI4NTc2ZWNlODg4
-    MTUyNmMwNGY5MWFiZjc4MTU5YWRjMmEwYTllNzcwM2QzMWMxNDE=

data/lib/dynflow/daemon.rb

@@ -1,30 +0,0 @@
-module Dynflow
-  class Daemon
-    include Algebrick::TypeCheck
-
-    def initialize(listener, world, lock_file = nil)
-      @listener  = Type! listener, Listeners::Abstract
-      @world     = Type! world, World
-      @lock_file = Type! lock_file, String, NilClass
-    end
-
-    def run
-      with_lock_file do
-        terminated = Future.new
-        trap('SIGINT') { @world.terminate terminated }
-        terminated.wait
-        @listener.terminate.wait
-      end
-    end
-
-    def with_lock_file(&block)
-      if @lock_file
-        raise "Lockfile #{@lock_file} is already present." if File.exist?(@lock_file)
-        File.write(@lock_file, "Locked at #{Time.now} by process #{$$}\n")
-      end
-      block.call
-    ensure
-      File.delete(@lock_file) if @lock_file
-    end
-  end
-end

data/lib/dynflow/executors/remote_via_socket.rb

@@ -1,43 +0,0 @@
-require 'multi_json'
-require 'socket'
-
-module Dynflow
-  module Executors
-    class RemoteViaSocket < Abstract
-      require 'dynflow/executors/remote_via_socket/core'
-
-      include Listeners::Serialization
-      include Algebrick::Matching
-
-      def initialize(world, socket_path)
-        super world
-        @core = Core.new world, socket_path
-      end
-
-      def execute(execution_plan_id, finished = Future.new)
-        @core.ask(Core::Execution[execution_plan_id, finished]).value!.value!
-        finished
-      rescue => e
-        finished.fail e unless finished.ready?
-        raise e
-      end
-
-      def event(execution_plan_id, step_id, event, future = Future)
-        @core.ask(Core::Event[execution_plan_id, step_id, event, future]).value!
-        future
-      end
-
-      def terminate(future = Future.new)
-        @core.ask(MicroActor::Terminate, future)
-      end
-
-      def initialized
-        @core.initialized
-      end
-
-      def connected?
-        @core.ask(Core::Connect).value!
-      end
-    end
-  end
-end

data/lib/dynflow/executors/remote_via_socket/core.rb

@@ -1,184 +0,0 @@
-module Dynflow
-  module Executors
-    class RemoteViaSocket < Abstract
-      class Core < MicroActor
-        include Listeners::Serialization
-
-        Message = Algebrick.type do
-          Job = Algebrick.type do
-            variants Event     = Executors::Abstract::Event,
-                     Execution = Executors::Abstract::Execution
-          end
-
-          variants Closed   = atom,
-                   Received = type { fields message: Protocol::Response },
-                   Connect  = atom,
-                   Job
-        end
-
-        TrackedJob = Algebrick.type do
-          fields! id: Integer, job: Protocol::Job, accepted: Future, finished: Future
-        end
-
-        module TrackedJob
-          def accept!
-            accepted.resolve true
-            self
-          end
-
-          def reject!(error)
-            accepted.fail error
-            finished.fail error
-            self
-          end
-
-          def success!(world)
-            raise unless accepted.ready?
-            finished.resolve(
-                match job,
-                      (on Core::Protocol::Execution.(execution_plan_id: ~any) do |uuid|
-                        world.persistence.load_execution_plan(uuid)
-                      end),
-                      (on Core::Protocol::Event do
-                        true
-                      end))
-            self
-          end
-
-          def fail!(error)
-            if accepted.ready?
-              finished.fail error
-            else
-              reject! error
-            end
-            self
-          end
-        end
-
-        def initialize(world, socket_path)
-          super(world.logger, world, socket_path)
-        end
-
-        private
-
-        def delayed_initialize(world, socket_path)
-          @socket_path  = Type! socket_path, String
-          @world        = Type! world, World
-          @socket       = nil
-          @last_id      = 0
-          @tracked_jobs = {}
-          connect
-        end
-
-        def termination
-          terminate! if disconnect
-        end
-
-        def on_message(message)
-          Type! message, Message
-          match message,
-                (on ~Job do |job|
-                  raise 'terminating' if terminating?
-                  job, future  =
-                      match job,
-                            (on ~Execution do |(execution_plan_uuid, future)|
-                              [Protocol::Execution[execution_plan_uuid], future]
-                            end),
-                            (on ~Event do |(execution_plan_id, step_id, event, future)|
-                              [Protocol::Event[execution_plan_id, step_id, event], future]
-                            end)
-                  id, accepted = add_tracked_job future, job
-                  success      = connect && begin
-                    send_message @socket, Protocol::Do[id, job]
-                    true
-                  rescue IOError => error
-                    logger.warn error
-                    false
-                  end
-
-                  unless success
-                    @tracked_jobs[id].reject!(
-                        Dynflow::Error.new(
-                            "Cannot do #{message}, no connection to a Listener"))
-                  end
-
-                  return accepted
-                end),
-
-                (on Received.(~Protocol::Accepted) do |(id)|
-                  @tracked_jobs[id].accept!
-                end),
-
-                (on Received.(~Protocol::Failed) do |(id, error)|
-                  @tracked_jobs.delete(id).reject! Dynflow::Error.new(error)
-                end),
-
-                (on Received.(~Protocol::Done) do |(id)|
-                  @tracked_jobs.delete(id).success! @world
-                end),
-
-                (on Closed do
-                  @socket = nil
-                  logger.info 'Disconnected from server.'
-                  @tracked_jobs.each do |_, c|
-                    c.fail! 'Connection to a Listener lost.'
-                  end
-                  @tracked_jobs.clear
-                  terminate! if terminating?
-                end),
-
-                (on Connect do
-                  connect
-                end)
-        end
-
-        def add_tracked_job(finished, job)
-          @tracked_jobs[id = (@last_id += 1)] = TrackedJob[id, job, accepted = Future.new, finished]
-          return id, accepted
-        end
-
-        def connect
-          return true if @socket
-          @socket = UNIXSocket.new @socket_path
-          logger.info 'Connected to server.'
-          read_socket_until_closed
-          true
-        rescue SystemCallError, IOError => error
-          logger.warn error
-          false
-        rescue => error
-          logger.fatal error
-          raise error
-        end
-
-        def disconnect
-          return true unless @socket
-
-          @socket.close
-          false
-        rescue Errno::ENOTCONN
-          true
-        end
-
-        def read_socket_until_closed
-          Thread.new do
-            catch(:stop_reading) do
-              loop { read_socket }
-            end
-          end
-        end
-
-        def read_socket
-          match message = receive_message(@socket),
-                Protocol::Message >-> { self << Received[message] },
-                NilClass.to_m >-> do
-                  self << Closed
-                  throw :stop_reading
-                end
-        rescue => error
-          logger.fatal error
-        end
-      end
-    end
-  end
-end

data/lib/dynflow/future.rb

@@ -1,173 +0,0 @@
-module Dynflow
-  class Future
-    Error            = Class.new Dynflow::Error
-    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