zmqmachine 0.6.0 → 0.7.1

data/.gitignore

@@ -0,0 +1,15 @@
+html
+pkg
+doc
+*.gem
+*.rbc
+*.tmproj
+nbproject
+*.bundle
+*.o
+.DS_Store
+.rbx
+examples/work
+benchmark
+*~
+*#*

data/AUTHORS.txt

@@ -0,0 +1,3 @@
+Chuck Remes, chuckremes (github)
+
+Tim Carey-Smith, halorgium (github)

data/History.txt

@@ -1,3 +1,22 @@
+== 0.7.1 / 2011-11-30
+  * Updated the Devices to use a Device::Configuration instance
+    for configuration rather than that long method signature.
+    Makes all components conform to this new configuration
+    mechanism consistently.
+
+== 0.7.0 / 2011-10-28
+  * Created a class for holding Reactor and Server configurations.
+    This is much nicer than passing in individual args or a hash.
+    
+  * Added the ZM::Servers module to make building servers a little
+    easier. The biggest improvement is for making servers that
+    utilize XREP/ROUTER sockets since the module handles the 
+    splitting of the routing envelope messages from the body.
+    
+  * Fixed a bug where a timer that raises an exception prevented
+    other periodical timers from renewing. Thanks to Tim
+    Carey-Smith for the bug report!
+
 == 0.6.0 / 2011-10-04
   * Compatibility with ffi-rzmq 0.9.0 and added some conditional
     logic to support 0mq 2.1.x and 3.x APIs.

data/examples/fake_ftp.rb

@@ -93,6 +93,10 @@ class FTPControlClient
 
     @data_client.should_expect reply['total_chunks']
   end
+  
+  def on_readable_error socket, error
+    puts "on_readable_error, error [#{error}], descr [#{ZMQ::Util.error_string}]"
+  end
 
   def get filename, &blk
     sub_address = ZM::Address.new @address.host, 5556, @address.transport
@@ -204,6 +208,10 @@ class FTPControlServer
       @pub_handler = nil
     end
   end
+  
+  def on_readable_error socket, error
+    puts "on_readable_error, error [#{error}], descr [#{ZMQ::Util.error_string}]"
+  end
 
   def on_writable socket
     puts "#{self.class.name}#on_writable ERROR, should never be called"
@@ -223,7 +231,7 @@ end
 
 
 # Run both handlers within the same reactor context
-ctx1 = ZM::Reactor.new(:test).run do |context|
+ctx1 = ZM::Reactor.new.run do |context|
 
   @request_server = FTPControlServer.new context, server_address
   context.rep_socket @request_server

data/examples/one_handed_ping_pong.rb

@@ -29,6 +29,7 @@ class PingPongHandler
     when :request
       rc = socket.connect address
       @context.register_readable socket
+      @context.register_writable socket
     end
   end
 
@@ -57,7 +58,7 @@ end
 
 handler = nil
 # Run both handlers within the same reactor context
-ctx1 = ZM::Reactor.new(:test).run do |context|
+ctx1 = ZM::Reactor.new.run do |context|
   handler = PingPongHandler.new context
 
   context.rep_socket handler

data/examples/ping_pong.rb

@@ -60,7 +60,7 @@ class PingHandler
 end
 
 # Run both handlers within the same reactor context
-ctx1 = ZM::Reactor.new(:test).run do |context|
+ctx1 = ZM::Reactor.new.run do |context|
   @pong_handler = PongHandler.new context
   context.rep_socket @pong_handler
 
@@ -76,7 +76,7 @@ end
 
 # Or, run each handler in separate contexts each with its
 # own thread.
-#ctx2 = ZM::Reactor.new(:test).run do |context|
+#ctx2 = ZM::Reactor.new.run do |context|
 #  @ping_handler = PingHandler.new context
 #  context.req_socket @ping_handler
 #end

data/examples/pub_sub.rb

@@ -79,8 +79,14 @@ end
 # handler is only getting instantiated and run in one reactor at a time. The subscriber
 # handlers can be instantiated multiple times in each reactor if you so choose.
 
+configuration = ZM::Configuration.new do
+  name 'publisher reactor'
+  poll_interval 3
+  exception_handler Proc.new { |exc| raise(exc) }
+end
+
 # Run all handlers within the same reactor context
-ctx1 = ZM::Reactor.new(:A).run do |context|
+ctx1 = ZM::Reactor.new(configuration).run do |context|
   @pub1_handler = PublisherHandler.new context, 5555, ['futures.us.es.m.10', 'futures.us.es.u.10']
   context.pub_socket @pub1_handler
 
@@ -105,7 +111,7 @@ end
 
 # Or, run each handler in separate contexts each with its
 # own thread.
-ctx2 = ZM::Reactor.new(:B).run do |context|
+ctx2 = ZM::Reactor.new.run do |context|
   #  @pub1_handler = PublisherHandler.new context, 5555, ['futures.us.es.m.10', 'futures.us.es.u.10']
   #  context.pub_socket @pub1_handler
 
@@ -128,7 +134,7 @@ ctx2 = ZM::Reactor.new(:B).run do |context|
   #  context.sub_socket @sub5_handler
 end
 
-ctx3 = ZM::Reactor.new(:C).run do |context|
+ctx3 = ZM::Reactor.new.run do |context|
   #  @pub1_handler = PublisherHandler.new context, 5555, ['futures.us.es.m.10', 'futures.us.es.u.10']
   #  context.pub_socket @pub1_handler
   #
@@ -151,7 +157,7 @@ ctx3 = ZM::Reactor.new(:C).run do |context|
   #  context.sub_socket @sub5_handler
 end
 
-ctx4 = ZM::Reactor.new(:D).run do |context|
+ctx4 = ZM::Reactor.new.run do |context|
   #  @pub1_handler = PublisherHandler.new context, 5555, ['futures.us.es.m.10', 'futures.us.es.u.10']
   #  context.pub_socket @pub1_handler
   #

data/examples/pubsub_forwarder.rb

@@ -78,17 +78,22 @@ sleep_time = 10
 # Run the forwarder device in a separate context. *Could* be run from
 # the same context as the publishers and subscribers too.
 #
-ctx1 = ZM::Reactor.new(:A).run do |context|
+ctx1 = ZM::Reactor.new.run do |context|
   incoming = ZM::Address.new '127.0.0.1', 5555, :tcp
   outgoing = "tcp://127.0.0.1:5556"
+  
+  config = ZM::Device::Configuration.new
+  config.reactor = context
+  config.incoming_endpoint = incoming
+  config.outgoing_endpoint = outgoing
 
-  forwarder = ZM::Device::Forwarder.new context, incoming, outgoing
+  forwarder = ZM::Device::Forwarder.new(config)
   puts "forwarder started"
 end
 
 # Or, run each handler in separate contexts each with its
 # own thread.
-ctx2 = ZM::Reactor.new(:B).run do |context|
+ctx2 = ZM::Reactor.new.run do |context|
   # start the publishers and subscribers after a 1 sec delay; give time
   # to the forwarder device to start up and get ready
   context.oneshot_timer(1000) do

data/examples/throttled_ping_pong.rb

@@ -75,7 +75,7 @@ end
 
 
 # Run both handlers within the same reactor context
-ctx1 = ZM::Reactor.new(:pong).run do |context|
+ctx1 = ZM::Reactor.new.run do |context|
   @pong_handler = PongHandler.new context
   context.pair_socket @pong_handler
 
@@ -87,7 +87,7 @@ end
 
 # Or, run each handler in separate contexts each with its
 # own thread.
-ctx2 = ZM::Reactor.new(:ping).run do |context|
+ctx2 = ZM::Reactor.new.run do |context|
   @ping_handler = PingHandler.new context
   context.pair_socket @ping_handler
 end

data/lib/zm/configuration.rb

@@ -0,0 +1,129 @@
+
+
+module ZMQMachine
+  module ConfigClassMaker
+    module MethodMaker
+
+      # Helper to create some accessor methods. We have a standard one where it returns
+      # the value with no arg, or sets the value with an arg. Then we create a second
+      # method with the explicit '=' on it to allow directly setting the value.
+      #
+      # This let's us do nice things like eval a block and set the instance vars.
+      # e.g.
+      #  SomeClass.new do
+      #    field1 'set to this string'
+      #  end
+      #
+      # or
+      #
+      #  some_class = SomeClass.new
+      #  some_class.field1 = 'set to this string'
+      #  puts some_class.field1 # => set to this string
+      #
+      # or
+      #
+      #  some_class = SomeClass.new
+      #  some_class.field1('set to this string')
+      #  puts some_class.field1 # => set to this string
+      #
+      def self.create_accessors(mod, fields)
+        fields.each do |field_name|
+          code = <<-code
+          def #{ field_name } (value = nil)
+            if value
+              @#{field_name} = value
+            else
+              @#{field_name}
+            end
+          end
+
+          def #{ field_name }=(value)
+            @#{field_name} = value
+          end
+          code
+
+          mod.class_eval code
+        end
+      end
+
+    end # module MethodMaker
+
+    # Dynamically generates Configuration classes. It can also create subclasses.
+    # Allows us to easily build subclasses of Configuration within the library. This
+    # functionality is *also* provided for users of this library to create their
+    # own Configuration classes when writing client/server programs. All of the
+    # inheritance is taken care of.
+    #
+    # +klass_name+ - should usually be 'Configuration'
+    # +fields+ - an array of strings corresponding to the accessor names
+    # +parent+ - the parent of this subclass (Object at the top level)
+    # +mod+ - the module under which this subclass should be placed
+    #
+    # module ZMQMachine
+    #   ZMQMachine::ConfigClassMaker.create_class('Configuration', %w( one two three), Object, ZMQMachine)
+    # end
+    #
+    # OR for a subclass
+    #
+    # module ZMQMachine
+    #  module Server
+    #    ZMQMachine::ConfigClassMaker.create_class('Configuration', %w( one two three), ZMQMachine::Configuration, ZMQMachine::Server)
+    #  end
+    # end
+    #
+    def self.create_class(klass_name, fields, parent, mod)
+      # the "here doc" usage here confuses the syntax beautifier so the indentation
+      # is wrong
+      klass = <<-KLASS
+      #{klass_name} = Class.new(#{parent}) do
+
+      Fields = #{fields.inspect}
+
+      # 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
+
+      ZMQMachine::ConfigClassMaker::MethodMaker.create_accessors(self, Fields)
+    end
+    KLASS
+
+    mod.module_eval(klass)
+  end
+end
+end
+
+module ZMQMachine
+
+  ZMQMachine::ConfigClassMaker.create_class('Configuration', %w( name poll_interval context log_endpoint exception_handler ), Object, ZMQMachine)
+end # ZMQMachine
+
+
+
+# TEST
+if $0 == __FILE__
+ZMQMachine::ConfigClassMaker.create_class('Configuration', %w( name context log_endpoint exception_handler ), Object, ZMQMachine)
+
+p (ZMQMachine::Configuration.methods - Object.methods).sort
+puts "\n\n"
+p (ZMQMachine::Configuration.new.methods - Object.new.methods).sort
+
+module ZMQMachine
+  module Server
+    ZMQMachine::ConfigClassMaker.create_class('Configuration', %w( bind connect endpoint ), ZMQMachine::Configuration, ZMQMachine::Server)
+  end
+end
+
+puts "\n\n"
+p (ZMQMachine::Server::Configuration.new.methods - Object.new.methods).sort
+end

data/lib/zm/device.rb

@@ -0,0 +1,4 @@
+
+%w( configuration forwarder queue ).each do |rb_file|
+  require File.join(File.dirname(__FILE__), 'device', rb_file)
+end

data/lib/zm/device/configuration.rb

@@ -0,0 +1,24 @@
+
+module ZMQMachine
+  module Device
+    ZMQMachine::ConfigClassMaker.create_class('Configuration', 
+    %w( reactor incoming_endpoint outgoing_endpoint topic hwm linger verbose ), 
+    ZMQMachine::Configuration, 
+    ZMQMachine::Device)
+    
+    class Configuration
+      
+      def initialize(&blk)
+        instance_eval(&blk) if block_given?
+
+        # set defaults
+        self.verbose ||= false
+        self.hwm ||= 1
+        self.linger ||= 0
+        self.topic ||= ''
+      end
+
+    end
+  end
+end
+

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

@@ -35,10 +35,8 @@
 #
 
 module ZMQMachine
-
   module Device
 
-
     # Used in conjunction with PUB/SUB sockets to allow multiple publishers to
     # all publish to the same "bus."
     #
@@ -51,108 +49,112 @@ module ZMQMachine
     #
     #  # the queue creates sockets and binds to both given addresses; all messages get
     #  # republished from +incoming+ to +outgoing+
-    #  forwarder = ZM::Device::Forwarder.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
+    #  config.topic = '' # get everything
+    #  forwarder = ZM::Device::Forwarder.new(config)
     #
     #  # the +pub_handler+ internally calls "connect" to the incoming address given above
-    #  pub1 = reactor.pub_socket pub_handler
-    #  pub2 = reactor.pub_socket pub_handler
+    #  pub1 = reactor.pub_socket(pub_handler)
+    #  pub2 = reactor.pub_socket(pub_handler)
     #
     #  # the +sub_handler+ internally calls "connect" to the outgoing address given above
-    #  subscriber = reactor.sub_socket sub_handler
+    #  subscriber = reactor.sub_socket(sub_handler)
     #
     class Forwarder
 
       class Handler
         attr_accessor :socket_out
 
-        def initialize reactor, address, opts = {}
-          @reactor = reactor
+        def initialize(config, address)
+          @reactor = config.reactor
           @address = address
-          @verbose = opts[:verbose] || false
-          @opts = opts
+          @verbose = config.verbose
+          @config = config
 
           @messages = []
         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!
+
           error_check(socket.subscribe_all) if :sub == socket.kind
         end
 
-        def on_writable socket
-          @reactor.deregister_writable socket
+        def on_writable(socket)
+          @reactor.deregister_writable(socket)
         end
 
-        def on_readable socket, messages
+        def on_readable(socket, messages)
           messages.each { |msg| @reactor.log(:device, "[fwd] [#{msg.copy_out_string}]") } if @verbose
 
           if @socket_out
-            rc = socket_out.send_messages messages
+            rc = socket_out.send_messages(messages)
             error_check(rc)
             messages.each { |message| message.close }
           end
         end
 
-        def on_readable_error socket, return_code
-          STDERR.puts "#{self.class}#on_readable_error, rc [#{return_code}], errno [#{ZMQ::Util.errno}], descr [#{ZMQ::Util.error_string}]"
+        def on_readable_error(socket, return_code)
+          @reactor.log(:error, "#{self.class}#on_readable_error, rc [#{return_code}], errno [#{ZMQ::Util.errno}], descr [#{ZMQ::Util.error_string}]")
         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
 
 
-      # Takes either a properly formatted string that can be converted into a ZM::Address
-      # or takes a ZM::Address directly.
-      #
       # Forwards all messages received by the +incoming+ address to the +outgoing+ address.
       #
-      def initialize reactor, incoming, outgoing, opts = {:verbose => false}
-        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, opts
-        @handler_out = Handler.new reactor, outgoing, opts
+        @handler_in = Handler.new(config, incoming)
+        @handler_out = Handler.new(config, outgoing)
 
         # create each socket and pass in the appropriate handler
-        @incoming = reactor.sub_socket @handler_in
-        @outgoing = reactor.pub_socket @handler_out
+        @incoming_sock = @reactor.sub_socket(@handler_in)
+        @outgoing_sock = @reactor.pub_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 Forwarder
 
   end # module Device
-
 end # module ZMQMachine