jobmanager 1.0.0

data/lib/jobmanager/system.rb

@@ -0,0 +1,240 @@
+#!/usr/bin/env ruby
+
+require 'English'
+require 'pathname'
+
+BANNER = "==============================================================\n"
+
+module JobManager
+
+  #
+  # This module contains the system programming required to invoke the
+  # job process and record its output and exit status.
+  #
+  module System
+
+    SLEEP_DURATION_PIPE_OPEN_BUT_EMPTY = 0.5
+    SLEEP_DURATION_PIPE_CLOSED         = 0.5
+    SLEEP_DURATION_WAIT_AFTER_KILL     = 10.0
+    BUFFER_SIZE                        = 4096
+    
+    # 
+    # ====Description: 
+    # This method forks and executes the command parameter.  It writes
+    # the output (stdout and stderr) of the forked process to the
+    # parameter log_stream.  This method logs operational information
+    # (when the command is started, finished, the result) via the
+    # logger command.
+    #
+    # The optional arguments include:
+    # timeout::
+    #    The timeout (in seconds) after which this process will
+    #    timeout and kill the forked process.  If this option is not
+    #    specified, no timeout will be applied- this process will wait
+    #    indefinitely for the forked process to complete.
+    # command_path::
+    #    The path this method will search through to find the passed
+    #    in command if the command has a relative path.  If this
+    #    option is not specified, the environment path will be used.
+    # 
+    # ====Parameters:
+    # [command]
+    #      The command to be invoked.
+    # [log_stream]
+    #      The stream to which this method will write the forked
+    #      process's output (stdout and stderr).
+    # [logger]
+    #      The logger instance to which this method will write
+    #      operational information.
+    # [optional_args]
+    #      A hash table of optional arguments.
+    # ====Returns:
+    # +true+ if the command was successful, +false+ otherwise.
+    def self.invoke_command(command,
+                            log_stream, 
+                            logger,
+                            optional_args = {},
+                            &block)
+
+      # Create a pipe which the forked process will write all of its
+      # output to (stdout and stderr), and this process will read said
+      # output from.
+      read_pipe, write_pipe = IO.pipe
+      original_time = Time.now()
+      success = false
+      timeout = optional_args[:timeout]
+      env_path = optional_args[:command_path] ? optional_args[:command_path] : ENV["PATH"]
+
+      # Parse out the executable from the command (eg. command = "ls -l /", exe = "ls")
+      exe = command.split(' ')[0]
+      
+      # Search the path for the executable (if the executable has a
+      # relative path), and ensure the file referenced is indeed
+      # executable.
+      if (!(exe_expanded_path = which(exe, env_path)))
+        if (Pathname.new(exe).absolute?())
+          logger.error("File #{exe} does not exist or is not executable!")
+        else
+          logger.error("File #{exe} does not exist in path (#{env_path}) or is not executable!")
+        end
+        return false
+      end
+      
+      exe = exe_expanded_path
+      
+      # Rebuild the command with the full path of the executable.
+      command_and_args = command.split(' ')
+      command_and_args[0] = exe
+      command = command_and_args.join(' ')
+      
+      # Fork a child process which will in turn exec the command.
+      if (child_pid = fork())
+        # The parent process.
+        
+        # This is primarily for testing purposes.
+        if (block) then block.call(child_pid) end
+        
+        # The parent process will only read from this pipe.
+        write_pipe.close()
+        
+        logger.info("Command (#{command}) launched, pid = #{child_pid}.")
+        
+        timed_out = false
+        
+        # while pipe is open and the timeout hasn't been reached
+        while (!timeout || !(timed_out = Time.now() - original_time > timeout))
+          bytes = ""
+          begin 
+            bytes = read_pipe.read_nonblock(BUFFER_SIZE)
+          rescue Errno::EAGAIN
+            # EAGAIN will be raised if there is nothing to read on the
+            # pipe.
+            sleep(SLEEP_DURATION_PIPE_OPEN_BUT_EMPTY)
+          rescue EOFError
+            # EOFError will be raised if the writer has closed the
+            # pipe.
+            break
+          rescue => error
+            logger.error("Unexpected Error (#{error.class}) " +
+                         "reading from the pipe associated with child process:" +
+                         "#{error.message}")
+            raise
+          end
+          
+          if (bytes.length() > 0)
+            log_stream << bytes
+          end
+        end
+        
+        # while the child is alive and the timeout hasn't been reached
+        while (!timeout || !(timed_out = Time.now() - original_time > timeout))
+          
+          # if the child process has exited, check the exit status
+          if (Process.waitpid(child_pid, Process::WNOHANG))
+            
+            # success? will return nil if the child didn't exit normally
+            success = $CHILD_STATUS.success?() ? true : false;
+            pid = $CHILD_STATUS.pid()
+            
+            if (success)
+              logger.info("Exited successfully")
+            else
+              if ($CHILD_STATUS.exited?())
+                logger.error("Failed! - exited normally with exit code: #{$CHILD_STATUS.exitstatus()}.")
+              elsif ($CHILD_STATUS.signaled?())
+                logger.error("Failed! - exited abnormally due to signal: #{$CHILD_STATUS.termsig()}.")
+              else
+                logger.error("Failed! - exited abnormally: #{$CHILD_STATUS.inspect()}")
+              end
+            end
+            
+            break
+          else
+            sleep(SLEEP_DURATION_PIPE_CLOSED)
+          end
+        end
+        
+        # if the child process has reached its timeout, kill it.
+        if (timed_out)
+          logger.error("Timed out after #{timeout} seconds.")
+          
+          # Kill the child process with the TERM signal first.  The
+          # child process can catch this signal and exit gracefully.
+          Process.kill("TERM", child_pid)
+          logger.error("Sent signal TERM to child process.")
+          
+          sleep(SLEEP_DURATION_WAIT_AFTER_KILL)
+          
+          # Check if the child pid has exited.
+          if (Process.waitpid(child_pid, Process::WNOHANG))
+            logger.error("Reaped pid from child process.")
+          else
+            # The child pid has not exited.  Send a KILL signal.
+            # A process can not catch this signal.
+            Process.kill("KILL", child_pid)
+            logger.error("Sent signal KILL to child process.")
+            
+            sleep(SLEEP_DURATION_WAIT_AFTER_KILL)
+            
+            # Check if the child pid has exited.
+            if (Process.waitpid(child_pid, Process::WNOHANG))
+              logger.error("Reaped pid from child process.")
+            else
+              # The child should've exited already.  Either the system
+              # is VERY slow and the OS hasn't gotten around to
+              # tearing down the process, or something very strange is
+              # going on.
+              logger.error("Failed to reap pid from child process.")
+            end
+          end
+        end
+        
+        return success
+      else
+        # The child process.
+        
+        # The child process will only write to this pipe.
+        read_pipe.close()
+        
+        # Redirect stdout and stderr to the pipe (to be read by the
+        # parent process).  Reset $stdout and $stderr, as they may
+        # have earlier been set to something other than STDOUT,STDERR.
+        STDOUT.reopen(write_pipe); $stdout = STDOUT
+        STDERR.reopen(write_pipe); $stderr = STDERR
+        
+        # Exec the command!
+        begin
+          exec(command)
+        rescue => e
+          print "Exec failed for command (#{command}), error: #{e}!";
+        end
+        
+        # We will only get here if an error was raised.
+        exit(1)
+      end
+    end
+
+
+    # 
+    # ====Description: 
+    # This method searches the path passed in for an executable with
+    # the name passed in.  It searches in order and returns the
+    # absolute pathname of the first match.
+    # ====Parameters:
+    # [name]
+    #      The name of the executable to search for.
+    # [path]
+    #      The path to search.
+    # ====Returns:
+    # The absolute pathname of the first match.
+    #
+    def self.which(name, path = ENV["PATH"])
+      if (Pathname.new(name).absolute?())
+        return (File.file?(name) && File.executable?(name)) ? name : nil
+      else 
+        candidates = path.split(':').map { |path| File.join(path, name)}
+        return candidates.find { |file| File.file?(file) && File.executable?(file) }
+      end  
+    end
+  end
+end

data/lib/jobmanager/teestream.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+module JobManager
+
+  #
+  # This class represents a stream whose only purpose is to forward
+  # messages on to a list of configured streams.
+  #
+  class TeeStream < IO
+    
+    # 
+    # ====Description: 
+    # This method creates an TeeStream instance initialized with the
+    # hash of streams passed in.  When a message is written to this
+    # stream, it will be forwarded to all hash values passed in.
+    # ====Parameters:
+    # [streams]
+    #      A hash table of stream name to stream.
+    #
+    def initialize(streams)
+      @streams = streams
+    end
+    
+    # 
+    # ====Description: 
+    # This method returns the stream associated with the stream name
+    # specified.
+    # ====Parameters:
+    # [name]
+    #      The name of the stream requested.
+    # ====Returns:
+    # The associated stream if it exists, nil otherwise
+    def get_stream(name)
+      @streams[name]
+    end
+    
+    # 
+    # ====Description: 
+    # This method forwards the string message to all configured
+    # streams.  Note: This class is derived from IO, and thus only
+    # needs to implement the write method in order for all of the
+    # write-related methods (<<, print, puts, putc, etc) to work free
+    # of charge, as all of these methods call write.
+    # ====Parameters:
+    # [str]
+    #      The string to be written.
+    # ====Returns:
+    # The length of the string.
+    #
+    def write(str)
+      @streams.each_value do |stream|
+        stream.write(str)
+      end   
+      
+      str.length
+    end
+
+    # 
+    # ====Description: 
+    # Flush all the configured streams.
+    #
+    def flush
+      @streams.each_value do |stream|
+        stream.flush()
+      end   
+    end
+    
+    # 
+    # ====Description: 
+    # Close all the configured streams.
+    #
+    def close
+      @streams.each_value do |stream|
+        stream.close()
+      end   
+    end
+  end
+end

data/lib/jobmanager/util.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env/ruby
+
+module JobManager
+
+  # 
+  # ====Description: 
+  # Helper method to temporarily disable warnings for the invocation
+  # of the block.
+  # ====Parameters:
+  # [block]
+  #      The block to be invoked.
+  #
+  def self.disable_warnings(&block)
+    save = $-w
+    $-w = false
+    
+    begin
+      block.call
+    ensure
+      $-w = save
+    end
+  end
+
+end
+

data/test/configs/all_values.yaml

@@ -0,0 +1,33 @@
+email_condition: always
+
+number_of_job_logs: 4
+
+central_log_mode: file
+
+job_logs_directory: temp/logs
+
+central_log_file: temp/logs/jobmanager.log
+
+command_path: /usr/designingpatterns/bin
+
+date_time_extension: true
+
+date_time_extension_format: '%F'
+
+zip_rotated_log_file: true
+
+timeout: 1800
+
+email_settings_file: email_settings.rb
+
+email_subject: "jobmanager results for <%=job_name%> on <%=host_name%> : <%=result%>"
+
+debug: true
+
+job_name: ze_echoer
+
+command: "echo hello"
+
+email_from_address: "sender_address@gmail.com"
+
+email_to_address: "receiver_address@gmail.com"

data/test/configs/bad_email_condition.yaml

@@ -0,0 +1,7 @@
+job_logs_directory: temp/logs
+
+job_name: ze_echoer
+
+command: "echo hello"
+
+email_condition: invalid

data/test/configs/bad_no_central_log_file.yaml

@@ -0,0 +1,7 @@
+job_logs_directory: temp/logs
+
+job_name: ze_echoer
+
+command: "echo hello"
+
+central_log_mode: file

data/test/configs/bad_number_of_job_logs.yaml

@@ -0,0 +1,7 @@
+job_logs_directory: temp/logs
+
+job_name: ze_echoer
+
+command: "echo hello"
+
+number_of_job_logs: 0

data/test/configs/bad_timeout_zero.yaml

@@ -0,0 +1,7 @@
+job_logs_directory: temp/logs
+
+job_name: ze_echoer
+
+command: "echo hello"
+
+timeout: 0

data/test/configs/email_settings.rb

@@ -0,0 +1,16 @@
+ActionMailer::Base.delivery_method = :test
+
+ActionMailer::Base.smtp_settings = {
+  :address => 'smtp.gmail.com',
+  :port   => 587,
+  :domain => "gmail.com",
+  :authentication => "login",
+  :user_name => "sender@gmail.com",
+  :password => "password",
+  :tls => :auto
+}
+
+SimpleEmail::Email.default_from = "Sender <sender@gmail.com>"
+SimpleEmail::Email.default_to = "Receiver <receiver@gmail.com>"
+
+

data/test/configs/incomplete_1.yaml

@@ -0,0 +1,23 @@
+email_condition: always
+
+number_of_job_logs: 4
+
+central_log_mode: file
+
+job_logs_directory: temp/logs
+
+command_path: /usr/designingpatterns/bin
+
+date_time_extension: true
+
+date_time_extension_format: '%F'
+
+zip_rotated_log_file: false
+
+timeout: 1
+
+email_subject: "jobmanager results for <%=job_name%> on <%=host_name%> : <%=result%>"
+
+debug: false
+
+email_from_address: "sender_address@gmail.com"