envoy 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in envoy.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    envoy (0.0.1)
+      broach (= 0.2.1)
+      i18n (~> 0.5.0)
+      pony (= 1.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.3)
+    broach (0.2.1)
+      json (~> 1.4)
+      nap (~> 0.3)
+    diff-lcs (1.1.2)
+    fakeweb (1.3.0)
+    i18n (0.5.0)
+    json (1.4.6)
+    mail (2.2.11)
+      activesupport (>= 2.3.6)
+      i18n (~> 0.5.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    nap (0.4)
+    polyglot (0.3.1)
+    pony (1.1)
+      mail (> 2.0)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  broach (= 0.2.1)
+  envoy!
+  fakeweb (= 1.3.0)
+  i18n (~> 0.5.0)
+  pony (= 1.1)
+  rspec (~> 2.1.0)

data/README

@@ -0,0 +1,43 @@
+A simple, extendable messaging system
+
+Usage
+
+require 'envoy'
+
+# Create a new messenger
+messenger = Envoy::Messenger.new
+
+# Define some transports
+messenger.transports.each do |transport|
+  transport.add_transport(:campfire, :account => 'foo', :token => 'bar', :room => 'my_room')
+end
+
+OR
+
+messenger.transport(:campfire, :account => 'foo', :token => 'bar', :room => 'my_room')
+
+# Add some messages
+messenger.messages.each do |message|
+  message.add_message(:name => 'Start deployment message', :subject => "Carlos started deployment of branch foo to production at #{Time.now}")
+  message.add_message(:name => 'End deployment message', :subject => "Carlos ended deployment of branch foo to production at #{Time.now}")
+end
+
+Email and Campfire Transports are included. Create your own by inheriting from Envoy::Transport
+
+OR
+
+messenger.message(:name => 'Start deployment message', :subject => "Carlos started deployment of branch foo to production at #{Time.now}")
+
+# Deliver messages one at a time
+
+messenger.deliver_start_deployment_message
+
+AND THEN
+
+messenger.deliver_end_deployment_message
+
+OR
+
+# Deliver all messages
+
+messenger.deliver_all_messages

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/envoy.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "envoy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "envoy"
+  s.version     = Envoy::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Carlos Rodriguez"]
+  s.email       = ["carlos@eddorre.com"]
+  s.homepage    = "http://github.com/eddorre/envoy"
+  s.summary     = %q{A simple, extendable messaging system built for deployments}
+  s.description = %q{A simple, extendable messaging system built for deployments}
+
+  s.rubyforge_project = "envoy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "broach", "0.2.1"
+  s.add_dependency "i18n", "~> 0.5.0"
+  s.add_dependency "pony", "1.1"
+
+  s.add_development_dependency "rspec", "~> 2.1.0"
+  s.add_development_dependency "fakeweb", "1.3.0"
+end

data/lib/envoy.rb

@@ -0,0 +1,3 @@
+require 'envoy/messenger'
+require 'envoy/transport'
+require 'envoy/message'

data/lib/envoy/message.rb

@@ -0,0 +1,12 @@
+module Envoy
+  class Message
+    attr_accessor :name, :body, :subject, :options
+
+    def initialize(name, subject, body = nil, options = {})
+      self.name = name
+      self.body = body
+      self.subject = subject
+      self.options = options
+    end
+  end
+end

data/lib/envoy/messenger.rb

@@ -0,0 +1,78 @@
+module Envoy
+  class NoTransportError < StandardError; end
+
+  class Messenger
+    attr_accessor :_transports, :_messages, :_sent_messages
+
+    def initialize
+      self._transports = []
+      self._messages = []
+      self._sent_messages = []
+    end
+
+    def transports(transport_options = {}, &block)
+      if !transport_options.empty?
+        raise ArgumentError if !transport_options.is_a?(Hash) and return
+        self._transports << self.transport(transport_options)
+      else
+        yield self if block_given?
+      end
+    end
+
+    def transport(transport_options = {})
+      transport_name = transport_options.delete(:name).to_s.capitalize
+      begin
+        transport_instance = Module.const_get("Envoy").const_get(transport_name).new(transport_options)
+      rescue
+        raise NoTransportError, "No transport exists for #{transport_name}" and return
+      end
+      self._transports << transport_instance
+    end
+    alias :add_transport :transport
+
+    def deliver_messages
+      self._messages.each do |message|
+        self._transports.each do |transport|
+          self.deliver_message(transport, message)
+        end
+      end
+    end
+
+    def deliver_message(transport, message)
+      unless self._sent_messages.include?({ :transport => transport, :message => message })
+        response = transport.send_message(message)
+        self._sent_messages << { :transport => transport, :message => message } if response
+      end
+    end
+
+    def messages(message_options = {}, &block)
+      if !message_options.empty?
+        raise ArgumentError if !message_options.is_a?(Hash) and return
+        self._messages << self.message(message_options)
+      else
+        yield self if block_given?
+      end
+    end
+
+    def message(message_options = {})
+      message_options.symbolize_keys!
+      self._messages << Envoy::Message.new(message_options[:name], message_options[:subject],
+        message_options[:body], message_options[:options])
+    end
+    alias :add_message :message
+
+    def method_missing(method, *args)
+      message = self._messages.select do |message|
+        message.name.to_s.gsub(' ', '_').downcase == method.to_s.gsub('deliver_', '')
+      end.first
+
+      unless message.nil?
+        self._transports.each do |transport|
+          self.deliver_message(transport, message)
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/envoy/transport.rb

@@ -0,0 +1,118 @@
+require 'broach'
+require 'pony'
+require 'i18n'
+require 'net/http'
+require 'uri'
+
+module Envoy
+  class Transport
+    class SendError < RuntimeError
+      attr_accessor :message, :created_at
+
+      def initialize(message, created_at)
+        self.message = message
+        self.created_at = created_at
+      end
+    end
+
+    attr_accessor :errors
+
+    def initialize(*args)
+      raise NotImplementedError, "This is an abstract class. You cannot instantiate this class directly."
+    end
+
+    def errors
+      @errors ||= []
+    end
+  end
+
+  class Campfire < Transport
+    attr_accessor :account, :token, :room, :use_ssl
+
+    def initialize(options = {})
+      self.account = options[:account]
+      self.room = options[:room]
+      self.token = options[:token]
+      self.use_ssl = options[:use_ssl]
+    end
+
+    def send_message(message)
+      Broach.settings = { 'account' => @account, 'token' => @token, 'use_ssl' => @use_ssl }
+      Broach.speak(self.room, message.body || message.subject)
+
+      return true
+
+      rescue Broach::APIError => error
+        self.errors << SendError.new(error, Time.now)
+        return false
+    end
+  end
+
+  class Webhook < Transport
+    attr_accessor :url, :headers
+
+    def initialize(options = {})
+      self.url = options[:url]
+      self.headers = options[:headers] || {}
+    end
+
+    def send_message(message)
+      url = URI.parse(@url)
+      request = Net::HTTP::Post.new(url.path)
+      request.body = message.options
+
+      @headers.each do |k,v|
+        request.add_field k,v
+      end
+
+      response = Net::HTTP.start(url.host, url.port) {|http| http.request(request)}
+
+      case response
+        when Net::HTTPSuccess, Net::HTTPFound
+          return true
+        else
+          return false
+      end
+
+      rescue URI::InvalidURIError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError, Net::ProtocolError => error
+        self.errors << SendError.new(error, Time.now)
+        return false
+    end
+  end
+
+  class Email < Transport
+    attr_accessor :host, :username, :password, :sender, :to, :port, :ssl, :authentication
+
+    def initialize(options = {})
+      self.host = options[:host]
+      self.username = options[:username]
+      self.sender = options[:sender]
+      self.to = options[:to]
+      self.port = options[:port] || 25
+      self.ssl = options[:ssl] || false
+      self.authentication = options[:authentication] || nil
+    end
+
+    def send_message(message)
+      if @host.to_sym == :sendmail
+        Pony.mail(:from => (@sender.nil? ? 'Envoy Messenger <envoymessenger@localhost>' : @sender),
+          :to => (@to.is_a?(String) ? @to : @to.join(',')),
+          :via => :sendmail, :body => message.body || message.subject, :subject => message.subject)
+      else
+        Pony.mail(:from => (@sender.nil? ? 'Envoy Messenger <envoymessenger@localhost>' : @sender),
+          :to => (@to.is_a?(String) ? @to : @to.join(',')), :via => :smtp, :via_options =>
+            {
+              :address => @host, :port => @port, :enable_starttls_auto => @ssl, :user_name => @username,
+              :password => @password, :authentication => @authentication, :body => message.body || message.subject, :subject => message.subject
+            })
+      end
+
+      return true
+
+      rescue StandardError => error
+        self.errors << SendError.new(error, Time.now)
+        return false
+    end
+  end
+end

data/lib/envoy/version.rb

@@ -0,0 +1,3 @@
+module Envoy
+  VERSION = "0.0.1"
+end

data/spec/messenger_spec.rb

@@ -0,0 +1,115 @@
+require 'envoy'
+include Envoy
+
+describe Messenger do
+  before(:each) do
+    @messenger = Messenger.new
+  end
+
+  it "should create a new instance of a messenger" do
+    @messenger.is_a?(Messenger).should be_true
+  end
+
+  describe "Adding messages" do
+    it "should add an instance of a message" do
+      @messenger.message(:name => 'Test message', :subject => 'Test subject')
+      @messenger._messages.first.is_a?(Message).should be_true
+    end
+
+    it "should add a message with add_message method" do
+      @messenger.add_message(:name => 'Test message', :subject => 'Test subject')
+      @messenger._messages.size.should == 1
+    end
+
+    it "should add two messages" do
+      @messenger.messages do |message|
+        message.add_message(:name => 'Test message', :subject => 'Test subject')
+        message.add_message(:name => 'Test message 2', :subject => 'Test subject 2')
+      end
+      @messenger._messages.size.should == 2
+    end
+
+    it "should add two messages with the same name" do
+      @messenger.messages do |message|
+        message.add_message(:name => 'Test message', :subject => 'Test subject')
+        message.add_message(:name => 'Test message', :subject => 'Test subject')
+      end
+      @messenger._messages.size.should == 2
+    end
+  end
+
+  describe "Adding transports" do
+    it "should add an instance of a transport" do
+      @messenger.transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+      @messenger._transports.first.is_a?(Transport).should be_true
+    end
+
+    it "should add a transport with add_transport method" do
+      @messenger.add_transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+      @messenger._transports.size.should == 1
+    end
+
+    it "should add two transports" do
+      @messenger.transports do |transport|
+        transport.add_transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+        transport.add_transport(:name => :campfire)
+      end
+
+      @messenger._transports.size.should == 2
+    end
+
+    it "should raise an exception when a transport doesn't exist" do
+      lambda { @messenger.transport(:name => :foo) }.should raise_error(Envoy::NoTransportError)
+    end
+  end
+
+  describe "Delivering messages" do
+    it "should deliver a message by name" do
+      Pony.stub!(:mail)
+      @messenger.add_message(:name => 'Test message', :subject => 'Test subject')
+      @messenger.add_transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+      @messenger._transports.first.should_receive(:send_message)
+
+      @messenger.deliver_test_message
+    end
+
+    it "should deliver a message by name when the name is passed as a symbol" do
+      Pony.stub!(:mail)
+      @messenger.add_message(:name => :test_message, :subject => 'Test subject')
+      @messenger.add_transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+      @messenger._transports.first.should_receive(:send_message)
+
+      @messenger.deliver_test_message
+    end
+
+    it "should deliver all messages" do
+      Pony.stub!(:mail)
+      @messenger.add_message(:name => 'Test message', :subject => 'Test subject')
+      @messenger.add_transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+      @messenger._transports.first.should_receive(:send_message).with(@messenger._messages.first)
+
+      @messenger.deliver_messages
+    end
+
+    it "should not re-send the same message more than once" do
+      Pony.stub!(:mail)
+      @messenger.add_message(:name => 'Test message', :subject => 'Test subject')
+      @messenger.add_transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+      @messenger._transports.first.should_receive(:send_message).with(@messenger._messages.first).once.and_return(true)
+
+      @messenger.deliver_messages
+      @messenger.deliver_messages
+    end
+
+    it "should deliver messages through two transports when delivering all messages" do
+      Pony.stub!(:mail)
+      Broach.stub!(:speak).and_return(true)
+      @messenger.add_message(:name => 'Test message', :subject => 'Test subject')
+      @messenger.add_transport(:name => :email, :host => :sendmail, :to => 'carlos@eddorre.com')
+      @messenger.add_transport(:name => :campfire)
+
+      @messenger.deliver_messages
+      @messenger._sent_messages.size.should == 2
+    end
+  end
+end

data/spec/transport_spec.rb

@@ -0,0 +1,115 @@
+require 'envoy'
+require 'fakeweb'
+include Envoy
+
+describe Transport do
+  before(:each) do
+    @message = Message.new('Test message', 'this is a test message')
+  end
+
+  describe "Campfire Transport" do
+    it "should send a message through broach" do
+      transport = Campfire.new(:account => 'foo', :token => 'bar', :room => 'meep')
+      Broach.should_receive(:speak).with(transport.room, @message.subject)
+      transport.send_message(@message)
+    end
+  end
+
+  describe "Email Transport" do
+    before(:each) do
+      @transport = Envoy::Email.new
+      @transport.to = 'carlos@eddorre.com'
+    end
+
+    it "should send a message through pony" do
+      @transport.host = :sendmail
+      Pony.should_receive(:mail)
+      @transport.send_message(@message)
+    end
+
+    it "should send a message through pony with sendmail" do
+      @transport.host = :sendmail
+
+
+      Pony.should_receive(:mail).with(:via => :sendmail, :from => 'Envoy Messenger <envoymessenger@localhost>',
+      :to => 'carlos@eddorre.com', :body => @message.subject, :subject => @message.subject)
+
+      @transport.send_message(@message)
+    end
+
+    it "should send a message through pony using SMTP" do
+      @transport.host = 'mail.eddorre.com'
+
+      Pony.should_receive(:mail).with(:from => 'Envoy Messenger <envoymessenger@localhost>', :to => 'carlos@eddorre.com', :via => :smtp, :via_options => { :address => @transport.host,
+        :port => 25, :enable_starttls_auto => false, :user_name => nil, :password => nil, :authentication => nil,
+        :body => @message.subject, :subject => @message.subject })
+
+      @transport.send_message(@message)
+    end
+
+    it "should send a message through pony with multiple recipients" do
+      @transport.to = ['carlos@eddorre.com', 'hello@eddorre.com']
+      @transport.host = :sendmail
+
+      Pony.should_receive(:mail).with(:via => :sendmail, :from => 'Envoy Messenger <envoymessenger@localhost>',
+      :to => 'carlos@eddorre.com,hello@eddorre.com', :body => @message.subject, :subject => @message.subject)
+
+      @transport.send_message(@message)
+    end
+
+    it "should send a message through pony with a set sender" do
+      @transport.host = :sendmail
+      @transport.sender = 'carlos@eddorre.com'
+
+      Pony.should_receive(:mail).with(:via => :sendmail, :from => 'carlos@eddorre.com',
+      :to => 'carlos@eddorre.com', :body => @message.subject, :subject => @message.subject)
+
+      @transport.send_message(@message)
+    end
+
+    it "should return false when an exception is triggered when attempting to send through pony" do
+      @transport.host = :sendmail
+      @transport.sender = 'carlos@eddorre.com'
+      @transport.to = 'carlos@eddorre.com'
+
+      Pony.stub!(:mail).and_raise(ArgumentError)
+
+      @transport.send_message(@message).should == false
+    end
+
+    it "should return true when there is no exception triggered when attempting to send through pony" do
+      @transport.host = :sendmail
+      @transport.sender = 'carlos@eddorre.com'
+      @transport.to = 'carlos@eddorre.com'
+
+      Pony.stub!(:mail).and_return(true)
+
+      @transport.send_message(@message).should == true
+    end
+  end
+
+  describe "Webhook Transport" do
+    before(:each) do
+      @transport = Envoy::Webhook.new
+      @transport.url = 'http://foo.com/'
+    end
+
+    it "should send a message to the webhook URL and return true when the service returns 200" do
+      FakeWeb.register_uri(:post, 'http://foo.com', :body => "OK", :status => ["200", "OK"])
+      @transport.send_message(@message).should == true
+    end
+
+    it "should send a message to the webhook url and return false when the service doesn't return a 200" do
+      FakeWeb.register_uri(:post, 'http://foo.com', :body => "Nothing here", :status => ["404", "Not Found"])
+      @transport.send_message(@message).should == false
+    end
+
+    it "should add errors to the transport when an exception is raised" do
+      Net::HTTP.stub!(:start).and_raise(Timeout::Error)
+      FakeWeb.register_uri(:post, 'http://foo.com', :body => "Nothing here", :status => ["404", "Not Found"])
+      @transport.send_message @message
+
+      @transport.errors.should_not be_nil
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification 
+name: envoy
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Carlos Rodriguez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-17 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: broach
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 5
+        - 0
+        version: 0.5.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: pony
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 1
+        version: "1.1"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id005
+description: A simple, extendable messaging system built for deployments
+email: 
+- carlos@eddorre.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- envoy.gemspec
+- lib/envoy.rb
+- lib/envoy/message.rb
+- lib/envoy/messenger.rb
+- lib/envoy/transport.rb
+- lib/envoy/version.rb
+- spec/messenger_spec.rb
+- spec/transport_spec.rb
+has_rdoc: true
+homepage: http://github.com/eddorre/envoy
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: envoy
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simple, extendable messaging system built for deployments
+test_files: 
+- spec/messenger_spec.rb
+- spec/transport_spec.rb