cztop 0.14.1 → 1.1.0.pre1

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

data/lib/cztop/socket/types.rb

@@ -1,29 +1,37 @@
+# frozen_string_literal: true
+
 module CZTop
   class Socket
+
     #  Socket types. Each constant in this namespace holds the type code used
     #  for the zsock_new() function.
     module Types
-      PAIR = 0
-      PUB = 1
-      SUB = 2
-      REQ = 3
-      REP = 4
+
+      PAIR   = 0
+      PUB    = 1
+      SUB    = 2
+      REQ    = 3
+      REP    = 4
       DEALER = 5
       ROUTER = 6
-      PULL = 7
-      PUSH = 8
-      XPUB = 9
-      XSUB = 10
+      PULL   = 7
+      PUSH   = 8
+      XPUB   = 9
+      XSUB   = 10
       STREAM = 11
       SERVER = 12
       CLIENT = 13
+
     end
 
+
     # All the available type codes, mapped to their Symbol equivalent.
     # @return [Hash<Integer, Symbol>]
-    TypeNames = Hash[
-      Types.constants.map { |name| i = Types.const_get(name); [ i, name ] }
-    ].freeze
+    TypeNames = Types.constants.to_h do |name|
+      i = Types.const_get(name)
+      [i, name]
+    end.freeze
+
 
     # @param type [Symbol, Integer] type from {Types} or like +:PUB+
     # @return [REQ, REP, PUSH, PULL, ... ] the new socket
@@ -33,75 +41,108 @@ module CZTop
     def self.new_by_type(type)
       case type
       when Integer
-        type_code = type
-        type_name = TypeNames[type_code] or
-          raise ArgumentError, "invalid type %p" % type
+        type_code  = type
+        type_name  = TypeNames[type_code] or
+          raise ArgumentError, format('invalid type %p', type)
         type_class = Socket.const_get(type_name)
       when Symbol
-        type_code = Types.const_get(type)
+        type_code  = Types.const_get(type)
         type_class = Socket.const_get(type)
       else
-        raise ArgumentError, "invalid socket type: %p" % type
+        raise ArgumentError, format('invalid socket type: %p', type)
       end
       ffi_delegate = Zsock.new(type_code)
-      sock = type_class.allocate
+      sock         = type_class.allocate
       sock.attach_ffi_delegate(ffi_delegate)
       sock
     end
 
+
+    def initialize(endpoints = nil); end
+
+
     # Client socket for the ZeroMQ Client-Server Pattern.
     # @see http://rfc.zeromq.org/spec:41
     class CLIENT < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_client(endpoints))
       end
+
     end
 
+
     # Server socket for the ZeroMQ Client-Server Pattern.
     # @see http://rfc.zeromq.org/spec:41
     class SERVER < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_server(endpoints))
       end
+
     end
 
+
     # Request socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class REQ < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_req(endpoints))
       end
+
     end
 
+
     # Reply socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class REP < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_rep(endpoints))
       end
+
     end
 
+
     # Dealer socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class DEALER < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_dealer(endpoints))
       end
+
     end
 
+
     # Router socket for the ZeroMQ Request-Reply Pattern.
     # @see http://rfc.zeromq.org/spec:28
     class ROUTER < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_router(endpoints))
       end
 
+
       # Send a message to a specific receiver. This is a shorthand for when
       # you send a message to a specific receiver with no hops in between.
       # @param receiver [String] receiving peer's socket identity
@@ -110,32 +151,42 @@ module CZTop
       #   destroyed.
       def send_to(receiver, message)
         message = Message.coerce(message)
-        message.prepend ""       # separator frame
+        message.prepend ''       # separator frame
         message.prepend receiver # receiver envelope
         self << message
       end
+
     end
 
+
     # Publish socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class PUB < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_pub(endpoints))
       end
+
     end
 
+
     # Subscribe socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class SUB < Socket
+
       # @param endpoints [String] endpoints to connect to
       # @param subscription [String] what to subscribe to
       def initialize(endpoints = nil, subscription = nil)
+        super(endpoints)
+
         attach_ffi_delegate(Zsock.new_sub(endpoints, subscription))
       end
 
       # @return [String] subscription prefix to subscribe to everything
-      EVERYTHING = ""
+      EVERYTHING = ''
 
       # Subscribes to the given prefix string.
       # @param prefix [String] prefix string to subscribe to
@@ -144,86 +195,128 @@ module CZTop
         ffi_delegate.set_subscribe(prefix)
       end
 
+
       # Unsubscribes from the given prefix.
       # @param prefix [String] prefix string to unsubscribe from
       # @return [void]
       def unsubscribe(prefix)
         ffi_delegate.set_unsubscribe(prefix)
       end
+
     end
 
+
     # Extended publish socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class XPUB < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_xpub(endpoints))
       end
+
     end
 
+
     # Extended subscribe socket for the ZeroMQ Publish-Subscribe Pattern.
     # @see http://rfc.zeromq.org/spec:29
     class XSUB < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_xsub(endpoints))
       end
+
     end
 
+
     # Push socket for the ZeroMQ Pipeline Pattern.
     # @see http://rfc.zeromq.org/spec:30
     class PUSH < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_push(endpoints))
       end
+
     end
 
+
     # Pull socket for the ZeroMQ Pipeline Pattern.
     # @see http://rfc.zeromq.org/spec:30
     class PULL < Socket
+
       # @param endpoints [String] endpoints to bind to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_pull(endpoints))
       end
+
     end
 
+
     # Pair socket for inter-thread communication.
     # @see http://rfc.zeromq.org/spec:31
     class PAIR < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_pair(endpoints))
       end
+
     end
 
+
     # Stream socket for the native pattern. This is useful when
     # communicating with a non-ZMQ peer over TCP.
     # @see http://api.zeromq.org/4-2:zmq-socket#toc16
     class STREAM < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_stream(endpoints))
       end
+
     end
 
+
     # Group-based pub/sub (vs topic-based). This is the publisher socket.
     # @see https://github.com/zeromq/libzmq/pull/1727
     class RADIO < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_radio(endpoints))
       end
+
     end
 
+
     # Group-based pub/sub (vs topic-based). This is the subscriber socket.
     # @see https://github.com/zeromq/libzmq/pull/1727
     class DISH < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_dish(endpoints))
       end
 
+
       # Joins the given group.
       # @param group [String] group to join, up to 15 characters
       # @return [void]
@@ -232,9 +325,10 @@ module CZTop
       # @raise [SystemCallError] in case of failure
       def join(group)
         rc = ffi_delegate.join(group)
-        raise_zmq_err("unable to join group %p" % group) if rc == -1
+        raise_zmq_err(format('unable to join group %p', group)) if rc == -1
       end
 
+
       # Leaves the given group.
       # @param group [String] group to leave
       # @return [void]
@@ -242,26 +336,38 @@ module CZTop
       # @raise [SystemCallError] in case of another failure
       def leave(group)
         rc = ffi_delegate.leave(group)
-        raise_zmq_err("unable to leave group %p" % group) if rc == -1
+        raise_zmq_err(format('unable to leave group %p', group)) if rc == -1
       end
+
     end
 
+
     # Scatter/gather pattern.
     # @see https://github.com/zeromq/libzmq/pull/1909
     class SCATTER < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_scatter(endpoints))
       end
+
     end
 
+
     # Scatter/gather pattern.
     # @see https://github.com/zeromq/libzmq/pull/1909
     class GATHER < Socket
+
       # @param endpoints [String] endpoints to connect to
       def initialize(endpoints = nil)
+        super
+
         attach_ffi_delegate(Zsock.new_gather(endpoints))
       end
+
     end
+
   end
 end

data/lib/cztop/socket.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module CZTop
   # Represents a CZMQ::FFI::Zsock.
   class Socket
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
     include ZsockOptions
@@ -21,6 +24,7 @@ module CZTop
       cert.apply(self) # NOTE: desired: raises if no secret key in cert
     end
 
+
     # Enables CURVE security and makes this socket a CURVE client.
     # @param client_cert [Certificate] client's certificate, to secure
     #   communication (and be authenticated by the server)
@@ -31,9 +35,7 @@ module CZTop
     #   which means it's not secret anymore
     # @raise [SystemCallError] if there's no secret key in client_cert
     def CURVE_client!(client_cert, server_cert)
-      if server_cert.secret_key
-        raise SecurityError, "server's secret key not secret"
-      end
+      raise SecurityError, "server's secret key not secret" if server_cert.secret_key
 
       client_cert.apply(self) # NOTE: desired: raises if no secret key in cert
       options.CURVE_serverkey = server_cert.public_key
@@ -41,30 +43,34 @@ module CZTop
 
     # @!endgroup
 
+
     # @return [String] last bound endpoint, if any
     # @return [nil] if not bound
     def last_endpoint
       ffi_delegate.endpoint
     end
 
+
     # Connects to an endpoint.
     # @param endpoint [String]
     # @return [void]
     # @raise [ArgumentError] if the endpoint is incorrect
     def connect(endpoint)
-      rc = ffi_delegate.connect("%s", :string, endpoint)
-      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+      rc = ffi_delegate.connect('%s', :string, endpoint)
+      raise ArgumentError, format('incorrect endpoint: %p', endpoint) if rc == -1
     end
 
+
     # Disconnects from an endpoint.
     # @param endpoint [String]
     # @return [void]
     # @raise [ArgumentError] if the endpoint is incorrect
     def disconnect(endpoint)
-      rc = ffi_delegate.disconnect("%s", :string, endpoint)
-      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+      rc = ffi_delegate.disconnect('%s', :string, endpoint)
+      raise ArgumentError, format('incorrect endpoint: %p', endpoint) if rc == -1
     end
 
+
     # Closes and destroys the native socket.
     # @return [void]
     # @note Don't try to use it anymore afterwards.
@@ -83,30 +89,29 @@ module CZTop
     # @return [void]
     # @raise [SystemCallError] in case of failure
     def bind(endpoint)
-      rc = ffi_delegate.bind("%s", :string, endpoint)
-      raise_zmq_err("unable to bind to %p" % endpoint) if rc == -1
-      @last_tcp_port = rc if rc > 0
+      rc = ffi_delegate.bind('%s', :string, endpoint)
+      raise_zmq_err(format('unable to bind to %p', endpoint)) if rc == -1
+      @last_tcp_port = rc if rc.positive?
     end
 
+
     # Unbinds from an endpoint.
     # @param endpoint [String]
     # @return [void]
     # @raise [ArgumentError] if the endpoint is incorrect
     def unbind(endpoint)
-      rc = ffi_delegate.unbind("%s", :string, endpoint)
-      raise ArgumentError, "incorrect endpoint: %p" % endpoint if rc == -1
+      rc = ffi_delegate.unbind('%s', :string, endpoint)
+      raise ArgumentError, format('incorrect endpoint: %p', endpoint) if rc == -1
     end
 
+
     # Inspects this {Socket}.
     # @return [String] shows class, native address, and {#last_endpoint}
     def inspect
-      "#<%s:0x%x last_endpoint=%p>" % [
-        self.class,
-        to_ptr.address,
-        last_endpoint
-      ]
+      format('#<%s:0x%x last_endpoint=%p>', self.class, to_ptr.address, last_endpoint)
     rescue Zsock::DestroyedError
-      "#<%s: invalid>" % self.class
+      format('#<%s: invalid>', self.class)
     end
+
   end
 end

data/lib/cztop/version.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
 module CZTop
-  VERSION = "0.14.1"
+
+  VERSION = '1.1.0.pre1'
+
 end