collins_notify 0.0.1

data/lib/collins_notify/configuration_mixin.rb

@@ -0,0 +1,98 @@
+module CollinsNotify; module ConfigurationMixin
+
+  include Collins::Util
+
+  def config
+    raise NotImplementedError.new "ConfigurationMixin#config must be implemented"
+  end
+
+  def valid?
+    raise NotImplementedError.new "ConfigurationMixin#valid? must be implemented"
+  end
+
+  def fatal?; severity <= Logger::FATAL; end
+  def error?; severity <= Logger::ERROR; end
+  def warn?; severity <= Logger::WARN; end
+  def info?; severity <= Logger::INFO; end
+  def debug?; severity <= Logger::DEBUG; end
+  def trace?; severity <= Logger::TRACE; end
+  def sevname
+    if trace? then
+      "TRACE"
+    else
+      Logger::SEV_LABEL[severity]
+    end
+  end
+
+  def test?; (config.test == true); end
+
+  # Handles magic getters/setters
+  def method_missing m, *args, &block
+    kname = m.to_s.gsub(/=$/, '') # key name, remove = in case it's assignment
+    is_configurable = configurable.key?(kname.to_sym) 
+    is_assignment = is_configurable && m.to_s[-1].eql?('=') && args.size > 0
+
+    # handles gets, these are the simplest
+    if is_configurable && !is_assignment then
+      get_cfg_var "@#{kname}".to_sym
+    elsif is_assignment then # handle set case
+      formatter_name = "format_#{kname}".to_sym
+      if args.size == 1 then
+        value = args.first
+      else
+        value = args
+      end
+
+      # Format value if a formatter exists
+      if respond_to?(formatter_name) then
+        value = send(formatter_name, value)
+      end
+
+      validator_name = "valid_#{kname}?".to_sym
+      unless respond_to?(validator_name) then
+        raise NotImplementedError.new "ConfigurationMixin##{validator_name} must be implemented"
+      end
+      if send(validator_name, value) then
+        set_cfg_var "@#{kname}".to_sym, value
+      else
+        raise CollinsNotify::ConfigurationError.new "#{kname} #{value.inspect} is not valid"
+      end
+    else
+      super
+    end
+  end
+
+  def to_hash
+    configurable.inject({}) do |ret, (k,v)|
+      ret.update(k => get_cfg_var("@#{k.to_s}".to_sym))
+    end
+  end
+
+  protected
+  def configurable
+    {
+      :collins            => {}, # collins configs
+      :config_file        => nil,
+      :logfile            => nil,
+      :recipient          => nil,
+      :selector           => {}, # optional collins asset to notify about
+      :severity           => Logger::INFO,
+      :template           => nil,
+      :template_dir       => nil, # legacy needs
+      :template_format    => :default,
+      :template_processor => :default,
+      :test               => false,
+      :timeout            => 10,
+      :type               => nil,
+    }
+  end
+
+  def get_cfg_var name
+    config.instance_variable_get name
+  end
+
+  def set_cfg_var name, value
+    config.instance_variable_set name, value
+  end
+
+end; end

data/lib/collins_notify/errors.rb

@@ -0,0 +1,4 @@
+module CollinsNotify
+  class CollinsNotifyException < StandardError; end
+  class ConfigurationError < CollinsNotifyException; end
+end

data/lib/collins_notify/notifier.rb

@@ -0,0 +1,165 @@
+require 'erb'
+require 'nokogiri'
+
+module CollinsNotify
+
+  class Notifier
+
+    include Collins::Util
+
+    class << self
+      def require_config *keys
+        @requires_config = keys.map{|k| k.to_sym}
+      end
+      def requires_config?
+        @requires_config && !@requires_config.empty?
+      end
+      def required_config_keys
+        @requires_config || []
+      end
+      def register_name name
+        @adapter_name = name
+      end
+      def adapter_name
+        @adapter_name
+      end
+      def supports_mimetype *mimetypes
+        @supported_mimetypes = mimetypes.map{|e| e.to_sym}
+      end
+      def mimetypes
+        @supported_mimetypes || [:text]
+      end
+      def adapters
+        ObjectSpace.each_object(Class).select { |klass| klass < self }.inject({}) do |ret,k|
+          ret.update(k.adapter_name => k)
+        end
+      end
+      def get_adapter application
+        type = application.type
+        config = application.config
+        adapter_config = config.adapters[type]
+        adapter = adapters[type]
+        (raise CollinsNotifyException.new("Invalid notify type #{type}")) if adapter.nil?
+        if adapter.requires_config? then
+          (raise CollinsNotify::ConfigurationError.new "No config found for #{type}") if adapter_config.nil?
+          adapter.required_config_keys.each do |key|
+            unless adapter_config.key?(key) then
+              raise CollinsNotify::ConfigurationError.new "Missing #{type}.#{key} config key"
+            end
+          end
+        end
+        (raise CollinsNotifyException.new("No config found for #{type}")) if adapter.requires_config? and adapter_config.nil?
+        adapter.new application
+      end
+    end
+
+    def initialize app
+      @config = app.config
+      @logger = app.logger
+    end
+
+    # Throw an exception if it cant be configured
+    def configure!
+      raise NotImplementedError.new "CollinsNotify::Notifier#configure! must be implemented"
+    end
+
+    # Return boolean indicating success/fail
+    def notify! message_obj = OpenStruct.new, to = nil
+      raise NotImplementedError.new "CollinsNotify::Notifier#notify! must be implemented"
+    end
+
+    def supports_text?
+      self.class.mimetypes.include?(:text)
+    end
+    def supports_html?
+      self.class.mimetypes.include?(:html)
+    end
+
+    protected
+    attr_reader :config
+    attr_reader :logger
+
+    # Retrieve (safely) a key from a binding
+    def fetch_bound_option b, name, default
+      begin
+        eval(name, b)
+      rescue Exception => e
+        logger.trace "Could not find value name #{name} in binding"
+        default
+      end
+    end
+
+    # Retrieve (safely) a key from a message object which may be a hash, OpenStruct, or arbitrary
+    # value
+    def fetch_mo_option mo, key, default
+      value = default
+      if mo.is_a?(Hash) && mo.key?(key) && !mo[key].nil? then
+        value = mo[key]
+      elsif mo.respond_to?(key) && !mo.send(key).nil? then
+        value = mo.send(key)
+      end
+      value
+    end
+
+    # b is the binding to use
+    def get_message_body b
+      if config.stdin? then
+        message_txt = $stdin.read.strip
+        if config.template_processor == :erb then
+          render_template message_txt, b
+        else
+          message_txt
+        end
+      elsif config.template? then
+        tmpl = config.resolved_template
+        logger.debug "Using template file #{tmpl}"
+        render_template File.new(tmpl), b
+      else
+        raise CollinsNotify::CollinsNotifyException.new "Unknown message body type"
+      end
+    end
+
+    def render_template tmpl, b
+      template_format = config.template_format
+      if template_format == :default && tmpl.is_a?(File) && tmpl.path.include?(".html") then
+        logger.info "Detected HTML formatted template file, will render to HTML if possible"
+        # If format was unspecified but it seems like it's html, make it so
+        template_format = :html
+      end
+      tmpl_txt = tmpl.is_a?(File) ? tmpl.read : tmpl
+      begin
+        template = ERB.new(tmpl_txt, nil, '<>')
+        html_text = plain_text = nil
+        if template_format == :html then
+          logger.debug "Template format is html, rendering it as HTML"
+          html_text = template.result(b)
+          plain_text = as_plain_text html_text
+        else
+          logger.debug "Template format is plain text, treating it as such"
+          plain_text = template.result(b)
+        end
+        if supports_html? then
+          logger.info "HTML is supported by #{self.class.adapter_name}"
+          handle_html b, html_text, plain_text
+        else
+          logger.info "Only plain text supported by #{self.class.adapter_name}"
+          logger.debug "Rendered plain text: '#{plain_text.gsub(/[\r\n]/, ' ')}'"
+          plain_text
+        end
+      rescue Exception => e
+        raise CollinsNotify::CollinsNotifyException.new "Invalid template #{tmpl} - #{e}"
+      end
+    end
+
+    # b is original binding, html is html version, plain_text is plain text version
+    def handle_html b, html, plain_text
+      html
+    end
+
+    def as_plain_text html
+      Nokogiri::HTML(html).text
+    end
+
+  end
+
+end

data/lib/collins_notify/options.rb

@@ -0,0 +1,128 @@
+require 'optparse'
+require 'yaml'
+
+module CollinsNotify
+
+  class Options < OptionParser
+    ETC_CONFIG = "/etc/collins_notify.yaml"
+
+    include Collins::Util
+
+    def self.app_name
+      File.basename($0)
+    end
+    def self.get_instance config
+      i = CollinsNotify::Options.new config
+      i.banner = "Usage: #{app_name} --config=CONFIG [options]"
+      i.separator ""
+      i.instance_eval { setup }
+      i
+    end
+
+    def parse! argv = default_argv
+      res = super
+      cfg_file = get_config_file
+      if cfg_file then #config.config_file then
+        yaml = YAML::load(File.open(cfg_file))
+        adapters = CollinsNotify::Notifier.adapters.keys
+        yaml.each do |k,v|
+          if adapters.include?(k.to_sym) then
+            config.adapters[k.to_sym] = symbolize_hash(v)
+          else
+            try_configure k, v
+          end
+        end
+      end
+      res
+    end
+
+    protected
+    attr_reader :config
+    def initialize config
+      @config = config
+      super()
+    end
+
+    def get_config_file
+      if config.config_file then
+        config.config_file
+      elsif File.exists?(ETC_CONFIG) && File.readable?(ETC_CONFIG) then
+        ETC_CONFIG
+      else
+        nil
+      end
+    end
+
+    def setup
+      separator "Specific options:"
+      on('-c', '--config=CONFIG', 'Notifier config. Must include any neccesary credentials for the specified notify type') do |config|
+        @config.config_file = config
+      end
+      on('--recipient=NAME', 'Email address, username, channel, etc') do |n|
+        @config.recipient = n
+      end
+      on('--selector=SELECTOR', 'Selector to use to retrieve collins assets') do |s|
+        @config.selector = eval(s)
+      end
+      on('--tag=TAG', 'Unique tag of asset') do |t|
+        @config.selector = {:tag => t}
+      end
+      adapters = CollinsNotify::Notifier.adapters.keys
+      msg = "Select notification type (#{adapters.sort.join(', ')})"
+      on('--type=TYPE', adapters, msg) do |t|
+        @config.type = t
+      end
+      separator ""
+      separator "Common options:"
+      on_tail('-d', '--debug', 'Legacy, same as -v') do
+        @config.increase_verbosity
+      end
+      on_tail('-h', '--help', 'This help') do
+        $stdout.puts self
+        exit 0
+      end
+      on_tail('--logfile=FILE', 'Log file to use, or stderr') do |file|
+        @config.logfile = file
+      end
+      on_tail('--template=TEMPLATE', 'Template to use for notifications, erb file') do |t|
+        @config.template = t
+      end
+      on_tail('--template-dir=DIR', 'Use fully qualified path in --template, do not use this') do |d|
+        @config.template_dir = d
+      end
+      on_tail('--template-format=FMT', [:default, :html], 'Template format (default, html).') do |t|
+        @config.template_format = t.to_sym
+      end
+      on_tail('--template-processor=PROC', [:default, :erb], 'Template processor (default, erb).') do |t|
+        @config.template_processor = t.to_sym
+      end
+      on_tail('-t', '--[no-]test', 'Enable or disable testing') do |t|
+        @config.test = t
+      end
+      on_tail('--timeout=TIMEOUT', Integer, 'Timeout in seconds, defaults to 10') do |t|
+        @config.timeout = t
+      end
+      on_tail('-v', '--verbose', verbose_help) do
+        @config.increase_verbosity
+      end
+      on_tail('-V', '--version', 'Software version') do
+        $stdout.puts "collins_notify #{CollinsNotify::Version}"
+        exit 0
+      end
+    end
+    def verbose_help
+      "Increase verbosity. Specify multiple -v options to increase (up to 4)"
+    end
+
+    private
+    def try_configure key, value
+      begin
+        config.send("#{key}=".to_sym, value)
+      rescue Exception => e
+        raise CollinsNotify::ConfigurationError.new "#{key} is not a valid config option"
+      end
+    end
+
+  end
+
+end

data/lib/collins_notify/version.rb

@@ -0,0 +1,19 @@
+module CollinsNotify; module Version
+
+  class << self
+    def location= loc
+      @location = loc
+    end
+    def location
+      @location || File.absolute_path(File.join(File.dirname(__FILE__), '..', '..', 'VERSION'))
+    end
+    def to_s
+      if location && File.exists?(location) then
+        File.read(location)
+      else
+        "0.0.0-pre"
+      end
+    end
+  end
+
+end; end

data/sample_config.yaml

@@ -0,0 +1,32 @@
+---
+:collins:
+    host: "https://collins.example.net"
+    username: "some_username"
+    password: "some_password"
+    timeout: 30
+:email:
+    address: "smtp.sendgrid.net"
+    port: 587
+    domain: "example.com"
+    user_name: "some_username"
+    password: "some_password"
+    authentication: "plain"
+    enable_starttls_auto: true
+    sender_address: "Collins <collins@example.com>"
+:hipchat:
+    api_token: "api_token_here"
+    colors:
+      success: "green"
+      error: "red"
+    notify: true
+    room: "AutoBots"
+    from_username: "Collins"
+:irc:
+    username: "some_username"
+    password: "some_password"
+    host: "hostname"
+    port: 6697
+    ssl: true
+    join: true
+    notice: true
+    channel: "#test"