onesnooper-server 0.0.1

data/examples/monitoring.data

@@ -0,0 +1,66 @@
+ARCH=x86_64
+MODELNAME="Intel(R) Xeon(R) CPU           E5649  @ 2.53GHz"
+DS_LOCATION_USED_MB=149998
+DS_LOCATION_TOTAL_MB=1092886
+DS_LOCATION_FREE_MB=887373
+DS = [
+  ID = 0,
+  USED_MB = 149998,
+  TOTAL_MB = 1092886,
+  FREE_MB = 887373
+]
+DS = [
+  ID = 120,
+  USED_MB = 149998,
+  TOTAL_MB = 1092886,
+  FREE_MB = 887373
+]
+HOSTNAME=host1.localhost
+VM_POLL=YES
+VM=[
+  ID=12036,
+  DEPLOY_ID=one-12036,
+  POLL="NETRX=247208960 NETTX=1786718208 USEDCPU=60.3 USEDMEMORY=16777216 NAME=one-12036 STATE=a" ]
+VM=[
+  ID=12037,
+  DEPLOY_ID=one-12037,
+  POLL="NETRX=231688192 NETTX=1806806016 USEDCPU=60.1 USEDMEMORY=16777216 NAME=one-12037 STATE=a" ]
+VM=[
+  ID=12039,
+  DEPLOY_ID=one-12039,
+  POLL="NETRX=155998208 NETTX=2421689344 USEDCPU=0.1 USEDMEMORY=1048576 NAME=one-12039 STATE=a" ]
+VM=[
+  ID=12139,
+  DEPLOY_ID=one-12139,
+  POLL="NETRX=4646912 NETTX=433727488 USEDCPU=0.2 USEDMEMORY=1048576 NAME=one-12139 STATE=a" ]
+VM=[
+  ID=12031,
+  DEPLOY_ID=one-12031,
+  POLL="NETRX=7949312 NETTX=1946089472 USEDCPU=0.1 USEDMEMORY=1048576 NAME=one-12031 STATE=a" ]
+VM=[
+  ID=12032,
+  DEPLOY_ID=one-12032,
+  POLL="NETRX=9022464 NETTX=2323913728 USEDCPU=0.2 USEDMEMORY=3145728 NAME=one-12032 STATE=a" ]
+VM=[
+  ID=12034,
+  DEPLOY_ID=one-12034,
+  POLL="NETRX=332258304 NETTX=4284767232 USEDCPU=50.5 USEDMEMORY=16777216 NAME=one-12034 STATE=a" ]
+VM=[
+  ID=-1,
+  DEPLOY_ID=Domain-0,
+  POLL="NETRX=0 NETTX=0 USEDCPU=3.7 USEDMEMORY=5233724 NAME=Domain-0 STATE=a" ]
+VM=[
+  ID=12035,
+  DEPLOY_ID=one-12035,
+  POLL="NETRX=209708032 NETTX=1790325760 USEDCPU=59.5 USEDMEMORY=16777216 NAME=one-12035 STATE=a" ]
+VERSION="4.10.1"
+HYPERVISOR=xen
+TOTALCPU=2400
+CPUSPEED=2533
+TOTALMEMORY=100654080
+FREEMEMORY=20727808
+USEDMEMORY=79926272
+USEDCPU=244
+FREECPU=2156
+NETTX=16400482
+NETRX=1170391

data/examples/send-dummy-data

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+# -------------------------------------------------------------------------- #
+# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
+# not use this file except in compliance with the License. You may obtain    #
+# a copy of the License at                                                   #
+#                                                                            #
+# http://www.apache.org/licenses/LICENSE-2.0                                 #
+#                                                                            #
+# Unless required by applicable law or agreed to in writing, software        #
+# distributed under the License is distributed on an "AS IS" BASIS,          #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+# See the License for the specific language governing permissions and        #
+# limitations under the License.                                             #
+#--------------------------------------------------------------------------- #
+
+# external dependencies
+require 'rubygems'
+
+require 'socket'
+require 'base64'
+require 'resolv'
+require 'ipaddr'
+
+# add local dirs to load path if necessary
+lib = File.expand_path(File.join('..', '..', 'lib'), __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+# add example dirs
+examples = File.expand_path(File.join('..'), __FILE__)
+
+# prepare data
+udp_socket = UDPSocket.new
+result = "SUCCESS"
+host_id = 527
+data64 = Base64::encode64(File.read(File.join(examples, 'monitoring.data'))).strip.delete("\n")
+
+# send data
+udp_socket.send("MONITOR #{result} #{host_id} #{data64}\n", 0, 'localhost', 9000)

data/lib/onesnooper-server.rb

@@ -0,0 +1,32 @@
+# Internals of the onesnooper-server application. Classes
+# in this namespace should not be used by external libraries.
+module OnesnooperServer; end
+
+# internal ruby dependencies
+require 'date'
+require 'ipaddr'
+require 'base64'
+
+# active support stuff
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/json'
+require 'active_support/inflector'
+require 'active_support/notifications'
+
+# external dependencies
+require 'eventmachine'
+require 'settingslogic'
+
+# internal components
+require 'onesnooper_server/version'
+require 'onesnooper_server/settings'
+require 'onesnooper_server/log'
+require 'onesnooper_server/store'
+require 'onesnooper_server/sql_store'
+require 'onesnooper_server/stores'
+require 'onesnooper_server/datagram'
+require 'onesnooper_server/datagrams'
+require 'onesnooper_server/payload_parser'
+require 'onesnooper_server/request_handler'
+require 'onesnooper_server/udp_handler'

data/lib/onesnooper_server/datagram.rb

@@ -0,0 +1,19 @@
+# Base class for all datagram processing classes. Defines
+# required stub methods. No functionality is implemented here.
+class OnesnooperServer::Datagram
+
+  # Initializes class instances.
+  #
+  # @param params [Hash] hash-like with params
+  def initialize(params = {})
+    @params = params
+  end
+
+  # Runs datagram processing for the chosen datagram type.
+  #
+  # @param deferred_callback [::EventMachine::DefaultDeferrable] response callback
+  def run(deferred_callback)
+    fail "This method needs to be implemented in subclasses"
+  end
+
+end

data/lib/onesnooper_server/datagrams.rb

@@ -0,0 +1,7 @@
+# Wrapper module for all available datagram processing
+# classes. Each class has to implement method stubs
+# outlined in `OnesnooperServer::Datagram`.
+module OnesnooperServer::Datagrams; end
+
+# Load all available datagram types
+Dir.glob(File.join(File.dirname(__FILE__), 'datagrams', "*.rb")) { |datagram_file| require datagram_file.chomp('.rb') }

data/lib/onesnooper_server/datagrams/failure_datagram.rb

@@ -0,0 +1,9 @@
+# Handles processing of datagrams with FAILED monitoring
+# messages. Doesn't perform any backend operations.
+class OnesnooperServer::Datagrams::FailureDatagram < ::OnesnooperServer::Datagram
+
+  def run(deferred_callback)
+    ::EventMachine.defer { deferred_callback.fail "Failed monitoring result will not be recorded" }
+  end
+
+end

data/lib/onesnooper_server/datagrams/invalid_datagram.rb

@@ -0,0 +1,9 @@
+# Handles processing of datagrams with invalid
+# messages. Doesn't perform any backend operations.
+class OnesnooperServer::Datagrams::InvalidDatagram < ::OnesnooperServer::Datagram
+
+  def run(deferred_callback)
+    ::EventMachine.defer { deferred_callback.fail "Invalid monitoring result will not be recorded" }
+  end
+
+end

data/lib/onesnooper_server/datagrams/success_datagram.rb

@@ -0,0 +1,60 @@
+# Handles processing of datagrams with SUCESS monitoring
+# messages. Performs 'save' operation on the backend.
+class OnesnooperServer::Datagrams::SuccessDatagram < ::OnesnooperServer::Datagram
+
+  def run(deferred_callback)
+    ::EventMachine.defer do
+      if parse_payload! && store_all!
+        deferred_callback.succeed "Successful monitoring result was " \
+                                  "recorded in #{store_info.join(', ')}"
+      else
+        deferred_callback.fail "Processing partially or completely failed, see logs"
+      end
+    end
+  end
+
+private
+
+  # Decodes and parses datagram payload into a
+  # hash-like structure. Modification is done
+  # in-place.
+  def parse_payload!
+    @params[:payload] = ::OnesnooperServer::PayloadParser.parse(@params[:payload])
+  end
+
+  # Stores decoded and parsed payload in all
+  # enabled data stores. Errors are logged
+  # but not otherwise reported.
+  #
+  # @return [Boolean] success in all stores
+  def store_all!
+    if @params[:payload].blank?
+      ::OnesnooperServer::Log.warn "[#{self.class.name}] Skipping empty payload " \
+                                   "from ONE ID:#{@params[:host_id]}"
+      return false
+    end
+
+    all_good = true
+    @params[:stores].each do |store|
+      begin
+        ::OnesnooperServer::Log.debug "[#{self.class.name}] Saving data in #{store.class.name}"
+        store.save!(DateTime.now, @params[:payload])
+      rescue => ex
+        ::OnesnooperServer::Log.error "[#{self.class.name}] Error while saving " \
+                                      "in #{store.class.name}: #{ex.message}"
+        all_good = false
+      end
+    end
+
+    all_good
+  end
+
+  # Returns human-readable information about enabled
+  # backend stores.
+  #
+  # @return [Array] list of textual store information
+  def store_info
+    @params[:stores].collect { |store| store.class.name }
+  end
+
+end

data/lib/onesnooper_server/log.rb

@@ -0,0 +1,74 @@
+require 'logger'
+
+# Wrapper for log subscribers combining the functionality
+# of `Logger` and `ActiveSupport::Notifications`. Allows
+# the use of Singleton-like logging facilities.
+class OnesnooperServer::Log
+
+  include ::Logger::Severity
+
+  attr_reader :logger, :log_prefix
+
+  # Default subscription handle for notifications
+  SUBSCRIPTION_HANDLE = "onesnooper-server.log"
+
+  # Creates a new logger
+  #
+  # @param log_dev [IO,String] The log device.  This is a filename (String) or IO object (typically +STDOUT+, +STDERR+, or an open file).
+  # @param log_prefix [String] String placed in front of every logged message
+  def initialize(log_dev, log_prefix = '[onesnooper-server]')
+    if log_dev.kind_of? ::Logger
+      @logger = log_dev
+    else
+      @logger = ::Logger.new(log_dev)
+    end
+
+    @log_prefix = log_prefix.blank? ? '' : log_prefix.strip
+
+    # subscribe to log messages and send to logger
+    @log_subscriber = ActiveSupport::Notifications.subscribe(self.class::SUBSCRIPTION_HANDLE) do |name, start, finish, id, payload|
+      @logger.log(payload[:level], "#{@log_prefix} #{payload[:message]}") if @logger
+    end
+  end
+
+  def close
+    ActiveSupport::Notifications.unsubscribe(@log_subscriber)
+  end
+
+  # @param severity [::Logger::Severity] severity
+  def level=(severity)
+    @logger.level = severity
+  end
+
+  # @return [::Logger::Severity]
+  def level
+    @logger.level
+  end
+
+  # @see info
+  def self.debug(message)
+    ActiveSupport::Notifications.instrument(self::SUBSCRIPTION_HANDLE, :level => ::Logger::DEBUG, :message => message)
+  end
+
+  # Log an +INFO+ message
+  # @param message [String] message the message to log; does not need to be a String
+  def self.info(message)
+    ActiveSupport::Notifications.instrument(self::SUBSCRIPTION_HANDLE, :level => ::Logger::INFO, :message => message)
+  end
+
+  # @see info
+  def self.warn(message)
+    ActiveSupport::Notifications.instrument(self::SUBSCRIPTION_HANDLE, :level => ::Logger::WARN, :message => message)
+  end
+
+  # @see info
+  def self.error(message)
+    ActiveSupport::Notifications.instrument(self::SUBSCRIPTION_HANDLE, :level => ::Logger::ERROR, :message => message)
+  end
+
+  # @see info
+  def self.fatal(message)
+    ActiveSupport::Notifications.instrument(self::SUBSCRIPTION_HANDLE, :level => ::Logger::FATAL, :message => message)
+  end
+
+end

data/lib/onesnooper_server/payload_parser.rb

@@ -0,0 +1,143 @@
+# Central parsing class for decoding and analyzing
+# the content of incoming monitoring messages. Implements
+# one publicly available method `parse(payload)`. Internally,
+# the payload is decoded from Base64 and parsed into a
+# hash-like structure.
+class OnesnooperServer::PayloadParser
+
+  TRIM_CLEANUP = /\s*/
+  KEY          = /[[[:upper:]]|[[:digit:]]|_]+/
+  VALUE        = /[[[:alnum:]]|_|\-|\.|:]+/
+  QUOTED_VALUE = /.+/
+  HASH_VALUE   = /[^\]]+/
+  EQUALS       = /#{TRIM_CLEANUP}=#{TRIM_CLEANUP}/
+
+  KEY_HASH_VALUE_REGEXP   = /#{TRIM_CLEANUP}^#{TRIM_CLEANUP}(?<key>#{KEY})#{EQUALS}\[(?<value>#{HASH_VALUE})\]#{TRIM_CLEANUP}$#{TRIM_CLEANUP}/m
+  KEY_QUOTED_VALUE_REGEXP = /#{TRIM_CLEANUP}^#{TRIM_CLEANUP}(?<key>#{KEY})#{EQUALS}"(?<value>#{QUOTED_VALUE})"#{TRIM_CLEANUP}$#{TRIM_CLEANUP}/
+  KEY_RAW_VALUE_REGEXP    = /#{TRIM_CLEANUP}^#{TRIM_CLEANUP}(?<key>#{KEY})#{EQUALS}(?<value>#{VALUE})#{TRIM_CLEANUP}$#{TRIM_CLEANUP}/
+
+  # Parses given payload into a hash-like structure. Payload
+  # is decoded from Base64 and then analyzed and parsed.
+  #
+  # @param payload [String] Base64-encoded payload with ONE monitoring data
+  # @return [Hash] hash-like structure with parsed payload
+  def self.parse(payload)
+    return {} if payload.blank?
+    analyze(decode(payload))
+  end
+
+private
+
+  # Decodes given Base64-encoded string.
+  #
+  # @param payload [String] Base64-encoded string
+  # @return [String] decoded string
+  def self.decode(payload)
+    ::OnesnooperServer::Log.debug "[#{self.name}] Decoding #{payload.inspect}"
+    begin
+      Base64.strict_decode64(payload)
+    rescue => ex
+      ::OnesnooperServer::Log.error "[#{self.name}] Decoding Base64 failed with: #{ex.message}"
+      return ''
+    end
+  end
+
+  # Analyzes payload content and returns a corresponding
+  # hash-like structure.
+  #
+  # @param payload [String] plain text payload in ONE format
+  # @param subpayload [Boolean] recursive call for parsing complex values
+  # @return [Hash] a hash-like structure with analyzed payload content
+  def self.analyze(payload, subpayload = false)
+    ::OnesnooperServer::Log.debug "[#{self.name}] Scanning decoded #{subpayload ? 'sub-' : '' }payload #{payload.inspect}"
+    return {} if payload.blank?
+
+    scanned_payload = {}
+    scannable_payload = StringScanner.new(payload)
+    begin
+      if scanned = scannable_payload.scan(KEY_HASH_VALUE_REGEXP)
+        scanned.strip!
+        ::OnesnooperServer::Log.debug "[#{self.name}] Scanned #{scanned.inspect}"
+        analyze_simple_pair(scanned, scanned_payload, KEY_HASH_VALUE_REGEXP, true)
+      elsif scanned = scannable_payload.scan(KEY_QUOTED_VALUE_REGEXP)
+        scanned.strip!
+        scanned.gsub! "\n", ''
+        ::OnesnooperServer::Log.debug "[#{self.name}] Scanned #{scanned.inspect}"
+        analyze_simple_pair(scanned, scanned_payload, KEY_QUOTED_VALUE_REGEXP)
+      elsif scanned = scannable_payload.scan(KEY_RAW_VALUE_REGEXP)
+        scanned.strip!
+        scanned.gsub! "\n", ''
+        ::OnesnooperServer::Log.debug "[#{self.name}] Scanned #{scanned.inspect}"
+        analyze_simple_pair(scanned, scanned_payload, KEY_RAW_VALUE_REGEXP)
+      else
+        ::OnesnooperServer::Log.error "[#{self.name}] Failed scanning #{subpayload ? 'sub-' : '' }payload " \
+                                      "#{payload.inspect} at #{scannable_payload.pos}"
+        break
+      end
+    end until scannable_payload.eos?
+
+    scanned_payload
+  end
+
+  # Parses complex value strings into a
+  # hash-like structure.
+  #
+  # @param complex_value [String] input string
+  # @return [Hash] result
+  def self.analyze_complex_value(complex_value)
+    complex_parsed = analyze(complex_value.gsub(',', "\n").strip.gsub("\n\n", "\n"), true)
+    unless complex_parsed['POLL'].blank?
+      ::OnesnooperServer::Log.debug "[#{self.name}] Found complex POLL values, triggering analysis"
+      complex_parsed['POLL'] = analyze(complex_parsed['POLL'].gsub(/\s+/, "\n"), true)
+    end
+
+    complex_parsed
+  end
+
+  # Parses simple key value strings into the given
+  # hash-like structure.
+  #
+  # @param key_value [String] input string
+  # @param parsed [Hash] output hash-like structure
+  # @param regexp [Regexp] regular expression for parsing
+  # @param suspected_complex [Boolean] suspect complex value
+  # @return [Boolean] success or failure
+  def self.analyze_simple_pair(key_value, parsed, regexp, suspected_complex = false)
+    matched = key_value.match(regexp)
+    if matched
+      ::OnesnooperServer::Log.debug "[#{self.name}] Matched #{key_value.inspect} " \
+                                    "as #{matched[:key].inspect} and #{matched[:value].inspect}"
+      if suspected_complex
+        parsed[matched[:key]] ||= []
+        parsed[matched[:key]] << analyze_complex_value(matched[:value])
+      else
+        parsed[matched[:key]] = typecast_if_num(matched[:value])
+      end
+    else
+      ::OnesnooperServer::Log.error "[#{self.name}] Couldn't match " \
+                                    "#{key_value.inspect} as key & simple value"
+    end
+
+    true
+  end
+
+  # Attempts to type-cast values to `Integer` or `Float` if this casting
+  # makes sense for the given value. Otherwise the original value
+  # is returned.
+  #
+  # @param potential_num [String] value to type-cast if applicable
+  # @return [String, Integer, Float] type-casted value if applicable
+  def self.typecast_if_num(potential_num)
+    return potential_num unless potential_num.kind_of? String
+
+    case potential_num
+    when potential_num.to_i.to_s
+      potential_num.to_i
+    when potential_num.to_f.to_s
+      potential_num.to_f
+    else
+      potential_num
+    end
+  end
+
+end