cztop 1.0.0 → 1.1.0.pre1

data/lib/cztop/poller/zpoller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # This is the trivial poller based on zpoller. It only supports polling
   # for readability, but it also supports doing that on CLIENT/SERVER sockets,
@@ -5,6 +7,7 @@ module CZTop
   #
   # @see http://api.zeromq.org/czmq3-0:zpoller
   class Poller::ZPoller
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
     include ::CZMQ::FFI
@@ -14,24 +17,26 @@ module CZTop
     # @param readers [Socket, Actor] any additional sockets to poll for input
     def initialize(reader, *readers)
       @sockets = {} # to keep references and return same instances
-      ptr = Zpoller.new(reader,
-                        *readers.flat_map {|r| [ :pointer, r ] },
-                        :pointer, nil)
+      ptr      = Zpoller.new(reader,
+                             *readers.flat_map { |r| [:pointer, r] },
+                             :pointer, nil)
       attach_ffi_delegate(ptr)
       remember_socket(reader)
       readers.each { |r| remember_socket(r) }
     end
 
+
     # Adds another reader socket to the poller.
     # @param reader [Socket, Actor] socket to poll for input
     # @return [void]
     # @raise [SystemCallError] if this fails
     def add(reader)
       rc = ffi_delegate.add(reader)
-      raise_zmq_err("unable to add socket %p" % reader) if rc == -1
+      raise_zmq_err(format('unable to add socket %p', reader)) if rc == -1
       remember_socket(reader)
     end
 
+
     # Removes a reader socket from the poller.
     # @param reader [Socket, Actor] socket to remove
     # @return [void]
@@ -40,10 +45,11 @@ module CZTop
     # @raise [SystemCallError] if this fails for another reason
     def remove(reader)
       rc = ffi_delegate.remove(reader)
-      raise_zmq_err("unable to remove socket %p" % reader) if rc == -1
+      raise_zmq_err(format('unable to remove socket %p', reader)) if rc == -1
       forget_socket(reader)
     end
 
+
     # Waits and returns the first socket that becomes readable.
     # @param timeout [Integer] how long to wait in ms, or 0 to avoid
     #   blocking, or -1 to wait indefinitely
@@ -54,11 +60,13 @@ module CZTop
       ptr = ffi_delegate.wait(timeout)
       if ptr.null?
         raise Interrupt if ffi_delegate.terminated
+
         return nil
       end
-      return socket_by_ptr(ptr)
+      socket_by_ptr(ptr)
     end
 
+
     # Tells the zpoller to ignore interrupts. By default, {#wait} will return
     # immediately if it detects an interrupt (when +zsys_interrupted+ is set
     # to something other than zero). Calling this method will supress this
@@ -68,6 +76,7 @@ module CZTop
       ffi_delegate.ignore_interrupts
     end
 
+
     # By default the poller stops if the process receives a SIGINT or SIGTERM
     # signal. This makes it impossible to shut-down message based architectures
     # like zactors. This method lets you switch off break handling. The default
@@ -91,6 +100,7 @@ module CZTop
       @sockets[socket.to_ptr.to_i] = socket
     end
 
+
     # Forgets the socket because it has been removed from the poller.
     # @param socket [Socket, Actor] the socket instance to forget
     # @return [void]
@@ -98,6 +108,7 @@ module CZTop
       @sockets.delete(socket.to_ptr.to_i)
     end
 
+
     # Gets the previously remembered socket associated to the given pointer.
     # @param ptr [FFI::Pointer] the pointer to a socket
     # @return [Socket, Actor] the socket associated to the given pointer
@@ -109,5 +120,6 @@ module CZTop
         # it ever returns a wrong pointer.
         raise_zmq_err("no socket known for pointer #{ptr.inspect}")
     end
+
   end
 end

data/lib/cztop/poller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # A non-trivial socket poller.
   #
@@ -9,23 +11,25 @@ module CZTop
   # * +zpoller+ can only poll for readability
   #
   class Poller
+
     include ::CZMQ::FFI
 
     # @param readers [Socket, Actor] sockets to poll for input
     def initialize(*readers)
-      @sockets = {} # needed to return the same socket objects
-      @events = {} # event masks for each socket
+      @sockets    = {} # needed to return the same socket objects
+      @events     = {} # event masks for each socket
       @poller_ptr = ZMQ.poller_new
       ObjectSpace.define_finalizer(@poller_ptr,
-        Proc.new do
-          ptr_ptr = ::FFI::MemoryPointer.new :pointer
-          ptr_ptr.write_pointer(@poller_ptr)
-          ZMQ.poller_destroy(ptr_ptr)
-        end)
+                                   proc do
+                                     ptr_ptr = ::FFI::MemoryPointer.new :pointer
+                                     ptr_ptr.write_pointer(@poller_ptr)
+                                     ZMQ.poller_destroy(ptr_ptr)
+                                   end)
       @event_ptr = FFI::MemoryPointer.new(ZMQ::PollerEvent)
       readers.each { |r| add_reader(r) }
     end
 
+
     # Adds a socket to be polled for readability.
     # @param socket [Socket, Actor] the socket
     # @param events [Integer] bitwise-OR'd events you're interested in (see
@@ -34,11 +38,12 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def add(socket, events)
       ptr = ptr_for_socket(socket)
-      rc = ZMQ.poller_add(@poller_ptr, ptr, nil, events)
+      rc  = ZMQ.poller_add(@poller_ptr, ptr, nil, events)
       HasFFIDelegate.raise_zmq_err if rc == -1
       remember_socket(socket, events)
     end
 
+
     # Convenience method to register a socket for readability. See {#add}.
     # @param socket [Socket, Actor] the socket
     # @return [void]
@@ -46,6 +51,7 @@ module CZTop
       add(socket, ZMQ::POLLIN)
     end
 
+
     # Convenience method to register a socket for writability. See {#add}.
     # @param socket [Socket, Actor] the socket
     # @return [void]
@@ -53,6 +59,7 @@ module CZTop
       add(socket, ZMQ::POLLOUT)
     end
 
+
     # Modifies the events of interest for the given socket.
     # @param socket [Socket, Actor] the socket
     # @param events [Integer] events you're interested in (see constants in
@@ -61,11 +68,12 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def modify(socket, events)
       ptr = ptr_for_socket(socket)
-      rc = ZMQ.poller_modify(@poller_ptr, ptr, events)
+      rc  = ZMQ.poller_modify(@poller_ptr, ptr, events)
       HasFFIDelegate.raise_zmq_err if rc == -1
       remember_socket(socket, events)
     end
 
+
     # Removes a previously registered socket. Won't raise if you're
     # trying to remove a socket that's not registered.
     # @param socket [Socket, Actor] the socket
@@ -73,11 +81,12 @@ module CZTop
     # @raise [ArgumentError] if it's not a socket
     def remove(socket)
       ptr = ptr_for_socket(socket)
-      rc = ZMQ.poller_remove(@poller_ptr, ptr)
+      rc  = ZMQ.poller_remove(@poller_ptr, ptr)
       HasFFIDelegate.raise_zmq_err if rc == -1
       forget_socket(socket)
     end
 
+
     # Removes a reader socket that was registered for readability only.
     #
     # @param socket [Socket, Actor] the socket
@@ -88,9 +97,10 @@ module CZTop
         remove(socket)
         return
       end
-      raise ArgumentError, "not registered for readability only: %p" % socket
+      raise ArgumentError, format('not registered for readability only: %p', socket)
     end
 
+
     # Removes a reader socket that was registered for writability only.
     #
     # @param socket [Socket, Actor] the socket
@@ -101,9 +111,10 @@ module CZTop
         remove(socket)
         return
       end
-      raise ArgumentError, "not registered for writability only: %p" % socket
+      raise ArgumentError, format('not registered for writability only: %p', socket)
     end
 
+
     # Waits for registered sockets to become readable or writable, depending
     # on what you're interested in.
     #
@@ -116,7 +127,7 @@ module CZTop
       rc = ZMQ.poller_wait(@poller_ptr, @event_ptr, timeout)
       if rc == -1
         case CZMQ::FFI::Errors.errno
-        # NOTE: ETIMEDOUT for backwards compatibility, although this API is
+          # NOTE: ETIMEDOUT for backwards compatibility, although this API is
           # still DRAFT.
         when Errno::EAGAIN::Errno, Errno::ETIMEDOUT::Errno
           return nil
@@ -124,9 +135,10 @@ module CZTop
           HasFFIDelegate.raise_zmq_err
         end
       end
-      return Event.new(self, @event_ptr)
+      Event.new(self, @event_ptr)
     end
 
+
     # Simpler version of {#wait}, which just returns the first socket of
     # interest, if any. This is useful if you either have only reader sockets,
     # or only have writer sockets.
@@ -140,27 +152,30 @@ module CZTop
       return event.socket if event
     end
 
+
     # @param ptr [FFI::Pointer] pointer to the socket
     # @return [Socket, Actor] socket corresponding to given pointer
     # @raise [ArgumentError] if pointer is not known
     def socket_for_ptr(ptr)
       @sockets[ptr.to_i] or
-        raise ArgumentError, "no socket known for pointer %p" % ptr
+        raise ArgumentError, format('no socket known for pointer %p', ptr)
     end
 
+
     # @return [Array<CZTop::Socket>] all sockets registered with this poller
     # @note The actual events registered for each sockets don't matter.
     def sockets
       @sockets.values
     end
 
+
     # Returns the event mask for the given, registered socket.
     # @param socket [Socket, Actor] which socket's events to return
     # @return [Integer] event mask for the given socket
     # @raise [ArgumentError] if socket is not registered
     def event_mask_for_socket(socket)
       @events[socket] or
-        raise ArgumentError, "no event mask known for socket %p" % socket
+        raise ArgumentError, format('no event mask known for socket %p', socket)
     end
 
     private
@@ -170,17 +185,20 @@ module CZTop
     # @raise [ArgumentError] if argument is not a socket
     def ptr_for_socket(socket)
       raise ArgumentError unless socket.is_a?(Socket) || socket.is_a?(Actor)
+
       Zsock.resolve(socket)
     end
 
+
     # Keeps a reference to the given socket, and remembers its event mask.
     # @param socket [Socket, Actor] the socket
     # @param events [Integer] the event mask
     def remember_socket(socket, events)
       @sockets[ptr_for_socket(socket).to_i] = socket
-      @events[socket] = events
+      @events[socket]                       = events
     end
 
+
     # Discards the referencel to the given socket, and forgets its event mask.
     # @param socket [Socket, Actor] the socket
     def forget_socket(socket)
@@ -188,33 +206,40 @@ module CZTop
       @events.delete(socket)
     end
 
+
     # Represents an event returned by {CZTop::Poller#wait}. This is useful to
     # find out whether the associated socket is now readable or writable, in
     # case you're interested in both. For a simpler variant, check out
     # {CZTop::Poller#simple_wait}.
     class Event
+
       # @param poller [CZTop::Poller] the poller instance
       # @param event_ptr [FFI::Pointer] pointer to the memory allocated for
       #   the event's data (a +zmq_poller_event_t+)
       def initialize(poller, event_ptr)
-        @poller = poller
+        @poller       = poller
         @poller_event = ZMQ::PollerEvent.new(event_ptr)
       end
 
+
       # @return [Socket, Actor] the associated socket
       def socket
         @socket ||= @poller.socket_for_ptr(@poller_event[:socket])
       end
 
+
       # @return [Boolean] whether it's readable
       def readable?
         @poller_event.readable?
       end
 
+
       # @return [Boolean] whether it's writable
       def writable?
         @poller_event.writable?
       end
+
     end
+
   end
 end

data/lib/cztop/polymorphic_zsock_methods.rb

@@ -1,24 +1,29 @@
-module CZTop
+# frozen_string_literal: true
 
+module CZTop
   # These are methods that can be used on a {Socket} as well as an {Actor}.
   # @see http://api.zeromq.org/czmq3-0:zsock
   module PolymorphicZsockMethods
+
     # Sends a signal.
     # @param status [Integer] signal (0-255)
     def signal(status = 0)
       ::CZMQ::FFI::Zsock.signal(ffi_delegate, status)
     end
 
+
     # Waits for a signal.
     # @return [Integer] the received signal
     def wait
       ::CZMQ::FFI::Zsock.wait(ffi_delegate)
     end
 
+
     # Set socket to use unbounded pipes (HWM=0); use this in cases when you are
     # totally certain the message volume can fit in memory.
     def set_unbounded
       ::CZMQ::FFI::Zsock.set_unbounded(ffi_delegate)
     end
+
   end
 end

data/lib/cztop/proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # Steerable proxy which switches messages between a frontend and a backend
   # socket.
@@ -6,11 +8,12 @@ module CZTop
   #
   # @see http://api.zeromq.org/czmq3-0:zproxy
   class Proxy
+
     include ::CZMQ::FFI
 
     # function pointer to the +zmonitor()+ function
     ZPROXY_FPTR = ::CZMQ::FFI.ffi_libraries.each do |dl|
-      fptr = dl.find_function("zproxy")
+      fptr = dl.find_function('zproxy')
       break fptr if fptr
     end
     raise LoadError, "couldn't find zproxy()" if ZPROXY_FPTR.nil?
@@ -28,13 +31,15 @@ module CZTop
       @actor.terminate
     end
 
+
     # Enable verbose logging of commands and activity.
     # @return [void]
     def verbose!
-      @actor << "VERBOSE"
+      @actor << 'VERBOSE'
       @actor.wait
     end
 
+
     # Returns a configurator object which you can use to configure the
     # frontend socket.
     # @return [Configurator] (memoized) frontend configurator
@@ -42,6 +47,7 @@ module CZTop
       @frontend ||= Configurator.new(self, :frontend)
     end
 
+
     # Returns a configurator object which you can use to configure the backend
     # socket.
     # @return [Configurator] (memoized) backend configurator
@@ -49,54 +55,59 @@ module CZTop
       @backend ||= Configurator.new(self, :backend)
     end
 
+
     # Captures all proxied messages and delivers them to a PULL socket bound
     # to the specified endpoint.
     # @note The PULL socket has to be bound before calling this method.
     # @param endpoint [String] the endpoint to which the PULL socket is bound to
     # @return [void]
     def capture(endpoint)
-      @actor << ["CAPTURE", endpoint]
+      @actor << ['CAPTURE', endpoint]
       @actor.wait
     end
 
+
     # Pauses proxying of any messages.
     # @note This causes any messages to be queued up and potentialy hit the
     #   high-water mark on the frontend or backend socket, causing messages to
     #   be dropped or writing applications to block.
     # @return [void]
     def pause
-      @actor << "PAUSE"
+      @actor << 'PAUSE'
       @actor.wait
     end
 
+
     # Resume proxying of messages.
     # @note This is only needed after a call to {#pause}, not to start the
     #   proxy. Proxying starts as soon as the frontend and backend sockets are
     #   properly attached.
     # @return [void]
     def resume
-      @actor << "RESUME"
+      @actor << 'RESUME'
       @actor.wait
     end
 
+
     # Used to configure the socket on one side of a {Proxy}.
     class Configurator
+
       # @return [Array<Symbol>] supported socket types
       SOCKET_TYPES = %i[
         PAIR PUB SUB REQ REP
         DEALER ROUTER PULL PUSH
         XPUB XSUB
-      ]
+      ].freeze
 
       # @param proxy [Proxy] the proxy instance
       # @param side [Symbol] :frontend or :backend
       def initialize(proxy, side)
         @proxy = proxy
-        @side = case side
-                when :frontend then "FRONTEND"
-                when :backend then "BACKEND"
-                else raise ArgumentError, "invalid side: #{side.inspect}"
-                end
+        @side  = case side
+                 when :frontend then 'FRONTEND'
+                 when :backend then 'BACKEND'
+                 else raise ArgumentError, "invalid side: #{side.inspect}"
+                 end
       end
 
       # @return [Proxy] the proxy this {Configurator} works on
@@ -111,27 +122,29 @@ module CZTop
       # @raise [ArgumentError] if the given socket type is invalid
       # @return [void]
       def bind(socket_type, endpoint)
-        unless SOCKET_TYPES.include?(socket_type)
-          raise ArgumentError, "invalid socket type: #{socket_type}"
-        end
-        @proxy.actor << [ @side, socket_type.to_s, endpoint ]
+        raise ArgumentError, "invalid socket type: #{socket_type}" unless SOCKET_TYPES.include?(socket_type)
+
+        @proxy.actor << [@side, socket_type.to_s, endpoint]
         @proxy.actor.wait
       end
 
+
       # Set ZAP domain for authentication.
       # @param domain [String] the ZAP domain
       def domain=(domain)
-        @proxy.actor << [ "DOMAIN", @side, domain ]
+        @proxy.actor << ['DOMAIN', @side, domain]
         @proxy.actor.wait
       end
 
+
       # Configure PLAIN authentication on this socket.
       # @note You'll have to use a {CZTop::Authenticator}.
       def PLAIN_server!
-        @proxy.actor << [ "PLAIN", @side ]
+        @proxy.actor << ['PLAIN', @side]
         @proxy.actor.wait
       end
 
+
       # Configure CURVE authentication on this socket.
       # @note You'll have to use a {CZTop::Authenticator}.
       # @param cert [Certificate] this server's certificate,
@@ -139,11 +152,13 @@ module CZTop
       def CURVE_server!(cert)
         public_key = cert.public_key
         secret_key = cert.secret_key or
-          raise ArgumentError, "no secret key in certificate"
+          raise ArgumentError, 'no secret key in certificate'
 
-        @proxy.actor << [ "CURVE", @side, public_key, secret_key ]
+        @proxy.actor << ['CURVE', @side, public_key, secret_key]
         @proxy.actor.wait
       end
+
     end
+
   end
 end

data/lib/cztop/send_receive_methods.rb

@@ -1,10 +1,12 @@
-module CZTop
+# frozen_string_literal: true
 
+module CZTop
   # These are methods that can be used on a {Socket} as well as an {Actor},
   # but actually just pass through to methods of {Message} (which take
   # a polymorphic reference, in Ruby as well as in C).
   # @see http://api.zeromq.org/czmq3-0:zmsg
   module SendReceiveMethods
+
     # Sends a message.
     #
     # @param message [Message, String, Array<parts>] the message to send
@@ -20,6 +22,7 @@ module CZTop
       self
     end
 
+
     # Receives a message.
     #
     # @return [Message]
@@ -31,5 +34,6 @@ module CZTop
     def receive
       Message.receive_from(self)
     end
+
   end
 end