sockd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0a446b2a9f0577de1dc8f750e0d49f913490f12
+  data.tar.gz: 0e6d76f5c7d9443182ed00888445be74080b1067
+SHA512:
+  metadata.gz: cee27594593028ab2417be7cf4898fc3f6be8b0087bc54fe97a3dae408b212fc986ca3777efcba4f65ba88d0e493ecdffeb97fbbd88851e8fe61402cef0e6d83
+  data.tar.gz: c1c8c2f2ead721ba3b756802626ead69d5a3262931cd0255f3de4072a13b1cdab8cff3d4a4debf6516f10bb51ecfb4e78592a1684dc1329004367b178d01fc19

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.vagrant/machines/default/virtualbox/action_provision

@@ -0,0 +1 @@
+1.5:5b9af9bc-a6a4-4a38-bcee-3dd882a77565

data/.vagrant/machines/default/virtualbox/action_set_name

@@ -0,0 +1 @@
+1426302069

data/.vagrant/machines/default/virtualbox/id

@@ -0,0 +1 @@
+5b9af9bc-a6a4-4a38-bcee-3dd882a77565

data/.vagrant/machines/default/virtualbox/index_uuid

@@ -0,0 +1 @@
+c2db229506d4472b8fb6d1e0d697d20f

data/.vagrant/machines/default/virtualbox/private_key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEA7xjuC39O1pFg27/RWTeSTOwaGWqCYka1WpLBRd1nr/2mZw81
+yjBGmWRwkD686TMZR+id5x+4bDTE9VasiZ3OU9EX6thL+8epVPdkBBRaQqluXHzW
+soLZ1sP8GprJkTMEzUJyBPiVEl/feVW55yzTHWAgDUWWrp4qd7VvRmk4e0W25NRF
+69EMMvHMaFneHYJZ9BiDh2w2OAM1ehdyHU4ruWm8UTjwEzpT98fJSsUhBcColtZT
+J7+cN8ksSiaihUlbJjzSS36CWrX5jBXyE4RYCFSEoHzp3vdO756j9bQqfdqMLfS4
+25C2azX6bQehlR3eSxK5CHixgzcWyyb2ZnT5TQIDAQABAoIBAQDB9BwuMXCXuEi1
+Gi5NzDmesqwdT/xCko9M0N19ujQBXKae1YTR5kVu6z4wlOQT3AK3BWkJ8v5csJXR
+WyUNYXjdHzHirOE+dmHTbfexI31wtBa1agOTvXfOsx8Pyd6XLabIhw0NIUV0KVeU
+CsmKUR9UpgR6H6gzMFTM1N5WZMaPn5VatDCv8/1n3wju+7CHClPuPdYfAoNNTPY0
+uIMkMVwguO9EjgNitbzfickQNT37UNyKXyqccVfdyvR7nnrs8QMIUH6Ny+dHwVei
++mkeOmEK8+vzCz/6XaRkgZ8lp3tKDRgaoUqIIK2zHGoS3YfugkbMhjI8E8NFpXVi
+plNRzYQVAoGBAPyTEsXD/1qVvIibowPzA/kvb1QAzkdosxY2X5O7eYbGWB7bQSvt
+hdp48/EalWOjp0CsUYCmXZRjU7BfIodbvVn87hAS2cc1BHqAgFmrx31jp/qfc4Zc
+iqjJ/dnUto/yw/9ymg6uAc4dWQkzFsUj/gpEFJYuDsjZxCDFEe4DUUiLAoGBAPJX
+EInRvuq6351Yq5YqHSuKhCxDAsF5Us+9dQqglQ5C7T/XuTb3bbgryvKU05FUVTQ4
+zI6cRbDKkamOMK3wFdSX7It6h7VYqnuyb+BB2kx/GYkguI2Gh2jDvu0GS8RmnVOe
+MzAACZW56jBCH8TIo1WyYbgnFsi5br9W/JrABiiHAoGAaaTKsVWttSH0Xd9bbAd1
+ngCtPCGqJkwwvBW6HHzJ9Al6Sk3DELCk0CDPSAWqfqaxCmgJHxp3Ad4Z3yertZo1
+tTIKEUcRODWAzgx5owgqxNOuKzIOjCChDsCOIVLLmaIdQPeaYJF/x8qWtzZbS9Im
+K/0V70sMfA457sr/GOLiWMkCgYBG4tTBm4q+2n7CZcd7G0KBE/lpgQhzU2u3vHFZ
+9HLlQwpm3FEfFO0RLC4nGwVvwz1REzQymt9/wSEueZsfpdSc5PuaKPM9RnxHxoAX
+Fuwl6B+uDtYs/6boLCnS5z6Oan2mkeXjKn+jPkiUaSMlypKMZKtU1IpDmIoeifFF
+ytmCTQKBgHOzJIaY5b/s0mRbBGKYPT7idRWT0a1XVvAsJOTTuYNsbzGpWGcNPr+n
+YmO2cl10W4YntFG3+U7uZYdEIqNK+mc1hs801dKmGdJqeBGwf0N6memJMLRZG+HX
+FI8PY96eiNVJfIjG/tORr443ziJTlWJJf//pOvHEtQE54erC6ocI
+-----END RSA PRIVATE KEY-----

data/.vagrant/machines/default/virtualbox/synced_folders

@@ -0,0 +1 @@
+{"virtualbox":{"/tmp/vagrant-opsworks":{"guestpath":"/tmp/vagrant-opsworks","hostpath":"/Users/mike/.vagrant.d/boxes/ubuntu1404-opsworks/0/virtualbox","disabled":false},"/vagrant":{"guestpath":"/vagrant","hostpath":"/Users/mike/Projects/sockd","disabled":false}}}

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sockd.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 PixelCog Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Sockd
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sockd'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sockd
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sockd/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/Vagrantfile

@@ -0,0 +1,4 @@
+Vagrant.configure("2") do |config|
+  config.vm.box = "ubuntu1404-opsworks"
+  config.vm.network "private_network", ip: "10.10.10.11"
+end

data/lib/sockd/errors.rb

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

data/lib/sockd/optparse.rb

@@ -0,0 +1,117 @@
+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,
+        daemonize: true,
+        pid_path:  "/var/run/#{safe_name}.pid",
+        log_path:  false,
+        force:     false,
+        user:      nil,
+        group:     nil,
+        verbose:   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 (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("-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

data/lib/sockd/runner.rb

@@ -0,0 +1,308 @@
+require "logger"
+require "socket"
+require "fileutils"
+require "sockd/errors"
+
+module Sockd
+  class Runner
+
+    attr_reader :options, :name
+
+    class << self
+      def define(*args, &block)
+        self.new(*args, &block)
+      end
+    end
+
+    def initialize(name, options = {}, &block)
+      @name = name
+      @options = {
+        :host      => "127.0.0.1",
+        :port      => 0,
+        :socket    => false,
+        :daemonize => true,
+        :pid_path  => "/var/run/#{safe_name}.pid",
+        :log_path  => false,
+        :force     => false,
+        :user      => nil,
+        :group     => nil
+      }.merge(options)
+
+      [:setup, :teardown, :handle].each do |opt|
+        self.public_send(opt, &options[opt]) if options[opt].respond_to?(:call)
+      end
+
+      yield self if block_given?
+    end
+
+    # merge options when set with self.options = {...}
+    def options=(val)
+      @options.merge!(val)
+    end
+
+    # generate a path-safe and username-safe string from our daemon name
+    def safe_name
+      name.gsub(/(^[0-9]*|[^0-9a-z])/i, '')
+    end
+
+    # define a "setup" callback by providing a block, or trigger the callback
+    # @runner.setup { |opts| Server.new(...) }
+    def setup(&block)
+      return self if block_given? && @setup = block
+      @setup.call(self) if @setup
+    end
+
+    # define a "teardown" callback by providing a block, or trigger the callback
+    # @runner.teardown { log "shutting down" }
+    def teardown(&block)
+      return self if block_given? && @teardown = block
+      @teardown.call(self) if @teardown
+    end
+
+    # define our socket handler by providing a block, or trigger the callback
+    # with the provided message
+    # @runner.handle { |msg| if msg == 'foo' then return 'bar' ... }
+    def handle(message = nil, &block)
+      return self if block_given? && @handle = block
+      @handle || (raise SockdError, "No message handler provided.")
+      @handle.call(message, self)
+    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
+      if options[:daemonize]
+        pid = daemon_running?
+        raise ProcError, "#{name} process already running (#{pid})" if pid
+        log "starting #{name} process..."
+        return self unless daemonize
+      end
+
+      drop_privileges options[:user], options[:group]
+
+      setup
+
+      on_interrupt do |signal|
+        log "#{signal} received, shutting down..."
+        teardown
+        exit 130
+      end
+
+      serve
+    end
+
+    # stop our service
+    def stop
+      if daemon_running?
+        pid = stored_pid
+        Process.kill('TERM', pid)
+        log "SIGTERM sent to #{name} (#{pid})"
+        if !wait_until(2) { daemon_stopped? pid } && options[:force]
+          Process.kill('KILL', pid)
+          log "SIGKILL sent to #{name} (#{pid})"
+        end
+        raise ProcError.new("unable to stop #{name} process") if daemon_running?
+      else
+        log "#{name} process not running"
+      end
+      self
+    end
+
+    # restart our service
+    def restart
+      stop
+      start
+    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"
+      end
+      puts response
+    end
+
+    protected
+
+    # run a server loop, passing data off to our handler
+    def serve
+      server do |server|
+        log "listening on " + server.local_address.inspect_sockaddr
+        while 1
+          sock = server.accept
+          begin
+            # wait for input
+            if IO.select([sock], nil, nil, 2.0)
+              handle sock
+            else
+              log "connection timed out"
+            end
+          rescue Errno::EPIPE, Errno::ECONNRESET
+            log "connection broken"
+          end
+          sock.close unless sock.closed?
+        end
+      end
+    end
+
+    # return a UNIXServer or TCPServer instance depending on config
+    def server(&block)
+      if options[:socket]
+        UNIXServer.open(options[:socket], &block)
+      else
+        TCPServer.open(options[:host], options[:port], &block)
+      end
+    rescue Errno::EACCES
+      sock = options[:socket] || "#{options[:host]}:#{options[:port]}"
+      raise ProcError, "unable to open socket: #{sock} (check permissions)"
+    end
+
+    # return a UNIXSocket or TCPSocket instance depending on config
+    def client(&block)
+      if options[:socket]
+        UNIXSocket.open(options[:socket], &block)
+      else
+        TCPSocket.open(options[:host], options[:port], &block)
+      end
+    rescue Errno::EACCES
+      sock = options[:socket] || "#{options[:host]}:#{options[:port]}"
+      raise ProcError, "unable to open socket: #{sock} (check permissions)"
+    end
+
+    # handle process termination signals
+    def on_interrupt(&block)
+      trap("INT")  { yield "SIGINT" }
+      trap("QUIT") { yield "SIGQUIT" }
+      trap("TERM") { yield "SIGTERM" }
+    end
+
+    # daemonize a process. returns true from the forked process, false otherwise
+    def daemonize
+
+      # ensure pid file and log file are writable if provided
+      pid_path = options[:pid_path] ? writable_file(options[:pid_path]) : nil
+      log_path = options[:log_path] ? writable_file(options[:log_path]) : nil
+
+      unless fork
+        Process.setsid
+        exit if fork
+        File.umask 0000
+        Dir.chdir "/"
+
+        # save pid file
+        File.open(pid_path, 'w') { |f| f.write Process.pid } if pid_path
+
+        # redirect our io
+        setup_logging(log_path)
+
+        # trap and ignore SIGHUP
+        Signal.trap('HUP') {}
+
+        # trap reopen our log files on SIGUSR1
+        Signal.trap('USR1') { setup_logging(log_path) }
+
+        return true
+      end
+
+      Process.waitpid
+      unless wait_until { daemon_running? }
+        raise ProcError, "failed to start #{@name} service"
+      end
+    end
+
+    # returns the process id if a daemon is running with our pid file
+    def daemon_running?(pid = nil)
+      pid ||= stored_pid
+      Process.kill(0, pid) if pid
+      pid
+    rescue Errno::ESRCH
+      false
+    end
+
+    # reverse of daemon_running?
+    def daemon_stopped?(pid = nil)
+      !daemon_running? pid
+    end
+
+    # 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
+
+      Process::Sys.setuid(uid) if uid
+      Process::Sys.setgid(gid) if gid
+    rescue ArgumentError => e
+      # user or group does not exist
+      raise ProcError, "unable to drop privileges (#{e})"
+    end
+
+    # redirect our output as per configuration
+    def setup_logging(log_path)
+      log_path ||= '/dev/null'
+      $stdin.reopen '/dev/null'
+      $stdout.reopen(log_path, 'a')
+      $stderr.reopen $stdout
+      $stdout.sync = true
+    end
+
+    # returns the pid stored in our pid_path
+    def stored_pid
+      return false unless options[:pid_path]
+      path = File.expand_path(options[:pid_path])
+      return false unless File.file?(path) && !File.zero?(path)
+      File.read(path).chomp.to_i
+    end
+
+    # ensure a writable file exists at the specified path
+    def writable_file(path)
+      path = File.expand_path(path)
+      begin
+        FileUtils.mkdir_p(File.dirname(path), :mode => 0755)
+        FileUtils.touch path
+        File.chmod(0644, path)
+      rescue Errno::EACCES, Errno::EISDIR
+      end
+      unless File.file?(path) && File.writable?(path)
+        raise ProcError, "unable to open file: #{path} (check permissions)"
+      end
+      path
+    end
+
+    def wait_until(timer = 5, interval = 0.1, &block)
+      until timer < 0 or block.call
+        timer -= interval
+        sleep interval
+      end
+      timer > 0
+    end
+
+    def log(message)
+      puts Time.now.strftime('%Y-%m-%d %H:%M:%S: ') + message
+    end
+  end
+end

data/lib/sockd/version.rb

@@ -0,0 +1,3 @@
+module Sockd
+  VERSION = "0.1.0"
+end

data/lib/sockd.rb

@@ -0,0 +1,31 @@
+require "sockd/errors"
+require "sockd/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
+
+  # instantiate command line option parser
+  def self.optparse(name, defaults = {}, &block)
+    OptionParser.new(name, defaults, &block)
+  end
+
+  # instantiate and run a sockd service using command line arguments
+  def self.run(name, options = {}, &block)
+    parser = optparse(name, options)
+    argv = parser.parse!
+    define(name, options, &block).run(*argv)
+  rescue OptionParserError, BadCommandError => e
+    warn "Error: #{e.message}"
+    warn "#{parser}\n"
+    exit
+  rescue SockdError => e
+    warn "Error: #{e.message}"
+    exit
+  end
+end

data/sockd.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sockd/version'
+
+Gem::Specification.new do |s|
+  s.name    = "sockd"
+  s.version = Sockd::VERSION
+  s.license = "MIT"
+
+  s.summary     = "A framework for single-threaded ruby socket daemons"
+  s.description = "Sockd makes it easy to create a single-threaded daemon which can listen on a TCP or Unix socket and respond to commands"
+
+  s.authors  = ["Mike Greiling"]
+  s.email    = "mike@pixelcog.com"
+  s.homepage = "http://pixelcog.com/"
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler", "~> 1.7"
+  s.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: sockd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mike Greiling
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Sockd makes it easy to create a single-threaded daemon which can listen
+  on a TCP or Unix socket and respond to commands
+email: mike@pixelcog.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .vagrant/machines/default/virtualbox/action_provision
+- .vagrant/machines/default/virtualbox/action_set_name
+- .vagrant/machines/default/virtualbox/id
+- .vagrant/machines/default/virtualbox/index_uuid
+- .vagrant/machines/default/virtualbox/private_key
+- .vagrant/machines/default/virtualbox/synced_folders
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- Vagrantfile
+- lib/sockd.rb
+- lib/sockd/errors.rb
+- lib/sockd/optparse.rb
+- lib/sockd/runner.rb
+- lib/sockd/version.rb
+- sockd.gemspec
+homepage: http://pixelcog.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A framework for single-threaded ruby socket daemons
+test_files: []