dynflow 0.7.9 → 0.8.0

data/lib/dynflow/connectors.rb

@@ -0,0 +1,7 @@
+module Dynflow
+  module Connectors
+    require 'dynflow/connectors/abstract'
+    require 'dynflow/connectors/direct'
+    require 'dynflow/connectors/database'
+  end
+end

data/lib/dynflow/connectors/abstract.rb

@@ -0,0 +1,41 @@
+module Dynflow
+  module Connectors
+    class Abstract
+      include Algebrick::TypeCheck
+      include Algebrick::Matching
+
+      def start_listening(world)
+        raise NotImplementedError
+      end
+
+      def stop_listening(world)
+        raise NotImplementedError
+      end
+
+      def terminate
+        raise NotImplementedError
+      end
+
+      def send(envelope)
+        raise NotImplementedError
+      end
+
+      # we need to pass the world, as the connector can be shared
+      # between words: we need to know the one to send the message to
+      def receive(world, envelope)
+        Type! envelope, Dispatcher::Envelope
+        match(envelope.message,
+              (on Dispatcher::Ping do
+                 response_envelope = envelope.build_response_envelope(Dispatcher::Pong, world)
+                 send(response_envelope)
+               end),
+              (on Dispatcher::Request do
+                 world.executor_dispatcher.tell([:handle_request, envelope])
+               end),
+              (on Dispatcher::Response do
+                 world.client_dispatcher.tell([:dispatch_response, envelope])
+               end))
+      end
+    end
+  end
+end

data/lib/dynflow/connectors/database.rb

@@ -0,0 +1,175 @@
+module Dynflow
+  module Connectors
+    class Database < Abstract
+
+      class PostgresListerner
+        def initialize(core, world_id, db)
+          @core     = core
+          @db       = db
+          @world_id = world_id
+          @started  = Concurrent::AtomicReference.new
+        end
+
+        def self.notify_supported?(db)
+          db.class.name == "Sequel::Postgres::Database"
+        end
+
+        def started?
+          @started.get
+        end
+
+        def start
+          @started.set true
+          @thread = Thread.new do
+            @db.listen("world:#{ @world_id }", :loop => true) do
+              if started?
+                @core << :check_inbox
+              else
+                break # the listener is stopped: don't continue listening
+              end
+            end
+          end
+        end
+
+        def notify(world_id)
+          @db.notify("world:#{world_id}")
+        end
+
+        def stop
+          @started.set false
+          notify(@world_id)
+        end
+      end
+
+      class Core < Actor
+        attr_reader :polling_interval
+
+        def initialize(connector, polling_interval)
+          @connector = connector
+          @world = nil
+          @executor_round_robin = RoundRobin.new
+          @stopped = false
+          @polling_interval = polling_interval
+        end
+
+        def stopped?
+          !!@stopped
+        end
+
+        def start_listening(world)
+          @world = world
+          @stopped = false
+          postgres_listen_start
+          self << :periodic_check_inbox
+        end
+
+        def stop_receiving_new_work
+          @world.coordinator.deactivate_world(@world.registered_world)
+        end
+
+        def stop_listening
+          @stopped = true
+          postgres_listen_stop
+        end
+
+        def periodic_check_inbox
+          self << :check_inbox
+          @world.clock.ping(self, polling_interval, :periodic_check_inbox) unless @stopped
+        end
+
+        def check_inbox
+          return unless @world
+          receive_envelopes
+        end
+
+        def handle_envelope(envelope)
+          world_id = find_receiver(envelope)
+          if world_id == @world.id
+            if @stopped
+              log(Logger::ERROR, "Envelope #{envelope} received for stopped world")
+            else
+              @connector.receive(@world, envelope)
+            end
+          else
+            send_envelope(update_receiver_id(envelope, world_id))
+          end
+        end
+
+        private
+
+        def postgres_listen_start
+          if PostgresListerner.notify_supported?(@world.persistence.adapter.db)
+            @postgres_listener ||= PostgresListerner.new(self, @world.id, @world.persistence.adapter.db)
+            @postgres_listener.start unless @postgres_listener.started?
+          end
+        end
+
+        def postgres_listen_stop
+          @postgres_listener.stop if @postgres_listener
+        end
+
+        def receive_envelopes
+          @world.persistence.pull_envelopes(@world.id).each do |envelope|
+            self.tell([:handle_envelope, envelope])
+          end
+        rescue => e
+          log(Logger::ERROR, "Receiving envelopes failed on #{e}")
+        end
+
+        def send_envelope(envelope)
+          @world.persistence.push_envelope(envelope)
+          if @postgres_listener
+            @postgres_listener.notify(envelope.receiver_id)
+          end
+        rescue => e
+          log(Logger::ERROR, "Sending envelope failed on #{e}")
+        end
+
+        def update_receiver_id(envelope, new_receiver_id)
+          Dispatcher::Envelope[envelope.request_id, envelope.sender_id, new_receiver_id, envelope.message]
+        end
+
+        def find_receiver(envelope)
+          if Dispatcher::AnyExecutor === envelope.receiver_id
+            any_executor.id
+          else
+            envelope.receiver_id
+          end
+        end
+
+        def any_executor
+          @executor_round_robin.data = @world.coordinator.find_worlds(true)
+          @executor_round_robin.next or raise Dynflow::Error, "No executor available"
+        end
+      end
+
+      def initialize(world = nil, polling_interval = nil)
+        polling_interval ||= begin
+                               if world && PostgresListerner.notify_supported?(world.persistence.adapter.db)
+                                 30 # when the notify is supported, we don't need that much polling
+                               else
+                                 1
+                               end
+                             end
+        @core  = Core.spawn('connector-database-core', self, polling_interval)
+        start_listening(world) if world
+      end
+
+      def start_listening(world)
+        @core.ask([:start_listening, world])
+      end
+
+      def stop_receiving_new_work(_)
+        @core.ask(:stop_receiving_new_work).wait
+      end
+
+      def stop_listening(_)
+        @core.ask(:stop_listening).then { @core.ask(:terminate!) }.wait
+      end
+
+      def send(envelope)
+        @core.ask([:handle_envelope, envelope])
+      end
+    end
+  end
+end

data/lib/dynflow/connectors/direct.rb

@@ -0,0 +1,71 @@
+module Dynflow
+  module Connectors
+    class Direct < Abstract
+
+      class Core < Actor
+
+        def initialize(connector)
+          @connector = connector
+          @worlds = {}
+          @executor_round_robin = RoundRobin.new
+        end
+
+        def start_listening(world)
+          @worlds[world.id] = world
+          @executor_round_robin.add(world) if world.executor
+        end
+
+        def stop_receiving_new_work(world)
+          @executor_round_robin.delete(world)
+        end
+
+        def stop_listening(world)
+          @worlds.delete(world.id)
+          @executor_round_robin.delete(world) if world.executor
+          reference.tell(:terminate!) if @worlds.empty?
+        end
+
+        def handle_envelope(envelope)
+          if world = find_receiver(envelope)
+            @connector.receive(world, envelope)
+          else
+            log(Logger::ERROR, "Receiver for envelope #{ envelope } not found")
+          end
+        end
+
+        private
+
+        def find_receiver(envelope)
+          receiver = if Dispatcher::AnyExecutor === envelope.receiver_id
+                       @executor_round_robin.next
+                     else
+                       @worlds[envelope.receiver_id]
+                     end
+          raise Dynflow::Error, "No executor available" unless receiver
+          return receiver
+        end
+      end
+
+      def initialize(world = nil)
+        @core  = Core.spawn('connector-direct-core', self)
+        start_listening(world) if world
+      end
+
+      def start_listening(world)
+        @core.ask([:start_listening, world])
+      end
+
+      def stop_receiving_new_work(world)
+        @core.ask([:stop_receiving_new_work, world]).wait
+      end
+
+      def stop_listening(world)
+        @core.ask([:stop_listening, world]).wait
+      end
+
+      def send(envelope)
+        @core.ask([:handle_envelope, envelope])
+      end
+    end
+  end
+end

data/lib/dynflow/coordinator.rb

@@ -0,0 +1,280 @@
+require 'dynflow/coordinator_adapters'
+
+module Dynflow
+  class Coordinator
+
+    include Algebrick::TypeCheck
+
+    class DuplicateRecordError < Dynflow::Error
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+        super("record #{record} already exists")
+      end
+    end
+
+    class LockError < Dynflow::Error
+      attr_reader :lock
+
+      def initialize(lock)
+        @lock = lock
+        super("Unable to acquire lock #{lock}")
+      end
+    end
+
+    class Record < Serializable
+      attr_reader :data
+
+      include Algebrick::TypeCheck
+
+      def self.new_from_hash(hash)
+        self.allocate.tap { |record| record.from_hash(hash) }
+      end
+
+      def self.constantize(name)
+        Serializable.constantize(name)
+      rescue NameError
+        # If we don't find the lock name, return the most generic version
+        Record
+      end
+
+      def initialize(*args)
+        @data ||= {}
+        @data = @data.merge(class: self.class.name).with_indifferent_access
+      end
+
+      def from_hash(hash)
+        @data      = hash
+        @from_hash = true
+      end
+
+      def to_hash
+        @data
+      end
+
+      def id
+        @data[:id]
+      end
+
+      # @api override
+      # check to be performed before we try to acquire the lock
+      def validate!
+        Type! id,       String
+        Type! @data,     Hash
+      end
+
+      def to_s
+        "#{self.class.name}: #{id}"
+      end
+
+      def ==(other_object)
+        self.class == other_object.class && self.id == other_object.id
+      end
+
+      def hash
+        [self.class, self.id].hash
+      end
+    end
+
+    class WorldRecord < Record
+      def initialize(world)
+        super
+        @data[:id]     = world.id
+        @data[:meta]   = world.meta
+      end
+
+      def meta
+        @data[:meta]
+      end
+    end
+
+    class ExecutorWorld < WorldRecord
+      def initialize(world)
+        super
+        self.active    = !world.terminating?
+      end
+
+      def active?
+        @data[:active]
+      end
+
+      def active=(value)
+        Type! value, Algebrick::Types::Boolean
+        @data[:active] = value
+      end
+    end
+
+    class ClientWorld < WorldRecord
+    end
+
+    class Lock < Record
+      def self.constantize(name)
+        Serializable.constantize(name)
+      rescue NameError
+        # If we don't find the lock name, return the most generic version
+        Lock
+      end
+
+      def to_s
+        "#{self.class.name}: #{id} by #{owner_id}"
+      end
+
+      def owner_id
+        @data[:owner_id]
+      end
+
+      # @api override
+      # check to be performed before we try to acquire the lock
+      def validate!
+        super
+        raise "Can't acquire the lock after deserialization" if @from_hash
+        Type! owner_id, String
+      end
+
+      def to_s
+        "#{self.class.name}: #{id} by #{owner_id}"
+      end
+    end
+
+    class LockByWorld < Lock
+      def initialize(world)
+        super
+        @world = world
+        @data.merge!(owner_id: "world:#{world.id}",  world_id: world.id)
+      end
+
+      def validate!
+        super
+        raise Errors::InactiveWorldError.new(@world) if @world.terminating?
+      end
+
+      def world_id
+        @data[:world_id]
+      end
+
+    end
+
+    class WorldInvalidationLock < LockByWorld
+      def initialize(world, invalidated_world)
+        super(world)
+        @data[:id] = "world-invalidation:#{invalidated_world.id}"
+      end
+    end
+
+    class AutoExecuteLock < LockByWorld
+      def initialize(*args)
+        super
+        @data[:id] = "auto-execute"
+      end
+    end
+
+    class ExecutionLock < LockByWorld
+      def initialize(world, execution_plan_id, client_world_id, request_id)
+        super(world)
+        @data.merge!(id: "execution-plan:#{execution_plan_id}",
+                     execution_plan_id: execution_plan_id,
+                     client_world_id: client_world_id,
+                     request_id: request_id)
+      end
+
+      # we need to store the following data in case of
+      # invalidation of the lock from outside (after
+      # the owner world terminated unexpectedly)
+      def execution_plan_id
+        @data[:execution_plan_id]
+      end
+
+      def client_world_id
+        @data[:client_world_id]
+      end
+
+      def request_id
+        @data[:request_id]
+      end
+    end
+
+    attr_reader :adapter
+
+    def initialize(coordinator_adapter)
+      @adapter = coordinator_adapter
+    end
+
+    def acquire(lock, &block)
+      Type! lock, Lock
+      lock.validate!
+      adapter.create_record(lock)
+      if block
+        begin
+          block.call
+        ensure
+          release(lock)
+        end
+      end
+    rescue DuplicateRecordError => e
+      raise LockError.new(e.record)
+    end
+
+    def release(lock)
+      Type! lock, Lock
+      adapter.delete_record(lock)
+    end
+
+    def release_by_owner(owner_id)
+      find_locks(owner_id: owner_id).map { |lock| release(lock) }
+    end
+
+    def find_locks(filter_options)
+      adapter.find_records(filter_options).map do |lock_data|
+        Lock.from_hash(lock_data)
+      end
+    end
+
+    def create_record(record)
+      Type! record, Record
+      adapter.create_record(record)
+    end
+
+    def update_record(record)
+      Type! record, Record
+      adapter.update_record(record)
+    end
+
+    def delete_record(record)
+      Type! record, Record
+      adapter.delete_record(record)
+    end
+
+    def find_records(filter)
+      adapter.find_records(filter).map do |record_data|
+        Record.from_hash(record_data)
+      end
+    end
+
+    def find_worlds(active_executor_only = false, filters = {})
+      ret = find_records(filters.merge(class: Coordinator::ExecutorWorld.name))
+      if active_executor_only
+        ret = ret.select(&:active?)
+      else
+        ret.concat(find_records(filters.merge(class: Coordinator::ClientWorld.name)))
+      end
+      ret
+    end
+
+    def register_world(world)
+      Type! world, Coordinator::ClientWorld, Coordinator::ExecutorWorld
+      create_record(world)
+    end
+
+    def delete_world(world)
+      Type! world, Coordinator::ClientWorld, Coordinator::ExecutorWorld
+      delete_record(world)
+    end
+
+    def deactivate_world(world)
+      Type! world, Coordinator::ExecutorWorld
+      world.active = false
+      update_record(world)
+    end
+  end
+end