snoopit 0.0.1

data/lib/snoopit/notification_manager.rb

@@ -0,0 +1,123 @@
+module Snoopit
+
+  class NotificationManager
+
+    attr :active, :config
+
+    def initialize(config=nil)
+      @active = {}
+      @config = config
+      load_default_notifiers unless @config.nil?
+    end
+
+    def load_notifier_config(config)
+      @config = config
+      load_default_notifiers
+      load = @config['load']
+      load_files(load) unless load.nil?
+    end
+
+    def register(notifier)
+      raise NameError.new "Notifier missing valid name: #{notifier.inspect}" if notifier.name.nil?
+      Snoopit.logger.debug "Registering notifier #{notifier.name}"
+      @active[notifier.name] = notifier
+    end
+
+    def unregister(notifier)
+      self.unregister_by_name notifier.name
+    end
+
+    def unregister_by_name(notifier_name)
+      @active.delete notifier_name
+    end
+
+    def get_notifier(name)
+      @active[name]
+    end
+
+    def notify(snoopies)
+      snoopies.each do |snoopy|
+        snoopy.sniffers.each do |sniffer|
+          sniffer_notify(sniffer)
+        end
+      end
+    end
+
+    def sniffer_notify(sniffer)
+      messages = get_sniffed_messages sniffer
+      sniffer.notifiers.each do |key, value|
+        n = @active[key]
+        next if n.nil?
+        messages.each do |message|
+          n.notify(message, value)
+        end
+      end
+    end
+
+    private
+
+    def load_default_notifiers
+      path = File.expand_path('../notifiers', __FILE__)
+      Dir.entries(path).each do |file|
+        next if File.directory? file
+        file_require "#{path}/#{file}"
+      end
+      create_default_notifiers
+    end
+
+    def create_default_notifiers
+      Snoopit::Notifiers.constants.select do  |c|
+        if Class === Snoopit::Notifiers.const_get(c)
+          config = @config[c.to_s.downcase]
+          unless config.nil?
+            o = Snoopit::Notifiers.const_get(c).new config
+            @active[o.name] = o
+          else
+            Snoopit.logger.debug "Notifier #{c.to_s.downcase} not loaded due to no configuration specified"
+          end
+        end
+      end
+    end
+
+    def file_require(file)
+      Snoopit.logger.debug "Requiring notifier file: #{file}"
+      require file
+    end
+
+    def load_files(load)
+      load.keys.each do |key|
+        entry = load[key]
+        next if entry['file'].nil?
+        next if entry['class'].nil?
+        file_require entry['file']
+        create_notifier entry['class'], entry['config']
+      end
+    end
+
+    def create_notifier(klass, notifier_config=nil)
+      o = Object.const_get(klass).new notifier_config
+      @active[o.name] = o
+    end
+
+    def get_sniffed_messages(sniffer)
+      messages = []
+      sniffer.sniffed.each do |sniffed|
+        messages << build_message(sniffed)
+      end
+      messages
+    end
+
+    def build_message(sniffed)
+      {
+          comment: sniffed.comment,
+          file: sniffed.file,
+          before: sniffed.before.register.reverse,
+          match: sniffed.match,
+          match_line_no: sniffed.line_no,
+          after: sniffed.after.register.reverse
+      }
+    end
+
+  end
+
+end

data/lib/snoopit/notifier.rb

@@ -0,0 +1,25 @@
+module Snoopit
+
+  # @abstract Subclass
+  # Override {#notify} method
+  class Notifier
+
+    attr_accessor :name, :configuration, :klass
+
+    # The name is used by the Snooper to identify type of notifier to create
+    # @param name [String] name of notifier if the name is nil the class name is used
+    # The empty constructor is used to initialize the class when loaded dynamically
+    # After loaded dynamically the method set_config is called to set the configuration
+    def initialize(config=nil, name=nil, klass=nil)
+      @name = name.nil? ? self.class.name : name
+      @klass = klass.nil? ? self.class.name : klass
+      @config = config
+    end
+
+    def notify(found, notify_params)
+      raise NotImplementedError.new 'Notifier#notify'
+    end
+
+  end
+
+end

data/lib/snoopit/notifiers/email.rb

@@ -0,0 +1,61 @@
+require 'net/smtp'
+require 'date'
+
+module Snoopit
+  module Notifiers
+
+    class Email < Snoopit::Notifier
+
+      attr :smtp_server, :port, :tls
+      # The name 'email' is used by the Snooper to identify type of notifier to create
+      # The empty constructor is used to initialize the class when loaded dynamically
+      # After loaded dynamically the method set_config is called by the base class to set the configuration
+      def initialize(config=nil)
+        super config, 'email'
+        @smtp_server = @config['smtp-server']
+        @port        = @config['port']
+        @tls         = @config['tls']
+        @user        = @config['user']
+        @password    = @config['password']
+      end
+
+      def notify(found, notifier_params)
+        send found, notifier_params
+      end
+
+      def send(msg, notifier_params)
+        begin
+          auth = notifier_params['authentication'].nil? ? :login : notifier_params['authentication'].to_sym
+          from = notifier_params['from'].nil? ? 'snoopit@snooper.notifier.com' : notifier_params['from']
+          formatted = build_msg from, notifier_params['to'], msg
+          smtp = Net::SMTP.new @smtp_server, @port
+          helo = @user.split('@')[1] || 'localhost'
+          smtp.enable_starttls_auto
+          smtp.start helo, @user, @password, auth do |smtp|
+            smtp.send_message(formatted, from, notifier_params['to'])
+          end
+        rescue => e
+          Snoopit.logger.warn e.message
+          Snoopit.logger.warn e.backtrace
+        end
+      end
+
+      def build_msg(from, to, msg)
+        msg = <<-MSG
+From: #{from}
+To: #{to.kind_of?(Array) ? to.join(', ') : to }
+Content-Type: text/plain
+Subject: #{msg[:comment]}
+Date: #{DateTime.now.rfc822}
+
+Snooper event on line: #{msg[:match_line_no]} in file: #{msg[:file]}
+
+#{msg[:before].join('')}#{msg[:match]}#{msg[:after].join('')}
+MSG
+        msg
+      end
+
+
+    end
+  end
+end

data/lib/snoopit/notifiers/http.rb

@@ -0,0 +1,85 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'awesome_print'
+
+module Snoopit
+  module Notifiers
+
+    class Http < Snoopit::Notifier
+
+      # The name  'http' is used by the Snooper to identify type of notifier to create
+      # The empty constructor is used to initialize the class when loaded dynamically
+      # After loaded dynamically the method set_config is called by the base class to set the configuration
+      def initialize(config=nil)
+        super config, 'http'
+        @api_key = config['api-key']
+      end
+
+      def notify(found, notify_params)
+        raise ArgumentError.new 'URL parameter must be set' if notify_params['url'].nil?
+        post_it found, notify_params, URI(notify_params['url'])
+      end
+
+      def post_it(found, notify_params, uri)
+        conn = get_conn uri
+        request = build_request uri, found, notify_params
+        post conn, request
+      end
+
+      def post(conn, request)
+        response = conn.request(request)
+        case response.code
+          when 200..299, 300..399
+            logger.debug 'Posted notification to: ' + response.uri.to_s
+            logger.debug.ap found
+          when 400..599
+            logger.warn 'Failed to send notification to uri: ' + response.uri.to_s
+            logger.warn 'Failed to send notification to uri: ' + response.message
+        end
+      rescue => e
+        Snoopit.logger.warn 'Failed to send notification to uri: ' + response.uri.to_s unless response.nil?
+        Snoopit.logger.warn 'Failed to send notification to uri: ' + e.message
+        Snoopit.logger.warn 'Failed to send notification to uri: ' + e.backtrace.join("\n")
+      ensure
+        conn.finish if conn.started?
+      end
+
+      def build_request(uri, found, notify_params)
+        request = Net::HTTP::Post.new(uri.path)
+        request.basic_auth notify_params['user'], notify_params['password'] unless notify_params['user'].nil?
+        request.body = found.to_json
+        set_headers request
+        request
+      end
+
+      def get_conn(uri)
+        case uri.scheme
+          when 'http'
+            set_http(uri)
+          when 'https'
+            set_https(uri)
+        end
+      end
+
+      def set_http(uri)
+        Net::HTTP.new uri.host, uri.port
+      end
+
+      def set_https(uri)
+        conn =  Net::HTTP.new uri.host, uri.port
+        conn.use_ssl = true
+        conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        conn
+      end
+
+      def set_headers(request)
+        request['Content-Type'] = 'application/json'
+        request['Authorization'] = 'Token token=' + @api_key unless @api_key.nil?
+      end
+
+    end
+
+  end
+
+end

data/lib/snoopit/notifiers/https.rb

@@ -0,0 +1,21 @@
+
+module Snoopit
+  module Notifiers
+
+    class Https < Snoopit::Notifier
+
+      # The name 'https' is used by the Snooper to identify type of notifier to create
+      # The empty constructor is used to initialize the class when loaded dynamically
+      # After loaded dynamically the method set_config is called by the base class to set the configuration
+      def initialize(config=nil)
+        super config, 'https'
+        @http = Snoopit::Notifiers::Http.new config
+      end
+
+      def notify(found, notify_params)
+        @http.notify(found, notify_params)
+      end
+
+    end
+  end
+end

data/lib/snoopit/notifiers/stomp.rb

@@ -0,0 +1,59 @@
+require 'stomp'
+require 'awesome_print'
+
+module Snoopit
+  module Notifiers
+
+    class Stomp < Snoopit::Notifier
+
+      # The name 'stomp' is used by the Snooper to identify type of notifier to create
+      # The empty constructor is used to initialize the class when loaded dynamically
+      # After loaded dynamically the method set_config is called by the base class to set the configuration
+      def initialize(config=nil)
+        super config, 'stomp'
+        @host     = config['host']  || 'localhost'
+        @port     = config['port']  || 61613
+        @login    = config['login']
+        @passcode = config['passcode']
+        @headers  = config['headers']
+      end
+
+      def get_connection
+        params =  { hosts: [ get_connect_params ] }
+        set_connect_headers params
+        ::Stomp::Connection.new params
+      rescue => e
+        Snoopit.logger.warn 'Stomp failed to connect: ' + params.to_json
+        Snoopit.logger.warn 'Stomp failed to connect: ' + e.message
+        Snoopit.logger.warn 'Stomp failed to connect: ' + e.backtrace.join('\n')
+        nil
+      end
+
+      def get_connect_params
+        params            = { host: @host, port: @port }
+        params[:login]    = @login unless @login.nil?
+        params[:passcode] = @passcode unless @passcode.nil?
+        params
+      end
+
+      def set_connect_headers(params)
+        params[:connect_headers] = @headers unless @headers.nil?
+      end
+
+      def notify(found, notify_params)
+        conn = get_connection
+        send_message(conn, found, notify_params) unless conn.nil?
+      rescue => e
+          Snoopit.logger.warn e.message
+          Snoopit.logger.warn e.backtrace.join('\n')
+      ensure
+        conn.disconnect unless conn.nil?
+      end
+
+      def send_message(conn, found, notify_params)
+        conn.publish notify_params['queue'], found.to_json, notify_params['headers']
+      end
+
+    end
+  end
+end

data/lib/snoopit/register.rb

@@ -0,0 +1,69 @@
+module Snoopit
+
+  # Behaves a bit like a CPU register
+  class Register
+
+    include Enumerable
+
+    attr :size, :register
+
+    # index always points to where the next element will be added
+    def initialize(size=10, data=nil)
+      if data.nil?
+        @register = Array.new size
+      else
+        @register = Array.new size
+        cloned = data.clone
+        [0...size].each { |i| @register[i] = cloned[i] }
+      end
+    end
+
+    # pushes one object to the front of the array and pops one off the end and returns is
+    def unshift(object)
+      return if @register.size == 0
+      @register.unshift object
+      @register.pop unless @register.size == 1
+    end
+
+    # pushes one object on to the end of the array and pops one off the front and returns is
+    def shift(object)
+      return if @register.size == 0
+      @register.push object
+      @register.slice! 0 unless @register.size == 1
+    end
+
+    alias_method :push_front, :unshift
+    alias_method :push_back, :shift
+
+    def [](index)
+      @register[index]
+    end
+
+    def []=(index, value)
+      @register[index] = value
+    end
+
+    def size
+      @register.size
+    end
+
+    def length
+      @register.length
+    end
+
+    def as_json(options=nil)
+       @register
+    end
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+
+    def each
+      @register.each { |r| yield r }
+    end
+
+  end
+
+
+end