uninterruptible 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ffdc9d6870a2bf9ae5573fbf9cc5b0e8a4d3f86
-  data.tar.gz: 81019ac427f4af4e182c8cf367ce9c807cef97a6
+  metadata.gz: 1947e00fb25907205555f9a1cbef1d5875008513
+  data.tar.gz: a6865bb7d65675c31aad797c4cd88634285419ce
 SHA512:
-  metadata.gz: 163f49c6706ade360df9626e817c92af5e0c6276d6867a2dab5a6b5ab4582e5ff7e25209316a778add47b8bf45629e0abae3c02f170c47c6b98db2e5a7f55370
-  data.tar.gz: 7dd7aa37124bde1196b48f6884d62b1db6214c695ac1f8e4b7c1ff1832d0f015c03829c6b502705857be79b29f8f156bdf4d4b05c1f280fdd1c6513765839097
+  metadata.gz: 33f6c792fa320d873e3d47d90f2500f7ec2fc589192ae18081df04a88bcda5518a198bffb0933005bb4af0ffe2636ee1c3542619ebb9604aa1fc2be2a913ae37
+  data.tar.gz: dd6b8c1f399b544a4977043176734aa50ea3857a1aa55bc1f8aeb0e9b3201e712785a510c8c23a0eb8613b89696aa0d1495ede000c19080e8e44eed07d416bd0

data/README.md

@@ -1,6 +1,6 @@
 # Uninterruptible
 
-Uninterruptible gives you zero downtime restarts for your TCP servers with nearly zero effort. Sounds good? Read on...
+Uninterruptible gives you zero downtime restarts for your socket servers with nearly zero effort. Sounds good? Read on.
 
 Small socket servers are great, sometimes you need a quick and efficient way of moving data between servers (or even
 processes on the same machine). Restarting these processes can be a bit hairy though, you either need to build your
@@ -60,14 +60,22 @@ finished processing all of it's existing connections. To kill the server (allowi
 ```ruby
 echo_server.configure do |config|
   config.start_command = 'ruby echo_server.rb' # *Required* Command to execute to start a new server process
-  config.bind_port = 6789 # *Required* Port to listen on, falls back to ENV['PORT']
-  config.bind_address = '::' # Address to listen on
+  config.bind = "tcp://0.0.0.0:12345" # *Required* Interface to listen on, falls back to 0.0.0.0 on ENV['PORT']
   config.pidfile_path = 'tmp/pids/echoserver.pid' # Location to write a pidfile, falls back to ENV['PID_FILE']
   config.log_path = 'log/echoserver.log' # Location to write logfile, defaults to STDOUT
   config.log_level = Logger::INFO # Log writing severity, defaults to Logger::INFO
 end
 ```
 
+Uninterruptible supports both TCP and UNIX sockets. To connect to a unix socket simply pass the path in the bind
+configuration parameter:
+
+```ruby
+echo_server.configure do |config|
+  config.bind = "unix:///tmp/echo_server.sock"
+end
+```
+
 ## The Magic
 
 Upon receiving `USR1`, your server will spawn a new copy of itself and pass the file descriptor of the open socket to
@@ -102,7 +110,7 @@ class EchoServer
 
   def worker_loop
     loop do
-      client_socket = tcp_server.accept
+      client_socket = socket_server.accept
       process_request(client_socket)
     end
   end

data/lib/uninterruptible.rb

@@ -1,8 +1,11 @@
 require "uninterruptible/version"
 require 'uninterruptible/configuration'
+require 'uninterruptible/binder'
 require 'uninterruptible/server'
 
 # All of the interesting stuff is in Uninterruptible::Server
 module Uninterruptible
   class ConfigurationError < StandardError; end
+
+  SERVER_FD_VAR = 'UNINTERRUPTIBLE_SERVER_FD'.freeze
 end

data/lib/uninterruptible/binder.rb

@@ -0,0 +1,69 @@
+require 'uri'
+
+module Uninterruptible
+  class Binder
+    attr_reader :bind_uri
+
+    # @param [String] bind_address The config for a server we're returning the socket for
+    #   @example
+    #     "unix:///tmp/server.sock"
+    #     "tcp://127.0.0.1:8080"
+    def initialize(bind_address)
+      @bind_uri = parse_bind_address(bind_address)
+    end
+
+    # Bind to the TCP or UNIX socket defined in the #bind_uri
+    #
+    # @return [TCPServer, UNIXServer] Successfully bound server
+    #
+    # @raise [Uninterruptible::ConfigurationError] Raised when the URI indicates a non-tcp or unix scheme
+    def bind_to_socket
+      case bind_uri.scheme
+      when 'tcp'
+        bind_to_tcp_socket
+      when 'unix'
+        bind_to_unix_socket
+      else
+        raise Uninterruptible::ConfigurationError, "Can only bind to TCP and UNIX sockets"
+      end
+    end
+
+    private
+
+    # Connect (or reconnect if the FD is set) to a TCP server
+    #
+    # @return [TCPServer] Socket server for the configured address and port
+    def bind_to_tcp_socket
+      if ENV[SERVER_FD_VAR]
+        TCPServer.for_fd(ENV[SERVER_FD_VAR].to_i)
+      else
+        TCPServer.new(bind_uri.host, bind_uri.port)
+      end
+    end
+
+    # Connect (or reconnect if FD is set) to a UNIX socket. Will delete existing socket at path if required.
+    #
+    # @return [UNIXServer] Socket server for the configured path
+    def bind_to_unix_socket
+      if ENV[SERVER_FD_VAR]
+        UNIXServer.for_fd(ENV[SERVER_FD_VAR].to_i)
+      else
+        File.delete(bind_uri.path) if File.exist?(bind_uri.path)
+        UNIXServer.new(bind_uri.path)
+      end
+    end
+
+    # Parse the bind address in the configuration
+    #
+    # @param [String] bind_address The config for a server we're returning the socket for
+    #
+    # @return [URI::Generic] Parsed version of the bind_address
+    #
+    # @raise [Uninterruptible::ConfigurationError] Raised if the bind_address could not be parsed
+    def parse_bind_address(bind_address)
+      URI.parse(bind_address)
+    rescue URI::Error
+      raise Uninterruptible::ConfigurationError, "Couldn't parse the bind address: \"#{bind_address}\""
+    end
+  end
+end

data/lib/uninterruptible/configuration.rb

@@ -3,7 +3,7 @@ module Uninterruptible
   #
   # See {Server#configure} for usage instructions.
   class Configuration
-    attr_writer :bind_port, :bind_address, :pidfile_path, :start_command, :log_path, :log_level
+    attr_writer :bind, :bind_port, :bind_address, :pidfile_path, :start_command, :log_path, :log_level
 
     # Available TCP Port for the server to bind to (required). Falls back to environment variable PORT if set.
     #
@@ -14,9 +14,14 @@ module Uninterruptible
       port.to_i
     end
 
-    # Address to bind the server to (defaults to +::+).
+    # Address to bind the server to (defaults to +0.0.0.0+).
     def bind_address
-      @bind_address || "::"
+      @bind_address || "0.0.0.0"
+    end
+
+    # URI to bind to, falls back to tcp://bind_address:bind_port if unset
+    def bind
+      @bind || "tcp://#{bind_address}:#{bind_port}"
     end
 
     # Location to write the pid of the current server to. If blank pidfile will not be written. Falls back to

data/lib/uninterruptible/server.rb

@@ -30,7 +30,7 @@ module Uninterruptible
   module Server
     def self.included(base)
       base.class_eval do
-        attr_reader :active_connections, :tcp_server, :mutex
+        attr_reader :active_connections, :socket_server, :mutex
       end
     end
 
@@ -52,7 +52,7 @@ module Uninterruptible
 
       logger.info "Starting server on #{server_configuration.bind_address}:#{server_configuration.bind_port}"
 
-      establish_tcp_server
+      establish_socket_server
       write_pidfile
       setup_signal_traps
       accept_connections
@@ -72,7 +72,7 @@ module Uninterruptible
     # use a different concurrency pattern, a thread per connection is the default.
     def accept_connections
       loop do
-        Thread.start(tcp_server.accept) do |client_socket|
+        Thread.start(socket_server.accept) do |client_socket|
           logger.debug "Accepted connection from #{client_socket.peeraddr.last}"
           process_request(client_socket)
         end
@@ -93,23 +93,17 @@ module Uninterruptible
       end
     end
 
-    # Listen (or reconnect) to the bind address and port specified in the config. If TCP_SERVER_FD is set in the env,
-    # reconnect to that file descriptor. Once @tcp_server is set, write the file descriptor ID to the env.
-    def establish_tcp_server
-      if ENV['TCP_SERVER_FD']
-        # If there's a file descriptor present, take over from a previous instance of this server and kill it off
-        logger.debug "Reconnecting to file descriptor..."
-        @tcp_server = TCPServer.for_fd(ENV['TCP_SERVER_FD'].to_i)
-        kill_parent
-      else
-        logger.debug "Opening new socket..."
-        @tcp_server = TCPServer.open(server_configuration.bind_address, server_configuration.bind_port)
-      end
+    # Listen (or reconnect) to the bind address and port specified in the config. If socket_server_FD is set in the env,
+    # reconnect to that file descriptor. Once @socket_server is set, write the file descriptor ID to the env.
+    def establish_socket_server
+      @socket_server = Uninterruptible::Binder.new(server_configuration.bind).bind_to_socket
+      # If there's a file descriptor present, take over from a previous instance of this server and kill it off
+      kill_parent if ENV[SERVER_FD_VAR]
 
-      @tcp_server.autoclose = false
-      @tcp_server.close_on_exec = false
+      @socket_server.autoclose = false
+      @socket_server.close_on_exec = false
 
-      ENV["TCP_SERVER_FD"] = @tcp_server.to_i.to_s
+      ENV[SERVER_FD_VAR] = @socket_server.to_i.to_s
     end
 
     # Send a TERM signal to the parent process. This will be called by a newly spawned server if it has been started
@@ -143,9 +137,9 @@ module Uninterruptible
       end
     end
 
-    # Stop listening on tcp_server, wait until all active connections have finished processing and exit with 0.
+    # Stop listening on socket_server, wait until all active connections have finished processing and exit with 0.
     def graceful_shutdown
-      tcp_server.close unless tcp_server.closed?
+      socket_server.close unless socket_server.closed?
 
       until active_connections.zero?
         sleep 0.5

data/lib/uninterruptible/version.rb

@@ -1,3 +1,3 @@
 module Uninterruptible
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/uninterruptible.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Dan Wentworth"]
   spec.email         = ["dan@atechmedia.com"]
 
-  spec.summary       = "Zero-downtime restarts for your trivial TCP servers"
+  spec.summary       = "Zero-downtime restarts for your trivial socket servers"
   spec.description   = "Uninterruptible gives your socket server magic restarting powers. Send your running "\
      "Uninterruptible server USR1 and it will start a brand new copy of itself which will immediately start handling "\
      "new requests while the old server stays alive until all of it's active connections are complete."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uninterruptible
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Dan Wentworth
@@ -71,9 +71,11 @@ files:
 - bin/console
 - bin/setup
 - lib/uninterruptible.rb
+- lib/uninterruptible/binder.rb
 - lib/uninterruptible/configuration.rb
 - lib/uninterruptible/server.rb
 - lib/uninterruptible/version.rb
+- uninterruptible-1.0.0.gem
 - uninterruptible.gemspec
 homepage: https://github.com/darkphnx/uninterruptible
 licenses:
@@ -98,5 +100,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Zero-downtime restarts for your trivial TCP servers
+summary: Zero-downtime restarts for your trivial socket servers
 test_files: []