quark 0.1.4 → 0.2.0

data/bin/quark

@@ -30,17 +30,26 @@ module Quark
 
         # -----------------------------------------------------------------------------
           opts.on('-S', '--socket FILE', 'Location of the Unix socket to accept commands from') do |file|
-            Quark::Config.set("quark.socket", file)
+            Quark::Config.set("quark.socket.enabled", true)
+            Quark::Config.set("quark.socket.path", file)
           end
 
         # -----------------------------------------------------------------------------
           opts.on('-a', '--address ADDR', 'The IP address for all servers to listen on') do |addr|
-            Quark::Config.set("quark.address", addr)
+            Quark::Config.get("quark",{}).each do |k,v|
+              if v.is_a?(Hash) and not v.get(:address).nil?
+                Quark::Config.set("quark.#{k}.address", addr)
+              end
+            end
           end
 
         # -----------------------------------------------------------------------------
-          opts.on('-p', '--port PORT', 'The TCP/UDP port to listen on') do |port|
-            Quark::Config.set("quark.port", port.to_i)
+          opts.on('-p', '--port PORT', 'The port for all servers to listen on') do |port|
+            Quark::Config.get("quark",{}).each do |k,v|
+              if v.is_a?(Hash) and not v.get(:port).nil?
+                Quark::Config.set("quark.#{k}.port", port.to_i)
+              end
+            end
           end
 
         # -----------------------------------------------------------------------------
@@ -87,11 +96,13 @@ module Quark
 
         # -----------------------------------------------------------------------------
           opts.on('', '--http-address ADDR', 'The IP address for the HTTP server to listen on') do |addr|
+            Quark::Config.set("quark.http.enabled", true)
             Quark::Config.set("quark.http.address", addr)
           end
 
         # -----------------------------------------------------------------------------
           opts.on('', '--http-port PORT', 'The HTTP port to listen on') do |port|
+            Quark::Config.set("quark.http.enabled", true)
             Quark::Config.set("quark.http.port", port.to_i)
           end
 
@@ -100,6 +111,23 @@ module Quark
             Quark::Config.set("quark.http.cors", mode)
           end
 
+        # -----------------------------------------------------------------------------
+          opts.on('-W', '--[no-]ws', 'Enable/disable Websocket server') do |mode|
+            Quark::Config.set("quark.websocket.enabled", mode)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('', '--ws-address ADDR', 'The IP address for the Websocket server to listen on') do |addr|
+            Quark::Config.set("quark.websocket.enabled", true)
+            Quark::Config.set("quark.websocket.address", addr)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('', '--ws-port PORT', 'The Websocket port to listen on') do |port|
+            Quark::Config.set("quark.websocket.enabled", true)
+            Quark::Config.set("quark.websocket.port", port.to_i)
+          end
+
         # -----------------------------------------------------------------------------
           opts.on('-D', '--debug', 'Enable debug mode') do
             Quark::Config.set("debug", true)

data/lib/quark.rb

@@ -4,219 +4,6 @@ require 'redis'
 require 'hiredis'
 require 'em-synchrony'
 require 'multi_json'
+require 'quark/errors'
 require 'quark/config'
-
-module Quark
-  class Error < Exception; end
-  class ArgumentError < Error; end
-  class InvalidCommand < Error; end
-
-  module SocketServer
-    Dir[File.join(File.dirname(__FILE__), "quark", "commands", "*.rb")].each do |rb|
-      require "#{rb.gsub(/\.rb$/,'')}"
-    end
-
-    def post_init()
-      self.setup()
-    end
-
-    def receive_data(data)
-      puts "DEBUG: Received '#{data}'" if Quark::Config.get("debug")
-      send_json(Quark::SocketServer.process_command(data))
-    end
-
-    def send_json(data)
-      send_data(MultiJson.dump(data)+"\n")
-    end
-
-    def self.setup(redis, prefix='quark')
-      @redis   = redis
-      @_prefix = prefix
-    end
-
-    def self.process_command(data)
-    # if the data perfectly resembles a graphite-formatted metric (without a command prefix)
-    # then assume the command is "observe"
-      if Quark::Config.get("quark.graphite_compat") and data =~ /^[\w\.\-]+ -?[\d\.]+ \d{10,13}$/
-        command   = "OBSERVE"
-        arguments = data.chomp
-      else
-        command, arguments = data.chomp.split(' ',2)
-      end
-
-      begin
-        if methods.include?(:"process_command_#{command.downcase}")
-          rv = send(:"process_command_#{command.downcase}", arguments)
-          if rv.nil?
-            return {
-              :success => true
-            }
-          else
-            return {
-              :success => true,
-              :command => data.chomp,
-              :results => rv
-            }
-          end
-        else
-          raise Quark::InvalidCommand.new("Unknown command '#{command.upcase}'")
-        end
-
-      rescue Quark::Error => e
-        return {
-          :success => false,
-          :command => data.chomp,
-          :error => {
-            :class   => e.class.name,
-            :message => e.message
-          }
-        }
-
-      rescue Exception => e
-        return {
-          :success => false,
-          :command => data.chomp,
-          :error => {
-            :class     => e.class.name,
-            :message   => e.message,
-            :backtrace => e.backtrace
-          }
-        }
-      end
-    end
-
-    def unbind()
-    end
-  end
-
-  class Server
-    def self.setup()
-      Quark::Config.set("quark.address",         "127.0.0.1")
-      Quark::Config.set("quark.port",            12161)
-      Quark::Config.set("quark.blocksize",       3600000)
-      Quark::Config.set("quark.tcp.enabled",     true)
-      Quark::Config.set("quark.udp.enabled",     false)
-      Quark::Config.set("quark.http.enabled",    false)
-      Quark::Config.set("quark.http.port",       12180)
-      Quark::Config.set("quark.http.cors",       false)
-      Quark::Config.set("quark.graphite_compat", true)
-      Quark::Config.set("debug",                 false)
-      nil
-    end
-
-    def self.connect()
-      @redis = Redis.new({
-        :host => Quark::Config.get("redis.host", "127.0.0.1"),
-        :port => Quark::Config.get("redis.port", 6379).to_i,
-        :db   => Quark::Config.get("redis.db", 0).to_i
-      })
-
-      @_prefix = Quark::Config.get("redis.prefix", "quark")
-
-      Quark::SocketServer.setup(@redis, @_prefix)
-    end
-
-    def self.run()
-      connect() unless defined?(@redis)
-
-      @address  = Quark::Config.get("quark.address")
-      @port     = Quark::Config.get("quark.port")
-      @filename = Quark::Config.get("quark.socket")
-
-      EM.run do
-        Signal.trap("INT")  { Quark::Server.quit() }
-        Signal.trap("TERM") { Quark::Server.quit() }
-
-        if Quark::Config.get("debug")
-          puts "Debug mode is ON"
-        end
-
-      # socket
-        if not @filename.nil? and File.writable?(File.dirname(@filename))
-          puts "Starting socket server at #{@filename}..."
-          EM::start_server(@filename, Quark::SocketServer)
-        end
-
-      # UDP server
-        if Quark::Config.get("quark.udp.enabled") === true
-          @udp_address = Quark::Config.get("quark.udp.address", @address)
-          @udp_port    = Quark::Config.get("quark.udp.port",    @port)
-
-          puts "Starting UDP server on #{@udp_address}:#{@udp_port}..."
-          EM::open_datagram_socket(@udp_address, @udp_port, Quark::SocketServer)
-        end
-
-      # TCP server
-        if Quark::Config.get("quark.tcp.enabled") === true
-          @tcp_address = Quark::Config.get("quark.tcp.address", @address)
-          @tcp_port    = Quark::Config.get("quark.tcp.port",    @port)
-
-          puts "Starting TCP server on #{@tcp_address}:#{@tcp_port}..."
-          EM::start_server(@tcp_address, @tcp_port, Quark::SocketServer)
-        end
-
-      # HTTP server
-        if Quark::Config.get("quark.http.enabled") === true
-          @http_address = Quark::Config.get("quark.http.address", @address)
-          @http_port    = Quark::Config.get("quark.http.port",    12180)
-
-          puts "Starting HTTP server on #{@http_address}:#{@http_port}..."
-          require 'quark/servers/http'
-
-          Quark::Server::HttpServer.new({
-            :address => @http_address,
-            :port    => @http_port
-          }).run()
-        end
-
-        if Quark::Config.get("quark.graphite_compat")
-          puts "Graphite compatibility mode enabled: all sockets will accept Graphite-formatted metrics as observations"
-        end
-      end
-    end
-
-    def self.daemonize()
-      return @_service if defined?(@_service)
-
-      @_service = proc do
-        self.run()
-      end
-
-      EM.defer(@_service)
-      return @_service
-    end
-
-
-  # removes metrics that match keys and (optionally) are older than 'to'
-  # if 'to' is negative, it is assumed to be n-seconds ago
-  #
-    def self.purge(keys, to=nil)
-      keys = [@_prefix, keys, '*'].join(':') if not keys.start_with?(@_prefix)
-      now = (Time.now.to_f * 1000).to_i
-      rv = []
-
-      @redis.keys(keys).each do |key|
-        x, name, block = key.split(':', 3)
-        block = block.to_i
-
-        if ((to = Integer(to)) rescue false)
-          if to < 0
-            to = now - (-1 * to * 1000)
-          end
-        end
-
-        if to.nil? or block < (to/Quark::Config.get("quark.blocksize")).to_i
-          @redis.del(key)
-          rv << key
-        end
-      end
-
-      rv
-    end
-
-    def self.quit()
-      puts "Stopping Quark..."
-      EM.stop()
-    end
-  end
-end
+require 'quark/server'

data/lib/quark/base_server.rb

@@ -0,0 +1,13 @@
+module Quark
+  class Server
+    class BaseServer
+      def self.start(options=nil)
+        return self.new(options).run()
+      end
+
+      def self.to_s()
+        self.name.split('::').last.gsub('Server','').upcase
+      end
+    end
+  end
+end

data/lib/quark/command_processor.rb

@@ -0,0 +1,83 @@
+module Quark
+  module CommandProcessor
+    Dir[File.join(File.dirname(__FILE__), "commands", "*.rb")].each do |cmd|
+      cmd = File.basename(cmd, '.rb')
+      require "quark/commands/#{cmd}"
+    end
+
+    def post_init()
+    end
+
+    def receive_data(data)
+      puts "DEBUG: Received '#{data.chomp.strip}'" if Quark::Config.get("debug")
+      data = Quark::CommandProcessor.process_command(data)
+      send_json(data)
+      data
+    end
+
+    def send_json(data)
+      data = MultiJson.dump(data)+"\n"
+      puts "DEBUG: Replying with #{data.chomp}" if Quark::Config.get("debug")
+      send_data(data)
+    end
+
+    def self.setup(redis, prefix='quark')
+      @redis   = redis
+      @_prefix = prefix
+    end
+
+    def self.process_command(data)
+    # if the data perfectly resembles a graphite-formatted metric (without a command prefix)
+    # then assume the command is "observe"
+      if Quark::Config.get("quark.graphite_compat") and data =~ /^[\w\.\-]+ -?[\d\.]+ \d{10,13}$/
+        command   = "OBSERVE"
+        arguments = data.chomp
+      else
+        command, arguments = data.chomp.split(' ',2)
+      end
+
+      begin
+        if methods.include?(:"process_command_#{command.downcase}")
+          rv = send(:"process_command_#{command.downcase}", arguments)
+          if rv.nil?
+            return {
+              :success => true
+            }
+          else
+            return {
+              :success => true,
+              :command => data.chomp,
+              :results => rv
+            }
+          end
+        else
+          raise Quark::InvalidCommand.new("Unknown command '#{command.upcase}'")
+        end
+
+      rescue Quark::Error => e
+        return {
+          :success => false,
+          :command => data.chomp,
+          :error => {
+            :class   => e.class.name,
+            :message => e.message
+          }
+        }
+
+      rescue Exception => e
+        return {
+          :success => false,
+          :command => data.chomp,
+          :error => {
+            :class     => e.class.name,
+            :message   => e.message,
+            :backtrace => e.backtrace
+          }
+        }
+      end
+    end
+
+    def unbind()
+    end
+  end
+end

data/lib/quark/commands/fetch.rb

@@ -1,5 +1,5 @@
 module Quark
-  module SocketServer
+  module CommandProcessor
     def self.process_command_fetch(data)
       raise Quark::ArgumentError.new("FETCH command requires at least 1 argument") if data.nil? or data.empty?
 

data/lib/quark/commands/observe.rb

@@ -1,5 +1,5 @@
 module Quark
-  module SocketServer
+  module CommandProcessor
     def self.process_command_observe(data)
       id, value, timestamp = data.chomp.split(' ')
       timestamp = timestamp.to_i

data/lib/quark/commands/peek.rb

@@ -1,6 +1,6 @@
 module Quark
-  module SocketServer
-    def process_command_peek(data)
+  module CommandProcessor
+    def self.process_command_peek(data)
       rv = {}
       keys = @redis.keys("#{@_prefix}:#{data}:*")
       peek_keys = []
@@ -17,9 +17,11 @@ module Quark
 
     # now that we have the most recent bucket, pull the most recent value from that bucket
       peek_keys.each do |peek|
-        rv[peek.split(':')[1]] = @redis.hgetall(peek).sort{|a,b|
+        data = @redis.hgetall(peek).sort{|a,b|
           a[0] <=> b[0]
         }.last
+
+        rv[peek.split(':')[1]] = [data[0].to_i, data[1].to_f]
       end
 
       return rv

data/lib/quark/commands/ping.rb

@@ -1,5 +1,5 @@
 module Quark
-  module SocketServer
+  module CommandProcessor
     require 'socket'
 
     def self.process_command_ping(data)

data/lib/quark/errors.rb

@@ -0,0 +1,5 @@
+module Quark
+  class Error < Exception; end
+  class ArgumentError < Error; end
+  class InvalidCommand < Error; end
+end

data/lib/quark/server.rb

@@ -0,0 +1,111 @@
+require 'quark/base_server'
+require 'quark/command_processor'
+
+
+module Quark
+  class Server
+    def self.setup()
+      Quark::Config.set("debug",                   false)
+      Quark::Config.set("quark.blocksize",         3600000)
+      Quark::Config.set("quark.graphite_compat",   true)
+      Quark::Config.set("quark.http.address",      "127.0.0.1")
+      Quark::Config.set("quark.http.cors",         false)
+      Quark::Config.set("quark.http.enabled",      false)
+      Quark::Config.set("quark.http.port",         12180)
+      Quark::Config.set("quark.socket.path",       "/var/run/quark.sock")
+      Quark::Config.set("quark.tcp.address",       "127.0.0.1")
+      Quark::Config.set("quark.tcp.enabled",       true)
+      Quark::Config.set("quark.tcp.port",          12161)
+      Quark::Config.set("quark.udp.address",       "127.0.0.1")
+      Quark::Config.set("quark.udp.enabled",       false)
+      Quark::Config.set("quark.udp.port",          12161)
+      Quark::Config.set("quark.websocket.address", "127.0.0.1")
+      Quark::Config.set("quark.websocket.enabled", false)
+      Quark::Config.set("quark.websocket.port",    12181)
+      nil
+    end
+
+    def self.connect()
+      @redis = Redis.new({
+        :host => Quark::Config.get("redis.host", "127.0.0.1"),
+        :port => Quark::Config.get("redis.port", 6379).to_i,
+        :db   => Quark::Config.get("redis.db", 0).to_i
+      })
+
+      @_prefix = Quark::Config.get("redis.prefix", "quark")
+
+      Quark::CommandProcessor.setup(@redis, @_prefix)
+    end
+
+    def self.run()
+      connect() unless defined?(@redis)
+
+      EM.run do
+        Signal.trap("INT")  { Quark::Server.quit() }
+        Signal.trap("TERM") { Quark::Server.quit() }
+
+        if Quark::Config.get("debug")
+          puts "Debug mode is ON"
+        end
+
+        Dir[File.join(File.dirname(__FILE__), 'servers', '*.rb')].each do |server|
+          server = File.basename(server,'.rb')
+
+        # dynamically load and run all enabled servers
+          if Quark::Config.get("quark.#{server.downcase}.enabled") === true
+            require "quark/servers/#{server.downcase}"
+            Quark::Server.const_get("#{server.capitalize}Server").start()
+          end
+        end
+
+        if Quark::Config.get("quark.graphite_compat")
+          puts "Graphite compatibility mode enabled: all sockets will accept Graphite-formatted metrics as observations"
+        end
+      end
+    end
+
+    def self.daemonize()
+      return @_service if defined?(@_service)
+
+      @_service = proc do
+        self.run()
+      end
+
+      EM.defer(@_service)
+      return @_service
+    end
+
+
+  # removes metrics that match keys and (optionally) are older than 'to'
+  # if 'to' is negative, it is assumed to be n-seconds ago
+  #
+    def self.purge(keys, to=nil)
+      keys = [@_prefix, keys, '*'].join(':') if not keys.start_with?(@_prefix)
+      now = (Time.now.to_f * 1000).to_i
+      rv = []
+
+      @redis.keys(keys).each do |key|
+        x, name, block = key.split(':', 3)
+        block = block.to_i
+
+        if ((to = Integer(to)) rescue false)
+          if to < 0
+            to = now - (-1 * to * 1000)
+          end
+        end
+
+        if to.nil? or block < (to/Quark::Config.get("quark.blocksize")).to_i
+          @redis.del(key)
+          rv << key
+        end
+      end
+
+      rv
+    end
+
+    def self.quit()
+      puts "Stopping Quark..."
+      EM.stop()
+    end
+  end
+end

data/lib/quark/servers/http.rb

@@ -1,6 +1,6 @@
 module Quark
   class Server
-    class HttpServer
+    class HttpServer < BaseServer
       require 'sinatra'
       require 'sinatra/cross_origin'
       require 'thin'
@@ -35,15 +35,15 @@ module Quark
         end
 
         get '/call/:command/?*' do
-          MultiJson.dump(Quark::SocketServer.process_command("#{params[:command].upcase} #{params[:splat].first.gsub('/',' ')}".strip))
+          MultiJson.dump(Quark::CommandProcessor.process_command("#{params[:command].upcase} #{params[:splat].first.gsub('/',' ')}".strip))
         end
 
         get '/observe/:metric/:value/?' do
-          MultiJson.dump(Quark::SocketServer.process_command_observe("#{params[:metric]} #{params[:value]} #{(Time.now.to_f * 1000).to_i}"))
+          MultiJson.dump(Quark::CommandProcessor.process_command_observe("#{params[:metric]} #{params[:value]} #{(Time.now.to_f * 1000).to_i}"))
         end
 
         get '/observe/:metric/:value/:timestamp/?' do
-          MultiJson.dump(Quark::SocketServer.process_command_observe("#{params[:metric]} #{params[:value]} #{params[:timestamp]}"))
+          MultiJson.dump(Quark::CommandProcessor.process_command_observe("#{params[:metric]} #{params[:value]} #{params[:timestamp]}"))
         end
 
         def _quark_command(command, payload)
@@ -69,6 +69,8 @@ module Quark
       end
 
       def run()
+        puts "Starting #{self.class.to_s} server on #{@_options.get(:address)}:#{@_options.get(:port)}..."
+
         Thin::Logging.silent = true unless Quark::Config.get("debug")
         Thin::Server.start(@_options.get(:address,'127.0.0.1'), @_options.get(:port, 12180).to_i, Base.new(), {
           :signals  => false,

data/lib/quark/servers/socket.rb

@@ -0,0 +1,21 @@
+
+module Quark
+  class Server
+    class SocketServer < BaseServer
+      require 'eventmachine'
+
+      def initialize(options=nil)
+        @_options = options || Quark::Config.get("quark.socket",{})
+      end
+
+      def run()
+        puts "Starting #{self.class.to_s} server at #{@_options.get(:path)}..."
+        EM::start_server(@_options.get(:path, "/var/run/quark.sock"), Quark::CommandProcessor)
+      end
+
+      def self.to_s()
+        "socket"
+      end
+    end
+  end
+end

data/lib/quark/servers/tcp.rb

@@ -0,0 +1,17 @@
+
+module Quark
+  class Server
+    class TcpServer < BaseServer
+      require 'eventmachine'
+
+      def initialize(options=nil)
+        @_options = options || Quark::Config.get("quark.tcp",{})
+      end
+
+      def run()
+        puts "Starting #{self.class.to_s} server on #{@_options.get(:address)}:#{@_options.get(:port)}..."
+        EM::start_server(@_options.get(:address, '127.0.0.1'), @_options.get(:port, 12161).to_i, Quark::CommandProcessor)
+      end
+    end
+  end
+end

data/lib/quark/servers/udp.rb

@@ -0,0 +1,17 @@
+
+module Quark
+  class Server
+    class UdpServer < BaseServer
+      require 'eventmachine'
+
+      def initialize(options=nil)
+        @_options = options || Quark::Config.get("quark.udp",{})
+      end
+
+      def run()
+        puts "Starting #{self.class.to_s} server on #{@_options.get(:address)}:#{@_options.get(:port)}..."
+        EM::open_datagram_socket(@_options.get(:address, '127.0.0.1'), @_options.get(:port, 12161).to_i, Quark::CommandProcessor)
+      end
+    end
+  end
+end

data/lib/quark/servers/websocket.rb

@@ -0,0 +1,52 @@
+
+module Quark
+  class Server
+    class WebsocketServer < BaseServer
+      require 'eventmachine'
+      require 'em-websocket'
+
+      class WebsocketProcessor
+        include Quark::CommandProcessor
+
+        def initialize(ws)
+          @ws = ws
+        end
+
+        def send_data(data)
+          @ws.send(data)
+        end
+      end
+
+      def initialize(options=nil)
+        @_options = options || Quark::Config.get("quark.websocket",{})
+      end
+
+      def run()
+        puts "Starting #{self.class.to_s} server on #{@_options.get(:address)}:#{@_options.get(:port)}..."
+
+        EM::WebSocket.run({
+          :host => @_options.get(:address, "127.0.0.1"),
+          :port => @_options.get(:port, 12181).to_i
+        }) do |ws|
+          processor = WebsocketProcessor.new(ws)
+
+          ws.onopen do
+            processor.post_init()
+          end
+
+          ws.onclose do
+            processor.unbind()
+          end
+
+          ws.onmessage do |data|
+            processor.receive_data(data)
+          end
+        end
+      end
+
+      def self.to_s()
+        "Websocket"
+      end
+    end
+  end
+end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: quark
 version: !ruby/object:Gem::Version
+  version: 0.2.0
   prerelease: 
-  version: 0.1.4
 platform: ruby
 authors:
 - Gary Hetzel
@@ -12,149 +12,115 @@ cert_chain: []
 date: 2014-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.7.9
-    none: false
-  prerelease: false
   name: multi_json
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &20685860 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '='
+    - - =
       - !ruby/object:Gem::Version
         version: 1.7.9
-    none: false
-- !ruby/object:Gem::Dependency
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-    none: false
   prerelease: false
+  version_requirements: *20685860
+- !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &20685400 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.0.0
-    none: false
-- !ruby/object:Gem::Dependency
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-    none: false
   prerelease: false
+  version_requirements: *20685400
+- !ruby/object:Gem::Dependency
   name: redis
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &20701280 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 3.0.0
-    none: false
-- !ruby/object:Gem::Dependency
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.5.2
-    none: false
   prerelease: false
+  version_requirements: *20701280
+- !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &20700820 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.5.2
-    none: false
-- !ruby/object:Gem::Dependency
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.0.3
-    none: false
   prerelease: false
+  version_requirements: *20700820
+- !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &20700220 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.0.3
-    none: false
-- !ruby/object:Gem::Dependency
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
+  prerelease: false
+  version_requirements: *20700220
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: &20699700 !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.0.35
-    none: false
+        version: 0.5.1
+  type: :runtime
   prerelease: false
+  version_requirements: *20699700
+- !ruby/object:Gem::Dependency
   name: hashlib
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &20699020 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.0.35
-    none: false
-- !ruby/object:Gem::Dependency
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-    none: false
   prerelease: false
+  version_requirements: *20699020
+- !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &20698360 !ruby/object:Gem::Requirement
     none: false
-- !ruby/object:Gem::Dependency
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+  type: :runtime
   prerelease: false
+  version_requirements: *20698360
+- !ruby/object:Gem::Dependency
   name: sinatra-cross_origin
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &20697860 !ruby/object:Gem::Requirement
     none: false
-- !ruby/object:Gem::Dependency
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+  type: :runtime
   prerelease: false
+  version_requirements: *20697860
+- !ruby/object:Gem::Dependency
   name: thin
-  requirement: !ruby/object:Gem::Requirement
+  requirement: &20697320 !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+  type: :runtime
+  prerelease: false
+  version_requirements: *20697320
 description: A small service for logging and retrieving timeseries metrics into a
   Redis server
 email: garyhetzel@gmail.com
@@ -164,12 +130,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/quark.rb
+- lib/quark/servers/socket.rb
+- lib/quark/servers/websocket.rb
+- lib/quark/servers/udp.rb
 - lib/quark/servers/http.rb
+- lib/quark/servers/tcp.rb
 - lib/quark/config.rb
-- lib/quark/commands/fetch.rb
-- lib/quark/commands/ping.rb
+- lib/quark/command_processor.rb
 - lib/quark/commands/peek.rb
+- lib/quark/commands/fetch.rb
 - lib/quark/commands/observe.rb
+- lib/quark/commands/ping.rb
+- lib/quark/errors.rb
+- lib/quark/server.rb
+- lib/quark/base_server.rb
 - bin/quark
 homepage: https://github.com/ghetzel/quark
 licenses: []
@@ -178,20 +152,20 @@ rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.28
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: A miniscule timeseries metrics logging service