riemann-client 1.0.0 → 1.1.0

data/lib/riemann/client/tcp_socket.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'socket'
 require 'fcntl'
 
 module Riemann
   class Client
-  # Socket: A specialized socket that has been configure
+    # Socket: A specialized socket that has been configure
     class TcpSocket
       class Error < Riemann::Client::Error; end
       class Timeout < Error; end
@@ -68,7 +70,6 @@ module Riemann
       #   connection dead and notifying the application layer.
       attr_reader :keepalive_count
 
-
       # Internal: Create and connect to the given location.
       #
       # options, same as Constructor
@@ -77,11 +78,11 @@ module Riemann
       def self.connect(options = {})
         s = new(options)
         s.connect
-        return s
+        s
       end
 
       # Internal: Creates a new KJess::Socket
-      def initialize( options = {} )
+      def initialize(options = {})
         @host = options[:host]
         @port = options[:port]
 
@@ -113,7 +114,7 @@ module Riemann
       # Returns a new ::Socket instance for
 
       def socket_factory(type)
-         sock = ::Socket.new(type, ::Socket::SOCK_STREAM, 0)
+        sock = ::Socket.new(type, ::Socket::SOCK_STREAM, 0)
 
         # close file descriptors if we exec
         if Fcntl.constants.include?(:F_SETFD) && Fcntl.constants.include?(:FD_CLOEXEC)
@@ -122,14 +123,14 @@ module Riemann
         # Disable Nagle's algorithm
         sock.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
 
-        if using_keepalive? then
-          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE , true)
-          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPIDLE , keepalive_idle)
+        if using_keepalive?
+          sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPIDLE, keepalive_idle)
           sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPINTVL, keepalive_interval)
-          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPCNT  , keepalive_count)
+          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPCNT, keepalive_count)
         end
 
-        return sock
+        sock
       end
 
       # Internal: Return the connected raw Socket.
@@ -139,7 +140,8 @@ module Riemann
       # Returns a ::Socket
       def socket
         return @socket unless closed?
-        @socket ||= connect()
+
+        @socket ||= connect
       end
 
       # Internal: Closes the internal ::Socket
@@ -154,7 +156,8 @@ module Riemann
       def closed?
         return true if @socket.nil?
         return true if @socket.closed?
-        return false
+
+        false
       end
 
       # Internal:
@@ -169,16 +172,16 @@ module Riemann
         deadline = Time.now.to_f + connect_timeout
 
         # Lookup destination address, we only want TCP.
-        addrs      = ::Socket.getaddrinfo(host, port, nil, ::Socket::SOCK_STREAM )
+        addrs      = ::Socket.getaddrinfo(host, port, nil, ::Socket::SOCK_STREAM)
         errors     = []
-        conn_error = lambda { raise errors.first }
+        conn_error = -> { raise errors.first }
         sock       = nil
 
         # Sort it so we get AF_INET, IPv4
-        addrs.sort.find( conn_error ) do |addr|
-          sock = connect_or_error( addr, deadline, errors )
+        addrs.sort.find(conn_error) do |addr|
+          sock = connect_or_error(addr, deadline, errors)
         end
-        return sock
+        sock
       end
 
       # Internal: Connect to the destination or raise an error.
@@ -195,13 +198,14 @@ module Riemann
       # Should the connection fail, append the exception to the errors array and
       # return false.
       #
-      def connect_or_error( addr, deadline, errors )
+      def connect_or_error(addr, deadline, errors)
         timeout = deadline - Time.now.to_f
         raise Timeout, "Could not connect to #{host}:#{port}" if timeout <= 0
-        return connect_nonblock( addr, timeout )
+
+        connect_nonblock(addr, timeout)
       rescue Error => e
         errors << e
-        return false
+        false
       end
 
       # Internal: Connect to the give address within the timeout.
@@ -210,36 +214,47 @@ module Riemann
       #
       # Return the ::Socket when it is connected, or raise an Error if no
       # connection was possible.
-      def connect_nonblock( addr, timeout )
+      def connect_nonblock(addr, timeout)
         sockaddr = ::Socket.pack_sockaddr_in(addr[1], addr[3])
-        sock     = self.socket_factory( addr[4] )
-        sock.connect_nonblock( sockaddr )
-        return sock
+        sock     = socket_factory(addr[4])
+        sock.connect_nonblock(sockaddr)
+        sock
       rescue Errno::EINPROGRESS
         if IO.select(nil, [sock], nil, timeout).nil?
-          sock.close rescue nil
+          begin
+            sock.close
+          rescue StandardError
+            nil
+          end
           raise Timeout, "Could not connect to #{host}:#{port} within #{timeout} seconds"
         end
-        return connect_nonblock_finalize( sock, sockaddr )
-      rescue => ex
-        sock.close rescue nil
-        raise Error, "Could not connect to #{host}:#{port}: #{ex.class}: #{ex.message}", ex.backtrace
+        connect_nonblock_finalize(sock, sockaddr)
+      rescue StandardError => e
+        begin
+          sock.close
+        rescue StandardError
+          nil
+        end
+        raise Error, "Could not connect to #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
       end
 
-
       # Internal: Make sure that a non-blocking connect has truely connected.
       #
       # Ensure that the given socket is actually connected to the given adddress.
       #
       # Returning the socket if it is and raising an Error if it isn't.
-      def connect_nonblock_finalize( sock, sockaddr )
-        sock.connect_nonblock( sockaddr )
-        return sock
+      def connect_nonblock_finalize(sock, sockaddr)
+        sock.connect_nonblock(sockaddr)
+        sock
       rescue Errno::EISCONN
-        return sock
-      rescue => ex
-        sock.close rescue nil
-        raise Error, "Could not connect to #{host}:#{port}: #{ex.class}: #{ex.message}", ex.backtrace
+        sock
+      rescue StandardError => e
+        begin
+          sock.close
+        rescue StandardError
+          nil
+        end
+        raise Error, "Could not connect to #{host}:#{port}: #{e.class}: #{e.message}", e.backtrace
       end
 
       # Internal: say if we are using TCP Keep Alive or not
@@ -255,12 +270,12 @@ module Riemann
       # Returns true or false
       def using_keepalive?
         using = false
-        if keepalive_active? then
-          using = [ :SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all? do |c|
+        if keepalive_active?
+          using = %i[SOL_SOCKET SO_KEEPALIVE SOL_TCP TCP_KEEPIDLE TCP_KEEPINTVL TCP_KEEPCNT].all? do |c|
             ::Socket.const_defined? c
           end
         end
-        return using
+        using
       end
 
       # Reads length bytes from the socket
@@ -274,18 +289,18 @@ module Riemann
           outbuf.replace('')
           buf = outbuf
         else
-          buf = ''
+          buf = String.new
         end
 
         while buf.length < length
-          unless rb = readpartial(length - buf.length)
+          unless (rb = readpartial(length - buf.length))
             break
           end
 
           buf << rb
         end
 
-        return buf
+        buf
       end
 
       # Internal: Read up to a maxlen of data from the socket and store it in outbuf
@@ -295,13 +310,13 @@ module Riemann
       #
       # Returns the bytes read
       def readpartial(maxlen, outbuf = nil)
-        return socket.read_nonblock(maxlen, outbuf)
+        socket.read_nonblock(maxlen, outbuf)
       rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::ECONNRESET
-        if wait_readable(read_timeout)
-          retry
-        else
+        unless wait_readable(read_timeout)
           raise Timeout, "Could not read from #{host}:#{port} in #{read_timeout} seconds"
         end
+
+        retry
       end
 
       # Internal: Write the given data to the socket
@@ -313,16 +328,16 @@ module Riemann
       #
       # returns nothing
       def write(buf)
-        until buf.nil? or (buf.length == 0) do
+        until buf.nil? || buf.empty?
           written = socket.write_nonblock(buf)
           buf = buf[written, buf.length]
         end
       rescue Errno::EWOULDBLOCK, Errno::EINTR, Errno::EAGAIN, Errno::ECONNRESET
-        if wait_writable(write_timeout)
-          retry
-        else
+        unless wait_writable(write_timeout)
           raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
         end
+
+        retry
       end
 
       def wait_writable(timeout = nil)

data/lib/riemann/client/udp.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Riemann
   class Client
     class UDP < Client
-      MAX_SIZE = 16384
+      MAX_SIZE = 16_384
 
       attr_accessor :host, :port, :max_size
 
-      def initialize(opts = {})
+      def initialize(opts = {}) # rubocop:disable Lint/MissingSuper
         @host     = opts[:host] || HOST
         @port     = opts[:port] || PORT
         @max_size = opts[:max_size] || MAX_SIZE
@@ -13,6 +15,7 @@ module Riemann
 
       def socket
         return @socket if connected?
+
         @socket = UDPSocket.new
       end
 
@@ -26,17 +29,18 @@ module Riemann
       end
 
       # Read a message from a stream
-      def read_message(s)
+      def read_message(_socket)
         raise Unsupported
       end
 
-      def send_recv(*a)
+      def send_recv(_message)
         raise Unsupported
       end
 
       def send_maybe_recv(message)
         encoded_string = message.encode.to_s
         raise TooBig unless encoded_string.length < @max_size
+
         socket.send(encoded_string, 0, @host, @port)
         nil
       end

data/lib/riemann/client.rb

@@ -1,111 +1,130 @@
+# frozen_string_literal: true
+
 require 'riemann'
 
-class Riemann::Client
-  class Error < RuntimeError; end
-  class InvalidResponse < Error; end
-  class ServerError < Error; end
-  class Unsupported < Error; end
-  class TooBig < Unsupported; end
+module Riemann
+  class Client
+    class Error < RuntimeError; end
+    class InvalidResponse < Error; end
+    class ServerError < Error; end
+    class Unsupported < Error; end
+    class TooBig < Unsupported; end
+
+    require 'socket'
+    require 'time'
 
-  require 'thread'
-  require 'socket'
-  require 'time'
+    HOST = '127.0.0.1'
+    PORT = 5555
+    TIMEOUT = 5
 
-  HOST = '127.0.0.1'
-  PORT = 5555
-  TIMEOUT = 5
+    require 'riemann/client/tcp'
+    require 'riemann/client/udp'
 
-  require 'riemann/client/tcp'
-  require 'riemann/client/udp'
+    attr_reader :tcp, :udp
 
-  attr_reader :tcp, :udp
+    def initialize(opts = {})
+      @options = opts.dup
+      @options[:host] ||= HOST
+      @options[:port] ||= PORT
+      @options[:timeout] ||= TIMEOUT
 
-  def initialize(opts = {})
-    @options = opts.dup
-    @options[:host] ||= HOST
-    @options[:port] ||= PORT
-    @options[:timeout] ||= TIMEOUT
+      @udp = UDP.new(@options)
+      @tcp = TCP.new(@options)
+      return unless block_given?
 
-    @udp = UDP.new(@options)
-    @tcp = TCP.new(@options)
-    if block_given?
       begin
         yield self
       ensure
         close
       end
     end
-  end
 
-  def host
-    @options[:host]
-  end
+    def host
+      @options[:host]
+    end
 
-  def port
-    @options[:port]
-  end
+    def port
+      @options[:port]
+    end
 
-  def timeout
-    @options[:timeout]
-  end
+    def timeout
+      @options[:timeout]
+    end
 
-  # Send a state
-  def <<(event_opts)
-    # Create state
-    case event_opts
-    when Riemann::State
-      event = event_opts
-    when Riemann::Event
-      event = event_opts
-    else
-      unless event_opts.include? :host
-        event_opts[:host] = Socket.gethostname
+    # Send a state
+    def <<(event)
+      # Create state
+      case event
+      when Riemann::State, Riemann::Event, Hash
+        # Noop
+      else
+        raise(ArgumentError, "Unsupported event class: #{event.class.name}")
       end
-      event = Riemann::Event.new(event_opts)
+
+      bulk_send([event])
     end
 
-    message = Riemann::Message.new :events => [event]
+    def bulk_send(events)
+      raise ArgumentError unless events.is_a?(Array)
 
-    # Transmit
-    send_maybe_recv message
-  end
+      message = Riemann::Message.new(events: normalize_events(events))
 
-  # Returns an array of states matching query.
-  def [](query)
-    response = query(query)
-    (response.events || []) |
-      (response.states || [])
-  end
+      send_maybe_recv(message)
+    end
 
-  def connect
-    # NOTE: connections are made automatically on send
-    warn "Riemann client#connect is deprecated"
-  end
+    def normalize_events(events)
+      events.map do |event|
+        case event
+        when Riemann::State, Riemann::Event
+          event
+        when Hash
+          e = if event.include?(:host)
+                event
+              else
+                event.dup.merge(host: Socket.gethostname)
+              end
+          Riemann::Event.new(e)
+        else
+          raise(ArgumentError, "Unsupported event class: #{event.class.name}")
+        end
+      end
+    end
 
-  # Close both UDP and TCP sockets.
-  def close
-    @udp.close
-    @tcp.close
-  end
+    # Returns an array of states matching query.
+    def [](query)
+      response = query(query)
+      (response.events || []) |
+        (response.states || [])
+    end
 
-  def connected?
-    tcp.connected? and udp.connected?
-  end
+    def connect
+      # NOTE: connections are made automatically on send
+      warn 'Riemann client#connect is deprecated'
+    end
 
-  # Ask for states
-  def query(string = "true")
-    send_recv Riemann::Message.new(:query => Riemann::Query.new(:string => string))
-  end
+    # Close both UDP and TCP sockets.
+    def close
+      @udp.close
+      @tcp.close
+    end
 
-  def send_recv(*a)
-    @tcp.send_recv *a
-  end
+    def connected?
+      tcp.connected? and udp.connected?
+    end
+
+    # Ask for states
+    def query(string = 'true')
+      send_recv Riemann::Message.new(query: Riemann::Query.new(string: string))
+    end
+
+    def send_recv(message)
+      @tcp.send_recv(message)
+    end
 
-  def send_maybe_recv(*a)
-    begin
-      @udp.send_maybe_recv *a
+    def send_maybe_recv(message)
+      @udp.send_maybe_recv(message)
     rescue TooBig
-      @tcp.send_maybe_recv *a
+      @tcp.send_maybe_recv(message)
     end
   end
 end