quark 0.0.7 → 0.1.0

data/bin/quark

@@ -7,28 +7,24 @@ module Quark
   class CLI
     class<<self
       def run()
-        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.udp.enabled",     false)
-        Quark::Config.set("quark.graphite_compat", true)
-        Quark::Config.set("debug",                 false)
+      # sets default options
+        Quark::Server.setup()
 
         (OptionParser.new do |opts|
           opts.banner = "Usage: quark [options]"
 
         # -----------------------------------------------------------------------------
-          opts.on('-H', '--redis-host HOST', 'Hostname of the Redis server to write to') do |host|
+          opts.on('', '--redis-host HOST', 'Hostname of the Redis server to write to') do |host|
             Quark::Config.set("redis.host", host)
           end
 
         # -----------------------------------------------------------------------------
-          opts.on('-P', '--redis-port PORT', 'Hostname of the Redis server to write to') do |port|
+          opts.on('', '--redis-port PORT', 'Hostname of the Redis server to write to') do |port|
             Quark::Config.set("redis.port", port)
           end
 
         # -----------------------------------------------------------------------------
-          opts.on('-N', '--redis-prefix PREFIX', 'The string used to prefix keys in Redis') do |prefix|
+          opts.on('', '--redis-prefix PREFIX', 'The string used to prefix keys in Redis') do |prefix|
             Quark::Config.set("redis.prefix", prefix)
           end
 
@@ -38,12 +34,12 @@ module Quark
           end
 
         # -----------------------------------------------------------------------------
-          opts.on('-a', '--tcp-address ADDR', 'The IP address for the TCP server to listen on') do |addr|
+          opts.on('-a', '--address ADDR', 'The IP address for the TCP server to listen on') do |addr|
             Quark::Config.set("quark.address", addr)
           end
 
         # -----------------------------------------------------------------------------
-          opts.on('-p', '--tcp-port PORT', 'The TCP port to listen on') do |port|
+          opts.on('-p', '--port PORT', 'The TCP port to listen on') do |port|
             Quark::Config.set("quark.port", port)
           end
 
@@ -53,13 +49,23 @@ module Quark
           end
 
         # -----------------------------------------------------------------------------
-          opts.on('-U', '--udp', 'Create a UDP server') do
-            Quark::Config.set("quark.udp.enabled", true)
+          opts.on('-T', '--[no-]tcp', 'Create a TCP server') do |mode|
+            Quark::Config.set("quark.tcp.enabled", mode)
           end
 
         # -----------------------------------------------------------------------------
-          opts.on('-D', '--debug', 'Enable debug mode') do
-            Quark::Config.set("debug", true)
+          opts.on('', '--tcp-address ADDR', 'The IP address for the TCP server to listen on') do |addr|
+            Quark::Config.set("quark.tcp.address", addr)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('', '--tcp-port PORT', 'The TCP port to listen on') do |port|
+            Quark::Config.set("quark.tcp.port", port)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-U', '--[no-]udp', 'Create a UDP server') do |mode|
+            Quark::Config.set("quark.udp.enabled", mode)
           end
 
         # -----------------------------------------------------------------------------
@@ -74,6 +80,25 @@ module Quark
             Quark::Config.set("quark.udp.port", port)
           end
 
+        # -----------------------------------------------------------------------------
+          opts.on('-H', '--[no-]http', 'Create an HTTP server') do |mode|
+            Quark::Config.set("quark.http.enabled", mode)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('', '--http-address ADDR', 'The IP address for the HTTP server to listen on') do |addr|
+            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.port", port)
+          end
+
+        # -----------------------------------------------------------------------------
+          opts.on('-D', '--debug', 'Enable debug mode') do
+            Quark::Config.set("debug", true)
+          end
 
         # -----------------------------------------------------------------------------
           opts.on('', '--[no-]graphite', 'Enable/disable Graphite socket compatibility mode') do |mode|

data/lib/quark.rb

@@ -5,6 +5,7 @@ require 'hiredis'
 require 'em-synchrony'
 require 'multi_json'
 require 'quark/config'
+require 'quark/servers/http'
 
 
 module Quark
@@ -28,6 +29,14 @@ module Quark
     end
 
     def receive_data(data)
+      send_json(Quark::SocketServer.process_command(data))
+    end
+
+    def send_json(data)
+      send_data(MultiJson.dump(data)+"\n")
+    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}$/
@@ -41,32 +50,32 @@ module Quark
         if methods.include?(:"process_command_#{command.downcase}")
           rv = send(:"process_command_#{command.downcase}", arguments)
           if rv.nil?
-            send_json({
+            return {
               :success => true
-            })
+            }
           else
-            send_json({
+            return {
               :success => true,
               :command => data.chomp,
               :results => rv
-            })
+            }
           end
         else
           raise Quark::InvalidCommand.new("Unknown command '#{command.upcase}'")
         end
 
       rescue Quark::Error => e
-        send_json({
+        return {
           :success => false,
           :command => data.chomp,
           :error => {
             :class   => e.class.name,
             :message => e.message
           }
-        })
+        }
 
       rescue Exception => e
-        send_json({
+        return {
           :success => false,
           :command => data.chomp,
           :error => {
@@ -74,34 +83,48 @@ module Quark
             :message   => e.message,
             :backtrace => e.backtrace
           }
-        })
+        }
       end
     end
 
-    def send_json(data)
-      send_data(MultiJson.dump(data)+"\n")
-    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.get("quark.http.cors",       false)
+      Quark::Config.set("quark.graphite_compat", true)
+      Quark::Config.set("debug",                 false)
+    end
+
     def self.run()
       @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)
@@ -110,15 +133,33 @@ module Quark
           EM::open_datagram_socket(@udp_address, @udp_port, Quark::SocketServer)
         end
 
-        if not @address.nil? and not @port.nil?
+      # TCP server
+        if Quark::Config.get("quark.tcp.enabled") === true
           puts "Starting TCP server on #{@address}:#{@port}..."
           EM::start_server(@address, @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}..."
+          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.quit()
+      puts "Stopping Quark..."
+      EM.stop()
+    end
   end
 end

data/lib/quark/commands/fetch.rb

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

data/lib/quark/commands/observe.rb

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

data/lib/quark/commands/ping.rb

@@ -2,7 +2,7 @@ module Quark
   module SocketServer
     require 'socket'
 
-    def process_command_ping(data)
+    def self.process_command_ping(data)
       return {
         :alive    => true,
         :hostname => Socket.gethostname(),

data/lib/quark/servers/http.rb

@@ -0,0 +1,70 @@
+module Quark
+  class Server
+    class HttpServer
+      require 'sinatra'
+      require 'sinatra/cross_origin'
+      require 'thin'
+
+      class Base < Sinatra::Base
+        configure do
+          mime_type :json, 'application/json'
+
+          if Quark::Config.get("quark.http.cors") === true
+            set :allow_origin, :any
+            set :allow_methods, [:get, :post, :options]
+            set :allow_credentials, true
+            enable :cross_origin
+          end
+        end
+
+        before do
+          if Quark::Config.get("quark.http.cors") === true
+            headers 'Access-Control-Allow-Headers' => 'origin, x-requested-with, accept'
+          end
+
+          content_type :json
+        end
+
+        get '/?' do
+          MultiJson.dump({
+            :status => :ok,
+            :config => Quark::Config.all()
+          })
+        end
+
+        get '/call/:command/?*' do
+          MultiJson.dump(Quark::SocketServer.process_command("#{params[:command].upcase} #{params[:splat].first.gsub('/',' ')}".strip))
+        end
+
+        def _quark_command(command, payload)
+          io = nil
+
+          case settings.quark_protocol
+          when :tcp
+            io = TCPSocket.new(settings.quark_host, settings.quark_port)
+            io.puts("#{command.upcase} #{payload}".strip)
+            rv = io.gets()
+          when :socket
+            io = Socket.new(settings.quark_socket)
+            io.puts("#{command.upcase} #{payload}".strip)
+            rv = io.gets()
+          end
+
+          return MultiJson.load(rv)
+        end
+      end
+
+      def initialize(options=nil)
+        @_options = options || Quark::Config.get("quark.http",{})
+      end
+
+      def run()
+        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,
+          :threaded => true,
+        })
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quark
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2014-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &15249980 !ruby/object:Gem::Requirement
+  requirement: &5731120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -21,10 +21,10 @@ dependencies:
         version: 1.7.9
   type: :runtime
   prerelease: false
-  version_requirements: *15249980
+  version_requirements: *5731120
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &15249020 !ruby/object:Gem::Requirement
+  requirement: &5730020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *15249020
+  version_requirements: *5730020
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &15248140 !ruby/object:Gem::Requirement
+  requirement: &5728780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *15248140
+  version_requirements: *5728780
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &15263700 !ruby/object:Gem::Requirement
+  requirement: &5742700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.5.2
   type: :runtime
   prerelease: false
-  version_requirements: *15263700
+  version_requirements: *5742700
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &15262720 !ruby/object:Gem::Requirement
+  requirement: &5739540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 1.0.3
   type: :runtime
   prerelease: false
-  version_requirements: *15262720
+  version_requirements: *5739540
 - !ruby/object:Gem::Dependency
   name: hashlib
-  requirement: &15261440 !ruby/object:Gem::Requirement
+  requirement: &5737440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,40 @@ dependencies:
         version: 0.0.35
   type: :runtime
   prerelease: false
-  version_requirements: *15261440
+  version_requirements: *5737440
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &5359100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *5359100
+- !ruby/object:Gem::Dependency
+  name: sinatra-cross_origin
+  requirement: &5356080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *5356080
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: &5352680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *5352680
 description: A small service for logging and retrieving timeseries metrics into a
   Redis server
 email: garyhetzel@gmail.com
@@ -86,6 +119,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/quark.rb
+- lib/quark/servers/http.rb
 - lib/quark/config.rb
 - lib/quark/commands/peek.rb
 - lib/quark/commands/fetch.rb