agent 0.1.0 → 0.9.0

data/lib/agent/push.rb

@@ -0,0 +1,70 @@
+require "agent/errors"
+
+module Agent
+  class Push
+    attr_reader :object, :uuid, :blocking_once, :notifier
+
+    def initialize(object, options={})
+      @object        = Marshal.dump(object)
+      @uuid          = options[:uuid] || UUID.generate
+      @blocking_once = options[:blocking_once]
+      @notifier      = options[:notifier]
+      @mutex         = Mutex.new
+      @cvar          = ConditionVariable.new
+      @sent          = false
+      @closed        = false
+    end
+
+    def sent?
+      @sent
+    end
+
+    def closed?
+      @closed
+    end
+
+    def wait
+      @mutex.synchronize do
+        until @sent || @closed
+          @cvar.wait(@mutex)
+        end
+        raise Errors::ChannelClosed if @closed
+      end
+    end
+
+    def receive
+      @mutex.synchronize do
+        raise Errors::ChannelClosed if @closed
+
+        if @blocking_once
+          value, error = @blocking_once.perform do
+            yield @object
+            @sent = true
+            @cvar.signal
+            @notifier.notify(self) if @notifier
+          end
+
+          return error
+        else
+          begin
+            yield @object
+            @sent = true
+            @cvar.signal
+            @notifier.notify(self) if @notifier
+          rescue Errors::Rollback
+          end
+        end
+      end
+    end
+
+    def close
+      @mutex.synchronize do
+        return if @sent
+        @closed = true
+        @cvar.broadcast
+        @notifier.notify(self) if @notifier
+      end
+    end
+
+  end
+end

data/lib/agent/queue.rb

@@ -0,0 +1,133 @@
+require "agent/queue/buffered"
+require "agent/queue/unbuffered"
+require "agent/errors"
+
+module Agent
+  class Queue
+    attr_reader :type, :queue, :operations, :pushes, :pops, :mutex
+
+    def initialize(type)
+      @type = type
+
+      raise Errors::Untyped unless @type
+      raise Errors::InvalidType unless @type.is_a?(Module)
+
+      @closed = false
+
+      @queue      = []
+      @operations = []
+      @pushes     = []
+      @pops       = []
+
+      @mutex = Mutex.new
+
+      reset_custom_state
+    end
+
+    def buffered?
+      # implement in subclass
+      raise Errors::NotImplementedError
+    end
+
+    def unbuffered?
+      # implement in subclass
+      raise Errors::NotImplementedError
+    end
+
+    def pop?
+      # implement in subclass
+      raise Errors::NotImplementedError
+    end
+
+    def push?
+      # implement in subclass
+      raise Errors::NotImplementedError
+    end
+
+    def close
+      mutex.synchronize do
+        raise Errors::ChannelClosed if @closed
+        @closed = true
+        @operations.each{|o| o.close }
+        @operations.clear
+        @queue.clear
+        @pushes.clear
+        @pops.clear
+
+        reset_custom_state
+      end
+    end
+
+    def closed?; @closed; end
+    def open?;   !@closed;   end
+
+    def push(object, options={})
+      raise Errors::InvalidType unless object.is_a?(@type)
+
+      push = Push.new(object, options)
+
+      mutex.synchronize do
+        raise Errors::ChannelClosed if @closed
+        operations << push
+        pushes << push
+        process
+      end
+
+      return push if options[:deferred]
+
+      push.wait
+    end
+
+    def pop(options={})
+      pop = Pop.new(options)
+
+      mutex.synchronize do
+        raise Errors::ChannelClosed if @closed
+        operations << pop
+        pops << pop
+        process
+      end
+
+      return pop if options[:deferred]
+
+      ok = pop.wait
+      [pop.object, ok]
+    end
+
+    def remove_operations(ops)
+      mutex.synchronize do
+        return if @closed
+
+        ops.each do |operation|
+          operations.delete(operation)
+        end
+
+        pushes.clear
+        pops.clear
+
+        operations.each do |operation|
+          if operation.is_a?(Push)
+            pushes << operation
+          else
+            pops << operation
+          end
+        end
+
+        reset_custom_state
+      end
+    end
+
+
+  protected
+
+    def reset_custom_state
+      # implement in subclass...or not...
+    end
+
+    def process
+      # implement in subclass
+      raise Errors::NotImplementedError
+    end
+
+  end
+end

data/lib/agent/queue/buffered.rb

@@ -0,0 +1,68 @@
+require "agent/queue"
+require "agent/errors"
+
+module Agent
+  class Queue
+    class Buffered < Queue
+      attr_reader :size, :max
+
+      def initialize(type, max=1)
+        raise Errors::InvalidQueueSize, "queue size must be at least 1" unless max >= 1
+        super(type)
+        @max = max
+      end
+
+      def buffered?;   true; end
+      def unbuffered?; false;  end
+
+      def push?; @max > @size; end
+      def pop?;  @size > 0;    end
+
+    protected
+
+      def reset_custom_state
+        @size = @queue.size
+      end
+
+      def process
+        return if (pops.empty? && !push?) || (pushes.empty? && !pop?)
+
+        operation = operations.first
+
+        loop do
+          if operation.is_a?(Push)
+            if push?
+              operation.receive do |obj|
+                @size += 1
+                queue.push(obj)
+              end
+              operations.delete(operation)
+              pushes.delete(operation)
+            elsif pop? && operation = pops[0]
+              next
+            else
+              break
+            end
+          else # Pop
+            if pop?
+              operation.send do
+                @size -= 1
+                queue.shift
+              end
+              operations.delete(operation)
+              pops.delete(operation)
+            elsif push? && operation = pushes[0]
+              next
+            else
+              break
+            end
+          end
+
+          operation = operations[0]
+          break unless operation
+        end
+      end
+
+    end
+  end
+end

data/lib/agent/queue/unbuffered.rb

@@ -0,0 +1,88 @@
+require "agent/queue"
+require "agent/errors"
+
+module Agent
+  class Queue
+    class Unbuffered < Queue
+
+      attr_reader :waiting_pushes, :waiting_pops
+
+      def buffered?;   false; end
+      def unbuffered?; true;  end
+
+      def push?; @waiting_pops > 0;   end
+      def pop?;  @waiting_pushes > 0; end
+
+    protected
+
+      def reset_custom_state
+        @waiting_pushes = pushes.size
+        @waiting_pops   = pops.size
+      end
+
+      def process
+        operation = operations.last
+
+        if operation.is_a?(Push)
+          @waiting_pushes += 1
+
+          pops.dup.each do |pop_operation|
+            if operation.blocking_once && operation.blocking_once == pop_operation.blocking_once
+              next
+            end
+
+            error = operation.receive do |value|
+              error = pop_operation.send do
+                value
+              end
+
+              @waiting_pops -= 1
+              operations.delete(pop_operation)
+              pops.delete(pop_operation)
+              raise Errors::Rollback if error
+            end
+
+            if error.nil? || error.message?("already performed")
+              @waiting_pushes -= 1
+              operations.pop
+              pushes.pop
+              break
+            end
+          end
+        else # Pop
+          @waiting_pops += 1
+
+          pushes.dup.each do |push_operation|
+            if operation.blocking_once && operation.blocking_once == push_operation.blocking_once
+              next
+            end
+
+            error = operation.send do
+              value = nil
+
+              error = push_operation.receive do |v|
+                value = v
+              end
+
+              @waiting_pushes -= 1
+              operations.delete(push_operation)
+              pushes.delete(push_operation)
+              raise Errors::Rollback if error
+
+              value
+            end
+
+            if error.nil? || error.message?("already performed")
+              @waiting_pops -= 1
+              operations.pop
+              pops.pop
+              break
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/agent/queues.rb

@@ -0,0 +1,50 @@
+require "agent/errors"
+
+module Agent
+  module Queues
+    LOCK = Mutex.new
+
+    class << self
+      attr_accessor :queues
+    end
+
+    self.queues = {}
+
+    def self.register(name, type, max)
+      raise Errors::Untyped unless type
+      raise Errors::InvalidType unless type.is_a?(Module)
+
+      LOCK.synchronize do
+        queue = queues[name]
+
+        if queue
+          if queue.type == type
+            return queue
+          else
+            raise Errors::InvalidType, "Type #{type.name} is different than the queue's type (#{queue.type.name})"
+          end
+        end
+
+        raise Errors::InvalidQueueSize, "queue size must be at least 0" unless max >= 0
+
+        if max > 0
+          queues[name] = Queue::Buffered.new(type, max)
+        else
+          queues[name] = Queue::Unbuffered.new(type)
+        end
+      end
+    end
+
+    def self.delete(name)
+      LOCK.synchronize{ queues.delete(name) }
+    end
+
+    def self.[](name)
+      LOCK.synchronize{ queues[name] }
+    end
+
+    def self.clear
+      LOCK.synchronize{ queues.clear }
+    end
+  end
+end

data/lib/agent/selector.rb

@@ -0,0 +1,119 @@
+require "agent/uuid"
+require "agent/push"
+require "agent/pop"
+require "agent/channel"
+require "agent/notifier"
+require "agent/errors"
+
+module Agent
+  def self.select!
+    raise Errors::BlockMissing unless block_given?
+    selector = Selector.new
+    yield selector
+    selector.select
+  ensure
+    if selector
+      selector.close_default_channel
+      selector.dequeue_operations
+    end
+  end
+
+  class Selector
+    attr_reader :cases
+
+    Case = Struct.new(:uuid, :channel, :direction, :value, :blk)
+
+    def initialize
+      @ordered_cases = []
+      @cases         = {}
+      @operations    = {}
+      @blocking_once = BlockingOnce.new
+      @notifier      = Notifier.new
+    end
+
+    def default(&blk)
+      if @default_case
+        raise Errors::DefaultCaseAlreadyDefinedError
+      else
+        @default_case = self.case(channel!(TrueClass, 1), :receive, &blk)
+      end
+    end
+
+    def timeout(t, &blk)
+      s = channel!(TrueClass, 1)
+      go!{ sleep t; s.send(true); s.close }
+      add_case(s, :timeout, &blk)
+    end
+
+    def case(chan, direction, value=nil, &blk)
+      raise "invalid case, must be a channel" unless chan.is_a?(Channel)
+      raise Errors::BlockMissing if blk.nil? && direction == :receive
+      raise Errors::InvalidDirection if direction != :send && direction != :receive
+      add_case(chan, direction, value, &blk)
+    end
+
+    def select
+      if !@ordered_cases.empty?
+        @ordered_cases.each do |cse|
+          if cse.direction == :send
+            @operations[cse.channel] << cse.channel.send(cse.value, :uuid => cse.uuid,
+                                                                    :blocking_once => @blocking_once,
+                                                                    :notifier => @notifier,
+                                                                    :deferred => true)
+          else # :receive || :timeout
+            @operations[cse.channel] << cse.channel.receive(:uuid => cse.uuid,
+                                                            :blocking_once => @blocking_once,
+                                                            :notifier => @notifier,
+                                                            :deferred => true)
+          end
+        end
+
+        if @default_case
+          @default_case.channel.send(true, :uuid => @default_case.uuid, :blocking_once => @blocking_once, :notifier => @notifier, :deferred => true)
+        end
+
+        @notifier.wait
+
+        execute_case(@notifier.payload)
+      end
+    end
+
+    def dequeue_operations
+      @operations.each do |channel, operations|
+        channel.remove_operations(operations)
+      end
+    end
+
+    def close_default_channel
+      @default_case.channel.close if @default_case
+    end
+
+
+  protected
+
+    def add_case(chan, direction, value=nil, &blk)
+      uuid = UUID.generate
+      cse = Case.new(uuid, chan, direction, value, blk)
+      @ordered_cases << cse
+      @cases[uuid] = cse
+      @operations[chan] = []
+      cse
+    end
+
+    def execute_case(operation)
+      raise Errors::ChannelClosed if operation.closed?
+
+      cse = @cases[operation.uuid]
+      blk, direction = cse.blk, cse.direction
+
+      if blk
+        if direction == :send || direction == :timeout
+          blk.call
+        else # :receive
+          blk.call(operation.object)
+        end
+      end
+    end
+
+  end
+end