cztop 1.0.0 → 1.1.0.pre1

data/lib/cztop/authenticator.rb

@@ -1,16 +1,18 @@
-module CZTop
+# frozen_string_literal: true
 
+module CZTop
   # Authentication for ZeroMQ security mechanisms.
   #
   # This is implemented using an {Actor}.
   #
   # @see http://api.zeromq.org/czmq3-0:zauth
   class Authenticator
+
     include ::CZMQ::FFI
 
     # function pointer to the +zauth()+ function
     ZAUTH_FPTR = ::CZMQ::FFI.ffi_libraries.each do |dl|
-      fptr = dl.find_function("zauth")
+      fptr = dl.find_function('zauth')
       break fptr if fptr
     end
     raise LoadError, "couldn't find zauth()" if ZAUTH_FPTR.nil?
@@ -23,6 +25,7 @@ module CZTop
     def initialize(cert_store = nil)
       if cert_store
         raise ArgumentError unless cert_store.is_a?(CertStore)
+
         cert_store = cert_store.ffi_delegate
         cert_store.__undef_finalizer # native object is now owned by zauth() actor
       end
@@ -38,13 +41,15 @@ module CZTop
       @actor.terminate
     end
 
+
     # Enable verbose logging of commands and activity.
     # @return [void]
     def verbose!
-      @actor << "VERBOSE"
+      @actor << 'VERBOSE'
       @actor.wait
     end
 
+
     # Add a list of IP addresses to the whitelist. For _NULL_, all clients
     # from these addresses will be accepted. For _PLAIN_ and _CURVE_, they
     # will be allowed to continue with authentication.
@@ -52,10 +57,11 @@ module CZTop
     # @param addrs [String] IP address(es) to allow
     # @return [void]
     def allow(*addrs)
-      @actor << ["ALLOW", *addrs]
+      @actor << ['ALLOW', *addrs]
       @actor.wait
     end
 
+
     # Add a list of IP addresses to the blacklist. For all security
     # mechanisms, this rejects the connection without any further
     # authentication. Use either a whitelist, or a blacklist, not not both. If
@@ -65,22 +71,23 @@ module CZTop
     # @param addrs [String] IP address(es) to deny
     # @return [void]
     def deny(*addrs)
-      @actor << ["DENY", *addrs]
+      @actor << ['DENY', *addrs]
       @actor.wait
     end
 
+
     # Configure PLAIN security mechanism using a plain-text password file. The
     # password file will be reloaded automatically if modified externally.
     #
     # @param filename [String] path to the password file
     # @return [void]
     def plain(filename)
-      @actor << ["PLAIN", *filename]
+      @actor << ['PLAIN', *filename]
       @actor.wait
     end
 
     # used to allow any CURVE client
-    ALLOW_ANY = "*"
+    ALLOW_ANY = '*'
 
     # Configure CURVE authentication, using a directory that holds all public
     # client certificates, i.e. their public keys. The certificates must have been
@@ -90,15 +97,17 @@ module CZTop
     # @param directory [String] the directory to take the keys from
     # @return [void]
     def curve(directory = ALLOW_ANY)
-      @actor << ["CURVE", directory]
+      @actor << ['CURVE', directory]
       @actor.wait
     end
 
+
     # Configure GSSAPI authentication.
     # @return [void]
     def gssapi
-      @actor << "GSSAPI"
+      @actor << 'GSSAPI'
       @actor.wait
     end
+
   end
 end

data/lib/cztop/beacon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   # Used for LAN discovery and presence.
   #
@@ -5,11 +7,12 @@ module CZTop
   #
   # @see http://api.zeromq.org/czmq3-0:zbeacon
   class Beacon
+
     include ::CZMQ::FFI
 
     # function pointer to the +zbeacon()+ function
     ZBEACON_FPTR = ::CZMQ::FFI.ffi_libraries.each do |dl|
-      fptr = dl.find_function("zbeacon")
+      fptr = dl.find_function('zbeacon')
       break fptr if fptr
     end
     raise LoadError, "couldn't find zbeacon()" if ZBEACON_FPTR.nil?
@@ -28,12 +31,14 @@ module CZTop
       @actor.terminate
     end
 
+
     # Enable verbose logging of commands and activity.
     # @return [void]
     def verbose!
-      @actor << "VERBOSE"
+      @actor << 'VERBOSE'
     end
 
+
     # Run the beacon on the specified UDP port.
     #
     # @param port [Integer] port number to
@@ -43,7 +48,7 @@ module CZTop
     #   interrupted
     # @raise [NotImplementedError] if the system doesn't support UDP broadcasts
     def configure(port)
-      @actor.send_picture("si", :string, "CONFIGURE", :int, port)
+      @actor.send_picture('si', :string, 'CONFIGURE', :int, port)
       ptr = Zstr.recv(@actor)
 
       # NULL if context terminated or interrupted
@@ -64,42 +69,49 @@ module CZTop
     # @raise [ArgumentError] if data is longer than {MAX_BEACON_DATA} bytes
     # @return [void]
     def publish(data, interval)
-      raise ArgumentError, "data too long" if data.bytesize > MAX_BEACON_DATA
-      @actor.send_picture("sbi", :string, "PUBLISH", :string, data,
-                              :int, data.bytesize, :int, interval)
+      raise ArgumentError, 'data too long' if data.bytesize > MAX_BEACON_DATA
+
+      @actor.send_picture('sbi', :string, 'PUBLISH', :string, data,
+                          :int, data.bytesize, :int, interval)
     end
 
+
     # Stop broadcasting the beacon.
     # @return [void]
     def silence
-      @actor << "SILENCE"
+      @actor << 'SILENCE'
     end
 
+
     # Start listening to beacons from peers.
     # @param filter [String] do a prefix match on received beacons
     # @return [void]
     def subscribe(filter)
-      @actor.send_picture("sb", :string, "SUBSCRIBE",
+      @actor.send_picture('sb', :string, 'SUBSCRIBE',
                           :string, filter, :int, filter.bytesize)
     end
 
+
     # Just like {#subscribe}, but subscribe to all peer beacons.
     # @return [void]
     def listen
-      @actor.send_picture("sb", :string, "SUBSCRIBE",
+      @actor.send_picture('sb', :string, 'SUBSCRIBE',
                           :string, nil, :int, 0)
     end
 
+
     # Stop listening to other peers.
     # @return [void]
     def unsubscribe
-      @actor << "UNSUBSCRIBE"
+      @actor << 'UNSUBSCRIBE'
     end
 
+
     # Receive next beacon from a peer.
     # @return [Message] 2-frame message with ([ipaddr, data])
     def receive
       @actor.receive
     end
+
   end
 end

data/lib/cztop/cert_store.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module CZTop
-
   # A store for CURVE security certificates, either backed by files on disk or
   # in-memory.
   #
   # @see http://api.zeromq.org/czmq3-0:zcertstore
   class CertStore
+
     include ::CZMQ::FFI
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
@@ -21,6 +23,7 @@ module CZTop
       attach_ffi_delegate(Zcertstore.new(location))
     end
 
+
     # Looks up a certificate in the store by its public key.
     #
     # @param pubkey [String] the public key in question, in Z85 format
@@ -29,9 +32,11 @@ module CZTop
     def lookup(pubkey)
       ptr = ffi_delegate.lookup(pubkey)
       return nil if ptr.null?
+
       Certificate.from_ffi_delegate(ptr)
     end
 
+
     # Inserts a new certificate into the store.
     #
     # @note The same public key must not be inserted more than once.
@@ -43,11 +48,12 @@ module CZTop
       raise ArgumentError unless cert.is_a?(Certificate)
 
       @_inserted_pubkeys ||= Set.new
-      pubkey = cert.public_key
+      pubkey               = cert.public_key
       raise ArgumentError if @_inserted_pubkeys.include? pubkey
 
       ffi_delegate.insert(cert.ffi_delegate)
       @_inserted_pubkeys << pubkey
     end
+
   end
 end

data/lib/cztop/certificate.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module CZTop
   # Represents a CZMQ::FFI::Zcert.
   class Certificate
+
     include HasFFIDelegate
     extend CZTop::HasFFIDelegate::ClassMethods
     include ::CZMQ::FFI
@@ -9,9 +12,11 @@ module CZTop
     # @return [void]
     def self.check_curve_availability
       return if Zsys.has_curve
+
       warn "CZTop: CURVE isn't available. Consider installing libsodium."
     end
 
+
     # Loads a certificate from a file.
     # @param filename [String, Pathname, #to_s] path to certificate file
     # @return [Certificate] the loaded certificate
@@ -20,6 +25,7 @@ module CZTop
       from_ffi_delegate(ptr)
     end
 
+
     # Creates a new certificate from the given keys (either binary or in Z85
     # format).
     # @param public_key [String] binary public key (32 or 40 bytes)
@@ -29,25 +35,28 @@ module CZTop
     # @raise [ArgumentError] if keys passed are invalid
     # @raise [SystemCallError] if this fails
     def self.new_from(public_key, secret_key = nil)
-      raise ArgumentError, "no public key given" unless public_key
+      raise ArgumentError, 'no public key given' unless public_key
+
       secret_key ||= "\x00" * 32 # no secret key given, provide 32 null bytes
 
       # convert Z85 => binary
       public_key = Z85.decode(public_key) if public_key.bytesize == 40
       secret_key = Z85.decode(secret_key) if secret_key.bytesize == 40
 
-      raise ArgumentError, "invalid public key size" if public_key.bytesize != 32
-      raise ArgumentError, "invalid secret key size" if secret_key.bytesize != 32
+      raise ArgumentError, 'invalid public key size' if public_key.bytesize != 32
+      raise ArgumentError, 'invalid secret key size' if secret_key.bytesize != 32
 
       ptr = Zcert.new_from(public_key, secret_key)
       from_ffi_delegate(ptr)
     end
 
+
     # Initialize a new in-memory certificate with random keys.
     def initialize
       attach_ffi_delegate(Zcert.new)
     end
 
+
     # Returns the public key either as Z85-encoded ASCII string (default) or
     # binary string.
     # @param format [Symbol] +:z85+ for Z85, +:binary+ for binary
@@ -59,10 +68,11 @@ module CZTop
       when :binary
         ffi_delegate.public_key.read_string(32)
       else
-        raise ArgumentError, "invalid format: %p" % format
+        raise ArgumentError, format('invalid format: %p', format)
       end
     end
 
+
     # Returns the secret key either as Z85-encoded ASCII string (default) or
     # binary string.
     # @param format [Symbol] +:z85+ for Z85, +:binary+ for binary
@@ -73,16 +83,17 @@ module CZTop
       case format
       when :z85
         key = ffi_delegate.secret_txt.force_encoding(Encoding::ASCII)
-        return nil if key.count("0") == 40
+        return nil if key.count('0') == 40
       when :binary
         key = ffi_delegate.secret_key.read_string(32)
         return nil if key.count("\0") == 32
       else
-        raise ArgumentError, "invalid format: %p" % format
+        raise ArgumentError, format('invalid format: %p', format)
       end
       key
     end
 
+
     # Get metadata.
     # @param key [String] metadata key
     # @return [String] value for meta key
@@ -90,32 +101,38 @@ module CZTop
     def [](key)
       ffi_delegate.meta(key)
     end
+
+
     # Set metadata.
     # @param key [String] metadata key
     # @param value [String] metadata value
     # @return [value]
     def []=(key, value)
       if value
-        ffi_delegate.set_meta(key, "%s", :string, value)
+        ffi_delegate.set_meta(key, '%s', :string, value)
       else
         ffi_delegate.unset_meta(key)
       end
     end
 
+
     # Returns meta keys set.
     # @return [Array<String>]
     def meta_keys
-      zlist = ffi_delegate.meta_keys
+      zlist     = ffi_delegate.meta_keys
       first_key = zlist.first
       return [] if first_key.null?
+
       keys = [first_key.read_string]
-      while key = zlist.next
+      while (key = zlist.next)
         break if key.null?
+
         keys << key.read_string
       end
       keys
     end
 
+
     # Save full certificate (public + secret) to files.
     # @param filename [String, #to_s] path/filename to public file
     # @return [void]
@@ -126,55 +143,67 @@ module CZTop
     def save(filename)
       # see https://github.com/zeromq/czmq/issues/1244
       raise ArgumentError, "filename can't be empty" if filename.to_s.empty?
+
       rc = ffi_delegate.save(filename.to_s)
-      return if rc == 0
-      raise_zmq_err("error while saving to file %p" % filename)
+      return if rc.zero?
+
+      raise_zmq_err(format('error while saving to file %p', filename))
     end
 
+
     # Saves the public key to file in ZPL ({Config}) format.
     # @param filename [String, #to_s] path/filename to public file
     # @return [void]
     # @raise [SystemCallError] if this fails
     def save_public(filename)
       rc = ffi_delegate.save_public(filename.to_s)
-      return if rc == 0
-      raise_zmq_err("error while saving to the file %p" % filename)
+      return if rc.zero?
+
+      raise_zmq_err(format('error while saving to the file %p', filename))
     end
 
+
     # Saves the secret key to file in ZPL ({Config}) format.
     # @param filename [String, #to_s] path/filename to secret file
     # @return [void]
     # @raise [SystemCallError] if this fails
     def save_secret(filename)
       rc = ffi_delegate.save_secret(filename.to_s)
-      return if rc == 0
-      raise_zmq_err("error while saving to the file %p" % filename)
+      return if rc.zero?
+
+      raise_zmq_err(format('error while saving to the file %p', filename))
     end
 
+
     # Applies this certificate on a {Socket} or {Actor}.
     # @param zocket [Socket, Actor] path/filename to secret file
     # @return [void]
     # @raise [SystemCallError] if secret key is undefined
     def apply(zocket)
-      raise ArgumentError, "invalid zocket argument %p" % zocket unless zocket
+      raise ArgumentError, format('invalid zocket argument %p', zocket) unless zocket
       return ffi_delegate.apply(zocket) unless secret_key.nil?
-      raise_zmq_err("secret key is undefined")
+
+      raise_zmq_err('secret key is undefined')
     end
 
+
     # Duplicates the certificate.
     # @return [Certificate]
     # @raise [SystemCallError] if this fails
     def dup
       ptr = ffi_delegate.dup
       return from_ffi_delegate(ptr) unless ptr.null?
-      raise_zmq_err("unable to duplicate certificate")
+
+      raise_zmq_err('unable to duplicate certificate')
     end
 
+
     # Compares this certificate to another.
     # @param other [Cert] other certificate
     # @return [Boolean] whether they have the same keys
     def ==(other)
       ffi_delegate.eq(other.ffi_delegate)
     end
+
   end
 end

data/lib/cztop/config/comments.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CZTop
   class Config
 
@@ -7,11 +9,13 @@ module CZTop
     #   are accessible.
     # @return [CommentsAccessor]
     def comments
-      return CommentsAccessor.new(self)
+      CommentsAccessor.new(self)
     end
 
+
     # Used to access a {Config}'s comments.
     class CommentsAccessor
+
       include Enumerable
 
       # @param config [Config]
@@ -19,26 +23,30 @@ module CZTop
         @config = config
       end
 
+
       # Adds a new comment.
       # @param new_comment [String]
       # @return [self]
       def <<(new_comment)
-        @config.ffi_delegate.set_comment("%s", :string, new_comment)
-        return self
+        @config.ffi_delegate.set_comment('%s', :string, new_comment)
+        self
       end
 
+
       # Deletes all comments for this {Config} item.
       # @return [void]
       def delete_all
         @config.ffi_delegate.set_comment(nil)
       end
 
+
       # Yields all comments for this {Config} item.
       # @yieldparam comment [String]
       # @return [void]
       def each
         while comment = _zlist.next
           break if comment.null?
+
           yield comment.read_string
         end
       rescue CZMQ::FFI::Zlist::DestroyedError
@@ -46,6 +54,7 @@ module CZTop
         nil
       end
 
+
       # Returns the number of comments for this {Config} item.
       # @return [Integer] number of comments
       def size
@@ -61,6 +70,8 @@ module CZTop
       def _zlist
         @config.ffi_delegate.comments
       end
+
     end
+
   end
 end

data/lib/cztop/config/serialization.rb

@@ -1,19 +1,25 @@
+# frozen_string_literal: true
+
 # Methods used around serialization of {CZTop::Config} items.
 module CZTop::Config::Serialization
+
   # Serialize to a string in the ZPL format.
   # @return [String]
   def to_s
     ffi_delegate.str_save.read_string
   end
 
+
   # Returns the path/filename of the file this {Config} tree was loaded from.
   # @return [String]
   def filename
     ffi_delegate.filename
   end
 
+
   # Some class methods for {Config} related to serialization.
   module ClassMethods
+
     # Loads a {Config} tree from a string.
     # @param string [String] the tree
     # @return [Config]
@@ -21,6 +27,7 @@ module CZTop::Config::Serialization
       from_ffi_delegate CZMQ::FFI::Zconfig.str_load(string)
     end
 
+
     # Loads a {Config} tree from a file.
     # @param path [String, Pathname, #to_s] the path to the ZPL config file
     # @raise [SystemCallError] if this fails
@@ -28,10 +35,13 @@ module CZTop::Config::Serialization
     def load(path)
       ptr = CZMQ::FFI::Zconfig.load(path.to_s)
       return from_ffi_delegate(ptr) unless ptr.null?
+
       CZTop::HasFFIDelegate.raise_zmq_err(
-        "error while reading the file %p" % path.to_s)
+        format('error while reading the file %p', path.to_s)
+      )
     end
 
+
     # Loads a {Config} tree from a marshalled string.
     # @note This method is automatically used by Marshal.load.
     # @param string [String] marshalled {Config}
@@ -39,18 +49,22 @@ module CZTop::Config::Serialization
     def _load(string)
       from_string(string)
     end
+
   end
 
+
   # Saves the Config tree to a file.
   # @param path [String, Pathname, #to_s] the path to the ZPL config file
   # @return [void]
   # @raise [SystemCallError] if this fails
   def save(path)
     rc = ffi_delegate.save(path.to_s)
-    return if rc == 0
-    raise_zmq_err("error while saving to the file %s" % path)
+    return if rc.zero?
+
+    raise_zmq_err(format('error while saving to the file %s', path))
   end
 
+
   # Reload config tree from same file that it was previously loaded from.
   # @raise [TypeError] if this is an in-memory config
   # @raise [SystemCallError] if this fails (no existing data will be
@@ -62,11 +76,13 @@ module CZTop::Config::Serialization
     # swap out the FFI delegate.
     filename = filename() or
       raise TypeError, "can't reload in-memory config"
-    ptr = CZMQ::FFI::Zconfig.load(filename)
+    ptr      = CZMQ::FFI::Zconfig.load(filename)
     return attach_ffi_delegate(ptr) unless ptr.null?
-    raise_zmq_err("error while reloading from the file %p" % filename)
+
+    raise_zmq_err(format('error while reloading from the file %p', filename))
   end
 
+
   # Serialize (marshal) this Config and all its children.
   #
   # @note This method is automatically used by Marshal.dump.
@@ -74,9 +90,13 @@ module CZTop::Config::Serialization
   def _dump(_level)
     to_s
   end
+
 end
 
+
 class CZTop::Config
+
   include Serialization
   extend Serialization::ClassMethods
+
 end