dynflow 0.7.9 → 0.8.0

data/lib/dynflow/listeners.rb

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

data/lib/dynflow/listeners/abstract.rb

@@ -1,17 +0,0 @@
-module Dynflow
-  module Listeners
-    class Abstract
-      include Algebrick::TypeCheck
-      attr_reader :world, :logger
-
-      def initialize(world)
-        @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,77 +0,0 @@
-module Dynflow
-  module Listeners
-    module Serialization
-      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
-
-        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
-          # TODO fix the workaround
-          # marshal and then use base64 because not all json libs can correctly escape binary data
-          def to_hash
-            super.update event: Base64.strict_encode64(Marshal.dump(event))
-          end
-
-          def self.product_from_hash(hash)
-            super(hash.merge 'event' => Marshal.load(Base64.strict_decode64(hash.fetch('event'))))
-          end
-        end
-      end
-
-      def dump(obj)
-        MultiJson.dump(obj.to_hash)
-      end
-
-      def 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
-
-      def receive_message(io)
-        if (message = io.gets)
-          load(message)
-        else
-          nil
-        end
-      rescue IOError
-        nil
-      end
-    end
-  end
-end

data/lib/dynflow/listeners/socket.rb

@@ -1,117 +0,0 @@
-module Dynflow
-  module Listeners
-    class Socket < Abstract
-      include Listeners::Serialization
-      include Algebrick::Matching
-
-      Terminate = Algebrick.atom
-
-      def initialize(world, socket_path, interval = 1)
-        super(world)
-
-        File.delete socket_path if File.exist? socket_path
-        @server = UNIXServer.new socket_path
-        File.chmod(0600, socket_path)
-
-        @clients         = []
-        @client_barriers = {}
-        @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(interval)
-        shutdown if @terminate
-
-        ios                   = [@server, *@clients]
-        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 ~Protocol::Do do |(id, job)|
-                    execute_job(readable, id, job)
-                  end),
-                  (on NilClass.to_m do
-                    remove_client readable
-                    logger.info 'Client disconnected.'
-                  end)
-          end
-        end
-      rescue => error
-        logger.fatal error
-      end
-
-      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
-                                               Protocol::Failed[id, error.message]
-                                             else
-                                               Protocol::Accepted[id]
-                                             end)
-          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
-      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
-
-      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/micro_actor.rb

@@ -1,102 +0,0 @@
-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/simple_world.rb

@@ -1,19 +0,0 @@
-module Dynflow
-  class SimpleWorld < World
-    def initialize(options_hash = {})
-      super options_hash
-      at_exit { self.terminate.wait } if options[:auto_terminate]
-      # we can check consistency here because SimpleWorld doesn't expect
-      # remote executor being in place.
-      self.consistency_check
-      self.execute_planned_execution_plans
-    end
-
-    def default_options
-      super.merge(pool_size:           5,
-                  persistence_adapter: PersistenceAdapters::Sequel.new('sqlite:/'),
-                  transaction_adapter: TransactionAdapters::None.new,
-                  auto_terminate:      true)
-    end
-  end
-end

data/test/remote_via_socket_test.rb

@@ -1,170 +0,0 @@
-require_relative 'test_helper'
-
-describe 'remote communication' do
-
-  let(:persistence_adapter) { Dynflow::PersistenceAdapters::Sequel.new('sqlite:/') }
-
-  module Helpers
-    def socket_path
-      @socket_path ||= Dir.tmpdir + "/dynflow_remote_#{rand(1e30)}"
-    end
-
-    def logger_adapter
-      WorldInstance.logger_adapter
-    end
-
-    def create_world
-      Dynflow::SimpleWorld.new logger_adapter:      logger_adapter,
-                               auto_terminate:      false,
-                               exit_on_terminate:   false,
-                               persistence_adapter: persistence_adapter
-    end
-
-    def create_remote_world
-      Dynflow::SimpleWorld.new(
-          logger_adapter:      logger_adapter,
-          auto_terminate:      false,
-          persistence_adapter: persistence_adapter,
-          exit_on_terminate:   false,
-          executor:            -> remote_world do
-            Dynflow::Executors::RemoteViaSocket.new(remote_world, socket_path)
-          end)
-    end
-
-    def create_listener(world)
-      Dynflow::Listeners::Socket.new world, socket_path, 0.05
-    end
-
-    def terminate(*terminable)
-      terminable.each { |t| t.terminate.wait }
-    end
-  end
-
-  include Helpers
-
-  it 'raises when not connected' do
-    remote_world = create_remote_world
-    result       = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
-    result.must_be :planned?
-    result.wont_be :triggered?
-    result.error.must_be_kind_of Dynflow::Error
-
-    terminate remote_world
-  end
-
-  describe 'execute_planned_execution_plans' do
-    specify do
-      remote_world = create_remote_world
-      result       = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
-      result.must_be :planned?
-      result.wont_be :triggered?
-      result.error.must_be_kind_of Dynflow::Error
-
-      remote_world.persistence.load_execution_plan(result.id).state.must_equal :planned
-
-      world    = create_world
-      listener = create_listener(world)
-
-      # waiting until it starts executing
-      assert(10.times do |i|
-        state = world.persistence.load_execution_plan(result.id).state
-        break :ok if [:running, :stopped].include? state
-        puts 'retry'
-        sleep 0.01 * i
-      end == :ok)
-
-      terminate remote_world, listener, world
-    end
-  end
-
-  describe 'shutting down' do
-    [:remote_world, :world, :listener].permutation.each do |order|
-      it "works when in order #{order}" do
-        objects = { world:        w = create_world,
-                    listener:     create_listener(w),
-                    remote_world: remote_world = create_remote_world }
-
-        result = remote_world.trigger Support::CodeWorkflowExample::Commit, 'sha'
-        result.must_be :planned?
-        result.finished.value!.must_be_kind_of Dynflow::ExecutionPlan
-
-        terminate *objects.values_at(*order)
-        assert true, 'it has to reach this'
-      end
-    end
-
-    it 'allows to work others' do
-      world    = create_world
-      listener = create_listener(world)
-      rmw1     = create_remote_world
-      rmw2     = create_remote_world
-
-      [rmw1.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished,
-       rmw2.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished].
-          each(&:value!)
-
-      terminate rmw1
-
-      refute rmw1.trigger(Support::CodeWorkflowExample::Commit, 'sha').triggered?
-      rmw2.trigger(Support::CodeWorkflowExample::Commit, 'sha').
-          finished.value!.must_be_kind_of Dynflow::ExecutionPlan
-
-      terminate rmw2, listener, world
-    end
-
-    it 'raises when disconnected while executing' do
-      world        = create_world
-      listener     = create_listener(world)
-      remote_world = create_remote_world
-
-      result = remote_world.trigger(Support::CodeWorkflowExample::Slow, 2)
-      result.must_be :planned?
-
-      terminate listener
-
-      -> { result.finished.value! }.must_raise Dynflow::Future::FutureFailed
-      terminate remote_world, world
-    end
-
-  end
-
-  it 'restarts' do
-    world        = create_world
-    listener     = create_listener(world)
-    remote_world = create_remote_world
-
-    remote_world.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
-
-    terminate listener
-    Thread.pass while remote_world.executor.connected?
-    listener = create_listener world
-    Thread.pass until remote_world.executor.connected?
-
-    remote_world.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
-
-    terminate listener, world
-    Thread.pass while remote_world.executor.connected?
-    world    = create_world
-    listener = create_listener world
-    Thread.pass until remote_world.executor.connected?
-
-    remote_world.trigger(Support::CodeWorkflowExample::Commit, 'sha').finished.value!
-
-    terminate listener, world, remote_world
-  end
-
-  describe '#connected?' do
-    specify do
-      remote_world = create_remote_world
-
-      remote_world.executor.connected?.must_equal false
-
-      world    = create_world
-      listener = create_listener world
-
-      remote_world.executor.connected?.must_equal true
-
-      terminate listener, world, remote_world
-    end
-  end
-end