riemann-client 0.2.2 → 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 971fad804164c0db71b3e689d9b866ad89a20e41
+  data.tar.gz: 1e7f35daae4ab58fa8018225959da905bfd5f77b
+SHA512:
+  metadata.gz: 904df6b31de7feda767274d2a776040287d2b3849280257abd5b167171adf990812b5deabfdde8a48a220b329564476c93a844bb195a11655736578784c84a3c
+  data.tar.gz: 3ccaa03c50e24502eee6e9e440279a1d5989b776f70ad04536654e3c887c3f14fb841502593fb84d3dbd9256749a7babb6870d4a7f4f9eb1c259f23f39b5e14f

data/lib/riemann/client.rb

@@ -18,14 +18,28 @@ class Riemann::Client
   require 'riemann/client/tcp'
   require 'riemann/client/udp'
 
-  attr_accessor :host, :port, :tcp, :udp, :timeout
+  attr_reader :tcp, :udp
 
   def initialize(opts = {})
-    @host = opts[:host] || HOST
-    @port = opts[:port] || PORT
-    @timeout = opts[:timeout] || TIMEOUT
-    @udp = UDP.new opts
-    @tcp = TCP.new opts
+    @options = opts.dup
+    @options[:host] ||= HOST
+    @options[:port] ||= PORT
+    @options[:timeout] ||= TIMEOUT
+
+    @udp = UDP.new(@options)
+    @tcp = TCP.new(@options)
+  end
+
+  def host
+    @options[:host]
+  end
+
+  def port
+    @options[:port]
+  end
+
+  def timeout
+    @options[:timeout]
   end
 
   # Send a state

data/lib/riemann/client/tcp.rb

@@ -1,24 +1,50 @@
+require 'monitor'
+require 'riemann/client/tcp_socket'
+
 module Riemann
   class Client
     class TCP < Client
       attr_accessor :host, :port, :socket
 
-      def initialize(opts = {})
-        @host = opts[:host] || HOST
-        @port = opts[:port] || PORT
-        @timeout = opts[:timeout] || TIMEOUT
-        @locket = Mutex.new
+      # Public: Set a socket factory -- an object responding
+      # to #call(options) that returns a Socket object
+      def self.socket_factory=(factory)
+        @socket_factory = factory
+      end
+
+      # Public: Return a socket factory
+      def self.socket_factory
+        @socket_factory || proc { |options| TcpSocket.connect(options) }
+      end
+
+      def initialize(options = {})
+        @options = options
+        @locket  = Monitor.new
       end
 
-      def connect
-        Timeout::timeout(@timeout) do
-          @socket = TCPSocket.new(@host, @port)
+      def socket
+        @locket.synchronize do
+          if @pid && @pid != Process.pid
+            close
+          end
+
+          if @socket and not @socket.closed?
+            return @socket
+          end
+
+          @socket = self.class.socket_factory.call(@options)
+          @pid    = Process.pid
+
+          return @socket
         end
       end
 
       def close
         @locket.synchronize do
-          @socket.close
+          if @socket && !@socket.closed?
+            @socket.close
+          end
+          @socket = nil
         end
       end
 
@@ -51,8 +77,8 @@ module Riemann
 
       def send_recv(message)
         with_connection do |s|
-          s << message.encode_with_length
-          read_message s
+          s.write(message.encode_with_length)
+          read_message(s)
         end
       end
 
@@ -65,25 +91,14 @@ module Riemann
         @locket.synchronize do
           begin
             tries += 1
-              yield(@socket || connect)
-          rescue IOError => e
-            raise if tries > 3
-            connect and retry
-          rescue Errno::EPIPE => e
-            raise if tries > 3
-            connect and retry
-          rescue Errno::ECONNREFUSED => e
+            yield(socket)
+          rescue IOError, Errno::EPIPE, Errno::ECONNREFUSED, InvalidResponse, Timeout::Error, Riemann::Client::TcpSocket::Error
+            close
             raise if tries > 3
-            connect and retry
-          rescue Errno::ECONNRESET => e
-            raise if tries > 3
-            connect and retry
-          rescue InvalidResponse => e
-            raise if tries > 3
-            connect and retry
-          rescue Timeout::Error => e
-            raise if tries > 3
-            connect and retry
+            retry
+          rescue Exception
+            close
+            raise
           end
         end
       end

data/lib/riemann/client/tcp_socket.rb

@@ -0,0 +1,334 @@
+require 'socket'
+require 'fcntl'
+
+module Riemann
+  class Client
+  # Socket: A specialized socket that has been configure
+    class TcpSocket
+      class Error < Riemann::Client::Error; end
+      class Timeout < Error; end
+
+      # Internal:
+      # The timeout for reading in seconds. Defaults to 2
+      attr_accessor :read_timeout
+
+      # Internal:
+      # The timeout for connecting in seconds. Defaults to 2
+      attr_reader :connect_timeout
+
+      # Internal:
+      # The timeout for writing in seconds. Defaults to 2
+      attr_reader :write_timeout
+
+      # Internal:
+      # The host this socket is connected to
+      attr_reader :host
+
+      # Internal:
+      # The port this socket is connected to
+      attr_reader :port
+
+      # Internal
+      #
+      # Used for setting TCP_KEEPIDLE: overrides tcp_keepalive_time for a single
+      # socket.
+      #
+      # http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/usingkeepalive.html
+      #
+      # tcp_keepalive_time:
+      #
+      #  The interval between the last data packet sent (simple ACKs are not
+      #  considered data) and the first keepalive probe; after the connection is
+      #  marked to need keepalive, this counter is not used any further.
+      attr_reader :keepalive_idle
+
+      # Internal
+      #
+      # Used for setting TCP_KEEPINTVL: overrides tcp_keepalive_intvl for a single
+      # socket.
+      #
+      # http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/usingkeepalive.html
+      #
+      # tcp_keepalive_intvl:
+      #
+      #   The interval between subsequential keepalive probes, regardless of what
+      #   the connection has exchanged in the meantime.
+      attr_reader :keepalive_interval
+
+      # Internal
+      #
+      # Used for setting TCP_KEEPCNT: overrides tcp_keepalive_probes for a single
+      # socket.
+      #
+      # http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/usingkeepalive.html
+      #
+      # tcp_keepalive_probes:
+      #
+      #   The number of unacknowledged probes to send before considering the
+      #   connection dead and notifying the application layer.
+      attr_reader :keepalive_count
+
+
+      # Internal: Create and connect to the given location.
+      #
+      # options, same as Constructor
+      #
+      # Returns an instance of KJess::Socket
+      def self.connect(options = {})
+        s = new(options)
+        s.connect
+        return s
+      end
+
+      # Internal: Creates a new KJess::Socket
+      def initialize( options = {} )
+        @host = options[:host]
+        @port = options[:port]
+
+        @connect_timeout = options[:connect_timeout] || options[:timeout] || 2
+        @read_timeout    = options[:read_timeout]    || options[:timeout] || 2
+        @write_timeout   = options[:write_timeout]   || options[:timeout] || 2
+
+        @keepalive_active   = options.fetch(:keepalive_active, true)
+        @keepalive_idle     = options[:keepalive_idle]     || 60
+        @keepalive_interval = options[:keepalive_interval] || 30
+        @keepalive_count    = options[:keepalive_count]    || 5
+
+        @socket             = nil
+      end
+
+      # Internal: Return whether or not the keepalive_active flag is set.
+      def keepalive_active?
+        @keepalive_active
+      end
+
+      # Internal: Low level socket allocation and option configuration
+      #
+      # Using the options from the initializer, a new ::Socket is created that
+      # is:
+      #
+      #   TCP, IPv4 only, autoclosing on exit, nagle's algorithm is disabled and has
+      #   TCP Keepalive options set if keepalive is supported.
+      #
+      # Returns a new ::Socket instance
+      def blank_socket
+        sock = ::Socket.new(::Socket::AF_INET, ::Socket::SOCK_STREAM, 0)
+
+        # close file descriptors if we exec
+        sock.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+        # 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)
+          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPINTVL, keepalive_interval)
+          sock.setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPCNT  , keepalive_count)
+        end
+
+        return sock
+      end
+
+      # Internal: Return the connected raw Socket.
+      #
+      # If the socket is closed or non-existent it will create and connect again.
+      #
+      # Returns a ::Socket
+      def socket
+        return @socket unless closed?
+        @socket ||= connect()
+      end
+
+      # Internal: Closes the internal ::Socket
+      #
+      # Returns nothing
+      def close
+        @socket.close unless closed?
+        @socket = nil
+      end
+
+      # Internal: Return true the socket is closed.
+      def closed?
+        return true if @socket.nil?
+        return true if @socket.closed?
+        return false
+      end
+
+      # Internal:
+      #
+      # Connect to the remote host in a non-blocking fashion.
+      #
+      # Raise Error if there is a failure connecting.
+      #
+      # Return the ::Socket on success
+      def connect
+        # Calculate our timeout deadline
+        deadline = Time.now.to_f + connect_timeout
+
+        # Lookup destination address, we only want    IPv4             , TCP
+        addrs      = ::Socket.getaddrinfo(host, port, ::Socket::AF_INET, ::Socket::SOCK_STREAM )
+        errors     = []
+        conn_error = lambda { raise errors.first }
+        sock       = nil
+
+        addrs.find( conn_error ) do |addr|
+          sock = connect_or_error( addr, deadline, errors )
+        end
+        return sock
+      end
+
+      # Internal: Connect to the destination or raise an error.
+      #
+      # Connect to the address or capture the error of the connection
+      #
+      # addr     - An address returned from Socket.getaddrinfo()
+      # deadline - the after which we should raise a timeout error
+      # errors   - a collection of errors to append an error too should we have one.
+      #
+      # Make an attempt to connect to the given address. If it is successful,
+      # return the socket.
+      #
+      # Should the connection fail, append the exception to the errors array and
+      # return false.
+      #
+      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 )
+      rescue Error => e
+        errors << e
+        return false
+      end
+
+      # Internal: Connect to the give address within the timeout.
+      #
+      # Make an attempt to connect to a single address within the given timeout.
+      #
+      # Return the ::Socket when it is connected, or raise an Error if no
+      # connection was possible.
+      def connect_nonblock( addr, timeout )
+        sockaddr = ::Socket.pack_sockaddr_in(addr[1], addr[3])
+        sock     = blank_socket()
+        sock.connect_nonblock( sockaddr )
+        return sock
+      rescue Errno::EINPROGRESS
+        if IO.select(nil, [sock], nil, timeout).nil?
+          sock.close rescue nil
+          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
+      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
+      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
+      end
+
+      # Internal: say if we are using TCP Keep Alive or not
+      #
+      # We will return true if the initialization options :keepalive_active is
+      # set to true, and if all the constants that are necessary to use TCP keep
+      # alive are defined.
+      #
+      # It may be the case that on some operating systems that the constants are
+      # not defined, so in that case we do not want to attempt to use tcp keep
+      # alive if we are unable to do so in any case.
+      #
+      # 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|
+            ::Socket.const_defined? c
+          end
+        end
+        return using
+      end
+
+      # Reads length bytes from the socket
+      #
+      # length - the number of bytes to read from the socket
+      # outbuf - an optional buffer to store the bytes in
+      #
+      # Returns the bytes read if no outbuf is specified
+      def read(length, outbuf = nil)
+        if outbuf
+          outbuf.replace('')
+          buf = outbuf
+        else
+          buf = ''
+        end
+
+        while buf.length < length
+          unless rb = readpartial(length - buf.length)
+            break
+          end
+
+          buf << rb
+        end
+
+        return buf
+      end
+
+      # Internal: Read up to a maxlen of data from the socket and store it in outbuf
+      #
+      # maxlen - the maximum number of bytes to read from the socket
+      # outbuf - the buffer in which to store the bytes.
+      #
+      # Returns the bytes read
+      def readpartial(maxlen, outbuf = nil)
+        return socket.read_nonblock(maxlen, outbuf)
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::ECONNRESET
+        if wait_readable(read_timeout)
+          retry
+        else
+          raise Timeout, "Could not read from #{host}:#{port} in #{read_timeout} seconds"
+        end
+      end
+
+      # Internal: Write the given data to the socket
+      #
+      # buf - the data to write to the socket.
+      #
+      # Raises an error if it is unable to write the data to the socket within the
+      # write_timeout.
+      #
+      # returns nothing
+      def write(buf)
+        until buf.nil? or (buf.length == 0) do
+          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
+          raise Timeout, "Could not write to #{host}:#{port} in #{write_timeout} seconds"
+        end
+      end
+
+      def wait_writable(timeout = nil)
+        IO.select(nil, [@socket], nil, timeout || write_timeout)
+      end
+
+      def wait_readable(timeout = nil)
+        IO.select([@socket], nil, nil, timeout || read_timeout)
+      end
+    end
+  end
+end

data/lib/riemann/version.rb

@@ -1,3 +1,3 @@
 module Riemann
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end

metadata

@@ -1,62 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: riemann-client
 version: !ruby/object:Gem::Version
-  version: 0.2.2
-  prerelease: 
+  version: 0.2.3
 platform: ruby
 authors:
 - Kyle Kingsbury
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-28 00:00:00.000000000 Z
+date: 2014-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: beefcake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.3.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.3.5
 - !ruby/object:Gem::Dependency
   name: trollop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.16.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.16.2
 - !ruby/object:Gem::Dependency
   name: mtrc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 0.0.4
 description: 
@@ -70,6 +63,7 @@ files:
 - lib/riemann/auto_state.rb
 - lib/riemann/client.rb
 - lib/riemann/client/tcp.rb
+- lib/riemann/client/tcp_socket.rb
 - lib/riemann/client/udp.rb
 - lib/riemann/event.rb
 - lib/riemann/message.rb
@@ -81,26 +75,25 @@ files:
 - README.markdown
 homepage: https://github.com/aphyr/riemann-ruby-client
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: riemann-client
-rubygems_version: 1.8.25
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Client for the distributed event system Riemann.
 test_files: []