cod 0.3.1 → 0.4.0

data/lib/cod/work_queue.rb

@@ -0,0 +1,129 @@
+
+
+module Cod
+  # Describes a queue that stores work items given through #schedule and works
+  # through those items in order if #predicate is true. 
+  #
+  # Synopsis: 
+  #   queue = WorkQueue.new
+  #   queue.predicate { true }
+  #   queue.schedule { 
+  #     # some work
+  #   }
+  # 
+  #   # Will try to work through items right now. 
+  #   queue.try_work
+  # 
+  #   # Will cleanly shutdown background threads, but not finish work. 
+  #   queue.shutdown
+  # 
+  class WorkQueue # :nodoc:
+    def initialize
+      # NOTE: This is an array that is protected by careful coding, rather
+      # than a mutex. Queue would be right, but Rubys GIL will interfere with
+      # that producing more deadlocks than I would like.
+      @queue = Array.new
+      
+      @try_work_exclusive_section = ExclusiveSection.new
+
+      @thread = Thread.start(&method(:thread_main))
+    end
+    
+    # The internal thread that is used to work on scheduled items in the
+    # background.
+    attr_reader :thread
+
+    def try_work
+      @try_work_exclusive_section.enter {
+        # NOTE if predicate is nil or not set, no work will be accomplished. 
+        # This is the way I need it. 
+        while !@queue.empty? && @predicate && @predicate.call
+          wi = @queue.shift
+          wi.call
+        end
+      }
+    end
+    
+    # Before any kind of work is attempted, this predicate must evaluate to 
+    # true. It is tested repeatedly. 
+    #
+    # Example: 
+    #   work_queue.predicate { connection.established? }
+    #
+    def predicate(&predicate)
+      @predicate = predicate
+    end
+
+    # Schedules a piece of work. 
+    # Example: 
+    #   work_queue.schedule { a_piece_of_work }
+    #
+    def schedule(&work)
+      @queue << work
+    end
+
+    # Shuts down the queue properly, without waiting for work to be completed.
+    #
+    def shutdown
+      @shutdown_requested = true
+      @thread.join
+    end
+    
+    # Returns the size of the queue. 
+    #
+    def size
+      @queue.size
+    end
+
+    def clear_thread_semaphore
+      @one_turn = false
+    end
+    def thread_semaphore_set?
+      @one_turn
+    end
+  private
+    def thread_main
+      Thread.current.abort_on_exception = true
+      
+      loop do
+        sleep 0.01
+        
+        try_work
+
+        # Signal the outside world that we've been around this loop once.
+        # See #clear_thread_semaphore and #thread_semaphore_set?
+        @one_turn = true
+        
+        return if @shutdown_requested
+      end
+    end
+  end
+  
+  # A section of code that is entered only once. Instead of blocking threads
+  # that are waiting to enter, it just returns nil.
+  #
+  class ExclusiveSection # :nodoc:
+    def initialize
+      @mutex = Mutex.new
+      @threads_in_block = 0
+    end
+    
+    # If no one is in the block given to #enter currently, this will yield
+    # to the block. If one thread is already executing that block, it will
+    # return nil.
+    #
+    def enter
+      @mutex.synchronize { 
+        return if @threads_in_block > 0
+        @threads_in_block += 1 }
+      begin
+        yield
+      ensure
+        fail "Assert fails, #{@threads_in_block} threads in block" \
+          if @threads_in_block != 1
+        @mutex.synchronize { 
+          @threads_in_block -= 1 }
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cod
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-20 00:00:00.000000000Z
+date: 2011-11-29 00:00:00.000000000Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: uuid
-  requirement: &70169583690420 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :runtime
-  prerelease: false
-  version_requirements: *70169583690420
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70169583689920 !ruby/object:Gem::Requirement
+  requirement: &70297088779060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70169583689920
+  version_requirements: *70297088779060
 - !ruby/object:Gem::Dependency
   name: flexmock
-  requirement: &70169583689340 !ruby/object:Gem::Requirement
+  requirement: &70297088777820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70169583689340
+  version_requirements: *70297088777820
 - !ruby/object:Gem::Dependency
   name: sdoc
-  requirement: &70169583688800 !ruby/object:Gem::Requirement
+  requirement: &70297088776720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70169583688800
+  version_requirements: *70297088776720
 description: 
 email: kaspar.schiess@absurd.li
 executables: []
@@ -67,37 +56,31 @@ files:
 - LICENSE
 - Rakefile
 - README
-- lib/cod/channel/base.rb
-- lib/cod/channel/beanstalk.rb
-- lib/cod/channel/pipe.rb
-- lib/cod/channel/tcp.rb
-- lib/cod/channel/tcpconnection.rb
-- lib/cod/channel/tcpserver.rb
+- lib/cod/beanstalk/channel.rb
+- lib/cod/beanstalk/serializer.rb
+- lib/cod/beanstalk/service.rb
+- lib/cod/beanstalk.rb
 - lib/cod/channel.rb
-- lib/cod/client.rb
-- lib/cod/connection/beanstalk.rb
-- lib/cod/directory/countdown.rb
-- lib/cod/directory/subscription.rb
-- lib/cod/directory.rb
-- lib/cod/object_io.rb
-- lib/cod/objectio/connection.rb
-- lib/cod/objectio/reader.rb
-- lib/cod/objectio/serializer.rb
-- lib/cod/objectio/writer.rb
+- lib/cod/pipe.rb
+- lib/cod/select.rb
+- lib/cod/select_group.rb
 - lib/cod/service.rb
-- lib/cod/topic.rb
+- lib/cod/simple_serializer.rb
+- lib/cod/tcp_client.rb
+- lib/cod/tcp_server.rb
+- lib/cod/work_queue.rb
 - lib/cod.rb
 - examples/example_scaffold.rb
 - examples/master_child.rb
-- examples/ping.rb
-- examples/pong.rb
-- examples/presence_client.rb
-- examples/presence_server.rb
-- examples/pubsub/client.rb
-- examples/pubsub/directory.rb
-- examples/pubsub/README
+- examples/ping_pong/ping.rb
+- examples/ping_pong/pong.rb
+- examples/presence/client.rb
+- examples/presence/server.rb
+- examples/queue/client.rb
+- examples/queue/queue.rb
+- examples/queue/README
+- examples/queue/send.rb
 - examples/service.rb
-- examples/service_directory.rb
 - examples/tcp.rb
 homepage: http://kschiess.github.com/cod
 licenses: []
@@ -113,6 +96,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3574736004851783821
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -121,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Really simple IPC.

data/examples/pubsub/README

@@ -1,12 +0,0 @@
-
-This is an example of PUB/SUB style messaging. You should run one directory
-and any number of clients. All clients should receive timestamps from the directory, once every second. 
-
-Experiments that can be made using this setup: 
-
-1) Disconnect a client, restart it. It should start receiving updates
-immediately.
-
-2) Disconnect the directory, restart it. It should start redistributing
-updates to all clients within 5 seconds.
-

data/examples/pubsub/client.rb

@@ -1,13 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
-require 'cod'
-
-channels = Struct.new(:directory, :answers).new(
-  Cod.beanstalk('localhost:11300', 'directory'), 
-  Cod.beanstalk('localhost:11300', 'directory.'+Cod.uuid))
-  
-topic = Cod::Topic.new('', channels.directory, channels.answers, :renew => 5)
-
-loop do
-  puts topic.get
-end
-

data/examples/pubsub/directory.rb

@@ -1,13 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
-require 'cod'
-
-channels = Struct.new(:directory).new(
-  Cod.beanstalk('localhost:11300', 'directory'))
-  
-directory = Cod::Directory.new(channels.directory)
-
-loop do
-  directory.publish '', Time.now
-  sleep 1
-end
-

data/examples/service_directory.rb

@@ -1,32 +0,0 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
-require 'cod'
-
-announce = Cod.pipe
-directory = Cod::Directory.new(announce)
-
-pipes = []
-pids = ['foo.bar', /^foo\..+/].map { |match_expr| 
-  # Creates a communication channel that both the parent and the child know
-  # about. After the fork, they will own unique ends to that channel. 
-  pipes << pipe = Cod.pipe  # store in pipes as well to prevent GC
-  
-  # Create a child that will receive messages that match match_expr.
-  fork do
-    puts "Spawned child: #{Process.pid}"
-    topic = Cod::Topic.new(match_expr, announce, pipe)
-    
-    sleep 0.1
-    loop do
-      message = topic.get
-      puts "#{Process.pid}: received #{message.inspect}."
-      
-      break if message == :shutdown
-    end
-  end }
-  
-directory.publish 'foo.bar', 'Hi everyone!'   # to both childs
-directory.publish 'foo.baz', 'Hi you!'        # only second child matches this
-directory.publish 'no.one', 'echo?'           # no one matches this
-
-directory.publish 'foo.bar', :shutdown        # shutdown children in orderly fashion
-Process.waitall

data/lib/cod/channel/base.rb

@@ -1,185 +0,0 @@
-
-module Cod
-  # Channels are the communication primitives you've always wanted (secretly).
-  # They are simple to use, abstract most of the OS away and allow direct 
-  # communication using language objects, not just strings. (Although you can
-  # fall back to just strings if you want to)
-  #
-  # == Construction
-  #
-  # The simplest way to obtain a new channel is through the Module Cod. It 
-  # provides the following channel types: 
-  #
-  # Cod.beanstalk(url, name)  :: connects to beanstalkd daemon
-  # Cod.pipe                  :: abstracts IO.pipe
-  # Cod.tcp(url)              :: connects to a tcp socket somewhere
-  # Cod.tcpserver(url)        :: the counterpart to Cod.tcp
-  #
-  # Please refer to the documentation of these methods for more information. 
-  #
-  # == Basic Interaction
-  #
-  # You can #put messages (Ruby objects) into a channel on one side: 
-  #
-  #   channel.put("some message")
-  #
-  # and #get messages on the other side: 
-  #
-  #   channel.get # => "some message"
-  #
-  # == Querying
-  #
-  # Are there messages waiting to be read from the channel? Use #waiting?: 
-  # 
-  #   channel.waiting? # => true or false
-  #
-  # == Cleaning up
-  #
-  # Be sure to #close the channel once you're done with it.
-  #
-  #   channel.close
-  #
-  class Channel::Base
-    def initialize(reader, writer)
-      @reader = reader
-      @writer = writer
-    end
-    
-    # Writes a Ruby object (the 'message') to the channel. This object will 
-    # be queued in the channel and become available for #get in a FIFO manner.
-    #
-    # Issuing a #put may also close the channel instance for subsequent #get's. 
-    #
-    # Example: 
-    #   chan.put 'test'
-    #   chan.put true
-    #   chan.put :symbol
-    #
-    def put(message)
-      # TODO Errno::EPIPE raised after a while when the receiver goes away. 
-      @writer.put(message)
-    end
-    
-    # Reads a Ruby object (a message) from the channel. Some channels may not
-    # allow reading after you've written to it once. Options that work: 
-    #
-    # <code>:timeout</code> :: Time to wait before throwing Cod::Channel::TimeoutError.
-    #
-    def get(opts={})
-      @reader.get(opts)
-    end
-    
-    # Returns true if there are messages waiting in the channel. 
-    #
-    def waiting?
-      # TODO EOFError is thrown when the other end has gone away
-      @reader.waiting?
-    end
-  
-    # Returns true if the channel is connected, and false if all hope must be
-    # given up of reconnecting this channel. 
-    #
-    def connected?
-      not_implemented
-    end
-    
-    # Closes reader and writer. 
-    #
-    def close
-      @reader.close if @reader
-      @writer.close if @writer
-      
-      @reader = @writer = nil
-    end
-    
-    # Returns the Identifier class below the current channel class. This is 
-    # a helper function that should only be used by subclasses. 
-    #
-    def identifier_class # :nodoc: 
-      self.class.const_get(:Identifier)
-    end
-
-    # Something to put into the data stream that is transmitted through a 
-    # channel that allows reconstitution of the channel at the other end. 
-    # The invariant is this: 
-    #
-    #   # channel1 and channel2 are abstract channels that illustrate my 
-    #   # meaning
-    #   channel1.put channel2
-    #   channel2a = channel1.get
-    #   channel2a.put 'foo'
-    #   channel2.get # => 'foo'
-    #   
-    # Note that this should also work if channel1 and channel2 are the same. 
-    #
-    def identifier # :nodoc: 
-      identifier_class.new(self)
-    end
-    
-    # ------------------------------------------------------------ marshalling
-
-    # Makes sure that we don't marshal this object, but the memento object
-    # returned by identifier. 
-    #
-    def _dump(d) # :nodoc: 
-      wire_data = to_wire_data
-      Marshal.dump(wire_data)
-    end
-     
-    # Loads the object from string. This doesn't always return the same kind
-    # of object that was serialized. 
-    #
-    def self._load(string) # :nodoc: 
-      wire_data = Marshal.load(string)
-      from_wire_data(wire_data)
-    end
-    
-  private
-  
-    # Returns the objects that need to be transmitted in order to reconstruct
-    # this object after transmission through the wire. 
-    #
-    # If you're using a serialisation method other than the Ruby built in 
-    # one, use this to obtain something in lieu of a channel that can be sent
-    # through the wire and reinterpreted at the other end. 
-    #
-    # Example: 
-    #
-    #   # this should work: 
-    #   obj = channel.to_wire_data
-    #   channel_equiv = Cod::Channel::Base.from_wire_data(obj)
-    #
-    def to_wire_data
-      identifier
-    end
-    
-    # Using an object previously returned by #to_wire_data, reconstitute the
-    # original channel or something that is alike it. What you send to this
-    # second channel (#put) you should be able to #get from this copy returned
-    # here. 
-    #
-    def self.from_wire_data(obj)
-      obj.resolve
-    end
-    
-    # ---------------------------------------------------------- error raising
-   
-    def direction_error(msg)
-      raise Cod::Channel::DirectionError, msg
-    end
-
-    def communication_error(msg)
-      raise Cod::Channel::CommunicationError, msg
-    end
-    
-    def not_implemented
-      trace = caller.reject {|l| l =~ %r{#{Regexp.escape(__FILE__)}}} # blatantly stolen from dependencies.rb in activesupport
-      exception = NotImplementedError.new(
-        "You called a method in Cod::Channel::Base. Missing implementation in "+
-        "the subclass #{self.class.name}!")
-      exception.set_backtrace trace
-      
-      raise exception
-    end
-  end
-end