jobmanager 1.0.0

data/lib/jobmanager/applicationconfig.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'configtoolkit'
+
+module JobManager
+
+  #
+  # This class is a configuration class used to represent the
+  # combination of the configurations specified in the jobmanager
+  # application's configuration file and the the jobmanager
+  # application's command line arguments.
+  #
+  class ApplicationConfig < ConfigToolkit::BaseConfig
+
+    EMAIL_CONDITIONS = [ :always, :never, :on_failure ]
+    CENTRAL_LOG_MODES = [ :syslog, :file ]
+
+    add_required_param(:command, String)
+    
+    add_required_param(:job_name, String)
+
+    add_required_param(:job_logs_directory, Pathname)
+    
+    add_optional_param(:email_condition, Symbol, :on_failure) do |value|
+      if (EMAIL_CONDITIONS.index(value) == nil)
+        raise_error("email_condition must be one of the following values: #{EMAIL_CONDITIONS.join(', ')}")
+      end
+    end
+
+    add_optional_param(:central_log_mode, Symbol, :syslog) do |value|
+      if (CENTRAL_LOG_MODES.index(value) == nil)
+        modes = CENTRAL_LOG_MODES.join(', ')
+        raise_error("central_log_mode must be one of the following values: #{modes}")
+      end
+    end
+
+    add_optional_param(:number_of_job_logs, Fixnum, 3) do |value|
+      if (value <= 0)
+        raise_error "value must be > 0"
+      end
+    end
+    
+    add_optional_param(:date_time_extension, ConfigToolkit::Boolean, true)
+    
+    add_optional_param(:date_time_extension_format, String, '%F_%T') do |value|
+      begin
+        DateTime.now.strftime(value)
+      rescue => e
+        raise_error("Invalid format #{e.message}")
+      end
+    end
+    
+    add_optional_param(:zip_rotated_log_file, ConfigToolkit::Boolean, false)
+    
+    add_optional_param(:debug, ConfigToolkit::Boolean, false)
+    
+    add_optional_param(:central_log_file, Pathname)
+    
+    add_optional_param(:command_path, String, ENV['PATH'])
+    
+    add_optional_param(:timeout, Fixnum) do |value|
+      if (value <= 0)
+        raise_error("timeout must be a positive integer (seconds)")
+      end    
+    end
+    
+    add_optional_param(:email_settings_file, Pathname, "email_settings.rb")
+    
+    add_optional_param(:email_subject, String, 
+                       "jobmanager results for <%=job_name%> on <%=host_name%> : <%=result%>")
+    
+    add_optional_param(:email_from_address, String)
+
+    add_optional_param(:email_to_address, String)
+    
+    def validate_all_values()
+      if (self.central_log_mode == :file && !self.central_log_file?)
+        raise_error("If central_log_mode is set to file, central_log_file must be specified.")
+      end
+      
+      if (self.central_log_mode == :syslog && self.central_log_file?)
+        raise_error("If central_log_mode is set to syslog, central_log_file should not be specified.")
+      end
+    end
+    
+  end
+end  
+

data/lib/jobmanager/applicationlogger.rb

@@ -0,0 +1,306 @@
+require 'syslog'
+require 'logger'
+require 'etc'
+
+require 'rubygems'
+require 'syslog_logger'
+
+
+module JobManager
+
+  # 
+  # This class is a base class for all of the ApplicationLogger*
+  # classes implemented in this file.  This class should not be
+  # instantiated directly.  This class derives from IO so that it can
+  # reuse the print methods (print, <<, puts, etc).
+  #
+  class ApplicationLogger < IO
+
+    # 
+    # This constant is a map between the shortcut methods in the
+    # Logger interface (debug, info, warn, etc) and their associated
+    # severity constants.
+    #
+    LEVEL_LOGGER_MAP = SyslogLogger::LOGGER_LEVEL_MAP.invert
+    
+    attr_accessor :job_name
+    attr_accessor :user_name
+  
+    def initialize(job_name, user_name)
+      @job_name = job_name ? job_name : "UNKNOWN"
+      @user_name = user_name
+    end
+    
+    #
+    # ====Description: 
+    # This method logs the given exception.
+    #
+    def record_exception(e)
+      error(e.message)
+      debug(e.backtrace.join("\n"))
+    end
+    
+    #
+    # ====Description: 
+    # This method logs the given exception and the associated tag.
+    #
+    def record_tagged_exception(message, e)
+      error("#{message}: Error (#{e.class}): #{e.message}")
+      debug(e.backtrace.join("\n"))
+    end
+    
+    #
+    # ====Description: 
+    # This method logs a message with severity level Logger::INFO.
+    #
+    def write(message)
+      info(message)
+    end
+        
+  end
+  
+  #
+  # This class provides a Logger interface and logs messages to syslog
+  # via the SysLogLogger gem.  In addition, this class provides a
+  # string instance method which allows the caller to retrieve a
+  # concatenation of all the messages written to this logger.  The
+  # level, user name, and job name are prepended to each message that
+  # is written to syslog.  A number of the interface methods are
+  # implemented via the method_missing method.
+  #
+  class ApplicationSyslogLogger < ApplicationLogger
+    #
+    # ====Description: 
+    # This method creates a new instance.
+    #
+    def initialize(program_name, 
+                   user_name, 
+                   job_name = nil)
+      
+      super(job_name, user_name)
+      
+      @program_name = program_name
+      @stringio = StringIO.new
+
+      @logger = SyslogLogger.new(program_name)
+    end
+
+    #
+    # ====Returns: 
+    # A string containing all mesages that were logged through this
+    # interface.
+    #
+    def string()
+      return @stringio.string()
+    end
+    
+    #
+    # ====Description: 
+    # This method is akin to the Logger::add interface method.
+    #
+    def add(severity, message = nil, &block)
+      wrap_record_send(LEVEL_LOGGER_MAP[severity], message || yield)
+    end
+    alias log add
+    
+    #
+    # ====Description: 
+    # This method closes the connection to the syslog daemon.
+    #
+    def close
+      if (Syslog.opened?) then Syslog.close() end
+    end
+    
+    private
+    
+    #
+    # ====Description: 
+    # This method is intended to handle all shortcut methods (debug,
+    # warn, info, etc.), as well as the level attribute methods.
+    #
+    def method_missing(*args, &block)
+      method = args.shift
+      
+      # if the method is a shortcut log method
+      if (SyslogLogger::LOGGER_MAP.find() {|key, value| method == key})
+        # wrap the message (with the job and user names)
+        wrap_record_send(method, (args.length > 0) ? args[0] : yield)
+      else
+        # otherwise forward the message directly on to the SyslogLogger instance.
+        @logger.send(method, *args, &block)
+      end
+    end
+    
+    def wrap(method, message)
+      level = method.to_s.upcase
+      return "#{level} [#{user_name()}, #{job_name()}] #{message}"
+    end
+    
+    def wrap_record_send(method, message)
+      if (!message) then return end
+      
+      # if the level of the message is within the level of the logger
+      if (SyslogLogger::LOGGER_LEVEL_MAP[method] >= @logger.level)
+        lines = message.split("\n")
+        
+        lines.each do |line|
+          wrapped_line = wrap(method, line)
+          @logger.send(method, wrapped_line)
+          @stringio << wrapped_line << "\n"
+        end
+      end
+    end
+  end
+
+  #
+  # This class provides a Logger interface and logs messages to an IO
+  # stream.  In addition, it provides a string instance method which
+  # allows the caller to retrieve a concatenation of all the messages
+  # written to this logger (with additional formatting such that the
+  # string represents exactly what was written to the IO stream).
+  # This class is implemented using the Logger class itself.  The user
+  # name, and job name are prepended to each message, which is then
+  # written via the Logger class (to a string stream) which is in turn
+  # written to the IO stream.  This was done so that the exact string
+  # that was logged to the IO stream could be later returned via the
+  # string instance method.  A number of the interface methods are
+  # implemented via the method_missing method.
+  #
+  class ApplicationIOLogger < ApplicationLogger
+
+    LOGGER_LEVELS = [ :debug,
+                      :info,
+                      :warn,
+                      :error,
+                      :fatal,
+                      :unknown 
+                    ]
+
+    #
+    # ====Description: 
+    # This method creates a new instance.
+    #
+    def initialize(io_stream,
+                   user_name, 
+                   job_name = nil)
+
+      super(job_name, user_name)
+      
+      @copy = StringIO.new
+      @io_stream = io_stream
+      
+      @logger_stringio = StringIO.new
+      @logger = Logger.new(@logger_stringio)
+      @logger.formatter = Logger::Formatter.new
+      @logger.datetime_format = '%FT%T '
+    end
+    
+    #
+    # ====Returns: 
+    # A string containing all mesages that were logged through this
+    # interface.
+    #
+    def string()
+      return @copy.string()
+    end
+    
+    #
+    # ====Description: 
+    # This method is akin to the Logger::add interface method.
+    #
+    def add(severity, message = nil, &block)
+      wrap_record_send(LEVEL_LOGGER_MAP[severity], message || yield)
+    end
+    alias log add
+    
+    #
+    # ====Description: 
+    # This method exists only to complete the Logger interface.  It
+    # is a noop.
+    #
+    def close
+    end
+    
+    private
+    def wrap(message)
+      if (!message) then return nil end
+      
+      return "[#{user_name()}, #{job_name()}] #{message}"
+    end
+    
+    #
+    # ====Description: 
+    # This method captures the output of the Logger instance and
+    # forwards it to the contained iostream and the aggregated string
+    # available for retrieval via the string method.
+    #
+    def wrap_record_send(method, message)
+      lines = message.split("\n")
+      lines.each do |line|
+        @logger.send(method, wrap(line))
+      end
+      
+      output = @logger_stringio.string()
+      @logger_stringio.string = ""
+      
+      @io_stream << output
+      @copy << output
+    end
+    
+    #
+    # ====Description: 
+    # This method is intended to handle all shortcut methods (debug,
+    # warn, info, etc.), as well as the level attribute methods.
+    #
+    def method_missing(*args, &block)
+      method = args.shift
+    
+      # if the method is a shortcut log method
+      if (LOGGER_LEVELS.find() {|key| method == key})
+        wrap_record_send(method, args[0] ? args[0] : yield)
+      else
+        # forward the method directly onto the Logger instance.
+        @logger.send(method, *args, &block)
+      end
+    end
+  end
+
+  #
+  # This class provides a Logger interface and logs messages to a
+  # file. In addition, it provides a string instance method which
+  # allows the caller to retrieve a concatenation of all the messages
+  # written to this logger.  A number of the interface methods are
+  # implemented via the method_missing method.
+  #
+  class ApplicationFileLogger < ApplicationIOLogger
+    
+    #
+    # ====Description: 
+    # This method creates a new instance.  All further messages
+    # written to this instance will be in turn written to the
+    # specified log file.
+    #
+    def initialize(log_file,
+                   user_name, 
+                   job_name = nil)
+      
+      FileUtils.mkdir_p(File.dirname(log_file))
+      @log_file_stream = File.open(log_file, "a")
+      
+      super(@log_file_stream,
+            user_name,
+            job_name)
+    end
+    
+    #
+    # ====Description: 
+    # This method closes the log file stream.
+    #
+    def close
+      @log_file_stream.close()
+    end
+  end
+
+end
+
+ 

data/lib/jobmanager/applicationoptionparser.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'jobmanager/applicationconfig.rb'
+
+module JobManager
+  
+  #
+  # This class is composed of the command line argument parsing code
+  # for the jobmanager application.
+  #
+  class ApplicationOptionParser
+    
+    # 
+    # ====Description: 
+    # This method parses the command line options and arguments passed
+    # in and returns a hash of these values.
+    # ====Parameters:
+    # [program_name]
+    #      The program name.
+    # [args]
+    #      The command line arguments.
+    # ====Returns:
+    # A hash of the command line options and arugments.
+    #    
+    def self.parse(program_name, args)
+      options = {}
+      opts = OptionParser.new 
+      
+      opts.program_name = program_name
+      opts.summary_width = 40
+      opts.banner = get_usage(program_name)
+
+      opts.separator ""
+      opts.separator "Specific options:"
+
+      is_job_name_set = false
+      opts.on("-j", "--job_name NAME", 
+              "The name of the job to be run, and thus the basename of the log file.") do |job_name|
+        options["job_name"] = job_name
+        is_job_name_set = true
+      end
+
+      opts.on("-l", "--job_logs_directory PATH", 
+              "The directory in which the job logs will be kept.") do |logs_directory|
+        options["job_logs_directory"] = logs_directory
+      end
+            
+      conditions = JobManager::ApplicationConfig::EMAIL_CONDITIONS.join(', ')
+      opts.on("-c", "--email_condition CONDITION", 
+              "The condition upon which results should be emailed.",
+              "Possible values are:(#{conditions}.") do |condition|
+        options["email_condition"] = condition
+      end    
+
+      modes = JobManager::ApplicationConfig::CENTRAL_LOG_MODES.join(', ')
+      opts.on("-m", "--central_log_mode MODE", 
+              "Possible values are #{modes}.") do |mode|
+        options["central_log_mode"] = mode
+      end
+
+      opts.on("-n", "--number_of_job_logs LOGS", 
+              "Number of log files to be kept per job.") do |number_of_logs|
+        options["number_of_job_logs"] = number_of_logs
+      end
+      
+      opts.on("-x", "--[no-]date_time_extension",
+              "Whether to add a date/time extension to the rotated log file.") do |value|
+        options["date_time_extension"] = value
+      end
+      
+      opts.on("-f", "--date_time_extension_format FORMAT", 
+              "The date/time format of the rotated log file extension.") do |format|
+        options["date_time_extension_format"] = format
+      end
+
+      opts.on("-z", "--[no-]zip_rotated_log_file",
+              "Zip the rotated log file.") do |value|
+        options["zip_rotated_log_file"] = value
+      end
+ 
+      opts.on("-r", "--central_log_file FILE", 
+              "The central log file to which jobmanager writes.",
+              "This field is only valid if central_log_mode is set to \"file\".") do |file|
+        options["central_log_file"] = file
+      end
+      
+      opts.on("-t", "--timeout TIMEOUT", OptionParser::DecimalInteger, 
+              "Timeout (in seconds) after which the script is killed.") do |timeout|
+        options["timeout"] = timeout
+      end
+            
+      opts.on("-e", "--email_settings_file PATH",
+              String,
+              "The configuration file for the simpleemail gem.",
+              "Note: If a relative path is specified, it will be considered to be relative to the",
+              "location of the configuration file.") do |file|
+        options["email_settings_file"] = file
+      end
+      
+      opts.on("-o", "--email_from_address ADDRESS", 
+              "The email address from which jobmanager sends results.") do |address|
+        options["email_from_address"] = address
+      end
+
+      opts.on("-o", "--email_to_address ADDRESS", 
+              "The email address to which jobmanager sends results.") do |address|
+        options["email_to_address"] = address
+      end
+      
+      opts.on("-p", "--command_path PATH", 
+              "The path to search for the command that jobmanager is invoked with.") do |path|
+        options["command_path"] = path
+      end
+      
+      opts.on("-s", "--email_subject SUBJECT", 
+              "The email subject, to be interpreted by ERB.",
+              "Allowed variables: (job_name, command, host_name, result, user_name)") do |subject|
+        options["email_subject"] = subject
+      end
+      
+      opts.on_tail("-d", "--[no-]debug", "Turn on/off debug trace.") do |value|
+        options["debug"] = value
+      end
+
+      opts.on_tail("-h", "--help", "Show this message.") do
+        puts opts, "\n"
+        exit(0)
+      end
+      
+      opts.parse!(args)
+      
+      if (args.length != 1)
+        puts opts, "\n"
+        raise ArgumentError, "One argument (command) is required!"
+      end
+      
+      options["command"] = args.shift()
+      
+      if (!is_job_name_set)
+        exe = options["command"].split(' ')[0]
+        options["job_name"] = File.basename(exe)
+      end
+      
+      options
+    end
+
+
+    def self.get_usage(program_name)
+      usage = <<-EOL
+
+Usage: #{program_name} [options] <command>
+
+See http://jobmanager.rubyforge.com for a more detailed description and usage examples.
+
+EOL
+      
+      usage
+    end
+    
+
+  end
+end