sockd 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d25ce828b55583f286558554e0fa7606403bdce4
-  data.tar.gz: c2d8410fe27052b5632652d89eb6076c3246e261
+  metadata.gz: 6eac67e5bf5c221e1246054c67fe114d0e1ce125
+  data.tar.gz: cd0fca78d6544e1b4badca98c291313bb2c3955f
 SHA512:
-  metadata.gz: b030f1bd71ad93b5bb32ba1de2fd2d23e095a9c0e73b260bc8558e7c700f1b14508407750162082b17a55c06045d052e4a2dece1afd4b02c104053c019dfd148
-  data.tar.gz: 58ce09e8c91b0fc8d269315cf29d6aeed1e896cc03e13e41df6cfbc63f3466b52621ee80d62d7051de6e4bbdcf4b4767a32bb269e51f5ec6644f4e04c3428003
+  metadata.gz: 4dee986312d3761ef7854df1a6f6937ddf3d3a9a086969ea056ec396334d4fb4f4c7e32bcbc3f94c174e019da22d83cc5e32a0232a40dd21797abfeaa9b2652b
+  data.tar.gz: 92af3f8162ba59946f266c01198c3b4fd08814a4fbba27d1b465989a57b3f1d3f80fbfa19ddfe4f4d6ffd15f4734d07e1916b6ab172f21d315b551e2f21a8bf0

data/lib/sockd/runner.rb

@@ -1,22 +1,20 @@
-require "logger"
 require "socket"
 require "timeout"
 require "fileutils"
-require "sockd/errors"
 
 module Sockd
   class Runner
 
+    class ServiceError < RuntimeError; end
+
     attr_reader :options, :name
 
     class << self
-      def define(*args, &block)
-        self.new(*args, &block)
-      end
+      alias define new
     end
 
-    def initialize(name, options = {}, &block)
-      @name = name
+    def initialize(name = nil, options = {}, &block)
+      @name = name || File.basename($0)
       @options = {
         :host      => "127.0.0.1",
         :port      => 0,
@@ -66,33 +64,24 @@ module Sockd
     # @runner.handle { |msg| if msg == 'foo' then return 'bar' ... }
     def handle(message = nil, socket = nil, &block)
       return self if block_given? && @handle = block
-      @handle || (raise SockdError, "No message handler provided.")
+      raise ArgumentError, "no message handler provided" unless @handle
       @handle.call(message, socket)
     end
 
-    # call one of start, stop, restart, or send
-    def run(method, *args)
-      if %w(start stop restart send).include?(method)
-        begin
-          self.public_send method.to_sym, *args
-        rescue ArgumentError => e
-          raise unless e.backtrace[1].include? "in `public_send"
-          raise BadCommandError, "wrong number of arguments for command: #{method}"
-        end
-      else
-        raise BadCommandError, "invalid command: #{method}"
-      end
-    end
-
     # start our service
     def start
       server do |server|
 
         if options[:daemonize]
           pid = daemon_running?
-          raise ProcError, "#{name} process already running (#{pid})" if pid
+          raise ServiceError, "#{name} process already running (#{pid})" if pid
           puts "starting #{name} process..."
-          return self unless daemonize
+          unless daemonize
+            unless send('ping', 10).chomp == 'pong'
+              raise ServiceError, "invalid ping response"
+            end
+            return self
+          end
         end
 
         drop_privileges options[:user], options[:group]
@@ -106,7 +95,8 @@ module Sockd
           exit 130
         end
 
-        log "listening on " + server.local_address.inspect_sockaddr
+        log "listening on #{server.local_address.inspect_sockaddr}"
+
         while true
           sock = server.accept
           begin
@@ -139,7 +129,7 @@ module Sockd
           Process.kill('KILL', pid)
           puts "SIGKILL sent to #{name} (#{pid})"
         end
-        raise ProcError.new("unable to stop #{name} process") if daemon_running?
+        raise ServiceError, "unable to stop #{name} process" if daemon_running?
       else
         warn "#{name} process not running"
       end
@@ -153,22 +143,16 @@ module Sockd
     end
 
     # send a message to a running service and return the response
-    def send(*args)
-      raise ArgumentError if args.empty?
-      message = args.join(' ')
-      response = nil
-      begin
-        client do |sock|
-          sock.write message + "\r\n"
-          response = sock.gets
-        end
-      rescue Errno::ECONNREFUSED, Errno::ENOENT
-        unless daemon_running?
-          abort "#{name} process not running"
-        end
-        abort "unable to establish connection"
+    def send(message, timeout = 30)
+      client do |sock|
+        sock.write "#{message}\r\n"
+        ready = IO.select([sock], nil, nil, timeout)
+        raise ServiceError, "timed out waiting for server response" unless ready
+        sock.recv(256)
       end
-      puts response
+    rescue Errno::ECONNREFUSED, Errno::ENOENT
+      raise ServiceError, "#{name} process not running" unless daemon_running?
+      raise ServiceError, "unable to establish connection"
     end
 
     # output a timestamped log message
@@ -185,29 +169,23 @@ module Sockd
           UNIXServer.new(options[:socket])
         rescue Errno::EADDRINUSE
           begin
-            Timeout.timeout(5) do
-              UNIXSocket.open(options[:socket]) do |sock|
-                sock.write "ping\r\n"
-                if sock.gets.chomp == "pong"
-                  raise ProcError, "socket #{options[:socket]} already in use by another instance of #{name}"
-                end
-              end
-            end
-            raise ProcError, "socket #{options[:socket]} already in use by another process"
-          rescue Errno::ECONNREFUSED, Timeout::Error
+            send('ping', 20)
+          rescue ServiceError
+            # socket stale, reopening
             File.delete(options[:socket])
             UNIXServer.new(options[:socket])
+          else
+            raise ServiceError, "socket #{options[:socket]} already in use by another process"
           end
         end.tap do
           # get user and group ids
-          uid = Etc.getpwnam(options[:user]).uid if options[:user]
-          gid = Etc.getgrnam(options[:group]).gid if options[:group]
-          gid = Etc.getpwnam(options[:user]).gid if !gid && options[:user]
+          uid, gid = user_id(options[:user]) if options[:user]
+          gid = group_id(options[:group]) if options[:group]
           File.chown(uid, gid, options[:socket]) if uid || gid
 
           # ensure mode is octal if string provided
           options[:mode] = options[:mode].to_i(8) if options[:mode].is_a?(String)
-          File.chmod(options[:mode], options[:socket])
+          File.chmod(options[:mode], options[:socket]) if options[:mode] != 0
         end
       else
         TCPServer.new(options[:host], options[:port])
@@ -219,7 +197,7 @@ module Sockd
       end
     rescue Errno::EACCES
       sock = options[:socket] || "#{options[:host]}:#{options[:port]}"
-      raise ProcError, "unable to open socket: #{sock} (check permissions)"
+      raise ServiceError, "unable to open socket: #{sock} (check permissions)"
     end
 
     # return a UNIXSocket or TCPSocket instance depending on config
@@ -231,7 +209,7 @@ module Sockd
       end
     rescue Errno::EACCES
       sock = options[:socket] || "#{options[:host]}:#{options[:port]}"
-      raise ProcError, "unable to open socket: #{sock} (check permissions)"
+      raise ServiceError, "unable to open socket: #{sock} (check permissions)"
     end
 
     # handle process termination signals
@@ -271,7 +249,7 @@ module Sockd
 
       Process.waitpid
       unless wait_until { daemon_running? }
-        raise ProcError, "failed to start #{@name} service"
+        raise ServiceError, "failed to start #{name} service"
       end
     end
 
@@ -291,15 +269,13 @@ module Sockd
 
     # drop privileges to the specified user and group
     def drop_privileges(user, group)
-      uid = Etc.getpwnam(user).uid if user
-      gid = Etc.getgrnam(group).gid if group
-      gid = Etc.getpwnam(user).gid if group.nil? && user
+      uid, gid = user_id(user) if user
+      gid = group_id(group) if group
 
       Process::Sys.setgid(gid) if gid
       Process::Sys.setuid(uid) if uid
-    rescue ArgumentError, Errno::EPERM => e
-      # user or group does not exist
-      raise ProcError, "unable to drop privileges (#{e})"
+    rescue Errno::EPERM => e
+      raise ServiceError, "unable to drop privileges (#{e})"
     end
 
     # redirect our output as per configuration
@@ -329,7 +305,7 @@ module Sockd
       rescue Errno::EACCES, Errno::EISDIR
       end
       unless File.file?(path) && File.writable?(path)
-        raise ProcError, "unable to open file: #{path} (check permissions)"
+        raise ServiceError, "unable to open file: #{path} (check permissions)"
       end
       path
     end
@@ -341,5 +317,18 @@ module Sockd
       end
       timer > 0
     end
+
+    def user_id(user)
+      user = Etc.getpwnam(user)
+      [user.uid, user.gid]
+    rescue ArgumentError
+      raise ServiceError, "unable to find user: #{user}"
+    end
+
+    def group_id(group)
+      Etc.getgrnam(group).gid
+    rescue ArgumentError
+      raise ServiceError, "unable to find group: #{user}"
+    end
   end
 end

data/lib/sockd/version.rb

@@ -1,3 +1,3 @@
 module Sockd
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/sockd.rb

@@ -1,32 +1,176 @@
-require "sockd/errors"
-require "sockd/optparse"
+require "yaml"
+require "optparse"
 require "sockd/runner"
 require "sockd/version"
 
 module Sockd
 
-  # instantiate a new sockd service
-  def self.define(name, options = {}, &block)
-    Runner.define(name, options, &block)
-  end
+  class ParseError < OptionParser::ParseError; end
+  class ConfigFileError < RuntimeError; end
 
-  # instantiate command line option parser
-  def self.optparse(name, defaults = {}, &block)
-    OptionParser.new(name, defaults, &block)
-  end
+  class << self
+
+    def define(name = nil, options = {}, &block)
+      Runner.define(name = nil, options, &block)
+    end
+
+    alias new define
+
+    def run(name = nil, options = {}, &block)
+      parse define(name, options, &block)
+    end
+
+    def parse(runner, argv = ARGV, &block)
+      raise ArgumentError, 'You must provide an instance of Sockd::Runner' unless runner.class <= Runner
+      options = {}
+      parser = optparser(runner.name, options, &block)
+      command, *message = parser.parse(argv)
+
+      if options[:config_save]
+        save_path = options[:config_path] || runner.options[:config_path]
+        raise ParseError, 'no config file path specified, unable to save' unless save_path
+        save_yaml options, save_path
+
+        puts "config saved to: #{path}"
+        exit
+      end
+
+      if options[:config_path]
+        read_yaml options, options[:config_path]
+      elsif runner.options[:config_path] && File.file?(runner.options[:config_path])
+        read_yaml options, runner.options[:config_path]
+      end
+
+      runner.options.merge! options
+
+      case command
+      when nil
+        runner.options[:daemonize] = false
+        runner.start
+      when 'start', 'stop', 'restart'
+        raise ParseError, "invalid arguments for #{command}" unless message.empty?
+        runner.public_send command.to_sym
+      else
+        message.unshift command unless command == 'send'
+        raise ParseError, 'no message provided' if message.empty?
+        puts runner.send message.join(' ')
+      end
+    rescue OptionParser::ParseError => e
+      puts "Error: #{e.message}"
+      puts parser
+      puts ''
+      exit 1
+    rescue ConfigFileError, Runner::ServiceError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    private
+
+    def optparser(name, options)
+      OptionParser.new do |opts|
+        opts.program_name = name
+        opts.summary_width = 25
+        opts.banner = <<-EOF.gsub /^[ ]{8}/, ''
+
+        Usage: #{name} [options] <command> [<message>]
+
+        Commands:
+            #{name}                 run server without forking
+            #{name} start           start as a daemon
+            #{name} stop [-f]       stop a running daemon
+            #{name} restart         stop, then start the daemon
+            #{name} send <message>  send a message to a running daemon
+            #{name} <message>       send a message (send command implied)
+
+        Options:
+        EOF
+
+        # allow user to specify custom options
+        yield opts, options if block_given?
+
+        opts.on('-p', '--port PORT', String, 'Listen on TCP port PORT') do |port|
+          options[:port] = port
+          options[:socket] = nil
+        end
+
+        opts.on('-H', '--host HOST', String, 'Listen on HOST') do |host|
+          options[:host] = host
+          options[:socket] = nil
+        end
+
+        opts.on('-s', '--socket PATH', String,
+                'Listen on Unix domain socket PATH (disables TCP support)') do |path|
+          options[:socket] = File.expand_path(path)
+        end
+
+        opts.on('-m', '--mode MODE', OptionParser::OctalInteger,
+                'Set file permissions when using Unix socket') do |mode|
+          options[:mode] = mode
+        end
+
+        opts.on('-P', '--pid PATH', String, 'Where to write the PID file') do |path|
+          options[:pid_path] = File.expand_path(path)
+        end
+
+        opts.on('-l', '--log PATH', String, 'Where to write the log file') do |path|
+          options[:log_path] = File.expand_path(path)
+        end
+
+        opts.on('-u', '--user USER', String,
+                'Assume the identity of USER when running as a daemon') do |user|
+          options[:user] = user
+        end
+
+        opts.on('-g', '--group GROUP', String,
+                'Assume group GROUP when running as a daemon') do |group|
+          options[:group] = group
+        end
+
+        opts.on('-f', '--force',
+                'Force kill if SIGTERM fails when running "stop" command') do
+          options[:force] = true
+        end
+
+        opts.separator ''
+        opts.separator 'Additional Options:'
+
+        opts.on_tail('--config PATH', String,
+                'Load default parameters from YAML file at PATH') do |path|
+          options[:config_path] = File.expand_path(path)
+        end
+
+        opts.on_tail('--save', 'Save current parameters into a config file') do
+          options[:config_save] = true
+        end
+
+        opts.on_tail('-h', '--help', 'Display this usage information') do
+          puts opts
+          puts ''
+          exit
+        end
+      end
+    end
+
+    def read_yaml(options, path)
+      config = YAML.load_file(path).merge!(options)
+      options.replace(config)
+    rescue Errno::EACCES, Errno::EISDIR => e
+      raise ConfigFileError, "unable to read config (#{e.message})"
+    end
+
+    def save_yaml(options, path)
+      options[:mode] = sprintf('0%o', options[:mode]) if options[:mode]
+      options.delete(:config_path)
+      options.delete(:config_save)
 
-  # instantiate and run a sockd service using command line arguments
-  def self.run(name, options = {}, &block)
-    runner = define(name, options, &block)
-    parser = optparse(runner.name, runner.options)
-    argv = parser.parse!
-    runner.run(*argv)
-  rescue OptionParserError, BadCommandError => e
-    warn "Error: #{e.message}"
-    warn "#{parser}\n"
-    exit
-  rescue SockdError => e
-    warn "Error: #{e.message}"
-    exit
+      FileUtils.mkdir_p(File.dirname(path), mode: 0755)
+      File.open(path, 'w') do |file|
+        file.write options.to_yaml
+      end
+      File.chmod(0644, path)
+    rescue Errno::EACCES, Errno::EISDIR => e
+      raise ConfigFileError, "unable to save config (#{e.message})"
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sockd
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Mike Greiling
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-14 00:00:00.000000000 Z
+date: 2015-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,8 +53,6 @@ files:
 - examples/listd.rb
 - examples/piglatin.rb
 - lib/sockd.rb
-- lib/sockd/errors.rb
-- lib/sockd/optparse.rb
 - lib/sockd/runner.rb
 - lib/sockd/version.rb
 - sockd.gemspec

data/lib/sockd/errors.rb

@@ -1,15 +0,0 @@
-module Sockd
-
-  class SockdError < StandardError
-  end
-
-  class OptionParserError < SockdError
-  end
-
-  class BadCommandError < SockdError
-  end
-
-  class ProcError < SockdError
-  end
-
-end

data/lib/sockd/optparse.rb

@@ -1,121 +0,0 @@
-require "fileutils"
-require "optparse"
-require "shellwords"
-require "sockd/errors"
-
-module Sockd
-  class OptionParser
-
-    attr_accessor :name, :options, :callback
-
-    def initialize(name = nil, defaults = {}, &block)
-      @name = name || File.basename($0)
-      @options = defaults.replace({
-        host:      "127.0.0.1",
-        port:      0,
-        socket:    false,
-        mode:      0660,
-        daemonize: true,
-        pid_path:  "/var/run/#{safe_name}.pid",
-        log_path:  false,
-        force:     false,
-        user:      false,
-        group:     false
-      }.merge(defaults))
-      @callback = block if block_given?
-    end
-
-    def safe_name
-      name.gsub(/(^[0-9]*|[^0-9a-z])/i, '')
-    end
-
-    def parser
-      @parser ||= ::OptionParser.new do |opts|
-        opts.summary_width = 25
-        opts.banner = <<-EOF.gsub /^[ ]{8}/, ''
-        Usage: #{name} [options] <command> [<message>]
-
-        Commands:
-            #{name}                 run server without forking
-            #{name} start           start as a daemon
-            #{name} stop [-f]       stop a running daemon
-            #{name} restart         stop, then start the daemon
-            #{name} send <message>  send a message to a running daemon
-            #{name} <message>       send a message (send command implied)
-
-        Options:
-        EOF
-
-        instance_exec(opts, &callback) if callback
-
-        opts.on("-p", "--port PORT", String, "Listen on TCP port PORT (default: #{options[:port]})") do |x|
-          options[:port] = x
-          # prefer TCP connection if explicitly setting a port
-          options[:socket] = nil
-        end
-
-        opts.on("-H", "--host HOST", String, "Listen on HOST (default: #{options[:host]})") do |x|
-          options[:host] = x
-          # prefer TCP connection if explicitly setting a host
-          options[:socket] = nil
-        end
-
-        opts.on("-s", "--socket SOCKET", String, "Listen on Unix socket path (disables network support)", "(default: #{options[:socket]})") do |x|
-          options[:socket] = File.expand_path(x)
-        end
-
-        opts.on("-m", "--mode MODE", String, "Set file permissions when using Unix socket", "(default: #{options[:mode]})") do |x|
-          options[:mode] = x
-        end
-
-        opts.on("-P", "--pid FILE", String, "Where to write the PID file", "(default: #{options[:pid_path]})") do |x|
-          options[:pid_path] = File.expand_path(x)
-        end
-
-        opts.on("-l", "--log FILE", String, "Where to write the log file", "(default: #{options[:log_path]})") do |x|
-          options[:log_path] = File.expand_path(x)
-        end
-
-        opts.on("-u", "--user USER", String, "Assume the identity of USER when running as a daemon", "(default: #{options[:user]})") do |x|
-          options[:user] = x
-        end
-
-        opts.on("-g", "--group GROUP", String, "Assume group GROUP when running as a daemon", "(default: #{options[:group]})") do |x|
-          options[:group] = x
-        end
-
-        opts.on("-f", "--force", String, "Force kill if SIGTERM fails when running 'stop' command") do
-          options[:force] = true
-        end
-
-        opts.separator "\n  Additional Options:"
-
-        opts.on_tail("-h", "--help", "Display this usage information.") do
-          puts "\n#{opts}\n"
-          exit
-        end
-      end
-    end
-
-    def parse!(argv = nil)
-      argv ||= ARGV.dup
-      argv = Shellwords.shellwords argv if argv.is_a? String
-
-      parser.parse! argv
-
-      if argv.empty?
-        argv.push 'start'
-        options[:daemonize] = false
-      end
-      argv.unshift 'send' unless %w(start stop restart send).include?(argv.first)
-
-      argv
-    rescue ::OptionParser::InvalidOption, ::OptionParser::MissingArgument => e
-      raise OptionParserError.new e
-    end
-
-    def to_s
-      parser.to_s
-    end
-  end
-end