dcell 0.9.0 → 0.10.0

data/celluloid-zmq/lib/celluloid/zmq.rb

@@ -1,36 +0,0 @@
-require 'ffi-rzmq'
-
-require 'celluloid/io'
-require 'celluloid/zmq/reactor'
-require 'celluloid/zmq/sockets'
-require 'celluloid/zmq/version'
-require 'celluloid/zmq/waker'
-
-module Celluloid
-  # Actors which run alongside 0MQ sockets
-  module ZMQ
-    class << self
-      attr_writer :context
-
-      # Included hook to pull in Celluloid
-      def included(klass)
-        klass.send :include, ::Celluloid
-        klass.use_mailbox { Celluloid::IO::Mailbox.new ZMQ::Reactor.new }
-      end
-
-      # Obtain a 0MQ context (or lazily initialize it)
-      def context(threads = 1)
-        return @context if @context
-        @context = ::ZMQ::Context.new(threads)
-        at_exit { @context.terminate }
-        @context
-      end
-      alias_method :init, :context
-    end
-
-    extend Forwardable
-
-    # Wait for the given IO object to become readable/writeable
-    def_delegators 'current_actor.mailbox.reactor', :wait_readable, :wait_writeable
-  end
-end

data/celluloid-zmq/lib/celluloid/zmq/reactor.rb

@@ -1,90 +0,0 @@
-module Celluloid
-  module ZMQ
-    # React to incoming 0MQ and Celluloid events. This is kinda sorta supposed
-    # to resemble the Reactor design pattern.
-    class Reactor
-      extend Forwardable
-
-      def_delegator :@waker, :signal, :wakeup
-      def_delegator :@waker, :cleanup, :shutdown
-
-      def initialize
-        @waker = Waker.new
-        @poller = ::ZMQ::Poller.new
-        @readers = {}
-        @writers = {}
-
-        rc = @poller.register @waker.socket, ::ZMQ::POLLIN
-        unless ::ZMQ::Util.resultcode_ok? rc
-          raise "0MQ poll error: #{::ZMQ::Util.error_string}"
-        end
-      end
-
-      # Wait for the given ZMQ socket to become readable
-      def wait_readable(socket)
-        monitor_zmq socket, @readers, ::ZMQ::POLLIN
-      end
-
-      # Wait for the given ZMQ socket to become writeable
-      def wait_writeable(socket)
-        monitor_zmq socket, @writers, ::ZMQ::POLLOUT
-      end
-
-      # Monitor the given ZMQ socket with the given options
-      def monitor_zmq(socket, set, type)
-        if set.has_key? socket
-          raise ArgumentError, "another method is already waiting on #{socket.inspect}"
-        else
-          set[socket] = Task.current
-        end
-
-        @poller.register socket, type
-
-        Task.suspend :zmqwait
-        socket
-      end
-
-      # Run the reactor, waiting for events, and calling the given block if
-      # the reactor is awoken by the waker
-      def run_once(timeout = nil)
-        if timeout
-          timeout *= 1000 # Poller uses millisecond increments
-        else
-          timeout = :blocking
-        end
-
-        rc = @poller.poll(timeout)
-
-        unless ::ZMQ::Util.resultcode_ok? rc
-          raise IOError, "0MQ poll error: #{::ZMQ::Util.error_string}"
-        end
-
-        @poller.readables.each do |sock|
-          if sock == @waker.socket
-            @waker.wait
-          else
-            task = @readers.delete sock
-            @poller.deregister sock, ::ZMQ::POLLIN
-
-            if task
-              task.resume
-            else
-              Celluloid::Logger.debug "ZMQ error: got read event without associated reader"
-            end
-          end
-        end
-
-        @poller.writables.each do |sock|
-          task = @writers.delete sock
-          @poller.deregister sock, ::ZMQ::POLLOUT
-
-          if task
-            task.resume
-          else
-            Celluloid::Logger.debug "ZMQ error: got write event without associated reader"
-          end
-        end
-      end
-    end
-  end
-end

data/celluloid-zmq/lib/celluloid/zmq/sockets.rb

@@ -1,130 +0,0 @@
-module Celluloid
-  module ZMQ
-    class Socket
-      # Create a new socket
-      def initialize(type)
-        @socket = Celluloid::ZMQ.context.socket ::ZMQ.const_get(type.to_s.upcase)
-      end
-
-      # Connect to the given 0MQ address
-      # Address should be in the form: tcp://1.2.3.4:5678/
-      def connect(addr)
-        puts "zomg connecting"
-        unless ::ZMQ::Util.resultcode_ok? @socket.connect addr
-          raise IOError, "error connecting to #{addr}: #{::ZMQ::Util.error_string}"
-        end
-        true
-      end
-
-      # Bind to the given 0MQ address
-      # Address should be in the form: tcp://1.2.3.4:5678/
-      def bind(addr)
-        unless ::ZMQ::Util.resultcode_ok? @socket.setsockopt(::ZMQ::LINGER, 0)
-          @socket.close
-          raise IOError, "couldn't set ZMQ::LINGER: #{::ZMQ::Util.error_string}"
-        end
-
-        unless ::ZMQ::Util.resultcode_ok? @socket.bind(addr)
-          raise IOError, "couldn't bind to #{addr}: #{::ZMQ::Util.error_string}"
-        end
-      end
-
-      # Close the socket
-      def close
-        @socket.close
-      end
-
-      # Does the 0MQ socket support evented operation?
-      def evented?
-        actor = Thread.current[:actor]
-        return unless actor
-
-        mailbox = actor.mailbox
-        mailbox.is_a?(Celluloid::IO::Mailbox) && mailbox.reactor.is_a?(Celluloid::ZMQ::Reactor)
-      end
-
-      # Hide ffi-rzmq internals
-      alias_method :inspect, :to_s
-    end
-
-    # Readable 0MQ sockets have a read method
-    module ReadableSocket
-      # Read a message from the socket
-      def read(buffer = '')
-        Celluloid.current_actor.wait_readable(@socket) if evented?
-
-        unless ::ZMQ::Util.resultcode_ok? @socket.recv_string buffer
-          raise IOError, "error receiving ZMQ string: #{::ZMQ::Util.error_string}"
-        end
-        buffer
-      end
-    end
-
-    # Writable 0MQ sockets have a send method
-    module WritableSocket
-      # Send a message to the socket
-      def send(message)
-        unless ::ZMQ::Util.resultcode_ok? @socket.send_string message
-          raise IOError, "error sending 0MQ message: #{::ZMQ::Util.error_string}"
-        end
-
-        message
-      end
-      alias_method :<<, :send
-    end
-
-    # ReqSockets are the counterpart of RepSockets (REQ/REP)
-    class ReqSocket < Socket
-      include ReadableSocket
-
-      def initialize
-        super :req
-      end
-    end
-
-    # RepSockets are the counterpart of ReqSockets (REQ/REP)
-    class RepSocket < Socket
-      include WritableSocket
-
-      def initialize
-        super :rep
-      end
-    end
-
-    # PushSockets are the counterpart of PullSockets (PUSH/PULL)
-    class PushSocket < Socket
-      include WritableSocket
-
-      def initialize
-        super :push
-      end
-    end
-
-    # PullSockets are the counterpart of PushSockets (PUSH/PULL)
-    class PullSocket < Socket
-      include ReadableSocket
-
-      def initialize
-        super :pull
-      end
-    end
-
-    # PubSockets are the counterpart of SubSockets (PUB/SUB)
-    class PubSocket < Socket
-      include WritableSocket
-
-      def initialize
-        super :pub
-      end
-    end
-
-    # SubSockets are the counterpart of PubSockets (PUB/SUB)
-    class SubSocket < Socket
-      include ReadableSocket
-
-      def initialize
-        super :sub
-      end
-    end
-  end
-end

data/celluloid-zmq/lib/celluloid/zmq/version.rb

@@ -1,5 +0,0 @@
-module Celluloid
-  module ZMQ
-    VERSION = "0.9.1"
-  end
-end

data/celluloid-zmq/lib/celluloid/zmq/waker.rb

@@ -1,55 +0,0 @@
-module Celluloid
-  module ZMQ
-    # You can't wake the dead
-    DeadWakerError = Class.new IOError
-
-    # Wakes up sleepy threads so that they can check their mailbox
-    # Works like a ConditionVariable, except it's implemented as a ZMQ socket
-    # so that it can be multiplexed alongside other ZMQ sockets
-    class Waker
-      PAYLOAD = "\0" # the payload doesn't matter, it's just a signal
-
-      def initialize
-        @sender   = ZMQ.context.socket(::ZMQ::PAIR)
-        @receiver = ZMQ.context.socket(::ZMQ::PAIR)
-
-        @addr = "inproc://waker-#{object_id}"
-        @sender.bind @addr
-        @receiver.connect @addr
-
-        @sender_lock = Mutex.new
-      end
-
-      # Wakes up the thread that is waiting for this Waker
-      def signal
-        @sender_lock.synchronize do
-          unless ::ZMQ::Util.resultcode_ok? @sender.send_string PAYLOAD
-            raise DeadWakerError, "error sending 0MQ message: #{::ZMQ::Util.error_string}"
-          end
-        end
-      end
-
-      # 0MQ socket to wait for messages on
-      def socket
-        @receiver
-      end
-
-      # Wait for another thread to signal this Waker
-      def wait
-        message = ''
-        rc = @receiver.recv_string message
-
-        unless ::ZMQ::Util.resultcode_ok? rc and message == PAYLOAD
-          raise DeadWakerError, "error receiving ZMQ string: #{::ZMQ::Util.error_string}"
-        end
-      end
-
-      # Clean up the IO objects associated with this waker
-      def cleanup
-        @sender_lock.synchronize { @sender.close rescue nil }
-        @receiver.close rescue nil
-        nil
-      end
-    end
-  end
-end

data/celluloid-zmq/spec/celluloid/zmq/actor_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'celluloid/rspec'
-
-describe Celluloid::ZMQ do
-  it_behaves_like "a Celluloid Actor", Celluloid::ZMQ
-end

data/celluloid-zmq/spec/spec_helper.rb

@@ -1,2 +0,0 @@
-require 'bundler/setup'
-require 'celluloid/zmq'