agent 0.1.0 → 0.9.0

data/lib/agent/uuid.rb

@@ -0,0 +1,36 @@
+require 'securerandom'
+
+# Borrowed from Celluloid. Using thread locals instead of extending the base
+# Thread class, though.
+module Agent
+  module UUID
+    values = SecureRandom.hex(9).match(/(.{8})(.{4})(.{3})(.{3})/)
+    PREFIX = "#{values[1]}_#{values[2]}_4#{values[3]}_8#{values[4]}".freeze
+    BLOCK_SIZE = 0x10000
+
+    @counter = 0
+    @counter_mutex = Mutex.new
+
+    def self.generate
+      thread = Thread.current
+
+      unless thread[:__agent_uuid_limit__]
+        @counter_mutex.synchronize do
+          block_base = @counter
+          @counter += BLOCK_SIZE
+          thread[:__agent_uuid_counter__] = block_base
+          thread[:__agent_uuid_limit__]   = @counter - 1
+        end
+      end
+
+      counter = thread[:__agent_uuid_counter__]
+      if thread[:__agent_uuid_counter__] >= thread[:__agent_uuid_limit__]
+        thread[:__agent_uuid_counter__] = thread[:__agent_uuid_limit__] = nil
+      else
+        thread[:__agent_uuid_counter__] += 1
+      end
+
+      "#{PREFIX}_#{sprintf("%012x", counter)}".freeze
+    end
+  end
+end

data/lib/agent/version.rb

@@ -1,3 +1,3 @@
 module Agent
-  VERSION = "0.1.0"
+  VERSION = "0.9.0"
 end

data/lib/agent/wait_group.rb

@@ -0,0 +1,43 @@
+require "agent/errors"
+
+module Agent
+  class WaitGroup
+    attr_reader :count
+
+    def initialize
+      @count = 0
+      @mutex = Mutex.new
+      @cvar  = ConditionVariable.new
+    end
+
+    def wait
+      @mutex.synchronize do
+        while @count > 0
+          @cvar.wait(@mutex)
+        end
+      end
+    end
+
+    def add(delta)
+      @mutex.synchronize do
+        modify_count(delta)
+      end
+    end
+
+    def done
+      @mutex.synchronize do
+        modify_count(-1)
+      end
+    end
+
+  protected
+
+    # Expects to be called inside of the mutex
+    def modify_count(delta)
+      @count += delta
+      raise Errors::NegativeWaitGroupCount if @count < 0
+      @cvar.signal if @count == 0
+    end
+
+  end
+end

data/spec/blocking_once_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+
+describe Agent::BlockingOnce do
+
+  before do
+    @blocking_once = Agent::BlockingOnce.new
+  end
+
+  it "should execute the block passed to it" do
+    r = []
+
+    @blocking_once.perform do
+      r << 1
+    end
+
+    r.size.should == 1
+    r.first.should == 1
+  end
+
+  it "should only execute the first block passed to it" do
+    r = []
+
+    @blocking_once.perform do
+      r << 1
+    end
+
+    @blocking_once.perform do
+      r << 2
+    end
+
+    r.size.should == 1
+    r.first.should == 1
+  end
+
+  it "should return the value returned from the block" do
+    value, error = @blocking_once.perform do
+      1
+    end
+
+    value.should == 1
+  end
+
+  it "should return nil for value and an error if it has already been used" do
+    value, error = @blocking_once.perform{ 1 }
+    value.should == 1
+    error.should be_nil
+
+    value, error = @blocking_once.perform{ 2 }
+    value.should be_nil
+    error.should_not be_nil
+    error.should be_message("already performed")
+  end
+
+  it "should roll back and allow the block to be executed again" do
+    s = Time.now.to_f
+
+    finished_channel = channel!(TrueClass, 2)
+
+    go! do
+      @blocking_once.perform do
+        sleep 0.1
+        finished_channel.send(true)
+        raise Agent::Errors::Rollback
+      end
+    end
+
+    sleep 0.1 # make sure the first @blocking_once calls #perform
+
+    go! do
+      @blocking_once.perform do
+        sleep 0.1
+        finished_channel.send(true)
+      end
+    end
+
+    2.times { finished_channel.receive }
+
+    finished_channel.close
+
+    # Three sleeps at 0.1 == 0.3, so if it's less than 0.3...
+    (Time.now.to_f - s).should < 0.3
+  end
+
+  it "should have minimal contention between threads when they contend for position" do
+    r, s = [], Time.now.to_f
+
+    # Using condition variables to maximize potential contention
+    mutex     = Mutex.new
+    condition = ConditionVariable.new
+
+    waiting_channel  = channel!(TrueClass, 2)
+    finished_channel = channel!(TrueClass, 2)
+
+    go! do
+      mutex.synchronize{ waiting_channel.send(true); condition.wait(mutex) }
+      @blocking_once.perform{ sleep 0.1; r << 1 }
+      finished_channel.send(true)
+    end
+
+    go! do
+      mutex.synchronize{ waiting_channel.send(true); condition.wait(mutex) }
+      @blocking_once.perform{ sleep 0.1; r << 1 }
+      finished_channel.send(true)
+    end
+
+    # wait for both the goroutines to be waiting
+    2.times{ waiting_channel.receive }
+
+    mutex.synchronize{ condition.broadcast }
+
+    # wait for the finished channel to be completed
+    2.times{ finished_channel.receive }
+
+    r.size.should == 1
+    # Onlt the first sleep should be performed, so things should quickly
+    (Time.now.to_f - s).should be_within(0.05).of(0.15)
+
+    waiting_channel.close
+    finished_channel.close
+  end
+
+end

data/spec/channel_spec.rb

@@ -1,38 +1,17 @@
-require "helper"
+require "spec_helper"
 
 describe Agent::Channel do
-  # http://golang.org/doc/go_spec.html#Channel_types
 
-  include Agent
-  let(:c) { Channel.new(:name => "spec", :type => String) }
-
-  it "should have a name" do
-    lambda { Channel.new(:type => String) }.should raise_error(Channel::NoName)
-    c.name.should == "spec"
-  end
-
-  it "should respond to close" do
-    lambda { c.close }.should_not raise_error
-    c.closed?.should be_true
-  end
-
-  it "should respond to closed?" do
-    c.closed?.should be_false
-    c.close
-    c.closed?.should be_true
-  end
-
-  context "deadlock" do
-    it "should deadlock on single thread" do
-      c = Channel.new(:name => "deadlock", :type => String)
-      lambda { c.receive }.should raise_error
+  context "naming" do
+    it "should not be required" do
+      c = nil
+      lambda { c = channel!(String) }.should_not raise_error
       c.close
     end
 
-    it "should not deadlock with multiple threads" do
-      c = Channel.new(:name => "deadlock", :type => String)
-      Thread.new { sleep(0.1); c.push "hi" }
-      lambda { c.receive }.should_not raise_error
+    it "be able to be set" do
+      c = channel!(String, :name => "gibberish")
+      c.name.should == "gibberish"
       c.close
     end
   end
@@ -43,102 +22,194 @@ describe Agent::Channel do
     # type. The value of an uninitialized channel is nil.
 
     it "should support send only" do
-      c = Channel.new(:name => "spec", :direction => :send, :type => String, :size => 3)
+      c = channel!(String, 3, :direction => :send)
 
       lambda { c << "hello"   }.should_not raise_error
       lambda { c.push "hello" }.should_not raise_error
       lambda { c.send "hello" }.should_not raise_error
 
-      lambda { c.pop }.should raise_error Channel::InvalidDirection
-      lambda { c.receive }.should raise_error Channel::InvalidDirection
+      c.direction.should == :send
+
+      lambda { c.pop }.should raise_error Agent::Errors::InvalidDirection
+      lambda { c.receive }.should raise_error Agent::Errors::InvalidDirection
 
       c.close
     end
 
     it "should support receive only" do
-      c = Channel.new(:name => "spec", :direction => :receive, :type => String)
+      c = channel!(String, :direction => :receive)
+
+      lambda { c << "hello"   }.should raise_error Agent::Errors::InvalidDirection
+      lambda { c.push "hello" }.should raise_error Agent::Errors::InvalidDirection
+      lambda { c.send "hello" }.should raise_error Agent::Errors::InvalidDirection
 
-      lambda { c << "hello"   }.should raise_error Channel::InvalidDirection
-      lambda { c.push "hello" }.should raise_error Channel::InvalidDirection
-      lambda { c.send "hello" }.should raise_error Channel::InvalidDirection
+      c.direction.should == :receive
 
       # timeout blocking receive calls
-      lambda { Timeout::timeout(0.1) { c.pop } }.should raise_error(Timeout::Error)
-      lambda { Timeout::timeout(0.1) { c.receive } }.should raise_error(Timeout::Error)
+      timed_out = false
+      select! do |s|
+        s.case(c, :receive){}
+        s.timeout(0.1){ timed_out = true }
+      end
+      timed_out.should == true
+      c.close
     end
 
     it "should default to bi-directional communication" do
+      c = channel!(String, 1)
       lambda { c.send "hello" }.should_not raise_error
       lambda { c.receive }.should_not raise_error
+
+      c.direction.should == :bidirectional
+    end
+
+    it "should be able to be dup'd as a uni-directional channel" do
+      c = channel!(String, 1)
+
+      send_only = c.as_send_only
+      send_only.direction.should == :send
+
+      receive_only = c.as_receive_only
+      receive_only.direction.should == :receive
+
+      send_only.send("nifty")
+      receive_only.receive[0].should == "nifty"
+    end
+  end
+
+  context "closing" do
+    before do
+      @c = channel!(String)
+    end
+
+    it "not raise an error the first time it is called" do
+      lambda { @c.close }.should_not raise_error
+      @c.closed?.should be_true
+    end
+
+    it "should raise an error the second time it is called" do
+      @c.close
+      lambda { @c.close }.should raise_error(Agent::Errors::ChannelClosed)
+    end
+
+    it "should respond to closed?" do
+      @c.closed?.should be_false
+      @c.close
+      @c.closed?.should be_true
+    end
+
+    it "should return that a receive was a failure when a channel is closed while being read from" do
+      go!{ sleep 0.01; @c.close }
+      _, ok = @c.receive
+      ok.should be_false
+    end
+
+    it "should raise an error when sending to a channel that has already been closed" do
+      @c.close
+      lambda { @c.send("a") }.should raise_error(Agent::Errors::ChannelClosed)
+    end
+
+    it "should raise an error when receiving from a channel that has already been closed" do
+      @c.close
+      lambda { @c.receive }.should raise_error(Agent::Errors::ChannelClosed)
+    end
+  end
+
+  context "deadlock" do
+    before do
+      @c = channel!(String)
+    end
+
+    it "should deadlock on single thread", :vm => :ruby do
+      lambda { @c.receive }.should raise_error
+    end
+
+    it "should not deadlock with multiple threads" do
+      go!{ sleep(0.1); @c.push "hi" }
+      lambda { @c.receive }.should_not raise_error
     end
   end
 
   context "typed" do
     it "should create a typed channel" do
-      lambda { Channel.new(:name => "spec") }.should raise_error Channel::Untyped
-      lambda { Channel.new(:name => "spec", :type => Integer) }.should_not raise_error
+      lambda { channel! }.should raise_error Agent::Errors::Untyped
+      c = nil
+      lambda { c = channel!(Integer) }.should_not raise_error
+      c.close
     end
 
     it "should reject messages of invalid type" do
-      lambda { c.send 1 }.should raise_error(Channel::InvalidType)
+      c = channel!(String)
+      go!{ c.receive }
+      lambda { c.send 1 }.should raise_error(Agent::Errors::InvalidType)
       lambda { c.send "hello" }.should_not raise_error
-      c.receive
+      c.close
     end
   end
 
-  context "transport" do
-    it "should default to memory transport" do
-      c.transport.should == Agent::Transport::Queue
-    end
-
-    context "channels of channels" do
-      # One of the most important properties of Go is that a channel is a first-class
-      # value that can be allocated and passed around like any other. A common use of
-      # this property is to implement safe, parallel demultiplexing.
-      # - http://golang.org/doc/effective_go.html#chan_of_chan
+  context "buffering" do
+    # The capacity, in number of elements, sets the size of the buffer in the channel.
+    # If the capacity is greater than zero, the channel is buffered: provided the
+    # buffer is not full, sends can succeed without blocking. If the capacity is zero
+    # or absent, the communication succeeds only when both a sender and receiver are ready.
 
-      it "should be a first class, serializable value" do
-        lambda { Marshal.dump(c) }.should_not raise_error
-        lambda { Marshal.load(Marshal.dump(c)).is_a? Channel }.should_not raise_error
-      end
+    it "should default to unbuffered" do
+      n = Time.now
+      c = channel!(String)
 
-      it "should be able to pass as a value on a different channel" do
-        c.send "hello"
+      go!{ sleep(0.15); c.send("hello") }
+      c.receive[0].should == "hello"
 
-        cm = Marshal.load(Marshal.dump(c))
-        cm.receive.should == "hello"
-      end
+      (Time.now - n).should be_within(0.05).of(0.15)
     end
 
-    context "capacity" do
-      # The capacity, in number of elements, sets the size of the buffer in the channel.
-      # If the capacity is greater than zero, the channel is asynchronous: provided the
-      # buffer is not full, sends can succeed without blocking. If the capacity is zero
-      # or absent, the communication succeeds only when both a sender and receiver are ready.
+    it "should support buffered" do
+      c = channel!(String, 2)
+      r = []
 
-      it "should default to synchronous communication" do
-        c = Channel.new(:name => "buffered", :type => String)
+      c.send "hello 1"
+      c.send "hello 2"
 
-        c.send "hello"
-        c.receive.should == "hello"
-        lambda { Timeout::timeout(0.1) { c.receive } }.should raise_error(Timeout::Error)
+      select! do |s|
+        s.case(c, :send, "hello 3")
+        s.timeout(0.1)
+      end
 
-        c.close
+      c.receive[0].should == "hello 1"
+      c.receive[0].should == "hello 2"
+      select! do |s|
+        s.case(c, :receive){|v| r.push(v) }
+        s.timeout(0.1)
       end
 
-      it "should support asynchronous communication with buffered capacity" do
-        c = Channel.new(:name => "buffered", :type => String, :size => 2)
+      c.close
+    end
+  end
 
-        c.send "hello 1"
-        c.send "hello 2"
-        lambda { Timeout::timeout(0.1) { c.send "hello 3" } }.should raise_error(Timeout::Error)
+  context "channels of channels" do
+    before do
+      @c = channel!(String, 1)
+    end
+
+    after do
+      @c.close unless @c.closed?
+    end
 
-        c.receive.should == "hello 1"
-        c.receive.should == "hello 2"
-        lambda { Timeout::timeout(0.1) { c.receive } }.should raise_error(Timeout::Error)
+    # One of the most important properties of Go is that a channel is a first-class
+    # value that can be allocated and passed around like any other. A common use of
+    # this property is to implement safe, parallel demultiplexing.
+    # - http://golang.org/doc/effective_go.html#chan_of_chan
 
-        c.close
-      end
+    it "should be a first class, serializable value" do
+      lambda { Marshal.dump(@c) }.should_not raise_error
+      lambda { Marshal.load(Marshal.dump(@c)).is_a?(Agent::Channel) }.should_not raise_error
+    end
+
+    it "should be able to pass as a value on a different channel" do
+      @c.send "hello"
+
+      cm = Marshal.load(Marshal.dump(@c))
+      cm.receive[0].should == "hello"
     end
   end