collins_notify 0.0.1

data/lib/collins_notify/adapter/hipchat.rb

@@ -0,0 +1,92 @@
+require 'hipchat'
+
+module CollinsNotify
+
+  class HipchatAdapter < Notifier
+    register_name :hipchat
+    supports_mimetype :text
+    require_config :api_token, :from_username # who to send the message as
+
+    # Constants for coloring different messages
+    module HipchatStatus
+      SUCCESS = "green"
+      WARNING = "yellow"
+      ERROR   = "red"
+      STATUS  = "purple"
+      RANDOM  = "random"
+    end
+
+    def configure!
+      @client = HipChat::Client.new api_token
+      cfg_colors = hipchat_options.fetch(:colors, {})
+      @colors = {
+        :success => cfg_colors.fetch(:success, HipchatStatus::SUCCESS),
+        :warning => cfg_colors.fetch(:warning, HipchatStatus::WARNING),
+        :error   => cfg_colors.fetch(:error, HipchatStatus::ERROR),
+        :status  => cfg_colors.fetch(:status, HipchatStatus::STATUS),
+        :random  => cfg_colors.fetch(:random, HipchatStatus::RANDOM)
+      }
+      logger.info "Configured Hipchat client"
+    end
+
+    # Bindings available
+    #   room_name - hipchat room
+    #   username - user message being sent as
+    #   at - If we are at'ing a person
+    def notify! message_obj = OpenStruct.new, to = nil
+      room_name = get_room message_obj
+      username = get_from_username message_obj
+      if room_name.nil? then
+        raise CollinsNotify::CollinsNotifyException.new "No obj.room or hipchat.room specified"
+      end
+      message = get_message_body(binding).strip.gsub(/[\n\r]/, ' ')
+      message = "@#{to} #{message}" unless to.nil?
+      logger.info "Notifying #{room_name} from #{username} with message #{message}"
+      if config.test? then
+        logger.info "Not sending hipchat message in test mode"
+        return true
+      end
+      opts = client_options(message_obj)
+      logger.debug "Using hipchat options #{opts.inspect}"
+      client[room_name].send(username, message, client_options(message_obj))
+    end
+
+    protected
+    attr_accessor :client, :colors
+    def api_token
+      hipchat_options[:api_token]
+    end
+    def color mo
+      if color = fetch_mo_option(mo, :color, false) then
+        return color
+      end
+      [:success, :warning, :error, :status].each do |key|
+        if fetch_mo_option(mo, key, false) then
+          return colors[key]
+        end
+      end
+      colors[:status]
+    end
+    def client_options mo
+      opts = {}
+      opts[:notify] = true if hipchat_options[:notify]
+      opts[:color] = color(mo)
+      opts
+    end
+    def get_from_username mo
+      fetch_mo_option(mo, :from_username, hipchat_options[:from_username])
+    end
+    def hipchat_options
+      @hipchat_options ||= symbolize_hash(deep_copy_hash(config.adapters[:hipchat]))
+    end
+    def get_room mo
+      if config.recipient then
+        config.recipient
+      else
+        fetch_mo_option(mo, :room, hipchat_options[:room])
+      end
+    end
+
+  end
+
+end

data/lib/collins_notify/adapter/irc.rb

@@ -0,0 +1,88 @@
+require 'collins_notify/adapter/helper/carried-pigeon'
+
+module CollinsNotify
+  class IrcAdapter < Notifier
+    register_name :irc
+    supports_mimetype :text
+    require_config :username, :host, :port
+
+    def configure!
+      # An exception gets thrown if needed
+      get_channel symbolize_hash(deep_copy_hash(config.adapters[:irc])), nil
+      nil
+    end
+
+    # Available in template binding:
+    #   message_obj - Depends on call
+    #   nick - nickname
+    #   channel - channel sending to
+    #   host - host connecting to
+    #   port - port on host being connected to
+    def notify! message_obj = OpenStruct.new, to = nil
+      tmp_config = symbolize_hash(deep_copy_hash(config.adapters[:irc]))
+      host = tmp_config.delete(:host)
+      port = tmp_config.delete(:port).to_i
+      nick = tmp_config.delete(:username)
+      channel = get_channel(tmp_config, to)
+      tmp_config.delete(:channel)
+      cp_config = {
+        :host => host,
+        :port => port,
+        :nick => nick,
+        :channel => channel,
+        :logger => logger
+      }
+      cp_config.merge!(tmp_config)
+      logger.trace "Using IRC config: #{cp_config.inspect}"
+      if config.test? then
+        logger.info "Not sending message in test mode"
+        return true
+      end
+      cp = try_connect cp_config
+      return false unless cp
+      logger.info "Connected to IRC"
+      begin
+        body = get_message_body(binding).strip.gsub(/[\n\r]/, ' ')
+        cp.message body, cp_config[:notice]
+        true
+      rescue CollinsNotify::CollinsNotifyException => e
+        logger.error "error sending irc notification - #{e}"
+        raise e
+      rescue Exception => e
+        logger.error "#{e.class.to_s} - error sending irc notification - #{e}"
+        raise CollinsNotify::CollinsNotifyException.new e
+      ensure
+        cp.die
+      end
+    end
+
+    protected
+    def get_channel hash, to
+      if config.recipient then
+        make_channel config.recipient
+      elsif to then
+        make_channel to
+      elsif hash[:channel] then
+        make_channel hash.delete(:channel)
+      else
+        raise CollinsNotify::ConfigurationError.new "No irc.channel or config.recipient specified"
+      end
+    end
+
+    def make_channel chan
+      name = chan.start_with?('#') ? chan : "##{chan}"
+      name.gsub(/[^A-Za-z0-9#]/, '_')
+    end
+
+    def try_connect config
+      begin
+        CarriedPigeon.new config
+      rescue Exception => e
+        logger.error "error connecting to server #{config[:host]} - #{e}"
+        false
+      end
+    end
+
+  end # class IrcAdapter
+
+end # module CollinsNotify

data/lib/collins_notify/application.rb

@@ -0,0 +1,55 @@
+module CollinsNotify
+  class Application
+    include CollinsNotify::ConfigurationMixin
+    include Collins::Util::Logging
+
+    attr_writer :config
+    attr_reader :logger
+
+    def initialize
+      @logger = get_logger :logfile => $stderr, :program => 'collins_notify'
+      @config = CollinsNotify::Configuration.new @logger
+    end
+
+    # Override ConfigMixin::#config
+    def config
+      @config
+    end
+
+    def configure! argv
+      o = CollinsNotify::Options.get_instance config
+      o.parse! argv
+      if config.logfile then
+        @logger = get_logger :logfile => config.logfile, :program => 'collins_notify'
+      end
+      @logger.level = config.severity
+    end
+
+    def notify! message_obj = OpenStruct.new, to = nil
+      Timeout::timeout(config.timeout) do
+        notifier.notify! message_obj, to
+      end
+    end
+
+    # Override ConfigurationMixin#valid?
+    def valid?
+      if config.valid? then
+        begin
+          @notifier = CollinsNotify::Notifier.get_adapter self
+          @notifier.configure!
+        rescue Exception => e
+          logger.error "Error configuring #{type} notification - #{e}"
+          pp e.backtrace
+          return false
+        end
+        true
+      else
+        false
+      end
+    end
+
+    protected
+    attr_accessor :notifier
+
+  end
+end

data/lib/collins_notify/command_runner.rb

@@ -0,0 +1,73 @@
+module CollinsNotify
+  class CommandRunner
+
+    def run args
+      app = CollinsNotify::Application.new
+
+      begin
+        app.configure! args
+        get_contact_and_asset app, true # throws exception if not configured properly
+      rescue SystemExit => e
+        exit e.status
+      rescue CollinsNotify::ConfigurationError => e
+        app.logger.fatal "Error with input option - #{e}"
+        exit 1
+      rescue StandardError => e
+        app.logger.fatal "Error parsing CLI options - #{e}"
+        $stdout.puts CollinsNotify::Options.get_instance(app.config)
+        exit 2
+      end
+      # This is legacy behavior
+      app.config.type = :email if app.config.type.nil?
+
+      unless app.valid? then
+        $stdout.puts CollinsNotify::Options.get_instance(app.config)
+        exit 3
+      end
+
+      app.logger.trace "Configuration -> #{app.config.to_hash.inspect}"
+
+      begin
+        contact, asset = get_contact_and_asset app
+        if !app.notify!(asset, contact) then
+          raise Exception.new "failed"
+        end
+      rescue Timeout::Error => e
+        app.logger.fatal "TIMEOUT sending notification via #{app.type}"
+        exit 4
+      rescue Exception => e
+        app.logger.fatal "ERROR sending notification via #{app.type} - #{e}"
+        exit 5
+      end
+
+      app.logger.info "Successfully sent #{app.type} notification"
+      exit 0
+    end
+
+    protected
+    def get_contact_and_asset app, test_only = false
+      return [nil, OpenStruct.new] unless app.selector and !app.selector.empty?
+      ccfg = app.config.collins
+      if ccfg.nil? or ccfg.empty? then
+        raise CollinsNotify::ConfigurationError.new "No collins configuration but selector specified"
+      end
+      collins = Collins::Client.new ccfg.merge(:logger => app.logger)
+      return if test_only
+      asset = nil
+      if app.selector[:tag] then
+        app.logger.info "Finding collins asset using asset tag #{app.selector[:tag]}"
+        asset = collins.get app.selector[:tag]
+      else
+        app.logger.info "Finding collins asset using asset selector #{app.selector.inspect}"
+        assets = collins.find(app.selector)
+        app.logger.debug "Found #{assets.size} assets in collins using selector, only using first"
+        asset = assets.first
+      end
+      if asset.nil? then
+        raise CollinsNotify::ConfigurationError.new "No asset found using #{app.selector.inspect}"
+      end
+      [asset.contact, asset]
+    end
+
+  end
+end

data/lib/collins_notify/configuration.rb

@@ -0,0 +1,198 @@
+module CollinsNotify
+
+  class Configuration
+    include CollinsNotify::ConfigurationMixin
+
+    attr_reader :logger
+    attr_accessor :adapters
+
+    def initialize logger, opts = {}
+      @adapters = {}
+      configurable.each do |key, value|
+        instance_variable_set "@#{key.to_s}".to_sym, value
+      end
+      @logger = logger
+      merge opts
+    end
+
+    # Override ConfigurationMixin#config
+    def config
+      self
+    end
+
+    # Override ConfigurationMixin#valid?
+    def valid?
+      adapters = CollinsNotify::Notifier.adapters.keys
+      if type.nil? || !adapters.include?(type) then
+        msg = "Invalid notifier type specified. Valid notifiers: #{adapters.sort.join(', ')}"
+        logger.error msg
+        return false
+      end
+      unless message_body? then
+        logger.error "No message body found in specified template or stdin"
+        return false
+      end
+      true
+    end
+
+    # Shorthand for severity assignment but silently fails if too verbose
+    def increase_verbosity
+      if severity > -1 then
+        self.severity -= 1
+        if trace? then
+          $DEBUG = true
+        end
+      end
+    end
+
+    def message_body?
+      template? || stdin?
+    end
+
+    def resolved_template
+      return nil unless template
+      if File.exists?(File.expand_path(template)) then
+        return File.expand_path(template)
+      elsif template_dir && File.exists?(File.expand_path(File.join(template_dir, template))) then
+        return File.expand_path(File.join(template_dir, template))
+      elsif File.exists?(File.expand_path(File.join(default_template_dir, template))) then
+        return File.expand_path(File.join(default_template_dir, template))
+      end
+    end
+
+    def stdin?
+      !$stdin.tty?
+    end
+
+    def template?
+      !resolved_template.nil?
+    end
+
+    alias_method :original_to_hash, :to_hash
+    def to_hash
+      original_to_hash.merge(:severity_name => sevname, :adapters => adapters)
+    end
+
+    protected
+    def default_template_dir
+      File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'templates'))
+    end
+
+    # Merge opts from the constructor into here
+    def merge opts
+      opts.each do |k,v|
+        if configurable.key?(k.to_sym) && !v.nil? then
+          self.send("#{k}=".to_sym, v)
+        end
+      end
+    end
+
+    ###################################################################################
+    # Validators and Formatters
+    ###################################################################################
+    def format_collins cfg
+      symbolize_hash(cfg) unless cfg.nil?
+    end
+    def valid_collins? cfg
+      if !cfg.nil? && cfg.is_a?(Hash) then
+        [:host,:username,:password].each do |key|
+          if !cfg.key?(key) then
+            return false
+          end
+        end
+        true
+      else
+        false
+      end
+    end
+
+    def format_config_file file
+      format_file file
+    end
+    def valid_config_file? file
+      valid_file? file
+    end
+
+    def format_logfile file
+      format_file file
+    end
+    def valid_logfile? file
+      valid_file? file
+    end
+
+    def valid_recipient? recip
+      !recip.nil?
+    end
+
+    def valid_selector? sel
+      !sel.nil? && sel.is_a?(Hash) && !sel.empty?
+    end
+
+    def format_severity sev
+      sev.to_i unless sev.nil?
+    end
+    def valid_severity? sev
+      !sev.nil? && sev.is_a?(Fixnum) && sev >= -1 && sev <= 3
+    end
+
+    def format_template file
+      f = format_file file
+      if File.exists?(f) then
+        f
+      elsif File.exists?(File.expand_path(File.join(default_template_dir, file))) then
+        File.expand_path(File.join(default_template_dir, file))
+      end
+    end
+    def valid_template? file
+      valid_file? file
+    end
+
+    def format_template_dir d
+      File.expand_path(d.to_s) unless d.nil?
+    end
+    def valid_template_dir? d
+      !d.nil? && File.exists?(d)
+    end
+
+    def format_template_format f
+      f.to_sym unless f.nil?
+    end
+    def valid_template_format? t
+      !t.nil? && t.is_a?(Symbol) && [:default,:html].include?(t)
+    end
+
+    def format_template_processor f
+      f.to_sym unless f.nil?
+    end
+    def valid_template_processor? t
+      !t.nil? && t.is_a?(Symbol) && [:default,:erb].include?(t)
+    end
+
+    def valid_test? t
+      !t.nil? && (t.is_a?(TrueClass) || t.is_a?(FalseClass))
+    end
+
+    def format_timeout t
+      t.to_i unless t.nil?
+    end
+    def valid_timeout? t
+      !t.nil? && t.is_a?(Fixnum) && t > 0
+    end
+
+    def format_type t
+      t.to_sym unless t.nil?
+    end
+    def valid_type? t
+      !t.nil? && t.is_a?(Symbol)
+    end
+
+    private
+    def format_file file
+      File.expand_path(file) unless file.nil?
+    end
+    def valid_file? file
+      !file.nil? && File.exists?(file) && File.readable?(file)
+    end
+  end
+
+end