agent 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in go.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    agent (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  agent!
+  rspec

data/README.md

@@ -0,0 +1,73 @@
+# Agent
+
+Agent is a diverse family of related approaches for modelling concurrent systems, in Ruby. In other words, it is a collection of different [process calculi](http://en.wikipedia.org/wiki/Process_calculus) primitives and patterns, with no specific, idiomatic affiliation to any specific implementation. A few available patterns so far:
+
+ - Goroutines on top of green Ruby threads
+ - Named, in-memory channels
+
+This gem is a work in progress & an experiment, so treat it as such. At the moment, it is heavily influenced by Google's Go and π-calculus primitives.
+
+# Working Code Examples
+
+ * [Producer, Consumer with Goroutines](https://github.com/igrigorik/agent/blob/master/spec/examples/producer_consumer_spec.rb)
+ * [Serializable Channels / Event-driven server](https://github.com/igrigorik/agent/blob/master/spec/examples/channel_of_channels_spec.rb)
+ * [Sieve of Eratosthenes](https://github.com/igrigorik/agent/blob/master/spec/examples/sieve_spec.rb)
+
+# Example: Goroutine Generator
+
+    producer = Proc.new do |c|
+      puts "Starting generator: #{c.name}"
+
+      i = 0
+      loop { c.pipe << i+= 1 }
+    end
+
+    c = Agent::Channel.new(name: :incr, type: Integer)
+
+    Generator = Struct.new(:name, :pipe)
+    g = Generator.new(:incr, c)
+
+    go(g, &producer)
+
+    c.receive
+    c.receive
+
+
+# Go & π-calculus: Background & Motivation
+
+*Do not communicate by sharing memory; instead, share memory by communicating.*
+
+Concurrent programming in many environments is made difficult by the subtleties required to implement correct access to shared variables. Google's Go encourages a different approach in which shared values are passed around on channels and, in fact, never actively shared by separate threads of execution. Only one goroutine has access to the value at any given time. Data races cannot occur, by design.
+
+One way to think about this model is to consider a typical single-threaded program running on one CPU. It has no need for synchronization primitives. Now run another such instance; it too needs no synchronization. Now let those two communicate; if the communication is the synchronizer, there's still no need for other synchronization. Unix pipelines, for example, fit this model perfectly. Although Go's approach to concurrency originates in Hoare's Communicating Sequential Processes (CSP), it can also be seen as a type-safe generalization of Unix pipes.
+
+To learn more about Go see following resources:
+
+ * [golang.org](http://golang.org/)
+ * [Go's concurrency](http://golang.org/doc/effective_go.html#concurrency)
+ * [Go's channels](http://golang.org/doc/effective_go.html#channels)
+
+# License
+
+(The MIT License)
+
+Copyright (c) 2010 Ilya Grigorik
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/agent.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "agent/version"
+
+Gem::Specification.new do |s|
+  s.name        = "agent"
+  s.version     = Agent::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ilya Grigorik"]
+  s.email       = ["ilya@igvita.com"]
+  s.homepage    = "https://github.com/igrigorik/agent"
+  s.summary     = %q{Agent is a diverse family of related approaches for modelling concurrent systems, in Ruby}
+  s.description = s.summary
+
+  s.rubyforge_project = "agent"
+  s.add_development_dependency "rspec"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { 'rspec2' }

data/lib/agent.rb

@@ -0,0 +1,15 @@
+require 'agent/channel'
+require 'agent/transport/queue'
+
+module Kernel
+  def go(*args, &blk)
+    Thread.new do
+      begin
+        blk.call(*args)
+      rescue Exception => e
+        p e
+        p e.backtrace
+      end
+    end
+  end
+end

data/lib/agent/channel.rb

@@ -0,0 +1,74 @@
+# Channels combine communication—the exchange of a value—with synchronization—guaranteeing
+# that two calculations (goroutines) are in a known state.
+# - http://golang.org/doc/effective_go.html#channels
+
+module Agent
+  class Channel
+    attr_reader :name, :transport, :chan
+
+    def initialize(opts = {})
+      @state      = :active
+      @name       = opts[:name]
+      @max        = opts[:size] || 1
+      @type       = opts[:type]
+      @direction  = opts[:direction] || :bidirectional
+      @transport  = opts[:transport] || Agent::Transport::Queue
+
+      raise NoName  if @name.nil?
+      raise Untyped if @type.nil?
+
+      @chan = @transport.new(@name, @max)
+    end
+
+    def marshal_load(ary)
+      @state, @name, @type, @direction, @transport = *ary
+      @chan = @transport.new(@name)
+      self
+    end
+
+    def marshal_dump
+      [@state, @name, @type, @direction, @transport]
+    end
+
+    def send(msg)
+      check_direction(:send)
+      check_type(msg)
+
+      @chan.send(Marshal.dump(msg))
+    end
+    alias :push :send
+    alias :<<   :send
+
+    def receive
+      check_direction(:receive)
+
+      msg = Marshal.load(@chan.receive)
+      check_type(msg)
+
+      msg
+    end
+    alias :pop  :receive
+
+    def closed?; @state == :closed; end
+    def close
+      @chan.close
+      @state = :closed
+    end
+
+    private
+
+      def check_type(msg)
+        raise InvalidType if !msg.is_a? @type
+      end
+
+      def check_direction(direction)
+        return if @direction == :bidirectional
+        raise InvalidDirection if @direction != direction
+      end
+
+      class InvalidDirection < Exception; end
+      class NoName < Exception; end
+      class Untyped < Exception; end
+      class InvalidType < Exception; end
+  end
+end

data/lib/agent/transport/queue.rb

@@ -0,0 +1,82 @@
+module Agent
+  module Transport
+
+    class Queue
+
+      @@registry = {}
+
+      def initialize(name, max = 1)
+        raise ArgumentError, "queue size must be positive" unless max > 0
+
+        @name = name
+        @max = max
+
+        if !@@registry[@name]
+          @@registry[@name] = {
+            :que => [],
+            :wait => [],
+            :mutex => Mutex.new,
+            :cvar => ConditionVariable.new
+          }
+        end
+      end
+
+      def data;         @@registry[@name];  end
+      def que;          data[:que]; end
+      def wait;  data[:wait]; end
+      def mutex; data[:mutex]; end
+      def cvar;  data[:cvar]; end
+
+      def max; @max; end
+      def size; que.size; end
+      def length; que.size; end
+
+      def push(obj)
+        mutex.synchronize {
+          while true
+            break if que.length < @max
+            cvar.wait(mutex)
+          end
+
+          que.push obj
+          cvar.signal
+        }
+      end
+      alias << push
+      alias enq push
+
+      def pop(*args)
+        mutex.synchronize {
+          while true
+            break if !que.empty?
+            cvar.wait(mutex)
+          end
+
+          retval = que.shift
+          cvar.signal
+
+          retval
+        }
+      end
+      alias shift pop
+      alias deq pop
+
+      def async?; @max > 1; end
+
+      def send(msg, nonblock = false)
+        raise ThreadError, "buffer full" if nonblock && que.length >= @max
+        push(msg)
+      end
+
+      def receive(nonblock = false)
+        raise ThreadError, "buffer empty" if nonblock && que.empty?
+        pop
+      end
+
+      def close
+        @@registry.delete @name
+      end
+
+    end
+  end
+end

data/lib/agent/version.rb

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

data/spec/channel_spec.rb

@@ -0,0 +1,145 @@
+require "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
+      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
+      c.close
+    end
+  end
+
+  context "direction" do
+    # A channel provides a mechanism for two concurrently executing functions to
+    # synchronize execution and communicate by passing a value of a specified element
+    # 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)
+
+      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.close
+    end
+
+    it "should support receive only" do
+      c = Channel.new(:name => "spec", :direction => :receive, :type => String)
+
+      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
+
+      # 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)
+    end
+
+    it "should default to bi-directional communication" do
+      lambda { c.send "hello" }.should_not raise_error
+      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
+    end
+
+    it "should reject messages of invalid type" do
+      lambda { c.send 1 }.should raise_error(Channel::InvalidType)
+      lambda { c.send "hello" }.should_not raise_error
+      c.receive
+    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
+
+      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 be able to pass as a value on a different channel" do
+        c.send "hello"
+
+        cm = Marshal.load(Marshal.dump(c))
+        cm.receive.should == "hello"
+      end
+    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 default to synchronous communication" do
+        c = Channel.new(:name => "buffered", :type => String)
+
+        c.send "hello"
+        c.receive.should == "hello"
+        lambda { Timeout::timeout(0.1) { c.receive } }.should raise_error(Timeout::Error)
+
+        c.close
+      end
+
+      it "should support asynchronous communication with buffered capacity" do
+        c = Channel.new(:name => "buffered", :type => String, :size => 2)
+
+        c.send "hello 1"
+        c.send "hello 2"
+        lambda { Timeout::timeout(0.1) { c.send "hello 3" } }.should raise_error(Timeout::Error)
+
+        c.receive.should == "hello 1"
+        c.receive.should == "hello 2"
+        lambda { Timeout::timeout(0.1) { c.receive } }.should raise_error(Timeout::Error)
+
+        c.close
+      end
+    end
+  end
+
+end

data/spec/examples/channel_of_channels_spec.rb

@@ -0,0 +1,59 @@
+require "helper"
+
+describe "Channel of Channels" do
+
+  Request = Struct.new(:args, :resultChan)
+
+  it "should be able to pass channels as first class citizens" do
+    server = Proc.new do |reqs|
+      2.times do |n|
+        res = Request.new(n, Agent::Channel.new(:name => "resultChan-#{n}", :type => Integer))
+
+        reqs << res
+        res.resultChan.receive.should == n+1
+      end
+    end
+
+    worker = Proc.new do |reqs|
+      loop do
+        req = reqs.receive
+        req.resultChan << req.args+1
+      end
+    end
+
+    clientRequests = Agent::Channel.new(:name => :clientRequests, :type => Request)
+
+    s = go(clientRequests, &server)
+    c = go(clientRequests, &worker)
+
+    s.join
+    clientRequests.close
+  end
+
+  it "should work with multiple workers" do
+    worker = Proc.new do |reqs|
+      loop do
+        req = reqs.receive
+        req.resultChan << req.args+1
+      end
+    end
+
+    clientRequests = Agent::Channel.new(:name => :clientRequests, :type => Request)
+
+    # start multiple workers
+    go(clientRequests, &worker)
+    go(clientRequests, &worker)
+
+    # start server
+    s = go clientRequests do |reqs|
+      2.times do |n|
+        res = Request.new(n, Agent::Channel.new(:name => "resultChan-#{n}", :type => Integer))
+
+        reqs << res
+        res.resultChan.receive.should == n+1
+      end
+    end
+
+    s.join
+  end
+end

data/spec/examples/go/producer_consumer.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+  "fmt"
+  "runtime"
+)
+
+func producer(c chan int, N int, s chan bool) {
+  for i := 0; i < N; i++ {
+    fmt.Printf("producer: %d\n", i)
+    c <- i
+  }
+  s <- true
+}
+
+func consumer(c chan int, N int, s chan bool) {
+  for i := 0; i < N; i++ {
+    fmt.Printf("consumer got: %d\n", <- c)
+  }
+  s <- true
+}
+
+func main() {
+  runtime.GOMAXPROCS(2)
+
+  c := make(chan int)
+  s := make(chan bool)
+
+  go producer(c, 10, s)
+  go consumer(c, 10, s)
+
+  <- s
+  <- s
+}

data/spec/examples/go/sieve.go

@@ -0,0 +1,76 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+  "flag"
+  "fmt"
+  "os"
+  "strconv"
+)
+
+var nth = flag.Bool("n", false, "print the nth prime only")
+
+// Send the sequence 2, 3, 4, ... to returned channel
+func generate() chan int {
+  ch := make(chan int)
+  go func() {
+    for i := 2; ; i++ {
+      ch <- i
+    }
+  }()
+  return ch
+}
+
+// Filter out input values divisible by 'prime', send rest to returned channel
+func filter(in chan int, prime int) chan int {
+  out := make(chan int)
+  go func() {
+    for {
+      if i := <-in; i%prime != 0 {
+        out <- i
+      }
+    }
+  }()
+  return out
+}
+
+func sieve() chan int {
+  out := make(chan int)
+  go func() {
+    ch := generate()
+    for {
+      prime := <-ch
+      out <- prime
+      ch = filter(ch, prime)
+    }
+  }()
+  return out
+}
+
+func main() {
+  flag.Parse()
+  n, err := strconv.Atoi(flag.Arg(0))
+  if err != nil {
+    fmt.Fprintf(os.Stderr, "bad argument\n")
+    os.Exit(1)
+  }
+  primes := sieve()
+  if *nth {
+    for i := 1; i < n; i++ {
+      <-primes
+    }
+    fmt.Println(<-primes)
+  } else {
+    for {
+      p := <-primes
+      if p <= n {
+        fmt.Println(p)
+      } else {
+        return
+      }
+    }
+  }
+}

data/spec/examples/producer_consumer_spec.rb

@@ -0,0 +1,83 @@
+require "helper"
+
+describe "Producer-Consumer" do
+  it "should synchronize by communication" do
+
+    #     func producer(c chan int, N int, s chan bool) {
+    #       for i := 0; i < N; i++ {
+    #         fmt.Printf("producer: %d\n", i)
+    #         c <- i
+    #       }
+    #       s <- true
+    #     }
+    #
+    #     func consumer(c chan int, N int, s chan bool) {
+    #       for i := 0; i < N; i++ {
+    #         fmt.Printf("consumer got: %d\n", <- c)
+    #       }
+    #       s <- true
+    #     }
+    #
+    #     func main() {
+    #       runtime.GOMAXPROCS(2)
+    #
+    #       c := make(chan int)
+    #       s := make(chan bool)
+    #
+    #       go producer(c, 10, s)
+    #       go consumer(c, 10, s)
+    #
+    #       <- s
+    #       <- s
+    #     }
+
+    producer = Proc.new do |c, n, s|
+      n.times do |i|
+        c << i
+        # puts "producer: #{i}"
+      end
+
+      s << "producer finished"
+    end
+
+    consumer = Proc.new do |c, n, s|
+      n.times do |i|
+        msg = c.receive
+        # puts "consumer got: #{msg}"
+      end
+
+      s << "consumer finished"
+    end
+
+    c = Agent::Channel.new(name: :c, type: Integer)
+    s = Agent::Channel.new(name: :s, type: String)
+
+    go(c, 3, s, &producer)
+    go(c, 3, s, &consumer)
+
+    s.pop.should == "producer finished"
+    s.pop.should == "consumer finished"
+
+    c.close
+    s.close
+  end
+
+  it "should work as generator" do
+    producer = Proc.new do |c|
+      i = 0
+      loop { c.pipe << i+= 1 }
+    end
+
+    Generator = Struct.new(:name, :pipe)
+    c = Agent::Channel.new(name: :incr, type: Integer)
+    g = Generator.new(:incr, c)
+
+    go(g, &producer)
+
+    c.receive.should == 1
+    c.receive.should == 2
+
+    c.chan.size.should == 0
+    c.receive.should == 3
+  end
+end

data/spec/examples/sieve_spec.rb

@@ -0,0 +1,143 @@
+require "helper"
+
+describe "sieve of Eratosthenes" do
+
+  # http://golang.org/doc/go_tutorial.html#tmp_353
+
+  it "should work using Channel primitives" do
+
+    # send the sequence 2,3,4, ... to returned channel
+    def generate
+      ch = Agent::Channel.new(name: 'generator', type: Integer)
+
+      go do
+        i = 1
+        loop { ch << i+= 1 }
+      end
+
+      return ch
+    end
+
+    # filter out input values divisible by *prime*, send rest to returned channel
+    def filter(in_channel, prime)
+      out = Agent::Channel.new(name: "filter-#{prime}", type: Integer)
+
+      go do
+        loop do
+          i = in_channel.receive
+          out << i if (i % prime) != 0
+        end
+      end
+
+      return out
+    end
+
+    def sieve
+      out = Agent::Channel.new(name: 'sieve', type: Integer)
+
+      go do
+        ch = generate
+        loop do
+          prime = ch.receive
+          out << prime
+          ch = filter(ch, prime)
+        end
+      end
+
+      return out
+    end
+
+    # run the sieve
+    n = 20
+    nth = false
+
+    primes = sieve
+    result = []
+
+    if nth
+      n.times { primes.receive }
+      puts primes.receive
+    else
+      loop do
+        p = primes.receive
+
+        if p <= n
+          result << p
+        else
+          break
+        end
+      end
+    end
+
+    result.should == [2,3,5,7,11,13,17,19]
+  end
+
+  it "should work with Ruby blocks" do
+
+    # send the sequence 2,3,4, ... to returned channel
+    generate = Proc.new do
+      ch = Agent::Channel.new(name: 'generator-block', type: Integer)
+
+      go do
+        i = 1
+        loop { ch << i+= 1 }
+      end
+
+      ch
+    end
+
+    # filter out input values divisible by *prime*, send rest to returned channel
+    filtr = Proc.new do |in_channel, prime|
+      out = Agent::Channel.new(name: "filter-#{prime}-block", type: Integer)
+
+      go do
+        loop do
+          i = in_channel.receive
+          out << i if (i % prime) != 0
+        end
+      end
+
+      out
+    end
+
+    sieve = -> do
+      out = Agent::Channel.new(name: 'sieve-block', type: Integer)
+
+      go do
+        ch = generate.call
+
+        loop do
+          prime = ch.receive
+          out << prime
+          ch = filtr.call(ch, prime)
+        end
+      end
+
+      out
+    end
+
+    # run the sieve
+    n = 20
+    nth = false
+
+    primes = sieve.call
+    result = []
+
+    if nth
+      n.times { primes.receive }
+      puts primes.receive
+    else
+      loop do
+        p = primes.receive
+
+        if p <= n
+          result << p
+        else
+          break
+        end
+      end
+    end
+
+    result.should == [2,3,5,7,11,13,17,19]
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,5 @@
+require 'timeout'
+require 'rspec'
+require 'yaml'
+
+require 'lib/agent'

data/spec/queue_spec.rb

@@ -0,0 +1,53 @@
+require 'helper'
+
+describe Agent::Transport::Queue do
+  include Agent::Transport
+
+  it "should support synchronous, unbuffered communication" do
+    lambda { Queue.new("spec") }.should_not raise_error
+
+    q = Queue.new("spec")
+    q.max.should == 1
+    q.async?.should be_false
+
+    lambda { q.send("hello") }.should_not raise_error
+    lambda { q.send("hello", true) }.should raise_error(ThreadError, "buffer full")
+
+    q.receive.should == "hello"
+    lambda { q.receive(true) }.should raise_error(ThreadError, "buffer empty")
+  end
+
+  it "should support asynchronous, buffered communication" do
+    lambda { Queue.new("spec", 2) }.should_not raise_error
+
+    q = Queue.new("spec", 2)
+    q.max.should == 2
+    q.async?.should be_true
+
+    lambda { q.send("hello 1") }.should_not raise_error
+    lambda { q.send("hello 2", true) }.should_not raise_error(ThreadError, "buffer full")
+    lambda { q.send("hello 3", true) }.should raise_error(ThreadError, "buffer full")
+
+    q.receive.should == "hello 1"
+    q.receive.should == "hello 2"
+    lambda { q.receive(true) }.should raise_error(ThreadError, "buffer empty")
+  end
+
+  it "should persist data between queue objects" do
+    q = Queue.new("spec")
+    q.send "hello"
+
+    q = Queue.new("spec")
+    q.receive.should == "hello"
+  end
+
+   it "should clear registry on close" do
+     q = Queue.new("spec")
+     q.send "hello"
+     q.close
+
+     q = Queue.new("spec")
+     lambda { q.receive(true) }.should raise_error(ThreadError, "buffer empty")
+   end
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: agent
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ilya Grigorik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-10 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Agent is a diverse family of related approaches for modelling concurrent systems, in Ruby
+email: 
+- ilya@igvita.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- agent.gemspec
+- autotest/discover.rb
+- lib/agent.rb
+- lib/agent/channel.rb
+- lib/agent/transport/queue.rb
+- lib/agent/version.rb
+- spec/channel_spec.rb
+- spec/examples/channel_of_channels_spec.rb
+- spec/examples/go/producer_consumer.go
+- spec/examples/go/sieve.go
+- spec/examples/producer_consumer_spec.rb
+- spec/examples/sieve_spec.rb
+- spec/helper.rb
+- spec/queue_spec.rb
+has_rdoc: true
+homepage: https://github.com/igrigorik/agent
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: agent
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Agent is a diverse family of related approaches for modelling concurrent systems, in Ruby
+test_files: 
+- spec/channel_spec.rb
+- spec/examples/channel_of_channels_spec.rb
+- spec/examples/go/producer_consumer.go
+- spec/examples/go/sieve.go
+- spec/examples/producer_consumer_spec.rb
+- spec/examples/sieve_spec.rb
+- spec/helper.rb
+- spec/queue_spec.rb