zmqmachine 0.6.0 → 0.7.1

data/lib/zm/server/configuration.rb

@@ -0,0 +1,53 @@
+
+module ZMQMachine
+  module Server
+    ZMQMachine::ConfigClassMaker.create_class('Configuration', 
+    %w( on_read bind connect endpoint topic hwm linger extra reactor ), 
+    ZMQMachine::Configuration, 
+    ZMQMachine::Server)
+  end
+end
+
+#module ZMQMachine
+#
+#  module Server
+#
+#    class Configuration
+#      Fields = %w( on_read bind connect endpoint topic hwm linger extra reactor name context log_endpoint exception_handler )
+#      
+#      # Creates a Configuration object from another object that conforms
+#      # to the Configuration protocol.
+#      #
+#      def self.create_from(other_config)
+#        config = new
+#        Fields.each do |name|
+#          config.send("#{name}", other_config.send(name.to_sym)) if config.respond_to?(name.to_sym)
+#        end
+#        config
+#      end
+#      
+#      def initialize(&blk)
+#        instance_eval(&blk) if block_given?
+#      end
+#
+#      Fields.each do |name|
+#        code = <<-code
+#        def #{ name } (value = nil)
+#          if value
+#            @#{name} = value
+#          else
+#            @#{name}
+#          end
+#        end
+#        
+#        def #{ name }=(value)
+#          @#{name} = value
+#        end
+#        code
+#
+#        class_eval code
+#      end
+#    end # class Configuration
+#    
+#  end # Server
+#end # ZMQMachine

data/lib/zm/server/pair.rb

@@ -0,0 +1,23 @@
+
+module ZMQMachine
+
+  module Server
+
+    module Pair
+      include Base
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.pair_socket(self)
+      end
+
+      def register_for_events socket
+        @reactor.register_readable socket
+        @reactor.register_writable socket
+      end
+
+    end # module Pair
+
+  end # module Server
+end # ZMQMachine

data/lib/zm/server/pub.rb

@@ -0,0 +1,23 @@
+
+module ZMQMachine
+
+  module Server
+
+    module PUB
+      include Base
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.pub_socket(self)
+      end
+
+      def register_for_events socket
+        @reactor.deregister_readable socket
+        @reactor.deregister_writable socket
+      end
+
+    end # module PUB
+
+  end # module Server
+end # ZMQMachine

data/lib/zm/server/pull.rb

@@ -0,0 +1,24 @@
+
+module ZMQMachine
+
+  module Server
+
+    module PULL
+      include Base
+
+      def write messages
+        # no op
+        close messages
+      end
+
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.pull_socket(self)
+      end
+
+    end # module PULL
+
+  end # module Server
+end # ZMQMachine

data/lib/zm/server/push.rb

@@ -0,0 +1,23 @@
+
+module ZMQMachine
+
+  module Server
+
+    module PUSH
+      include Base
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.push_socket(self)
+      end
+
+      def register_for_events socket
+        @reactor.deregister_readable socket
+        @reactor.deregister_writable socket
+      end
+
+    end # module PUSH
+
+  end # module Servers
+end # ZMQMachine

data/lib/zm/server/rep.rb

@@ -0,0 +1,42 @@
+
+module ZMQMachine
+
+  module Server
+
+    module REP
+      include Base
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.rep_socket(self)
+      end
+    end # module REP
+
+
+    module XREP
+      include Base
+      include RoutingEnvelope
+
+      def on_readable socket, messages, envelope
+        @routing = save_routing envelope
+
+        @on_read.call socket, messages, envelope
+        close_messages(envelope + messages)
+      end
+
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.xrep_socket(self)
+      end
+    end # module XREP
+
+
+    module ROUTER
+      include XREP
+    end # module ROUTER
+
+  end # module Server
+end # ZMQMachine

data/lib/zm/server/req.rb

@@ -0,0 +1,41 @@
+
+module ZMQMachine
+
+  module Server
+
+    module REQ
+      include Base
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.req_socket(self)
+      end
+
+    end # module REQ
+
+    module XREQ
+      include Base
+      include RoutingEnvelope
+
+      def on_readable socket, messages, envelope
+        @routing = save_routing envelope
+
+        @on_read.call socket, messages, envelope
+        close_messages(envelope + messages)
+      end
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.xreq_socket(self)
+      end
+
+    end # module XREQ
+
+    module DEALER
+      include XREQ
+    end # module DEALER
+
+  end # module Server
+end # ZMQMachine

data/lib/zm/server/routing_envelope.rb

@@ -0,0 +1,26 @@
+
+module ZMQMachine
+  
+  module Server
+    
+    module RoutingEnvelope
+      # Saves the return routing information for XREP sockets
+      def save_routing messages
+        @routing_messages = []
+        @routing_strings = []
+        messages.each do |message|
+          string = message.copy_out_string
+          @routing_strings << string
+          @routing_messages << ZMQ::Message.new(string)
+        end
+
+        @routing_messages
+      end
+
+      def routing_strings
+        @routing_strings.dup
+      end
+    end
+    
+  end
+end

data/lib/zm/server/sub.rb

@@ -0,0 +1,40 @@
+
+module ZMQMachine
+
+  module Server
+
+    module SUB
+      include Base
+      
+      def initialize configuration
+        @topic = configuration.topic || ''
+        super
+      end
+
+      def write messages
+        # no op
+        close messages
+      end
+
+
+      private
+
+      def allocate_socket
+        @socket = @reactor.sub_socket(self)
+      end
+
+      def register_for_events socket
+        subscribe socket, @topic
+
+        super
+      end
+
+      def subscribe socket, topic
+        rc = socket.subscribe topic
+      end
+
+
+    end # module SUB
+
+  end # module Server
+end # ZMQMachine

data/lib/zm/sockets.rb

@@ -1,4 +1,4 @@
 
-%w( base req rep pair pub sub xreq xrep push pull ).each do |rb_file|
+%w( base envelope_help req rep pair pub sub push pull ).each do |rb_file|
   require File.join(File.dirname(__FILE__), 'sockets', rb_file)
 end

data/lib/zm/sockets/base.rb

@@ -129,7 +129,7 @@ module ZMQMachine
         @raw_socket.sendmsgs messages
       end
 
-      if LibZMQ.version2? || LibZMQ.version3?
+      if ZMQ::LibZMQ.version2? || ZMQ::LibZMQ.version3?
 
         # Retrieve the IDENTITY value assigned to this socket.
         #
@@ -153,13 +153,13 @@ module ZMQMachine
           rc = @raw_socket.recvmsgs parts, ZMQ::Util.nonblocking_flag
 
           if ZMQ::Util.resultcode_ok?(rc)
-            deliver(parts, rc)
+            @handler.on_readable self, parts
           else
             # verify errno corresponds to EAGAIN
             if eagain?
               more = false
             elsif valid_socket_error?
-              deliver([], rc)
+              @handler.on_readable_error self, rc
             end
           end
         end
@@ -178,15 +178,6 @@ module ZMQMachine
 
       private
 
-      def deliver parts, rc
-        if ZMQ::Util.resultcode_ok?(rc)
-          @handler.on_readable self, parts
-        else
-          # this branch is never called
-          @handler.on_readable_error self, rc
-        end
-      end
-
       def eagain?
         ZMQ::EAGAIN == ZMQ::Util.errno
       end

data/lib/zm/sockets/envelope_help.rb

@@ -0,0 +1,49 @@
+
+module ZMQMachine
+
+  module Socket
+
+    # Two socket types (XREQ/XREP also called DEALER/ROUTER) have message
+    # parts for routing the message to the appropriate destination. This
+    # extra routing data is commonly called the routing envelope.
+    #
+    # The module provides logic for separating the routing envelope from
+    # the message body. The envelope is passed separately to the user's
+    # #on_readable method.
+    #
+    module EnvelopeHelp
+
+      # Convenience method for sending a multi-part message. The
+      # +messages+ and +envelope+ arguments must implement Enumerable.
+      #
+      def send_messages messages, envelope = nil
+        envelope ? @raw_socket.sendmsgs(envelope + messages) : @raw_socket.sendmsgs(messages)
+      end
+
+      # Used by the reactor. Never called by user code.
+      #
+      def resume_read
+        rc = 0
+        more = true
+
+        while ZMQ::Util.resultcode_ok?(rc) && more
+          parts, envelope = [], []
+          rc = @raw_socket.recv_multipart parts, envelope, ZMQ::Util.nonblocking_flag
+
+          if ZMQ::Util.resultcode_ok?(rc)
+            @handler.on_readable self, parts, envelope
+          else
+            # verify errno corresponds to EAGAIN
+            if eagain?
+              more = false
+            elsif valid_socket_error?
+              @handler.on_readable_error self, rc
+            end
+          end
+        end
+      end
+
+    end # module EnvelopeSeparation
+
+  end # Socket
+end # ZMQMachine

data/lib/zm/sockets/pair.rb

@@ -46,7 +46,6 @@ module ZMQMachine
         @kind = :pair
 
         super
-        @state = :ready
       end
 
       # Attach a handler to the PAIR socket.

data/lib/zm/sockets/pub.rb

@@ -46,7 +46,6 @@ module ZMQMachine
         @kind = :pub
 
         super
-        @state = :ready
       end
 
       # Attach a handler to the PUB socket.

data/lib/zm/sockets/rep.rb

@@ -74,6 +74,51 @@ module ZMQMachine
       end
     end # class Rep
 
+    class XRep
+      include ZMQMachine::Socket::Base
+      include ZMQMachine::Socket::EnvelopeHelp
+
+      def initialize context, handler
+        @poll_options = ZMQ::POLLIN
+        @kind = :xreply
+
+        super
+      end
+
+      # Attach a handler to the XREP socket.
+      #
+      # A XREP socket has no restrictions on the number of sends and
+      # recieves. Each send will silently prepend a message part to
+      # your outgoing data which the REQ/XREQ socket on the other end
+      # will use for matching up the transaction.
+      #
+      # This socket expects its +handler+ to
+      # implement at least the #on_readable method. This method
+      # will be called whenever a reply arrives. The #on_writable method
+      # will be called continually until the socket HWM is breached.
+      #
+      # For error handling purposes, the handler must also
+      # implement #on_readable_error.
+      #
+      def on_attach handler
+        raise ArgumentError, "Handler must implement an #on_readable method" unless handler.respond_to? :on_readable
+        raise ArgumentError, "Handler must implement an #on_readable_error method" unless handler.respond_to? :on_readable_error
+        raise ArgumentError, "Handler must implement an #on_writable method" unless handler.respond_to? :on_writable
+        raise ArgumentError, "Handler must implement an #on_writable_error method" unless handler.respond_to? :on_writable_error
+        super
+      end
+
+
+      private
+
+      def allocate_socket context
+        sock = ZMQ::Socket.new context.pointer, ZMQ::XREP
+        sock
+      end
+    end # class XRep
+    
+    Router = XRep # same thing, different name
+
   end # module Socket
 
 end # module ZMQMachine