collins_notify 0.0.1

data/Gemfile

@@ -0,0 +1,15 @@
+source :rubygems
+
+gem 'collins_client', '~> 0.2.10'
+gem 'hipchat',        '~> 0.7.0'
+gem 'mail',           '~> 2.4.4'
+gem 'nokogiri',       '~> 1.5.2'
+
+group :development do
+  gem "rspec", "~> 2.12.0"
+  gem "yard", "~> 0.8.3"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.2.0"
+  gem "jeweler", "~> 1.8.4"
+  gem "simplecov"
+end

data/README.rdoc

@@ -0,0 +1,27 @@
+= collins-notify
+
+CLI and library for sending templated (or not) notifications via email, hipchat,
+and IRC.
+
+== Exit Codes
+
+Exit codes only apply to when you use the CommandRunner (via the collins-notify
+CLI interface). Otherwise, exceptions and return values will indicate the status
+of an operation.
+
+* 0 - Success
+* 1 - Invalid configuration value
+* 2 - Could not parse CLI options
+* 3 - Unable to run with specified configuration
+* 4 - Timeout talking to remote service
+* 5 - General error sending notification
+
+== Contributing to collins-notify
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.

data/Rakefile

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'jeweler'
+require 'yard'
+
+jeweler = Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "collins_notify"
+  gem.homepage = "https://github.com/tumblr/collins/tree/master/support/ruby/collins-notify"
+  gem.license = "MIT"
+  gem.summary = %Q{Notifications for Collins}
+  gem.description = %Q{Send notifications via hipchat, IRC and email}
+  gem.email = "bmatheny@tumblr.com"
+  gem.authors = ["Blake Matheny"]
+  %w[config.yaml spec/**/* .gitignore .rspec .rvmrc .document .rbenv-version].each do |fp|
+    gem.files.exclude fp
+  end
+  gem.add_runtime_dependency 'collins_client', '~> 0.2.10'
+  gem.add_runtime_dependency 'hipchat',        '~> 0.7.0'
+  gem.add_runtime_dependency 'mail',           '~> 2.4.4'
+  gem.add_runtime_dependency 'nokogiri',       '~> 1.5.2'
+end
+
+task :help do
+  puts("rake -T                  # See available rake tasks")
+  puts("rake spec                # Run tests")
+  puts("rake make                # version:bump:patch gemspec build")
+  puts("rake publish             # run copy_gem")
+  puts("rake all                 # make then publish")
+  puts("rake                     # this help")
+end
+
+task :publish do
+  package_abs = jeweler.jeweler.gemspec_helper.gem_path
+  package_name = File.basename(package_abs)
+
+  puts "Run 'copy_gem #{package_name}'"
+end
+
+task :make => ["version:bump:patch", "gemspec", "build"] do
+  puts("Done!")
+end
+
+task :all => [:make, :publish]
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.fail_on_error = false
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :help
+task :rspec => :spec
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+  t.options = ['--markup', 'markdown']
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/collins-notify

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'collins_notify'
+require 'pp'
+
+CollinsNotify::CommandRunner.new.run ARGV

data/lib/collins_notify.rb

@@ -0,0 +1,16 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'logger'
+require 'timeout'
+require 'collins_client'
+require 'collins_notify/errors'
+require 'collins_notify/configuration_mixin'
+require 'collins_notify/configuration'
+require 'collins_notify/command_runner'
+require 'collins_notify/options'
+require 'collins_notify/version'
+require 'collins_notify/notifier'
+require 'collins_notify/adapter/email'
+require 'collins_notify/adapter/hipchat'
+require 'collins_notify/adapter/irc'
+require 'collins_notify/application'

data/lib/collins_notify/adapter/email.rb

@@ -0,0 +1,108 @@
+require 'mail'
+
+module CollinsNotify
+  class EmailAdapter < Notifier
+    register_name :email
+    supports_mimetype :text, :html
+    require_config
+
+    def configure!
+      mail_cfg = mail_options
+      del_meth = mail_cfg.fetch(:delivery_method, :smtp)
+      logger.info "Configuring email delivery method #{del_meth}"
+      logger.debug "Using email config values #{mail_cfg.inspect}"
+      Mail.defaults do
+        delivery_method del_meth, mail_cfg
+      end
+      nil
+    end
+
+    # Available in template binding
+    #   sender_address - Address of sender
+    #   recipient_address - Resolved address of recipient
+    #   subject - Mail subject
+    #   message_obj - Depends on call
+    def notify! message_obj = OpenStruct.new, to = nil
+      sender_address = get_sender_address message_obj
+      recipient_address = get_recipient_address message_obj, to
+      subject = get_subject message_obj
+      message = get_message_body(binding)
+      subject = message.subject # Subject may change based on message template
+      (raise CollinsNotify::CollinsNotifyException.new("No subject specified")) if subject.nil?
+      logger.info "From: #{sender_address}, To: #{recipient_address}, Subject: #{subject}"
+      logger.trace "Message body:\n#{message}"
+      begin
+        mail = Mail.new message
+        logger.debug "Attempting to deliver email message"
+        if config.test? then
+          logger.info "Not delivering email, running in test mode"
+        else
+          logger.info "Delivering email message"
+          mail.deliver!
+        end
+        true
+      rescue Exception => e
+        logger.fatal "Error sending email - #{e}"
+        false
+      end
+    end
+
+    protected
+    def get_recipient_address mo, to
+      if config.recipient then
+        make_address config.recipient
+      elsif to then
+        make_address to
+      elsif fetch_mo_option(mo, :recipient, nil) then
+        make_address fetch_mo_option(mo, :recipient, nil)
+      else
+        raise CollinsNotify::ConfigurationError.new "No email.recipient or config.recipient specified"
+      end
+    end
+
+    def get_sender_address mo
+      default = mail_options.fetch(:sender_address, "Notifier <notifier@example.com>")
+      fetch_mo_option(mo, :sender_address, default)
+    end
+
+    def get_subject mo
+      default = mail_options.fetch(:subject, nil)
+      fetch_mo_option(mo, :subject, default)
+    end
+
+    def handle_html b, html, plain_text
+      is_html = !html.nil?
+      message = Mail::Message.new plain_text
+      if is_html then
+        message.body = ""
+        message.html_part = Mail::Part.new do
+          content_type 'text/html; charset=UTF-8'
+          body html
+        end
+        message.text_part = Mail::Part.new do
+          body plain_text
+        end
+      end
+      message[:from] = fetch_bound_option(b, "sender_address", "NOOP") unless message.from
+      message[:to] = fetch_bound_option(b, "recipient_address", "NOOP") unless message.to
+      message[:subject] = fetch_bound_option(b, "subject", "Collins Notifier") unless message.subject
+      message
+    end
+
+    def mail_options
+      @mail_options ||= symbolize_hash(deep_copy_hash(config.adapters[:email]))
+    end
+
+    def make_address address
+      if address.include?("@") then
+        return address
+      end
+      domain = "example.com"
+      if mail_options[:domain] then
+        domain = mail_options[:domain]
+      end
+      "#{address}@#{domain}"
+    end
+
+  end
+end

data/lib/collins_notify/adapter/helper/carried-pigeon.rb

@@ -0,0 +1,213 @@
+require "addressable/uri"
+require "socket"
+require "openssl"
+
+# Code is largely ripped off from https://github.com/portertech/carrier-pigeon which carriers an MIT
+# license. Carrier pigeon offers no ability to detect a 433 response (nickname already in use) and
+# automatically fix it. There's also not much in the way of debugging. That's all that is added
+# here.
+class CarriedPigeon
+
+  def self.send(options={})
+    raise "You must supply a message" unless options[:message]
+    if options[:uri] then
+      uri = Addressable::URI.parse(options[:uri])
+      options[:host] = uri.host
+      options[:port] = uri.port || 6667
+      options[:nick] = uri.user
+      options[:password] = uri.password
+      unless options[:channel] then
+        options[:channel] = "#" + uri.fragment
+      end
+    end
+    pigeon = CarriedPigeon.new options
+    pigeon.message options[:message], options[:notice]
+    pigeon.die
+  end
+
+  attr_reader :connected, :logger, :options
+  def initialize(options={})
+    [:host, :port, :nick, :channel, :logger].each do |option|
+      raise "You must provide an IRC #{option}" unless options.has_key?(option)
+    end
+    @logger = options[:logger]
+    @options = options
+    connect! if (options.fetch(:connect, true)) # default to connect, same as old behavior
+  end
+
+  def auth
+    # Only auth if not connected and password is specified
+    if connected? or !password then
+      return false
+    end
+    # Must be first according to RFC 2812
+    sendln "PASS #{password}", :log
+    sendln "USER #{nick} 0 * :#{real_name}", :log
+    true
+  end
+
+  def connect!
+    return false if connected?
+    tcp_socket = TCPSocket.new(host, port)
+    if ssl? then
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+      @socket.sync = true
+      @socket.sync_close = true
+      @socket.connect
+    else
+      @socket = tcp_socket
+    end
+    if auth? and not auth then
+      die
+      raise "Could not authenticate"
+    end
+    set_nick!
+    @connected = true
+    issue_nickserv_command
+    register
+  end
+
+  def message message, notice = false, opts = {}
+    command = notice ? "NOTICE" : "PRIVMSG"
+    # Reset join/channel/channel_password options if specified
+    options[:join] = opts[:join] if opts.key?(:join)
+    options[:channel] = opts[:channel] if opts.key?(:channel)
+    if opts.key?(:channel) then
+      options[:channel_password] = opts[:channel_password]
+    end
+    join!
+    sendln "#{command} #{channel} :#{message}", :log
+  end
+
+  def die
+    begin
+      sendln "QUIT :quit", :log
+      socket.gets until socket.eof?
+    rescue Exception => e
+      logger.error "Error quitting IRC - #{e}"
+    ensure
+      socket.close
+    end
+  end
+
+  protected
+  attr_accessor :socket
+
+  def auth?; options.key?(:password); end
+  def channel_password?; options.key?(:channel_password); end
+  def connected?; (connected == true); end
+  def join?; (options[:join] == true); end
+  def nickserv_command?; options.key?(:nickserv_command); end
+  def nickserv_password?; options.key?(:nickserv_password); end
+  def register_first?; (options[:register_first] == true); end
+  def ssl?; (options[:ssl] == true); end
+
+  def channel; options[:channel]; end
+  def channel_password; options[:channel_password]; end
+  def host; options[:host]; end
+  def mode; options.fetch(:mode, 0); end
+  def nick; options[:nick]; end
+  def nickserv_command; options[:nickserv_command]; end
+  def nickserv_password; options[:nickserv_password]; end
+  def password; options[:password]; end
+  def port; options[:port]; end
+  def real_name; options.fetch(:real_name, nick); end
+
+  # Where a response was an error or not
+  def error? response
+    rc = response_code response
+    rc >= 400 && rc < 600
+  end
+
+  # Generate a nickname, useful if yours is taken
+  def gen_nick name
+    names = name.split('_')
+    if names.size == 1 then
+      "#{name}_1"
+    elsif names.last.to_i > 0 then
+      num = names.pop.to_i
+      if num > 10 then
+        raise "Too many nicknames generated (10)"
+      end
+      "#{names.join('_')}_#{num + 1}"
+    else
+      "#{name}_1"
+    end
+  end
+
+  def issue_nickserv_command
+    if nickserv_password? then
+      sendln "PRIVMSG NICKSERV :IDENTIFY #{nickserv_password}"
+    elsif nickserv_command? then
+      sendln nickserv_command
+    end
+  end
+
+  def join!
+    return unless join?
+    join = "JOIN #{channel}"
+    join += " #{channel_password}" if channel_password?
+    sendln join, :log
+  end
+
+  def log_response
+    response = socket.gets
+    if error? response then
+      logger.error "IRC response: #{response.strip}"
+    else
+      logger.trace "IRC response: #{response.strip}"
+    end
+    response
+  end
+
+  def register
+    if register_first?
+      while line = socket.gets
+        case line
+          when /^PING :(.+)$/i
+            sendln "PONG :#{$1}"
+            break
+        end
+      end
+    end
+  end
+
+  # 0 on no response code, otherwise integer
+  def response_code response
+    response.to_s.split[1].to_i
+  end
+
+  # Send an IRC command to a socket, second arg can be one of :log or :none
+  # :log - log the response and get it
+  # :none - do nothing
+  def sendln cmd, log_or_get = :none
+    logger.trace "IRC command : #{cmd}"
+    r = socket.puts cmd
+    case log_or_get
+    when :log
+      log_response
+    else
+      r
+    end
+  end
+
+  def set_nick! name = nil
+    if name.nil? then
+      name = nick
+    end
+    response = sendln "NICK #{name}", :log
+    rc = response_code response
+    if rc == 433 then
+      logger.info "Generating new NICK to connect with"
+      set_nick! gen_nick(name)
+    elsif error?(response) then
+      raise "Unable to set nick to #{name} - #{response}"
+    else
+      # Reset nick if needed
+      options[:nick] = name
+    end
+  end
+
+end