baton 0.3.6

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log/*
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+bundler_args: --without=darwin
+script: bundle exec rspec

data/COPYING

@@ -0,0 +1,8 @@
+Copyright (c) 2012 Macmillan Digital Science, Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+source 'http://gems.dsci.it'
+
+gemspec
+
+group :darwin do
+  gem "guard-rspec", "~> 0.5.8"
+  gem 'rb-fsevent', "~> 0.4.3.1"
+  gem 'growl_notify', "~> 0.0.3"
+end

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,77 @@
+# Baton - Server Orchestration Tool
+
+[![Build Status](https://secure.travis-ci.org/digital-science/baton.png)](http://travis-ci.org/digital-science/baton)
+
+## Description
+
+Baton is a general purpose server orchestration tool.
+
+## Getting Started
+
+    git clone git@github.com:digital-science/baton.git
+    cd baton
+    bundle install
+
+## Testing
+
+    bundle exec rspec
+
+## Install
+
+You can either:
+
+    gem install baton
+
+Or, in your Gemfile:
+
+    gem 'baton'
+
+## How to use
+
+Please check an existing extension, e.g. [baton-ping](https://github.com/digital-science/baton-ping), for more information about how to use and extend baton. 
+Since baton was created as a base for other extensions, it doesn't do anything in particular by itself but provide the structure and a basic setup on top of RabbitMQ and EventMachine.
+
+## Details and Building Extensions
+
+Baton relies on [EventMachine](http://rubyeventmachine.com/) and [AMQP](http://rubyamqp.info/) for message passing. The gem defines a basic set of classes operating on top of RabbitMQ. The initial configuration will setup an input exchange and an output exchange. 
+
+On the input exchange, baton will wait for meaningful messages to perform actions (described by each service) and it will output messages to the output exchange.
+
+### API
+
+This is the entry point for input messages. One should extend the API class and add meaningful methods that ultimately use `publish` to publish messages to the input exchange. One example can be found [here](https://github.com/digital-science/baton-ping/blob/master/lib/baton/baton-ping/api.rb#L8)
+
+### Executable script
+
+Any baton extension should have an executable script that will start the extension service. [Here](https://github.com/digital-science/baton-ping/blob/master/bin/baton-ping) is an example.
+
+### Service
+
+The Service is the starting point of any baton extension. The idea of the service is to setup consumers for the input messages arriving from the API. By implementing `setup_consumers` one will allow the consumers to receive messages. [Here](https://github.com/digital-science/baton-ping/blob/master/lib/baton/baton-ping.rb) is an example.
+
+### Consumer Manager
+
+This class is an orchestration class that attaches observers to the consumers (like logger, etc), binds the input queues to the correct exchanges, dispatches the received messages to the consumers and updates the observers on changes. One doesn't need to extend this class unless one wants to change it's behaviour.
+
+### Consumer
+
+This class must be extended in order to process each received message. One should implement `process_message` at least, in order to give meaning to each received message. One can also override `routing_key` in order to listen to specific messages. [Here](https://github.com/digital-science/baton-ping/blob/master/lib/baton/baton-ping/ping_consumer.rb) is an example of an implementation.
+
+### Channel
+
+Like the consumer manager, this class doesn't need to be extended. It provides functionality to setup the exchanges and add consumers. 
+
+### Observer
+
+The observer class provides methods to notify observers. It is by default included in the consumers so that the output exchange (and possibly loggers, etc) receive the output messages.
+
+
+## Minimal Extension
+
+[baton-ping](https://github.com/digital-science/baton-ping) provides what we consider to be a minimal extension to baton. One should note that there is an extra class on `baton-ping` called [monitor](https://github.com/digital-science/baton-ping/blob/master/lib/baton/baton-ping/monitor.rb). This is a good example of what to do with output messages from a baton extension. Together with [baton-ping-monitor](https://github.com/digital-science/baton-ping/blob/master/bin/baton-ping-monitor) it provides a standard way of consuming output messages and do something relevant with them.
+
+If you would like to create your own extension, simple install baton, as explained above, and run the following:
+
+    batonize gem GEMNAME -b
+
+This will create a basic gem structure withe the necessary files to create a minimum viable baton extension.

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:test)
+task :test => :spec
+
+task :console do
+  sh "irb -rubygems -I lib -r baton.rb"
+end

data/baton.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/baton/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["John Griffin", "Carlos Vilhena"]
+  gem.email         = ["johnog@gmail.com", "carlosvilhena@gmail.com"]
+  gem.description   = "Baton"
+  gem.summary       = "Baton"
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n").reject! { |fn| fn.include? ".tgz" }
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n").reject! { |fn| fn.include? ".tgz" }
+  gem.name          = "baton"
+  gem.require_paths = ["lib"]
+  gem.version       = Baton::VERSION
+
+  gem.add_runtime_dependency "amqp", "~> 0.8.4"
+  gem.add_runtime_dependency "eventmachine", "~> 1.0.0.beta.4"
+  gem.add_runtime_dependency "em-http-request", "1.0.0"
+  gem.add_runtime_dependency "bunny", "~> 0.7.8"
+  gem.add_runtime_dependency "thor"
+
+  gem.add_development_dependency "rspec", "~> 2.7"
+  gem.add_development_dependency "moqueue", "~> 0.1.4"
+  gem.add_development_dependency "fakefs", "~> 0.4.0"
+  gem.add_development_dependency "rake", "~> 0.9.2"
+  gem.add_development_dependency "webmock", "~> 1.7.7"
+  gem.add_development_dependency "minitar", "0.5.3"
+end

data/bin/batonize

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+
+module Baton
+  class CLI < Thor
+    include Thor::Actions
+
+    desc "gem GEMNAME", "Creates a skeleton for creating a rubygem that extends Baton called baton-GEMNAME"
+
+    method_option :bin, :type => :boolean, :default => false, :aliases => '-b', :banner => "Generate a binary for your library."
+
+    def gem(name)
+      name = "baton-#{name.chomp("/")}"
+      target = File.join(Dir.pwd, name)
+      constant_name = name.split('_').map{|p| p[0..0].upcase + p[1..-1] }.join
+      constant_name = constant_name.split('-').map{|q| q[0..0].upcase + q[1..-1] }.join('::') if constant_name =~ /-/
+      constant_array = constant_name.split('::')
+      FileUtils.mkdir_p(File.join(target, 'config'))
+      FileUtils.mkdir_p(File.join(target, 'lib', "baton"))
+      FileUtils.mkdir_p(File.join(target, 'lib', 'baton', name))
+      git_user_name = `git config user.name`.chomp
+      git_user_email = `git config user.email`.chomp
+      opts = {
+        :name           => name,
+        :constant_name  => constant_name,
+        :constant_array => constant_array,
+        :author         => git_user_name.empty? ? "TODO: Write your name" : git_user_name,
+        :email          => git_user_email.empty? ? "TODO: Write your email address" : git_user_email
+      }
+
+      template(File.join("gem/Gemfile.tt"),                       File.join(target, "Gemfile"),                               opts)
+      template(File.join("gem/Rakefile.tt"),                      File.join(target, "Rakefile"),                              opts)
+      template(File.join("gem/LICENSE.tt"),                       File.join(target, "LICENSE"),                               opts)
+      template(File.join("gem/README.md.tt"),                     File.join(target, "README.md"),                             opts)
+      template(File.join("gem/gitignore.tt"),                     File.join(target, ".gitignore"),                            opts)
+      template(File.join("gem/gem.gemspec.tt"),                   File.join(target, "#{name}.gemspec"),                       opts)
+      template(File.join("gem/config/gem.cfg.tt"),                File.join(target, "config/#{name}.cfg"),                    opts)
+      template(File.join("gem/lib/baton/gem.rb.tt"),              File.join(target, "lib/baton/#{name}.rb"),                  opts)
+      template(File.join("gem/lib/baton/gem/version.rb.tt"),      File.join(target, "lib/baton/#{name}/version.rb"),          opts)
+      template(File.join("gem/lib/baton/gem/gem-consumer.rb.tt"), File.join(target, "lib/baton/#{name}/#{name}-consumer.rb"), opts)
+      template(File.join("gem/lib/baton/gem/gem-monitor.rb.tt"),  File.join(target, "lib/baton/#{name}/#{name}-monitor.rb"),  opts)
+      template(File.join("gem/lib/baton/gem/gem-api.rb.tt"),      File.join(target, "lib/baton/#{name}/#{name}-api.rb"),      opts)
+      if options[:bin]
+        template(File.join("gem/bin/gem.tt"),          File.join(target, 'bin', name),              opts)
+        template(File.join("gem/bin/gem-monitor.tt"),  File.join(target, 'bin', "#{name}-monitor"), opts)
+      end
+
+      Dir.chdir(target) { `git init`; `git add .` }
+    end
+
+    def self.source_root
+      File.expand_path(File.join(File.dirname(__FILE__), '../lib/baton/templates'))
+    end
+
+  end
+end
+
+Baton::CLI.start

data/lib/baton.rb

@@ -0,0 +1,13 @@
+require "baton/configuration"
+require "baton/version"
+require "baton/logging"
+
+module Baton
+  def self.configuration
+    @configuration ||= Baton::Configuration.new
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
+end

data/lib/baton/api.rb

@@ -0,0 +1,27 @@
+require "baton"
+require "bunny"
+require "json"
+
+module Baton
+  class API
+
+    # Public: Method that publishes a message using Bunny to an exchange.
+    #
+    # message - a json object containing the message
+    # key - the routing key used to forward the message to the right queue(s)
+    #
+    # Examples
+    #
+    #   publish("{\"message\":\"a message\",\"type\":\"a type\"}", "server.production")
+    #
+    # Returns nothing.
+    def self.publish(message, key)
+      b = Bunny.new(Baton.configuration.connection_opts)
+      b.start
+      e = b.exchange(Baton.configuration.exchange, :auto_delete => false)
+      e.publish(message, :key => key, :mandatory => true)
+      b.stop
+    end
+
+  end
+end

data/lib/baton/channel.rb

@@ -0,0 +1,47 @@
+require "baton/consumer"
+require "baton/logging"
+
+module Baton
+  class Channel
+    include Baton::Logging
+
+    attr_accessor :channel, :exchange_in, :exchange_out, :connection
+
+    # Public: Initialize a Channel. It creates an AMQP  connection, a channel, 
+    # an input and an output exchange and finally attaches the handle_channel_exception
+    # callback to the on_error event on the channel.
+    def initialize
+      @connection   = AMQP.connect(Baton.configuration.connection_opts)
+      @channel      = AMQP::Channel.new(@connection)
+      @exchange_in  = channel.direct(Baton.configuration.exchange)
+      @exchange_out = channel.direct(Baton.configuration.exchange_out)
+      @channel.on_error(&method(:handle_channel_exception))
+    end
+
+    # Public: creates a consumer manager with a consumer attached and starts
+    # listening to messages.
+    #
+    # consumer - An instance of Baton::Consumer. it will typically be a extension of
+    # Baton::Consumer (e.g. Baton::DeployConsumer).
+    #
+    # Examples
+    #
+    #   add_consumer(consumer)
+    #
+    # Returns nothing.
+    def add_consumer(consumer)
+      Baton::ConsumerManager.new(consumer, channel, exchange_in, exchange_out).start
+    end
+
+    # Public: Callback to handle errors on an AMQP channel.
+    #
+    # channel - An AMQP channel
+    # channel_close - 
+    #
+    # Returns nothing.
+    #
+    def handle_channel_exception(channel, channel_close)
+      logger.error "Channel-level exception: code = #{channel_close.reply_code}, message = #{channel_close.reply_text}"
+    end
+  end
+end

data/lib/baton/configuration.rb

@@ -0,0 +1,63 @@
+require "yaml"
+require "baton/logging"
+
+module Baton
+  class Configuration
+    include Baton::Logging
+
+    attr_accessor :exchange, :exchange_out, :ohai_file,
+      :host, :vhost, :user, :password,
+      :pusher_app_id, :pusher_key, :pusher_secret, :config_path
+
+    # Public: Loads the config file given as parameter and sets up RabbitMQ's options.
+    #
+    # path - A file path representing a config file
+    #
+    # Examples
+    #
+    #   config_file = "/path/to/file"
+    #
+    # Returns nothing.
+    # Raises Errno::ENOENT if file cannot be found.
+    def config_path=(path)
+      config_file = YAML.load_file(path)
+      setup_rabbitmq_opts(config_file)
+    rescue Errno::ENOENT => e
+      self.host = "localhost"
+      logger.error "Could not find a baton configuration file at #{path}"
+    end
+
+    # Public: Setup RabbitMQ's options from a config file.
+    #
+    # config_file - A hash representing a config file
+    #
+    # Examples
+    #
+    #   setup_rabbitmq_opts({
+    #     "RABBIT_HOST" => "localhost",
+    #     "RABBIT_VHOST" => "baton",
+    #     "RABBIT_USER" => "baton",
+    #     "RABBIT_PASS" => "password"
+    #     })
+    #
+    # Returns nothing.
+    def setup_rabbitmq_opts(config_file)
+      self.host     = config_file.fetch("RABBIT_HOST") {"localhost"}
+      self.vhost    = config_file["RABBIT_VHOST"]
+      self.user     = config_file["RABBIT_USER"]
+      self.password = config_file["RABBIT_PASS"]
+    end
+
+    # Public: Defines the connection options for RabbitMQ as a Hash.
+    #
+    # Examples
+    #
+    #   connection_options
+    #   # => {:host=>"localhost", :vhost=>"baton", :user=>"baton", :password=>"password"}
+    #
+    # Returns a hash of RabbitMQ connection options.
+    def connection_opts
+      {:host => host, :vhost => vhost, :user => user, :password => password, :pass => password}.delete_if{|k,v| v.nil?}
+    end
+  end
+end

data/lib/baton/consumer.rb

@@ -0,0 +1,89 @@
+require "baton/observer"
+
+module Baton
+  class Consumer
+    include Baton::Observer
+    include Baton::Logging
+
+    attr_accessor :consumer_name, :server, :consumer_manager
+
+    # Public: Initialize a Consumer.
+    #
+    # consumer_name - A String naming the consumer.
+    # server - An instance of Baton::Server.
+    def initialize(consumer_name, server)
+      @consumer_name, @server = consumer_name, server
+    end
+
+    # Public: Defines the routing key for the consumer. Messages with the
+    # defined routing queue will be consumed by this consumer.
+    #
+    # Examples
+    #
+    #   routing_key
+    #   # => "central-apu.production"
+    #
+    # Returns the routing key.
+    def routing_key
+      "#{consumer_name}.#{server.environment}"
+    end
+
+    # Public: Method that wraps a block and notifies when errors occur.
+    #
+    # Examples
+    #
+    #   exception_notifier do
+    #     <your code>
+    #   end
+    #
+    # Returns nothing.
+    def exception_notifier
+      yield
+    rescue Exception => e
+      notify_error(e.class, e.message)
+    end
+
+    # Public: Method that decodes a json message and passes it to process_message
+    # to be processed.
+    #
+    # payload  - A message in json format
+    #
+    # Examples
+    #
+    #   handle_message("{\"message\":\"a message\",\"type\":\"a type\"}")
+    #
+    # Returns nothing.
+    def handle_message(payload)
+      exception_notifier do
+        message = JSON.load(payload)
+        process_message(message)
+      end
+    end
+
+    # Public: Method that will be called when handle_message receives a message.
+    # It should be implemented by baton-like gems and it should add logic to 
+    # process messages.
+    #
+    # message  - A message in ruby-format
+    #
+    # Examples
+    #
+    #   process_message({"type" => "current"})
+    #
+    # Returns Output depends on the implementation.
+    def process_message(message)
+    end
+
+    # Public: Method that provides an hash of attributes, if they are needed.
+    #
+    # Examples
+    #
+    #   attributes
+    #   # => {type: "pong"}.merge(server.attributes)
+    #
+    # Returns Output depends on the implementation.
+    def attributes
+    end
+
+  end
+end