ustate-client 0.0.1

data/lib/ustate/query_string.treetop

@@ -0,0 +1,116 @@
+module UState
+  grammar QueryString
+    # (state =~ "foo" or state == "bar") and service == "foo"
+    # Binding order proceeds from loosest to tightest.
+    
+    rule or
+      first:and rest:(space 'or' space and)* {
+        def sql
+          rest.elements.map { |x| x.and }.
+            inject(first.sql) do |a, sub|
+              a | sub.sql
+            end
+        end
+      }
+    end
+
+    rule and
+      first:primary rest:(space 'and' space primary)* {
+        def sql
+          rest.elements.map { |x| x.primary }.
+            inject(first.sql) do |a, sub|
+              a & sub.sql
+            end
+        end
+      }
+    end
+
+    rule primary
+      '(' space? x:or space? ')' {
+        def sql
+          x.sql
+        end
+      }
+      / 
+      predicate
+    end 
+
+    rule predicate
+      equals / not_equals / approximately
+    end
+
+    rule approximately
+      field space? '=~' space? string {
+        def sql
+          Sequel::SQL::StringExpression.like field.sql, string.sql
+        end
+      }
+    end   
+
+    rule not_equals
+      field space? '!=' space? value {
+        def sql
+          Sequel::SQL::BooleanExpression.from_value_pairs({field.sql => value.sql}, :AND, true)
+        end
+      }
+    end
+ 
+    rule equals
+      field space? ('=' / '==') space? value {
+        def sql
+          Sequel::SQL::BooleanExpression.from_value_pairs field.sql => value.sql
+        end
+      }
+    end
+
+    rule value
+      double_quoted_string / float / integer
+    end
+
+    rule integer
+      '-'? [0-9]+ {
+        def ruby_value
+          Integer(text_value)
+        end
+        alias sql ruby_value
+      }
+    end
+
+    rule float
+      '-'? [0-9]+ '.' [0-9]+ {
+        def ruby_value
+          Float(text_value)
+        end
+
+        alias sql ruby_value
+      }
+    end
+
+    rule field
+#      [a-zA-Z] [a-zA-Z_0-9]*
+      ("state" / "host" / "service" / "description" / "metric_f") {
+        def sql
+          text_value.to_sym
+        end
+      }
+    end
+
+    rule string
+      double_quoted_string
+    end   
+ 
+    # This doesn't work! Taken from the docs... :(    
+    rule double_quoted_string
+      '"' (!'"' . / '\"')* '"' {
+        def ruby_value
+          text_value[1..-2].gsub('\"', '"')
+        end
+        alias sql ruby_value
+      }
+    end
+
+    rule space
+      [\s]+
+    end
+  end
+end

data/lib/ustate/server/backends/base.rb

@@ -0,0 +1,103 @@
+# Largely stolen from Thin
+
+class UState::Server::Backends::Base
+  TIMEOUT = 5
+  MAXIMUM_CONNECTIONS = 1024
+  MAX_CONNECTIONS = 512
+
+  attr_accessor :server
+  attr_accessor :timeout
+  attr_accessor :maximum_connections
+  attr_writer :ssl, :ssl_options
+  def ssl?; @ssl; end
+
+  def initialize(opts = {})
+    @connections = []
+    @timeout = opts[:timeout] || TIMEOUT
+    @maximum_connections = opts[:maximum_connections] || MAXIMUM_CONNECTIONS
+  end
+
+  def start
+    @stopping = false
+    starter = proc do
+      connect
+      @running = true
+    end
+
+    # Allow for early run-up of eventmachine
+    if EventMachine.reactor_running?
+      starter.call
+    else
+      EventMachine.run &starter
+    end
+  end
+
+  # Graceful stop
+  def stop
+    @running = false
+    @stopping = true
+
+    # Stop accepting connections
+    disconnect
+    stop! if @connections.empty?
+  end
+
+  # Force stop
+  def stop!
+    @running = false
+    @stopping = false
+
+    EventMachine.stop if EventMachine.reactor_running?
+    @connections.each { |connection| connection.close_connection }
+    close
+  end
+
+  # Configure backend
+  def config
+    EventMachine.epoll
+
+    @maximum_connections =
+      EventMachine.set_descriptor_table_size(@maximum_connections)
+  end
+
+  # Free up resources used by the backend
+  def close
+  end
+
+  def running?
+    @running
+  end
+
+  # Called by a connection when it's unbound
+  def connection_finished(connection)
+    @connections.delete connection
+
+    # Finalize graceful stop if there's no more active connections.
+    stop! if @stopping and @connections.empty?
+  end
+
+  # No connections?
+  def empty?
+    @connections.empty?
+  end
+
+  # No of connections
+  def size
+    @connections.size
+  end
+
+  protected
+
+  # Initialize a new connection to a client
+  def initialize_connection(connection)
+    connection.backend = self
+    connection.index = @server.index 
+    connection.comm_inactivity_timeout = @timeout
+
+#    if @ssl
+#      connection.start_tls(@ssl_options
+#    end
+    
+    @connections << connection
+  end
+end

data/lib/ustate/server/backends/tcp.rb

@@ -0,0 +1,33 @@
+# Stolen from Thin
+
+class UState::Server
+  class Backends::TCP < Backends::Base
+    require 'socket'
+   
+    attr_accessor :host, :port
+
+    HOST = '127.0.0.1'
+    PORT = 55956
+
+    def initialize(opts = {})
+      @host = opts[:host] || HOST
+      @port = opts[:port] || PORT
+      super opts
+    end
+
+    # Connect the server
+    def connect
+      puts "Listening on #{@host}:#{@port}"
+      @signature = EventMachine.start_server(@host, @port, Connection, &method(:initialize_connection))
+    end
+
+    # Stops server
+    def disconnect
+      EventMachine.stop_server @signature
+    end
+
+    def to_s
+      "#{@host}:#{@port}"
+    end
+  end
+end

data/lib/ustate/server/backends.rb

@@ -0,0 +1,4 @@
+module UState::Server::Backends
+  require 'ustate/server/backends/base'
+  require 'ustate/server/backends/tcp'
+end

data/lib/ustate/server/connection.rb

@@ -0,0 +1,82 @@
+# Instantiated by EventMachine for each new connection
+# Mostly from Thin.
+class UState::Server::Connection < EventMachine::Connection
+  attr_accessor :backend
+  attr_accessor :index
+
+  # Called to prepare the connection for a request
+  def post_init
+    @state = :length
+    @buffer = ""
+  end
+
+  # Called when data is received
+  def receive_data(data = '')
+    @buffer << data
+   
+    case @state
+    when :length
+      # Length header
+      if @buffer.bytesize >= 4
+        @length = @buffer.slice!(0,4).unpack('N').first
+        @state = :data
+        receive_data unless @buffer.empty?
+      end
+    when :data
+      # Data
+      if @buffer.bytesize >= @length
+        receive_message @buffer.slice!(0, @length)
+        @state = :length
+        receive_data unless @buffer.empty?
+      end
+    end
+  end
+
+  # Called with a message type and data.
+  def receive_message(data)
+    begin
+      message = UState::Message.decode data
+      if states = message.states
+        # State update
+        states.each do |state|
+          @index << state
+        end
+        send UState::Message.new(ok: true)
+      elsif q = message.query
+        res = @index.query(q)
+        send UState::Message.new(ok: true, states: res)
+      else
+        send UState::Message.new(ok: false, error: "unknown message type")
+      end
+    rescue Exception => e
+      puts e
+      puts e.backtrace.join("\n")
+      m = UState::Message.new(ok: false, error: e.message)
+      send m
+    end
+  end
+
+  def send(message)
+    send_data message.encode_with_length
+  end
+
+  # Called when the connection is unbound from the socket and can no longer be
+  # used to process requests.
+  def unbind
+    @backend.connection_finished self
+  end
+
+  def remote_address
+    socket_address
+  end
+
+  def terminate_request
+    close_connection_after_writing rescue nil
+  end
+
+  protected
+
+  def socket_address
+    Socket.unpack_sockaddr_in(get_peername)[1]
+  end
+end

data/lib/ustate/server/graphite.rb

@@ -0,0 +1,11 @@
+class UState
+  class Server::Graphite
+    def initialize(opts)
+      
+    end
+
+    def on_state
+      
+    end
+  end
+end

data/lib/ustate/server/index.rb

@@ -0,0 +1,134 @@
+module UState
+  class Server::Index
+    # Combines state messages. Responds to queries for particular states.
+    # Forwards messages to various receivers.
+    # Inserts are NOT threadsafe.
+    
+    class ParseFailed < Server::Error; end
+
+    require 'sequel'
+
+    THREADS = 1000
+    BUFFER_SIZE = 10
+    
+    attr_reader :db, :queue 
+
+    def initialize(opts = {})
+      @db = Sequel.sqlite
+
+      @threads = opts[:threads] || THREADS
+      @pool = []
+
+      setup_db
+    end
+
+    def clear
+      setup_db
+    end
+
+    def <<(s)
+      process s
+    end
+
+    def thread(s)
+      Thread.new do
+        process s
+        @pooltex.synchronize do
+          @pool.delete Thread.current
+        end
+      end
+    end
+
+    def on_state_change(old, new)
+    end
+
+    def on_state(state)
+    end
+
+    def process(s)
+      if current = @db[:states][host: s.host, service: s.service]
+        # Update
+        if current[:time] <= s.time
+          if current[:state] != s.state
+            on_state_change current, s
+          end           
+
+          # Update
+          @db[:states].filter(host: s.host, service: s.service).update(
+            state: s.state,
+            time: s.time,
+            description: s.description,
+            metric_f: s.metric_f
+          )
+        end
+      else
+        # Insert
+        @db[:states].insert(
+          host: s.host,
+          service: s.service,
+          state: s.state,
+          time: s.time,
+          description: s.description,
+          metric_f: s.metric_f
+        )
+      end
+
+      on_state s
+    end
+
+    # Returns an array of States matching Query.
+    def query(q)
+      parser = QueryStringParser.new
+      if q.string
+        unless expression = parser.parse(q.string)
+          raise ParseFailed, "error parsing #{q.string.inspect} at line #{parser.failure_line}:#{parser.failure_column}: #{parser.failure_reason}"
+        end
+        filter = expression.sql
+      else
+        # No string? All states.
+        filter = true
+      end
+      
+      ds = @db[:states].filter filter
+      ds.all.map do |row|
+        row_to_state row
+      end
+    end
+
+    # Converts a row to a State
+    def row_to_state(row)
+      State.new(row)
+    end
+    
+    def setup_db
+      @db.drop_table :states rescue nil
+      @db.create_table :states do
+        String :host
+        String :service
+        String :state
+        String :description, :text => true
+        Integer :time
+        Float :metric_f
+        primary_key [:host, :service]
+      end
+    end
+
+    def start
+      stop!
+      @pool = []
+    end
+
+    # Finish up
+    def stop
+      @pool.each do |thread|
+        thread.join
+      end
+    end
+
+    def stop!
+      @pool.each do |thread|
+        thread.kill
+      end
+    end
+  end
+end