engineyard-serverside 1.2.0

data/lib/vendor/dataflow/dataflow/actor.rb

@@ -0,0 +1,22 @@
+module Dataflow
+  class Actor < Thread
+    def initialize(&block)
+      @stream = Variable.new
+      @port = Port.new(@stream)
+      # Run this block in a new thread
+      super { instance_eval &block }
+    end
+
+    def send message
+      @port.send message
+    end
+
+  private
+    
+    def receive
+      result = @stream.head
+      @stream = @stream.tail
+      result
+    end
+  end
+end

data/lib/vendor/dataflow/dataflow/equality.rb

@@ -0,0 +1,28 @@
+# The purpose of this file is to make equality use method calls in as
+# many Ruby implementations as possible. If method calls are used,
+# then equality operations using dataflow variaables becomes seemless
+# I realize overriding core classes is a pretty nasty hack, but if you
+# have a better idea that also passes the equality_specs then I'm all
+# ears. Please run the rubyspec before committing changes to this file.
+
+class Object
+  def ==(other)
+    object_id == other.object_id
+  end
+end
+
+class Symbol
+  def ==(other)
+    object_id == other.object_id
+  end
+end
+
+class Regexp
+  def ==(other)
+    other.is_a?(Regexp) && 
+    casefold? == other.casefold? &&
+    kcode == other.kcode &&
+    options == other.options &&
+    source == other.source
+  end
+end

data/lib/vendor/dataflow/dataflow/future_queue.rb

@@ -0,0 +1,24 @@
+module Dataflow
+  class FutureQueue
+    include Dataflow
+    declare :push_port, :pop_port
+    
+    def initialize
+      local do |pushed, popped|
+        unify push_port, Dataflow::Port.new(pushed)
+        unify pop_port, Dataflow::Port.new(popped)
+        
+        Thread.new {
+          loop do
+            barrier pushed.head, popped.head
+            unify popped.head, pushed.head
+            pushed, popped = pushed.tail, popped.tail
+          end
+        }
+      end
+    end
+
+    def push(x) push_port.send x end
+    def pop(x) pop_port.send x end
+  end
+end

data/lib/vendor/dataflow/dataflow/port.rb

@@ -0,0 +1,54 @@
+require 'thread'
+
+module Dataflow
+  class Port  
+    include Dataflow
+    LOCK = Mutex.new
+
+    class Stream
+      include Dataflow
+      declare :head, :tail
+    
+      # Defining each allows us to use the enumerable mixin
+      # None of the list can be garbage collected less the head is
+      # garbage collected, so it will grow indefinitely even though
+      # the function isn't recursive.
+      include Enumerable
+      def each
+        s = self
+        loop do
+          yield s.head
+          s = s.tail
+        end
+      end
+
+      # Backported Enumerable#take for any 1.8.6 compatible Ruby
+      unless method_defined?(:take)
+        def take(num)
+          result = []
+          each_with_index do |x, i|
+            return result if num == i
+            result << x
+          end
+        end
+      end
+    end
+  
+    # Create a stream object, bind it to the input variable
+    # Instance variables are necessary because @end is state
+    def initialize(x)
+      @end = Stream.new
+      unify x, @end
+    end
+  
+    # This needs to be synchronized because it uses @end as state
+    def send value
+      LOCK.synchronize do
+        unify @end.head, value
+        unify @end.tail, Stream.new
+        @end = @end.tail
+      end
+    end
+  end
+end
+

data/lib/vendor/dataflow/examples/barrier.rb

@@ -0,0 +1,9 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |lock1, lock2|
+  flow { unify lock1, :unlocked }
+  flow { unify lock2, :unlocked }
+  barrier lock1, lock2
+  puts "Barrier broken!"  
+end

data/lib/vendor/dataflow/examples/data_driven.rb

@@ -0,0 +1,17 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |stream, doubles, triples, squares|
+  unify stream, Array.new(5) { Dataflow::Variable.new }
+  
+  Thread.new { unify doubles, stream.map {|n| n*2 } }
+  Thread.new { unify triples, stream.map {|n| n*3 } }
+  Thread.new { unify squares, stream.map {|n| n**2 } }  
+
+  Thread.new { stream.each {|x| unify x, rand(100) } }
+
+  puts "original: #{stream.inspect}"
+  puts "doubles:  #{doubles.inspect}"
+  puts "triples:  #{triples.inspect}"
+  puts "squares:  #{squares.inspect}"  
+end

data/lib/vendor/dataflow/examples/dataflow_http_gets.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+require 'net/http'
+include Dataflow
+
+# Be gentle running this one
+Thread.abort_on_exception = true
+local do |stream, branding_occurences, number_of_mentions|
+  unify stream, Array.new(10) { Dataflow::Variable.new }
+  stream.each {|s| Thread.new(s) {|v| unify v, Net::HTTP.get_response(URI.parse("http://www.cuil.com/search?q=#{rand(1000)}")).body } }
+  Thread.new { unify branding_occurences, stream.map {|http_body| http_body.scan /cuil/ } }
+  Thread.new { unify number_of_mentions, branding_occurences.map {|occurences| occurences.length } }
+  puts number_of_mentions.inspect
+end

data/lib/vendor/dataflow/examples/flow.rb

@@ -0,0 +1,20 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+# flow without parameters
+local do |x|
+  flow do 
+    # other stuff
+    unify x, 1337
+  end
+  puts x
+end
+
+# flow with an output parameter
+local do |x|
+  flow(x) do
+    # other stuff
+    1337
+  end
+  puts x
+end

data/lib/vendor/dataflow/examples/future_http_gets.rb

@@ -0,0 +1,12 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+require 'net/http'
+include Dataflow
+
+# Be gentle running this one
+Thread.abort_on_exception = true
+local do |stream, branding_occurences, number_of_mentions|
+  unify stream, Array.new(10) { need_later { Net::HTTP.get_response(URI.parse("http://www.cuil.com/search?q=#{rand(1000)}")).body } }
+  unify branding_occurences, need_later { stream.map {|http_body| http_body.scan /cuil/ } }
+  unify number_of_mentions, need_later { branding_occurences.map {|occurences| occurences.length } }
+  puts number_of_mentions.inspect
+end

data/lib/vendor/dataflow/examples/future_queue.rb

@@ -0,0 +1,11 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |queue, first, second|
+  unify queue, Dataflow::FutureQueue.new
+  queue.pop first
+  queue.push 1
+  queue.push 2
+  queue.pop second
+  puts "first:  #{first}, second: #{second}"
+end

data/lib/vendor/dataflow/examples/instance_variables.rb

@@ -0,0 +1,15 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+
+class AnimalHouse
+  include Dataflow
+  declare :small_cat, :big_cat
+
+  def fetch_big_cat
+    Thread.new { unify big_cat, small_cat.upcase }
+    unify small_cat, 'cat'
+    big_cat
+  end
+end
+
+puts AnimalHouse.new.fetch_big_cat
+

data/lib/vendor/dataflow/examples/laziness.rb

@@ -0,0 +1,9 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |x, y, z|
+  Thread.new { unify y, by_need { 4 } }
+  Thread.new { unify z, x + y }
+  Thread.new { unify x, by_need { 3 } }  
+  puts z
+end

data/lib/vendor/dataflow/examples/local_variables.rb

@@ -0,0 +1,11 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |x, y, z|
+  # notice how the order automatically gets resolved
+  Thread.new { unify y, x + 2 }
+  Thread.new { unify z, y + 3 }
+  Thread.new { unify x, 1 }
+  puts z
+end
+  

data/lib/vendor/dataflow/examples/messages.rb

@@ -0,0 +1,26 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+Ping = Actor.new {
+  3.times {
+    case receive
+    when "Ping"
+      puts "Ping"
+      Pong.send "Pong"
+    end
+  }
+}
+
+Pong = Actor.new {
+  3.times {
+    case receive
+    when "Pong"
+      puts "Pong"
+      Ping.send "Ping"
+    end
+  }
+}
+
+Ping.send "Ping"
+Ping.join
+Pong.join

data/lib/vendor/dataflow/examples/port_http_gets.rb

@@ -0,0 +1,13 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+require 'net/http'
+include Dataflow
+
+# Be gentle running this one
+Thread.abort_on_exception = true
+local do |port, stream, branding_occurences, number_of_mentions|
+  unify port, Dataflow::Port.new(stream)
+  10.times { Thread.new(port) {|p| p.send Net::HTTP.get_response(URI.parse("http://www.cuil.com/search?q=#{rand(1000)}")).body } }
+  Thread.new { unify branding_occurences, stream.take(10).map {|http_body| http_body.scan /cuil/ } }
+  Thread.new { unify number_of_mentions, branding_occurences.map {|occurences| occurences.length } }
+  puts number_of_mentions.inspect
+end

data/lib/vendor/dataflow/examples/port_send.rb

@@ -0,0 +1,10 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+local do |port, stream|
+  unify port, Dataflow::Port.new(stream)
+  Thread.new {port.send 2}
+  Thread.new {port.send 8}
+  Thread.new {port.send 1024}
+  puts stream.take(3).sort.inspect
+end

data/lib/vendor/dataflow/examples/ring.rb

@@ -0,0 +1,21 @@
+require "#{File.dirname(__FILE__)}/../dataflow"
+include Dataflow
+
+# Send M messages each along a ring of N nodes
+N = 4
+M = 2
+actors = Array.new(N) { Dataflow::Variable.new }
+
+N.times do |n|
+  unify actors[n], Actor.new {
+    M.times do |m|
+      receive
+      puts "[#{n} #{m}]"
+      actors[(n+1) % N].send :msg
+    end
+    puts "[#{n}] done"
+  }
+end
+
+actors.first.send :msg
+actors.each { |x| x.join }

data/lib/vendor/dataflow/spec/actor_spec.rb

@@ -0,0 +1,28 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe 'Syncronously sending to an Actor' do  
+  it 'passes in each message received and preserves order' do
+    local do |port, stream, actor|
+      unify port, Dataflow::Port.new(stream)
+      unify actor, Dataflow::Actor.new { 3.times { port.send receive } }
+      actor.send 1
+      actor.send 2
+      stream.take(2).should == [1, 2]
+      actor.send 3
+      stream.take(3).should == [1, 2, 3]
+    end
+  end
+end
+
+describe 'Asyncronously sending to an Actor' do
+  it 'passes in each message received and preserves order' do
+    local do |port, stream, actor|
+      unify port, Dataflow::Port.new(stream)
+      unify actor, Dataflow::Actor.new { 3.times { port.send receive } }
+      Thread.new {actor.send 2}
+      Thread.new {actor.send 8}
+      Thread.new {actor.send 1024}
+      stream.take(3).sort.should == [2, 8, 1024]      
+    end
+  end
+end

data/lib/vendor/dataflow/spec/anonymous_variables_spec.rb

@@ -0,0 +1,21 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe 'Using an anonymous variable' do
+  it 'works with Variable instances' do
+    container = [Dataflow::Variable.new]
+    unify container.first, 1337
+    container.first.should == 1337
+  end
+
+  it 'works with Dataflow.local' do
+    container = [Dataflow.local]
+    unify container.first, 1337
+    container.first.should == 1337
+  end
+
+  it 'works with #local' do
+    container = [local]
+    unify container.first, 1337
+    container.first.should == 1337
+  end
+end

data/lib/vendor/dataflow/spec/barrier_spec.rb

@@ -0,0 +1,25 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe 'A barrier' do
+  it 'waits for variables to be bound before continuing' do
+    local do |x, y, barrier_broken|
+      Thread.new do 
+        barrier x, y
+        unify barrier_broken, true
+      end
+      Thread.new { unify x, :x }
+      Thread.new { unify y, :y }
+      barrier_broken.should be_true
+    end
+  end
+
+  it 'continues for variables that are already bound' do
+    local do |x, y, barrier_broken|
+      unify x, :x
+      unify y, :y
+      barrier x, y
+      unify barrier_broken, true
+      barrier_broken.should be_true
+    end
+  end
+end

data/lib/vendor/dataflow/spec/by_need_spec.rb

@@ -0,0 +1,55 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe 'A by_need expression' do
+  describe 'when a method is called on it' do
+    it 'binds its variable' do
+      local do |x, y, z|
+        Thread.new { unify y, by_need { 4 } }
+        Thread.new { unify z, x + y }
+        Thread.new { unify x, by_need { 3 } }
+        z.should == 7
+      end
+    end
+  end
+
+  describe 'when a bound variable is unified to it' do
+    it 'passes unififcation for equal values' do
+      local do |x|
+        unify x, by_need { 1 }
+        unify x, 1
+        x.should == 1
+
+        y = by_need { 1 }
+        unify y, 1
+        y.should == 1
+      end
+    end
+
+    it 'fails unififcation for unequal values' do
+      local do |x|
+        unify x, by_need { 1 }
+        lambda { unify x, 2 }.should raise_error(Dataflow::UnificationError)
+
+        y = by_need { 1 }
+        lambda { unify y, 2 }.should raise_error(Dataflow::UnificationError)
+      end
+    end
+
+    describe 'when it is unified to a bound variable' do
+      it 'passes unififcation for equal values' do
+        local do |x|
+          unify x, 1
+          unify x, by_need { 1 }
+          x.should == 1
+        end
+      end
+      
+      it 'fails unification for unequal values' do
+        local do |x|
+          unify x, 1
+          lambda { unify x, by_need { 2 } }.should raise_error(Dataflow::UnificationError)
+        end
+      end
+    end
+  end
+end