Class: Quark::Server

Inherits:
Object
  • Object
show all
Defined in:
lib/quark/server.rb,
lib/quark/base_server.rb,
lib/quark/servers/tcp.rb,
lib/quark/servers/udp.rb,
lib/quark/servers/http.rb,
lib/quark/servers/socket.rb,
lib/quark/servers/websocket.rb

Defined Under Namespace

Classes: BaseServer, HttpServer, SocketServer, TcpServer, UdpServer, WebsocketServer

Class Method Summary collapse

Class Method Details

.connect ⇒ Object 



28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/quark/server.rb', line 28

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

.daemonize ⇒ Object 



67
68
69
70
71
72
73
74
75
76
 
# File 'lib/quark/server.rb', line 67

def self.daemonize()
  return @_service if defined?(@_service)

  @_service = proc do
    self.run()
  end

  EM.defer(@_service)
  return @_service
end

.purge(keys, to = nil) ⇒ Object

removes metrics that match keys and (optionally) are older than ‘to’ if ‘to’ is negative, it is assumed to be n-seconds ago



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/quark/server.rb', line 82

def self.purge(keys, to=nil)
  keys = [@_prefix, 'observations', keys, '*'].join(':') if not keys.start_with?("#{@_prefix}:observations")
  now = (Time.now.to_f * 1000).to_i
  rv = []

  @redis.keys(keys).each do |key|
    x, y, name, block = key.split(':', 4)
    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

.quit ⇒ Object 



106
107
108
109
 
# File 'lib/quark/server.rb', line 106

def self.quit()
  puts "Stopping Quark..."
  EM.stop()
end

.run ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/quark/server.rb', line 40

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

.setup ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/quark/server.rb', line 7

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