zmqmachine 0.6.0 → 0.7.1

data/lib/zm/{devices → device}/queue.rb

@@ -35,7 +35,6 @@
 #
 
 module ZMQMachine
-
   module Device
 
 
@@ -53,102 +52,122 @@ module ZMQMachine
     #
     #  # the queue creates sockets and binds to both given addresses; all messages get
     #  # routed between the two
-    #  queue = ZM::Device::Queue.new reactor, "tcp://192.168.0.100:5050", "tcp://192.168.0.100:5051"
+    #  config = ZM::Device::Configuration.new
+    #  config.reactor = reactor
+    #  config.incoming_endpoint = "tcp://192.168.0.100:5050"
+    #  config.outgoing_endpoint = "tcp://192.168.0.100:5051"
+    #  config.verbose = false
+    #  config.linger = 10 # ms
+    #  config.hwm = 0
+    #  queue = ZM::Device::Queue.new(config)
     #
     #  # the +client_handler+ internally calls "connect" to the incoming address given above
-    #  client = reactor.req_socket client_handler
-    #  client2 = reactor.req_socket client_handler
+    #  client = reactor.req_socket(client_handler)
+    #  client2 = reactor.req_socket(client_handler)
     #
     #  # the +server_handler+ internally calls "connect" to the outgoing address given above
-    #  server = reactor.rep_socket server_handler
+    #  server = reactor.rep_socket(server_handler)
     #
     class Queue
 
-      class Handler
+      class XReqHandler
         attr_accessor :socket_out
 
-        def initialize reactor, address, dir, opts = {}
-          @reactor = reactor
+        def initialize(config, address, direction)
+          @reactor = config.reactor
           @address = address
-          @verbose = opts[:verbose] || false
-          @opts = opts
-          @dir = dir
+          @verbose = config.verbose
+          @config = config
+          @direction = direction
         end
 
-        def on_attach socket
-          set_options socket
-          rc = socket.bind @address
+        def on_attach(socket)
+          set_options(socket)
+          rc = socket.bind(@address)
           error_check(rc)
-          #FIXME: error handling!
         end
 
-        def on_writable socket
-          @reactor.deregister_writable socket
+        def on_writable(socket)
+          @reactor.deregister_writable(socket)
         end
 
-        def on_readable socket, messages
-          messages.each { |msg| @reactor.log(:device, "[Q#{@dir}] [#{msg.copy_out_string}]") } if @verbose
+        def on_readable(socket, messages, envelope)
+          all = (envelope + messages)
+          all.each { |msg| @reactor.log(:device, "[Q#{@direction}] [#{msg.copy_out_string}]") } if @verbose
 
           if @socket_out
             # FIXME: need to be able to handle EAGAIN/failed send
-            rc = socket_out.send_messages messages
-            messages.each { |message| message.close }
+            rc = socket_out.send_messages(all)
+            all.each { |message| message.close }
           end
         end
 
-        if LibZMQ.version2?
+        if ZMQ::LibZMQ.version2?
 
-          def set_options socket
-            error_check(socket.raw_socket.setsockopt(ZMQ::HWM, (@opts[:hwm] || 1)))
-            error_check(socket.raw_socket.setsockopt(ZMQ::LINGER, (@opts[:linger] || 0)))
+          def set_options(socket)
+            error_check(socket.raw_socket.setsockopt(ZMQ::HWM, @config.hwm))
+            error_check(socket.raw_socket.setsockopt(ZMQ::LINGER, @config.linger))
           end
 
-        elsif LibZMQ.version3?
+        elsif ZMQ::LibZMQ.version3?
 
-          def set_options socket
-            error_check(socket.raw_socket.setsockopt(ZMQ::SNDHWM, (@opts[:hwm] || 1)))
-            error_check(socket.raw_socket.setsockopt(ZMQ::RCVHWM, (@opts[:hwm] || 1)))
-            error_check(socket.raw_socket.setsockopt(ZMQ::LINGER, (@opts[:linger] || 0)))
+          def set_options(socket)
+            error_check(socket.raw_socket.setsockopt(ZMQ::SNDHWM, @config.hwm))
+            error_check(socket.raw_socket.setsockopt(ZMQ::RCVHWM, @config.hwm))
+            error_check(socket.raw_socket.setsockopt(ZMQ::LINGER, @config.linger))
           end
 
         end
 
-        def error_check rc
+        def error_check(rc)
           if ZMQ::Util.resultcode_ok?(rc)
             false
           else
-            STDERR.puts "Operation failed, errno [#{ZMQ::Util.errno}] description [#{ZMQ::Util.error_string}]"
-            caller(1).each { |callstack| STDERR.puts(callstack) }
+            @reactor.log(:error, "Operation failed, errno [#{ZMQ::Util.errno}] description [#{ZMQ::Util.error_string}]")
+            caller(1).each { |callstack| @reactor.log(:callstack, callstack) }
             true
           end
         end
 
-      end # class Handler
+      end # class XReqHandler
+
+      class XRepHandler < XReqHandler
+        
+        def on_readable(socket, messages, envelope)
+          all = envelope + messages
+          all.each { |msg| @reactor.log(:device, "[Q#{@direction}] [#{msg.copy_out_string}]") } if @verbose
 
+          if @socket_out
+            # FIXME: need to be able to handle EAGAIN/failed send
+            rc = socket_out.send_messages(all)
+            all.each { |message| message.close }
+          end
+        end
+      end
 
       # Takes either a properly formatted string that can be converted into a ZM::Address
       # or takes a ZM::Address directly.
       #
       # Routes all messages received by either address to the other address.
       #
-      def initialize reactor, incoming, outgoing, opts = {}
-        incoming = Address.from_string incoming if incoming.kind_of? String
-        outgoing = Address.from_string outgoing if outgoing.kind_of? String
+      def initialize(config)
+        @reactor = config.reactor
+        incoming = Address.from_string(config.incoming_endpoint.to_s)
+        outgoing = Address.from_string(config.outgoing_endpoint.to_s)
 
         # setup the handlers for processing messages
-        @handler_in = Handler.new reactor, incoming, :in, opts
-        @handler_out = Handler.new reactor, outgoing, :out, opts
+        @handler_in = XRepHandler.new(config, incoming, :in)
+        @handler_out = XReqHandler.new(config, outgoing, :out)
 
         # create each socket and pass in the appropriate handler
-        @incoming = reactor.xrep_socket @handler_in
-        @outgoing = reactor.xreq_socket @handler_out
+        @incoming_sock = @reactor.xrep_socket(@handler_in)
+        @outgoing_sock = @reactor.xreq_socket(@handler_out)
 
         # set each handler's outgoing socket
-        @handler_in.socket_out = @outgoing
-        @handler_out.socket_out = @incoming
+        @handler_in.socket_out = @outgoing_sock
+        @handler_out.socket_out = @incoming_sock
       end
     end # class Queue
 
   end # module Device
-
 end # module ZMQMachine

data/lib/zm/log_client.rb

@@ -109,14 +109,14 @@ module ZMQMachine
       @reactor.deregister_writable socket
     end
 
-    if LibZMQ.version2?
+    if ZMQ::LibZMQ.version2?
 
       def set_options socket
         socket.raw_socket.setsockopt ZMQ::HWM, 0
         socket.raw_socket.setsockopt ZMQ::LINGER, 0
       end
 
-    elsif LibZMQ.version3?
+    elsif ZMQ::LibZMQ.version3?
 
       def set_options socket
         socket.raw_socket.setsockopt ZMQ::SNDHWM, 0

data/lib/zm/log_server.rb

@@ -0,0 +1,68 @@
+#--
+#
+# Author:: Chuck Remes
+# Homepage::  http://github.com/chuckremes/zmqmachine
+# Date:: 20111101
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2011 by Chuck Remes. All Rights Reserved.
+# Email: cremes at mac dot com
+#
+# (The MIT License)
+#
+# 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.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+module ZMQMachine
+
+  class LogServer
+    include Server::SUB
+
+    def initialize(configuration)
+      configuration.on_read = method(:on_read)
+      super
+
+      @file = configuration.extra[:file] || STDOUT
+    end
+
+    # Writes all messages to the file.
+    #
+    def on_read socket, messages
+      string = ''
+      messages.each_with_index do |message, index|
+        string << '|' if index > 0
+        string << "#{message.copy_out_string}"
+      end
+
+      @file.print "#{string}\n"
+      @file.flush
+    end
+
+    def write messages
+      # no op
+    end
+
+  end # class LogServer
+
+end

data/lib/zm/reactor.rb

@@ -39,46 +39,58 @@ module ZMQMachine
   class Reactor
     attr_reader :name, :context, :logger, :exception_handler
 
+    # Takes a ZMQ::Configuration instance to initialize itself.
+    #
     # +name+ provides a name for this reactor instance. It's unused
     # at present but may be used in the future for allowing multiple
-    # reactors to communicate amongst each other.
+    # reactors to communicate amongst each other. Defaults to 'unnamed'
+    # if it isn't set.
     #
     # +poll_interval+ is the number of milliseconds to block while
-    # waiting for new 0mq socket events; default is 10
+    # waiting for new 0mq socket events; default is 10 ms.
     #
-    # +opts+ may contain a key +:zeromq_context+. When this
-    # hash is provided, the value for :zeromq_context should be a
+    # +context+ should be a
     # 0mq context as created by ZMQ::Context.new. The purpose of
     # providing a context to the reactor is so that multiple
     # reactors can share a single context. Doing so allows for sockets
     # within each reactor to communicate with each other via an
     # :inproc transport (:inproc is misnamed, it should be :incontext).
     # By not supplying this hash, the reactor will create and use
-    # its own 0mq context.
+    # its own 0mq context. Default is nil.
     #
-    # +opts+ may also include a +:log_transport+ key. This should be
+    # +log_endpoint+ is a
     # a transport string for an endpoint that a logger client may connect
     # to for publishing log messages. when this key is defined, the
     # client is automatically created and connected to the indicated
-    # endpoint.
-    #
-    # Lastly, +opts+ may include a +exception_handler+ key. The exception
-    # handler should respond to #call and take a single argument.
-    #
-    def initialize name, poll_interval = 10, opts = {}
-      @name = name
+    # endpoint. Default is nil.
+    #
+    # +exception_handler+ is called for all exceptions. The
+    # handler should respond to #call and take a single argument. Default
+    # is to just raise the exception and exit.
+    #
+    #  config = ZM::Configuration.new
+    #  config.context = master_context
+    #  config.log_endpoint = endpoint
+    #  config.name = :test_rig
+    #  config.poll_interval = 100 # defaults to 10 if unset
+    #  Reactor.new(config).run do |reactor|
+    #    reactor.oneshot_timer(50) { print("At least 50ms have elapsed\n")}
+    #  end
+    #
+    def initialize configuration = nil
+      configuration ||= Configuration.new
+      @name = configuration.name || 'unnamed'
       @running = false
       @thread = nil
-      @poll_interval = determine_interval poll_interval
-      @timers = ZMQMachine::Timers.new
+      @poll_interval = determine_interval(configuration.poll_interval || 10)
 
       @proc_queue = []
       @proc_queue_mutex = Mutex.new
 
       # could raise if it fails to allocate a Context
-      @context = if opts[:zeromq_context]
+      @context = if configuration.context
         @shared_context = true
-        opts[:zeromq_context]
+        configuration.context
       else
         @shared_context = false
         ZMQ::Context.new
@@ -89,14 +101,13 @@ module ZMQMachine
       @raw_to_socket = {}
       Thread.abort_on_exception = true
 
-      if opts[:log_transport]
-        @logger = LogClient.new self, opts[:log_transport]
+      if configuration.log_endpoint
+        @logger = LogClient.new self, configuration.log_endpoint
         @logging_enabled = true
       end
 
-      if opts[:exception_handler]
-        @exception_handler = opts[:exception_handler]
-      end
+      @exception_handler = configuration.exception_handler if configuration.exception_handler
+      @timers = ZMQMachine::Timers.new(@exception_handler)
     end
 
     def shared_context?
@@ -249,6 +260,7 @@ module ZMQMachine
     def xreq_socket handler_instance
       create_socket handler_instance, ZMQMachine::Socket::XReq
     end
+    alias :dealer_socket :xreq_socket
 
     # Creates a XREP socket and attaches +handler_instance+ to the
     # resulting socket. Should only be paired with one other
@@ -264,6 +276,7 @@ module ZMQMachine
     def xrep_socket handler_instance
       create_socket handler_instance, ZMQMachine::Socket::XRep
     end
+    alias :router_socket :xrep_socket
 
     # Creates a PAIR socket and attaches +handler_instance+ to the
     # resulting socket. Works only with other #pair_socket instances
@@ -437,16 +450,16 @@ module ZMQMachine
     end
 
     # Publishes log messages to an existing transport passed in to the Reactor
-    # constructor using the :log_transport key.
+    # constructor using the :log_endpoint key.
     #
-    #  Reactor.new :log_transport => 'inproc://reactor_log'
+    #  Reactor.new :log_endpoint => 'inproc://reactor_log'
     #
     # +level+ parameter refers to a key to indicate severity level, e.g. :warn,
     # :debug, level0, level9, etc.
     #
     # +message+ is a plain string that will be written out in its entirety.
     #
-    # When no :log_transport was defined when creating the Reactor, all calls
+    # When no :log_endpoint was defined when creating the Reactor, all calls
     # just discard the messages.
     #
     #  reactor.log(:info, "some message")
@@ -518,11 +531,11 @@ module ZMQMachine
         sleep(@poll_interval / 1000.0)
       else
         rc = @poller.poll @poll_interval
-      end
 
-      if ZMQ::Util.resultcode_ok?(rc)
-        @poller.readables.each { |sock| @raw_to_socket[sock].resume_read }
-        @poller.writables.each { |sock| @raw_to_socket[sock].resume_write }
+        if ZMQ::Util.resultcode_ok?(rc)
+          @poller.readables.each { |sock| @raw_to_socket[sock].resume_read }
+          @poller.writables.each { |sock| @raw_to_socket[sock].resume_write }
+        end
       end
 
       rc

data/lib/zm/server.rb

@@ -0,0 +1,4 @@
+
+%w( base routing_envelope req rep pair pub sub push pull configuration ).each do |rb_file|
+  require File.join(File.dirname(__FILE__), 'server', rb_file)
+end

data/lib/zm/server/base.rb

@@ -0,0 +1,139 @@
+
+module ZMQMachine
+
+  module Server
+
+    module Base
+      def initialize configuration
+        @reactor = configuration.reactor
+        @configuration = configuration
+
+        @on_read = @configuration.on_read
+        allocate_socket
+
+        @message_queue = []
+      end
+
+      def shutdown
+        @reactor.log :debug, "#{self.class}#shutdown_socket, closing reactor socket"
+        @on_read = nil
+        @reactor.close_socket @socket
+      end
+
+      def on_attach socket
+        # socket options *must* be set before we bind/connect otherwise they are ignored
+        set_options socket
+        rc = -1
+
+        if @configuration.bind
+          rc = socket.bind @configuration.endpoint
+          @reactor.log :debug, "#{self.class}#on_attach, bind rc [#{rc}], endpoint #{@configuration.endpoint}"
+          raise "#{self.class}#on_attach, failed to bind to endpoint [#{@configuration.endpoint}]" unless ZMQ::Util.resultcode_ok?(rc)
+        elsif @configuration.connect
+          rc = socket.connect @configuration.endpoint
+          @reactor.log :debug, "#{self.class}#on_attach, connect rc [#{rc}], endpoint #{@configuration.endpoint}"
+          raise "#{self.class}#on_attach, failed to connect to endpoint [#{@configuration.endpoint}]" unless ZMQ::Util.resultcode_ok?(rc)
+        end
+
+
+        register_for_events socket
+      end
+
+      # Takes an array of ZM::Message instances and writes them out to the socket. If any
+      # socket write fails, the message is saved. We will attempt to write it again in
+      # 10 milliseconds or when another message array is sent, whichever comes first.
+      #
+      # All messages passed here are guaranteed to be written in the *order they were
+      # received*.
+      #
+      def write messages, verbose = false
+        @verbose = verbose
+        @message_queue << messages
+        write_queue_to_socket
+      end
+
+      # Prints each message when global debugging is enabled.
+      #
+      # Forwards +messages+ on to the :on_read callback given in the constructor.
+      #
+      def on_readable socket, messages
+        @on_read.call socket, messages
+        close_messages messages
+      end
+
+      # Just deregisters from receiving any further write *events*
+      #
+      def on_writable socket
+        #@reactor.log :debug, "#{self.class}#on_writable, deregister for writes on sid [#{@session_id}]"
+        @reactor.deregister_writable socket
+      end
+
+      def on_readable_error socket, return_code
+        STDERR.puts "#{self.class}#on_readable_error, rc [#{return_code}], errno [#{ZMQ::Util.errno}], description [#{ZMQ::Util.error_string}], sock #{socket.inspect}"
+      end
+
+      def on_writable_error socket, return_code
+        STDERR.puts "#{self.class}#on_writable_error, rc [#{return_code}], errno [#{ZMQ::Util.errno}], description [#{ZMQ::Util.error_string}], sock #{socket.inspect}"
+      end
+
+
+      private
+
+
+      def register_for_events socket
+        @reactor.register_readable socket
+        @reactor.deregister_writable socket
+      end
+
+      if ZMQ::LibZMQ.version2?
+
+        def set_options socket
+          socket.raw_socket.setsockopt ZMQ::HWM, (@configuration.hwm || 0)
+          socket.raw_socket.setsockopt ZMQ::LINGER, (@configuration.linger || 1)
+        end
+
+      elsif ZMQ::LibZMQ.version3?
+
+        def set_options socket
+          socket.raw_socket.setsockopt ZMQ::RCVHWM, (@configuration.hwm || 0)
+          socket.raw_socket.setsockopt ZMQ::SNDHWM, (@configuration.hwm || 0)
+          socket.raw_socket.setsockopt ZMQ::LINGER, (@configuration.linger || 1)
+        end
+
+      end
+
+      def write_queue_to_socket
+        until @message_queue.empty?
+          messages = get_next_message_array
+
+          rc = @socket.send_messages messages
+
+          if ZMQ::Util.resultcode_ok?(rc) # succeeded, so remove the message from the queue
+            @message_queue.shift
+            close_messages messages
+          elsif ZMQ::Util.errno == ZMQ::EAGAIN
+            # schedule another write attempt in 10 ms; break out of the loop
+            @reactor.log :debug, "#{self.class}#write_queue_to_socket, failed to write messages; scheduling next attempt"
+            @reactor.oneshot_timer 10, method(:write_queue_to_socket)
+            break
+          end
+        end
+      end
+
+      def get_next_message_array
+        messages = @message_queue.at(0)
+        messages.each { |message| @reactor.log :write, message.copy_out_string } if @verbose
+        messages
+      end
+
+      def close_messages messages
+        messages.each { |message| message.close }
+      end
+
+      def allocate_socket() nil; end
+
+    end # module Base
+
+  end # module Server
+
+end # ZMQMachine