emissary 1.3.0

data/bin/emissary-setup

@@ -0,0 +1,75 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'rubygems/source_index'
+
+require 'fileutils'
+
+class Object
+	def blank?
+		nil? or empty?
+	end
+end
+
+if ARGV.length != 1
+	puts File.basename($0) << ': <config path>'
+	exit 0
+end
+
+config_path = ARGV[0].to_s
+
+if not File.exists?(config_path)
+	puts "Directory [#{config_path}] doesn't exist - creating."
+	FileUtils.mkdir_p config_path
+end
+
+si = Gem::SourceIndex.from_gems_in(*Gem::SourceIndex.installed_spec_directories)
+
+gem_spec = si.find_name('emissary', Gem::Requirement.default).last
+
+emissary_etc_path = File.join(gem_spec.full_gem_path, 'etc')
+
+if emissary_etc_path.blank?
+	puts "Unable to find gem 'emissary' in the default gem paths - are you sure you installed it?"
+	exit 1
+end
+
+puts "Emissary Path: '#{emissary_etc_path}'"
+puts "Checking ETC files"
+
+['emissary', 'init.d', 'sysconfig'].each do |part|
+
+
+	src_path = File.join(emissary_etc_path, part)
+	dst_path = File.join(config_path, part)
+
+	puts "Configuration files for '#{part}' found at: #{src_path}"
+
+	if not File.exists?(dst_path)
+		puts "  - Creating missing '#{dst_path}' directory."
+		FileUtils.mkdir_p [ dst_path ]
+	end
+
+	Dir.glob(src_path + '/*').each do |file|
+		src_file = File.join(src_path, File.basename(file))
+		dst_file = File.join(dst_path, File.basename(file))
+
+		if not File.exists?(dst_file)
+			puts "  - Copying '#{src_file}' --> '#{dst_file}'"
+			FileUtils.cp src_file, dst_file
+		else
+			puts "  - Skipping overwrite of pre-existing configuration file '#{dst_file}'"
+		end
+	end
+end
+
+
+print "Checking run directory - "
+if not File.exists?('/var/run/emissary')
+	puts "missing!\n  - Creating missing '/var/run/emissary' run directory"
+	FileUtils.mkdir_p ['/var/run/emissary']
+else
+	puts "looks good."
+end
+
+puts "Setup done - please adjust your configuration files to meet your particular needs now."

data/etc/emissary/config.ini

@@ -0,0 +1,13 @@
+[general]
+
+# what operator types are monitoring for message events (comma seperated list)
+operators = [ amqp ]
+
+# pid_dir: Where to store the Process ID file which contains the id of the process
+# and is used for stoping and reloading the service
+pid_dir = /var/run
+
+# log_level: the level of information to log. see 'man 3 syslog' for list of log levels
+log_level = NOTICE
+
+agents = [ all ]

data/etc/init.d/emissary

@@ -0,0 +1,50 @@
+#!/bin/sh
+# $Id: emissary 496 2009-03-14 02:26:46Z ccorliss $
+# emissary      This shell script takes care of starting and stopping emissary.
+#
+# chkconfig: 2345 99 10
+# description: emissary provides support for handling of network events.
+
+CONFIG_FILE=/etc/emissary/config.ini
+EMISSARY_EXECUTABLE="$(ruby -rrubygems -e 'puts Gem.bindir')/emissary"
+
+[ -f "${CONFIG_FILE}" ] || exit 0
+
+. /etc/rc.d/init.d/functions
+
+if [ -f /etc/sysconfig/emissary ]; then
+	. /etc/sysconfig/emissary
+fi
+
+# See how we were called.
+case "$1" in
+  start)
+    # Start daemon.
+    echo -n "Starting emissary: "
+    daemon ${EMISSARY_EXECUTABLE} -d --config-file ${CONFIG_FILE} start
+    touch /var/lock/subsys/emissary
+    echo    
+    ;;
+  stop)
+    # Stop daemon.
+    echo -n "Shutting down emissary: "
+    daemon ${EMISSARY_EXECUTABLE} --config-file ${CONFIG_FILE} stop
+    echo
+    rm -f /var/lock/subsys/emissary
+    ;;
+  restart)
+    daemon ${EMISSARY_EXECUTABLE} --config-file ${CONFIG_FILE} restart
+    ;;
+  status)
+    daemon ${EMISSARY_EXECUTABLE} --config-file ${CONFIG_FILE} status
+    ;;
+  reconfig)
+    daemon ${EMISSARY_EXECUTABLE} --config-file ${CONFIG_FILE} reconfig
+  	;;
+  *)
+    echo "Usage: emissary {start|stop|restart|status|reconfig}"
+    exit 1
+    ;;
+esac
+
+exit 0

data/lib/emissary.rb

@@ -0,0 +1,223 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+require 'rubygems'
+require 'uuid'
+require 'digest/md5'
+require 'yaml'
+
+begin
+  require 'thread'
+  require 'fastthread'
+rescue LoadError
+end
+
+module Emissary
+  # :stopdoc:
+  LIBPATH = File.expand_path(File.dirname(File.expand_path(__FILE__))) + File::SEPARATOR
+  PATH = File.dirname(LIBPATH) + File::SEPARATOR
+  VERSION = ::YAML.load(File.read(File.join(PATH, 'VERSION.yml'))).values.join '.'
+
+  EXTERNALS_BASE      = File.join(File::SEPARATOR, 'opt')
+  EXTERNAL_IDENTITIES = File.join(EXTERNALS_BASE, 'emissary', 'identities')
+  EXTERNAL_AGENTS     = File.join(EXTERNALS_BASE, 'emissary', 'agents')
+  EXTERNAL_OPERATORS  = File.join(EXTERNALS_BASE, 'emissary', 'operators')
+
+  DEFAULT_EXCHANGE        = :direct
+  DAEMON_RECHECK_INTERVAL = 10
+  IP_CHECK_DOMAIN         = 'checkip.dyndns.org'
+  IP_CHECK_URL            = "http://#{IP_CHECK_DOMAIN}"
+  # :startdoc:
+
+  class << self 
+    @@pid = nil
+    def PID
+      @@pid
+    end
+    
+    # Returns the version string for the library.
+    #
+    def version
+      VERSION
+    end
+  
+    # Returns the library path for the module. If any arguments are given,
+    # they will be joined to the end of the libray path using
+    # <tt>File.join</tt>.
+    #
+    def libpath( *args )
+      args.empty? ? LIBPATH : File.join(LIBPATH, args.flatten)
+    end
+  
+    # Returns the path for the module. If any arguments are given,
+    # they will be joined to the end of the path using
+    # <tt>File.join</tt>.
+    #
+    def path( *args )
+      args.empty? ? PATH : File.join(PATH, args.flatten)
+    end
+
+    def sublib_path( *args )
+      args.empty? ? PATH : File.join(LIBPATH, 'emissary', args.flatten)
+    end
+    
+    def klass_from_handler(klass = nil, handler = nil, *args)
+      klass = if handler and handler.is_a? Class and not handler.nil?
+        raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
+        handler
+      elsif handler.is_a? Module
+        resource_name = "RESOURCE_#{handler.to_s.upcase.split('::').pop}"
+        begin
+          klass.const_get(resource_name)
+        rescue NameError
+          klass.const_set(resource_name, Class.new(klass) { include handler } )
+        end
+      elsif klass.nil?
+        raise ArgumentError, "klass must be a valid class constant for #{name}#klass_from_handler"
+      elsif handler.nil?
+        raise ArgumentError, "handler must be a valid class or module"
+      else
+        klass
+      end
+  
+      arity = klass.instance_method(:initialize).arity
+      expected = arity >= 0 ? arity : -(arity + 1)
+      if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+        raise ArgumentError, "wrong number of arguments for #{klass}#initialize (#{args.size} for #{expected})"
+      end
+  
+      klass
+    end
+  
+    def klass_loaded?(class_name)
+      begin
+        !!klass_const(class_name)
+      rescue NameError
+        false
+      end
+    end
+  
+    def klass_const(class_name, autoload = false)
+      return class_name if class_name.is_a? Class or class_name.is_a? Module
+  
+      klass = Object
+      
+      class_name.split('::').each do |c|
+        begin
+          klass = klass.const_get(c.to_sym)
+        rescue NameError => e 
+          if autoload
+            require_klass( (klass == Object ? c : "#{klass.to_s}::#{c}") )
+            redo
+          end
+        end
+      end
+      
+      klass.to_s == class_name ? klass : nil
+    end
+    
+    def load_klass(class_name)
+      load libpath(*class_name.downcase.split(/::/)) + '.rb'
+    end
+    
+    def require_klass(class_name)
+      require libpath(*class_name.downcase.split(/::/))
+    end
+  
+    def logger
+      Emissary::Logger.instance
+    end
+    
+    def generate_uuid
+      UUID.generate
+    end
+    
+    def identity
+      @@identity ||= Emissary::Identity.instance
+    end
+    
+    # Sets up a line of communication
+    #
+    def call handler, config, *args
+      unless handler.is_a? Class or handler.is_a? Module
+        klass_name = 'Emissary::Operator::' + handler.to_s.upcase
+        begin
+          require_klass klass_name
+        rescue LoadError => e
+          begin
+            require_klass Emissary::EXTERNAL_OPERATORS + '::' + handler.to_s.upcase
+          #rescue LoadError
+            # raise the original exception if we still haven't found the file
+          #  raise e
+          end
+        end
+        handler = klass_const klass_name
+      end
+      
+      klass = klass_from_handler(Operator, handler, config)
+  
+      operator = klass.new(config, *args)
+      operator.validate_config!
+      block_given? and yield operator
+      operator
+    end
+  
+    # Dispatches a message to the agent specified by the message
+    #
+    def dispatch message, config, *args
+      unless message.is_a? Emissary::Message
+        raise ArgumentError, "message is not an Emissary::Message" 
+      end
+      
+      begin
+        agent_type = 'Emissary::Agent::' + message.agent.to_s.capitalize
+        begin
+          require_klass agent_type 
+        rescue LoadError => e
+          begin
+            require_klass Emissary::EXTERNAL_AGENTS + '::' + message.agent.to_s.capitalize
+          rescue LoadError
+            # raise the original exception if we still haven't found the file
+            raise e
+          end
+        end
+      rescue Exception => e
+        Emissary.logger.error "Dispatcher Error: #{e.class.name}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+        message = message.error(e)
+        agent_type = 'Emissary::Agent::Error'
+      end
+  
+      handler = klass_const agent_type, true
+      
+      klass = klass_from_handler(Agent, handler, message, config, *args)
+  
+      Emissary.logger.debug " [--] Dispatching message to: #{agent_type}"
+      agent = klass.new(message, config, *args)
+      block_given? and yield agent
+      agent
+    end
+  end
+
+  # autoload core object extensions
+  Dir[sublib_path('core_ext', '*.rb')].each do |core_extension|
+    require core_extension
+  end
+end # module Emissary
+
+$:.unshift Emissary::LIBPATH
+
+[ :errors, :logger, :operator, :agent, :identity, :message, :config, :gem_helper ].each do |sublib|
+  require Emissary.sublib_path sublib.to_s
+end

data/lib/emissary/agent.rb

@@ -0,0 +1,61 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+module Emissary
+  class Agent
+    attr_reader :name, :message, :method, :config, :operator
+    attr_accessor :args
+    
+    def initialize message, config, operator
+      @message  = message
+      @operator = operator
+      @config   = config
+      
+      @method   = message.method.to_sym rescue :__bad_method__
+      @args     = message.args.clone
+      
+      unless valid_methods.first == :any or valid_methods.include? @method 
+        raise ArgumentError, "Invalid method '#{@method.to_s}' for agent '#{message.agent}'"
+      end
+      
+      post_init
+    end
+  
+    def post_init(); end
+
+    def valid_methods
+      raise StandardError, 'Not implemented'
+    end
+    
+    def activate
+      catch(:skip_implicit_response) do
+        result = self.__send__(method, *args)
+        response = if not result.kind_of? ::Emissary::Message
+          response = message.response
+          response.status = [ :ok, (result == true || result.nil? ? 'Succeeded.' : result ) ]
+          response
+        else
+          result
+        end
+        
+        send response
+      end
+    end
+    
+    def send message
+      operator.send message
+    end
+  end
+end

data/lib/emissary/agent/emissary.rb

@@ -0,0 +1,163 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+require 'tempfile'
+require 'fileutils'
+
+module Emissary
+  class Agent::Emissary < Agent
+    INIT_DATA = [
+      ::Emissary.identity.name,
+      ::Emissary.identity.public_ip,
+      ::Emissary.identity.local_ip,
+      ::Emissary.identity.instance_id,
+      ::Emissary.identity.server_id,
+      ::Emissary.identity.cluster_id,
+      ::Emissary.identity.account_id,
+      ::Emissary.identity.queue_name,
+      ::Emissary.version
+    ]
+    
+    def valid_methods
+      [ :reconfig, :selfupdate, :startup, :shutdown, :initdata, :reinit ]
+    end
+    
+    def reconfig new_config
+      throw :skip_implicit_response if new_config.strip.empty?
+      
+      if (test(?w, config[:agents][:emissary][:config_path]))
+        begin
+          ((tmp = Tempfile.new('new_config')) << new_config).flush
+          Emissary::Daemon.get_config(tmp.path)
+        rescue Exception => e
+          resonse = message.response
+          response.status_type = :error
+          response.status_note = e.message
+          return response
+        else
+          FileUtils.mv tmp.path, config[:agents][:emissary][:config_path]
+          # signal a USR1 to our parent, which will cause it to kill the
+          # children and restart them after rereading it's configuration
+          Process.kill('HUP', config[:parent_pid])
+        ensure
+          tmp.close
+        end
+      end      
+
+    end
+
+    def selfupdate version = :latest
+      begin
+        emissary_gem = ::Emissary::GemHelper.new('emissary')
+        request_version, source_uri = emissary_gem.versions(version).flatten
+        current_version, _ = emissary_gem.versions(:current).flatten
+
+        unless not emissary_gem.installable? request_version
+          ::Emissary.logger.debug "Emissary SelfUpdate to version '#{request_version.to_s}' requested."
+          new_version = emissary_gem.update(request_version, source_uri)
+          ::Emissary.logger.debug "Emissary gem updated from '#{::Emissary.version}' to '#{new_version}'"
+        else
+          ::Emissary.logger.debug " -- SELFUPDATE -- [         VERSION: #{version}]"
+          ::Emissary.logger.debug " -- SELFUPDATE -- [ CURRENT_VERSION: #{current_version}]"
+          ::Emissary.logger.debug " -- SELFUPDATE -- [ REQUEST_VERSION: #{request_version}]"
+          
+          notice = 'Emissary selfupdate skipped - ' + case true
+            when request_version.nil?
+              if version == :latest
+                "already at latest version."
+              else
+                "non-existent version '#{version}'"
+              end
+            when current_version == request_version
+              "already at specified version #{version}."
+            when current_version > request_version
+              "downgrade to version #{request_version} not allowed."
+            else
+              "unable to update from #{::Emissary.version} to requested version #{request_version}."
+          end
+          ::Emissary.logger.warn notice
+          response = message.response
+          response.status_note = notice
+          return response
+        end
+      rescue ::Gem::InstallError, ::Gem::GemNotFoundException => e
+        ::Emissary.logger.error "Emissary selfupdate failed with reason: #{e.message}"
+        return message.error(e)
+      else
+        ::Emissary.logger.debug "SelfUpdate: About to detach and run commands"
+        with_detached_process('emissary-selfupdate') do
+          %x{
+            emissary stop;
+            sleep 2; 
+            ps uxa | grep -v grep | grep '(emissary|emop_)' | awk '{ print $2 }' | xargs kill -9;
+            sleep 1;
+            source /etc/cloudrc;
+            emissary start -d;
+          }
+        end
+        ::Emissary.logger.debug "SelfUpdate: Child detached"
+        throw :skip_implicit_response
+      end
+    end
+    
+    def startup
+      message = initdata
+      message.recipient = config[:startup]
+      ::Emissary.logger.notice "Sending Startup message with args: #{message.args.inspect}"
+      message
+    end
+    alias :reinit :startup
+    
+    def initdata
+      response = message.response
+      response.args = INIT_DATA
+      response
+    end
+    
+    def shutdown
+      message.recipient = config[:shutdown]
+      message.args = [
+        ::Emissary.identity.server_id,
+        ::Emissary.identity.cluster_id,
+        ::Emissary.identity.account_id,
+        ::Emissary.identity.instance_id
+      ]
+      ::Emissary.logger.notice "Sending Shutdown message with args: #{message.args.inspect}"
+      message
+    end
+
+private
+
+    def with_detached_process(name = nil)
+      raise Exception, 'Block missing for with_detached_process call' unless block_given?
+
+      # completely seperate from our parent process
+      pid = Kernel.fork do
+        Process.setsid
+        exit!(0) if fork
+        $0 = name unless name.nil?
+        Dir.chdir '/'
+        ::Emissary.logger.debug "SelfUpdate: Detached and running update command block now..."
+        yield
+        ::Emissary.logger.debug "SelfUpdate: Finished running update command block - exiting..."
+        exit!(0)
+      end
+
+      ::Emissary.logger.debug "SelfUpdate: Detaching child process now."
+      #don't worry about the child anymore - it's on it's own
+      Process.detach(pid)
+    end
+  end
+end