smith 0.5.7

data/lib/smith/application/agency.rb

@@ -0,0 +1,126 @@
+# -*- encoding: utf-8 -*-
+require 'dm-core'
+
+module Smith
+  class Agency
+
+    include Logger
+
+    attr_reader :agents, :agent_processes
+
+    def initialize(opts={})
+      DataMapper.setup(:default, "yaml:///#{Smith.config.agency.cache_path}")
+
+      @agent_processes = AgentCache.new(:paths => opts.delete(:paths))
+    end
+
+    def setup_queues
+      Messaging::Receiver.new('agency.control', :auto_delete => true, :durable => false, :strict => true).ready do |receiver|
+        receiver.subscribe do |r|
+          r.reply do |responder|
+            # Add a logger proc to the responder chain.
+            responder.callback { |ret| logger.debug { ret } if ret && !ret.empty? }
+
+            begin
+              Command.run(r.payload.command, r.payload.args, :agency => self,  :agents => @agent_processes, :responder => responder)
+            rescue Command::UnkownCommandError => e
+              responder.value("Unknown command: #{r.payload.command}")
+            end
+          end
+        end
+      end
+
+      Messaging::Receiver.new('agent.lifecycle', :auto_delete => true, :durable => false).ready do |receiver|
+        receiver.subscribe do |r|
+          case r.payload.state
+          when 'dead'
+            dead(r.payload)
+          when 'acknowledge_start'
+            acknowledge_start(r.payload)
+          when 'acknowledge_stop'
+            acknowledge_stop(r.payload)
+          else
+            logger.warn { "Unkown command received on agent.lifecycle queue: #{r.payload.state}" }
+          end
+        end
+      end
+
+      Messaging::Receiver.new('agent.keepalive', :auto_delete => true, :durable => false).ready do |receiver|
+        receiver.subscribe do |r|
+          keep_alive(r.payload)
+        end
+      end
+    end
+
+    def start_monitoring
+      @agent_monitor = AgentMonitoring.new(@agent_processes)
+      @agent_monitor.start_monitoring
+    end
+
+    # Stop the agency. This will wait for one second to ensure
+    # that any messages are flushed.
+    def stop
+      Smith.stop(true)
+    end
+
+    private
+
+    def acknowledge_start(agent_data)
+      @agent_processes[agent_data.name].tap do |agent_process|
+        if agent_data.pid == agent_process.pid
+          agent_process.monitor = agent_data.monitor
+          agent_process.singleton = agent_data.singleton
+          agent_process.metadata = agent_data.metadata
+          agent_process.acknowledge_start
+        else
+          logger.error { "Agent reports different pid during acknowledge_start: #{agent_data.name}" }
+        end
+      end
+    end
+
+    def acknowledge_stop(agent_data)
+      @agent_processes[agent_data.name].tap do |agent_process|
+        if agent_data.pid == agent_process.pid
+          agent_process.pid = nil
+          agent_process.monitor = nil
+          agent_process.singleton = nil
+          agent_process.started_at = nil
+          agent_process.last_keep_alive = nil
+          agent_process.acknowledge_stop
+        else
+          if agent_process.pid
+            logger.error { "Agent reports different pid during acknowledge_stop: #{agent_data.name}" }
+          end
+        end
+      end
+    end
+
+    def dead(agent_data)
+      @agent_processes[agent_data.name].no_process_running
+      logger.fatal { "Agent is dead: #{agent_data.name}" }
+    end
+
+    def keep_alive(agent_data)
+      @agent_processes[agent_data.name].tap do |agent_process|
+        if agent_data.pid == agent_process.pid
+          agent_process.last_keep_alive = agent_data.time
+          logger.verbose { "Agent keep alive: #{agent_data.name}: #{agent_data.time}" }
+
+          # We need to call save explicitly here as the keep alive is not part of
+          # the state_machine which is the thing that writes the state to disc.
+          agent_process.save
+        else
+          if agent_process.pid
+            logger.error { "Agent reports different pid during acknowledge_stop: #{agent_data.name}" }
+          end
+        end
+      end
+    end
+
+    # FIXME this doesn't work.
+    def delete_agent_process(agent_pid)
+      @agent_processes.invalidate(agent_pid)
+      AgentProcess.first('pid' => agent_pid).destroy!
+    end
+  end
+end

data/lib/smith/bootstrap.rb

@@ -0,0 +1,153 @@
+# -*- encoding: utf-8 -*-
+#
+# This should never be run directly it should only ever be run by
+# the agency.
+
+$: << File.dirname(__FILE__) + '/..'
+
+require 'smith'
+
+module Smith
+  class AgentBootstrap
+
+    attr_reader :agent
+
+    include Logger
+
+    def initialize(path, agent_name)
+      # FIXME
+      # This doesn't do what I think it should. If an exception is
+      # thrown in setup_control_queue, for example, it just kills
+      # the agent without it actually raising the exception.
+      Thread.abort_on_exception = true
+      @agent_name = agent_name
+      @agent_filename = Pathname.new(path).join("#{agent_name.snake_case}.rb").expand_path
+    end
+
+    def signal_handlers
+      logger.debug { "Installing default signal handlers" }
+      %w{TERM INT QUIT}.each do |sig|
+        @agent.install_signal_handler(sig) do |sig|
+          logger.error { "Agent received: signal #{sig}: #{agent.name}" }
+          terminate!
+        end
+      end
+    end
+
+    def load_agent
+      logger.debug { "Loading #{@agent_name} from: #{@agent_filename.dirname}" }
+      add_agent_load_path
+      load @agent_filename
+      @agent = Kernel.const_get(@agent_name).new
+    end
+
+    def start!
+      write_pid_file
+      @agent.run
+      @agent.started
+    end
+
+    # Exceptional shutdown of the agent. Note. Whenever this is
+    # called it almost certain that the reactor is not going to
+    # be running. So it must be restarted and then shutdown again
+    # See the note at the in main.
+    def terminate!(exception=nil)
+      logger.error { format_exception(exception) } if exception
+      logger.error { "Terminating: #{@agent_name}." }
+
+      if Smith.running?
+        send_dead_message
+        unlink_pid_file
+        Smith.stop
+      else
+        logger.debug { "Reconnecting to AMQP Broker." }
+        Smith.start do
+          send_dead_message
+          unlink_pid_file
+          Smith.stop
+        end
+      end
+    end
+
+    # Clean shutdown of the agent.
+    def shutdown
+      unlink_pid_file
+      Smith.stop if Smith.running?
+    end
+
+    private
+
+    def write_pid_file
+      @pid = Daemons::PidFile.new(Daemons::Pid.dir(:normal, Dir::tmpdir, nil), ".rubymas-#{@agent_name.snake_case}", true)
+      @pid.pid = Process.pid
+    end
+
+    def send_dead_message
+      logger.debug { "Sending dead message to agency: #{@agent_name}" }
+      Messaging::Sender.new('agent.lifecycle', :auto_delete => true, :durable => false).ready do |sender|
+        sender.publish(ACL::Payload.new(:agent_lifecycle).content(:state => 'dead', :name => @agent_name))
+      end
+    end
+
+    def unlink_pid_file
+      if @pid && @pid.exist?
+        logger.debug { "Cleaning up pid file: #{@pid.filename}" }
+      end
+    end
+
+    def format_exception(exception)
+      str = "#{exception.class.to_s}: #{exception.message}\n\t"
+      if exception.backtrace
+        str << exception.backtrace[0..-1].join("\n\t")
+      end
+      str
+    end
+
+    # Add the ../lib to the load path. This assumes the directory
+    # structure is:
+    #
+    # $ROOT_PATH/agents
+    #        .../lib
+    #
+    # where $ROOT_PATH can be anywhere.
+    #
+    # This needs to be better thought out.
+    # TODO think this through some more.
+    def add_agent_load_path
+      path = @agent_filename.dirname.dirname.join('lib')
+      # The load path may be a pathname or a string. Change to strings.
+      unless $:.detect { |p| p.to_s == path.to_s }
+        logger.debug { "Adding #{path} to load path" }
+        $: << path
+      end
+    end
+  end
+end
+
+path = ARGV[0]
+agent_name = ARGV[1]
+
+exit 1 if agent_name.nil? || path.nil?
+
+# Set the running instance name to the name of the agent.
+$0 = "#{agent_name}"
+
+# load the acls
+Smith.load_acls
+
+bootstrapper = Smith::AgentBootstrap.new(path, agent_name)
+
+# I've tried putting the exception handling in the main reactor loog
+# but it doesn't do anything. I know theres a resaon for this but I
+# don't what it is at the moment. Just beware that whenever there
+# is an exception the recator is not going going to be running.
+begin
+  Smith.start do
+    bootstrapper.load_agent
+    bootstrapper.signal_handlers
+    bootstrapper.start!
+  end
+  bootstrapper.shutdown
+rescue Exception => e
+  bootstrapper.terminate!(e)
+end

data/lib/smith/cache.rb

@@ -0,0 +1,61 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  class Cache
+
+    include Enumerable
+
+    def initialize
+      @cache = {}
+    end
+
+    def operator(operator)
+      @operator = operator
+    end
+
+    def entry(name, options=nil)
+      if @cache[name]
+        @cache[name]
+      else
+        if @operator.respond_to?(:call)
+          @cache[name] = @operator.call(name, options)
+        else
+          nil
+        end
+      end
+    end
+
+    alias :[] :entry
+
+    def entries
+      @cache.keys.map(&:to_s)
+    end
+
+    def invalidate(name)
+      @cache.delete(name)
+    end
+
+    def each
+      @cache.each_value { |v| yield v }
+    end
+
+    def empty?
+      @cache.empty?
+    end
+
+    def exist?(name)
+      !@cache[name].nil?
+    end
+
+    def size
+      @cache.size
+    end
+
+    def to_s
+      @cache.to_s
+    end
+
+    def update(name, entry)
+      @cache[name] = entry
+    end
+  end
+end

data/lib/smith/command.rb

@@ -0,0 +1,128 @@
+# -*- encoding: utf-8 -*-
+
+require 'trollop'
+
+module Smith
+  class Command
+    class UnkownCommandError < RuntimeError; end
+
+    include Logger
+
+    # Load and run the command specified. This method takes:
+    # +target+ which is either a list of agents or the agency
+    # +vars+ variables to be passed in to the command. This takes the
+    # form of a hash and accessor methods are generated named after the
+    # key of the hash.
+
+    def self.run(command, args, vars)
+      # Change _ to - underscores look so ugly as a command name.
+      command = command.gsub(/-/, '_')
+      logger.debug { "Agency command: #{command}#{(args.empty?) ? '' : " #{args.join(', ')}"}." }
+
+      load_command(command)
+
+      clazz = Commands.const_get(Extlib::Inflection.camelize(command)).new
+
+      begin
+        options, target = parse_options(clazz, args)
+
+        vars.merge(:options => options, :target => target).each do |k,v|
+          clazz.instance_eval <<-EOM, __FILE__, __LINE__ + 1
+            instance_variable_set(:"@#{k}", v)
+            def #{k}=(z); @#{k} = z; end
+            def #{k}; @#{k}; end
+          EOM
+        end
+
+        clazz.execute
+
+      rescue Trollop::CommandlineError => e
+        vars[:responder].value(parser_help(clazz, :prefix => "Error: #{e.message}.\n"))
+      rescue Trollop::HelpNeeded
+        vars[:responder].value(parser_help(clazz))
+      end
+    end
+
+    # Banner callback. This is called when the parser is called.
+    # I'm sure there is a better way of doing this.
+    def self.banner(command)
+      "smithctl #{command} OPTIONS [Agents]"
+    end
+
+    private
+
+    # Determine whether the command is an agency or smithctl command and load
+    # accordingly.
+    def self.load_command(cmd)
+      require command_path(cmd)
+    end
+
+    # Check to see if the command is an agency or smithctl command.
+    def self.agency?
+      Smith.constants.include?(:Agency)
+    end
+
+    # Return the full path of the ruby class.
+    def self.command_path(command)
+      send("#{command_type(command)}_path").join(command)
+    end
+
+    # What type of command is it?
+    def self.command_type(command)
+      case
+      when agency_command?(command)
+        :agency
+      when smithctl_command?(command)
+        :smithctl
+      else
+        raise UnkownCommandError, "Unknown command: #{command}"
+      end
+    end
+
+    # Is the command an agency command?
+    def self.agency_command?(cmd)
+     agency_path.join(cmd).sub_ext('.rb').exist?
+    end
+
+    # Is the command a smithctl command?
+    def self.smithctl_command?(cmd)
+      smithctl_path.join(cmd).sub_ext('.rb').exist?
+    end
+
+    # Return the agency command base path.
+    def self.agency_path
+      base_path.join('agency')
+    end
+
+    # Return the smithctl command base path.
+    def self.smithctl_path
+      base_path.join('smithctl')
+    end
+
+    # Return the command base path.
+    def self.base_path
+      @c64a6f4f ||= Smith.root_path.join('lib').join("smith").join('commands')
+    end
+
+    # Uses the options_parser method in the specific command class to procees
+    # any options associated with that command. If no options_parser method
+    # exits then an empty Array is returned. Any members of the args array
+    # that are not parsed by the options parser are return as the target, i.e.
+    # the agent(s) that the command is to operate on.
+    def self.parse_options(clazz, args)
+      if clazz.respond_to?(:options_parser)
+        [clazz.options_parser.parse(args), args]
+      else
+        [{}, args]
+      end
+    end
+
+    def self.parser_help(clazz, opts={})
+      StringIO.new.tap do |help|
+        help.puts opts[:prefix] if opts[:prefix]
+        clazz.options_parser.educate(help)
+        help.rewind
+      end.read
+    end
+  end
+end