vcseif 1.2.0

data/lib/vcseif/utils/lock_file.rb

@@ -0,0 +1,90 @@
+# Copyright 2001-2013 Rally Software Development Corp. All Rights Reserved.
+
+require 'time'
+
+require_relative "exceptions"
+require_relative "proctbl"
+
+class LockFile
+
+  def self.exists?(filename)
+    begin
+      if File.exists?(filename) and File.readable?(filename)
+        return true
+      else
+        return false
+      end
+    rescue => ex
+      lockex = VCSEIF_Exceptions::UnrecoverableException.new("#{ex.message}")
+      raise lockex, ex.message.to_s
+    end
+  end
+
+  def self.locker_is_running?(filename, locker)
+    # return false if no lock file exists OR the PID that wrote the lock file is no longer running
+    return false if !File.exists?(filename)
+    holder = self.current_lock_holder(filename)
+    return false if holder == "" or holder.nil?
+    locker_pid = 0
+    started    = ""
+    holder.scan(/^(\d+)/) {|p| locker_pid = p[0]}
+    running = ProcTable.target_process(locker_pid)
+
+    return false if running.nil?
+    return true
+  end
+
+  def self.current_lock_holder(filename)
+    holder = ""
+    if !File.exists?(filename)
+        raise VCSEIF_Exceptions::UnrecoverableException.new("lock file %s does not exists" % filename)
+    end
+    begin
+      lf = File.open(filename, "r")
+      entry = lf.read()
+      if !entry.nil? and entry.length > 0 and entry.strip().length > 0
+        entry = entry.strip()
+        chunks = entry.split(' ')
+        if (not chunks.empty?) and (chunks.length == 4)
+           holder = chunks.first
+        end
+      end
+      lf.close
+    rescue => ex
+      lockex = VCSEIF_Exceptions::UnrecoverableException.new("#{ex.message}")
+      raise lockex, ex.message.to_s
+    end
+    if holder.empty?
+        raise VCSEIF_Exceptions::UnrecoverableException.new("lock file is empty or contains non-standard content")
+    end
+    return holder
+  end
+
+  def self.create_lock(filename)
+    # remove any existing lock
+    self.destroy_lock(filename)
+
+    # and write the lock file with the PID of this process and a current timestamp
+    begin
+      info = "%d %s\n" % [$$, Time.now.utc.strftime("%Y-%m-%d %H:%M:%S Z")]
+      lf = File.new(filename, "w")
+      lf.write("%s\n" % info)
+      lf.close
+    rescue => ex
+      lockex = VCSEIF_Exceptions::UnrecoverableException.new("#{ex.message}")
+      raise lockex, ex.message.to_s
+    end
+  end
+
+
+  def self.destroy_lock(filename)
+    # remove the existing lock file 
+    begin
+      File.delete(filename) if File.exists?(filename)
+    rescue => ex
+      lockex = VCSEIF_Exceptions::UnrecoverableException.new("#{ex.message}")
+      raise lockex, ex.message.to_s
+    end
+  end
+
+end

data/lib/vcseif/utils/proctbl.rb

@@ -0,0 +1,146 @@
+# Copyright 2001-2013 Rally Software Development Corp. All Rights Reserved.
+
+require 'socket'
+require 'date'
+
+$os = 'posix'
+begin
+  require 'win32ole'
+  $os = 'windows'
+rescue LoadError => ex
+end
+
+class ProcessInfo
+
+  attr_accessor :uid, :pid, :ppid, :started, :cmdline
+
+  def initialize(fields)
+    @uid = 0   # default to a Windows "safe" value
+    user_field = fields[0]
+    @pid     =   fields[1].to_i
+    @ppid    =   fields[2].to_i
+    junk     =   fields[3]
+    @started =   fields[4]
+    @cmdline =   fields[5]
+    begin
+      uid = user_field.to_i
+      @uid = uid
+    rescue Exception => ex
+      begin
+        require 'etc'
+        user = Etc.getpwnam(user_field)
+        @uid = user.uid.to_i
+      rescue
+        # do nothing, we'll limp along with the default value established earlier
+      end
+    end
+  end
+
+  def to_s
+    "%5s %5s %5s %12s %s" % [@pid, @uid, @ppid, @started, @cmdline]
+  end
+end
+
+
+class ProcTable
+
+  def self.all_processes()
+      all_procs = []
+
+      case $os
+        when 'posix'
+          all_procs = ProcTable.posix_processes()
+        when 'windows'
+          all_procs = ProcTable.windows_processes()
+      end
+
+      #all_procs.each do |proc|
+      #  puts "%5d %s" % [proc['pid'], proc['cmdline']]
+      #end
+
+      return all_procs
+  end
+
+  def self.posix_processes()
+    all_procs = []
+    ps_output = `ps -ef`  # ps_output is single string
+    pslines = ps_output.split("\n")
+    hdr_line = pslines[0]
+    cmd_column_ix = hdr_line.index('CMD')
+    proc_lines =  pslines[1..pslines.length-1]
+    proc_lines.each do |ps_entry|
+      #puts "|#{ps_entry}|"
+      fields = ps_entry.lstrip().split(/\s+/)
+      #uid, pid, ppid, junk, started = fields[0], fields[1], fields[2], fields[3], fields[4]
+      fields[5] = ps_entry[cmd_column_ix..ps_entry.length-1]
+      proc_info = ProcessInfo.new(fields)
+      all_procs << proc_info
+      #puts "#{proc.inspect}"
+    end
+    return all_procs
+  end
+
+  def self.windows_processes()
+    all_procs = []
+    host = Socket.gethostname()
+    wmi = WIN32OLE.connect("winmgmts://#{host}/root/cimv2")
+    wmi.InstancesOf("Win32_Process").each do |wproc|
+      if wproc.CreationDate.nil?
+          startDate = nil
+      else
+          startDate = Date.parse(wproc.CreationDate.split('.').first)
+      end
+      fields = [0, wproc.ProcessId, wproc.ParentProcessId, "", startDate, wproc.CommandLine]
+      proc_info = ProcessInfo.new(fields)
+      all_procs << proc_info
+    end
+    return all_procs
+  end
+
+  def self.target_process(target_pid)
+    aps = ProcTable.all_processes
+    target_proc = aps.select{|proc| proc.pid == target_pid.to_i}
+    return target_proc.first if target_proc.length > 0
+    return nil
+  end
+
+  def self.processes_owned_by(target_uid=Process.uid)
+    aps = ProcTable.all_processes
+    tups = aps.select{|proc| proc.uid == target_uid.to_i}
+    return tups
+  end
+
+  def self.processes_matching_pattern(pattern)
+    # this is not a true and foolproof regex pattern matching operation
+    # The unfortunate truth is that any pattern arg that has a backslash in it
+    # is probably going to fail, even though we'd like things like "foo\w+niski" to work.
+    # So, given that we expect most callers to provide a simple string, we'll first
+    # "adjust" their pattern by replacing backslashes with a token string of "<BACKWHACK>"
+    # and then also "adjust" each process cmdline text that same way (mostly to compensate
+    # for the MSWIN unfortunate choice of '\' as the path element separator char).
+    # and only then do we do a regex check for a match.  
+    # If there are any matches using this algorithm, we'll return the results.
+    # Otherwise we will go ahead and perform the normal regex without any adjustments
+    # on the off chance that the caller actually provided a valid regex pattern string 
+    # instead of a string literal with no regex entities embedded.
+
+    aps = ProcTable.all_processes
+
+    matches = []
+    aux_pattern = pattern.gsub('\\', '<BACKWHACK>')
+    aps.each do |proc| 
+      next if proc.cmdline == nil  # seems to only happen in Windoze land...
+      command = proc['cmdline']
+      aux_cmdline = command.gsub('\\', '<BACKWHACK>')
+      matches << proc if aux_cmdline =! /#{aux_pattern}/
+    end
+
+    return matches if matches.length > 0
+
+    mps = aps.select{|proc| proc.cmdline =~ /#{pattern}/}
+    return mps
+  end
+
+end
+
+

data/lib/vcseif/utils/rally_logger.rb

@@ -0,0 +1,223 @@
+# Copyright 2001-2013 Rally Software Development Corp. All Rights Reserved.
+
+require "logger"
+require "time"
+
+# Tweak logger message format, with thanks to 
+# blog.grayproductions.net/articles/the_books_are_wrong_about_logger+ruby+logger+format
+class CustomLogFormat < Logger::Formatter
+  def call(severity, time, program_name, message)
+    datetime = time.utc.strftime("%Y-%m-%d %H:%M:%S Z")
+    return "[%s] %5s : %s\n" % [datetime, severity, message]
+  end
+end
+
+class RallyLogger
+
+  attr_accessor :errors_cache, :cache_errors, :warnings_cache, :cache_warnings
+  attr_reader   :logger
+
+  VCSEIF_MAX_LOGFILES = 10
+  VCSEIF_MAX_LOGFILE_SIZE = 5*1024*1024  # 5 MB
+
+  def initialize(logfile_name=nil, max_logfiles=VCSEIF_MAX_LOGFILES, max_file_size=VCSEIF_MAX_LOGFILE_SIZE)
+    if logfile_name.nil?
+      @logger = Logger.new(STDOUT)
+    else
+      @logger = Logger.new(logfile_name, max_logfiles, max_file_size)
+    end 
+
+    @cache_errors    = false
+    @cache_warnings  = false
+    @errors_cache    = []
+    @warnings_cache  = []
+
+    @logger.formatter = CustomLogFormat.new  # Install custom formatter
+    @logger.level = Logger::DEBUG
+  end
+
+  public
+  def set_level(level)
+    case level
+      when 'Fatal'
+        @logger.level = Logger::FATAL
+      when 'Error'
+        @logger.level = Logger::ERROR
+      when 'Warn'
+        @logger.level = Logger::WARN
+      when 'Warning'
+        @logger.level = Logger::WARN
+      when 'Info'
+        @logger.level = Logger::INFO
+      when 'Debug'
+        @logger.level = Logger::DEBUG
+    end
+  end
+
+  def fatal(text, exception=nil)
+    context = !exception.nil? ? exception_context(exception) : nominal_context()
+    @logger.fatal("#{context} - " + text)
+  end
+
+  def error(text, exception=nil)
+    context = !exception.nil? ? exception_context(exception) : nominal_context()
+    message = "#{context} - " + text
+    @logger.error(message)
+    if @cache_errors
+      datetime = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S Z")
+      info = {:time => datetime, :message => message}
+      @errors_cache.push(info)
+    end
+  end
+
+  def warning(text, exception=nil)
+    context = !exception.nil? ? exception_context(exception) : nominal_context()
+    message = "#{context} - " + text
+    @logger.warn(message)
+    if @cache_warnings
+      datetime = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S Z")
+      info = {:time => datetime, :message => message}
+      @warnings_cache.push(info)
+    end
+  end
+
+  alias_method :warn, :warning
+
+  def info(text, exception=nil)
+    @logger.info("#{nominal_context()} - " + text)
+  end
+
+  def debug(text, exception=nil)
+    context = !exception.nil? ? exception_context(exception) : nominal_context()
+    @logger.debug("#{context} - " + text)
+  end
+
+  def unknown(text, exception=nil)
+    context = !exception.nil? ? exception_context(exception) : nominal_context()
+    @logger.unknown("#{context} - " + text)
+  end
+
+  def write(text)
+    @logger << (text + "\n")
+  end
+
+  def entry(text)
+    timestamp = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S Z")
+    twig = "[%s] %s" % [timestamp, text]
+    write(twig)
+  end
+
+#  def exception(ex)
+#    if (ex.kind_of? RecoverableException)
+#      warn("Message " + ex.message)
+#    else
+#      error("Message " + ex.message)
+#      error( "Stack Trace")
+#      ex.backtrace.each {|trace| write(trace) }
+#    end
+#  end
+
+  def cache_errors(cache_on)
+    if cache_on === true
+      @cache_errors = true
+    else
+      @cache_errors = false
+    end
+  end
+
+  def cache_warnings(cache_on)
+    if cache_on === true
+      @cache_warnings = true
+    else
+      @cache_warnings = false
+    end
+  end
+
+  def clear_caches_and_flags
+    @warnings_cache  = []
+    @errors_cache    = []
+    @cache_errors    = false
+    @cache_warnings  = false
+  end
+
+  private
+
+  def caller_info()
+##
+##    stack_frames = caller(0)
+##    stack_frames.each_with_index do |stack, ix|
+##      puts "%d) %s" % [ix+1, stack]
+##    end
+##
+    file, line, method = ["", "", ""]
+    whence = caller(3).first
+    if whence =~ /^(.+?):(\d+)(?::in `(.*)')?/
+      file, line, method = $1, $2.to_i, $3
+      [file, line, method]
+    end
+    return [file, line, method]
+  end
+
+  def nominal_context()
+    # ideally, we'd like to include the file_name:line_number only if this is being 
+    # called because an exception has been raised
+    target_class = "<main>"
+    file_name, line_number, method = caller_info()
+    begin
+      file_content = File.open(file_name, "r").read()
+      file_content.gsub(/\r\n?/, "\n")
+      lines = file_content.split("\n")
+      line_number.downto(0).each do |ix|
+        if lines[ix] =~ /^\s*class\s+(\w+)/
+          target_class = $1 
+          #puts "found target_class #{target_class}"
+          break
+        else
+          #puts "no class in line: #{file_content[ix]}"
+        end
+      end
+    rescue Exception => ex
+      puts "unable to open or read #{file_name}"
+    end
+    
+    # squish out any leading 'block in ' text in method
+    # or rearrange if it mentions 'rescue in block in ' or 'block (n levels) in '
+    method = method.sub(/^block in /, '')
+    if method =~ /^block \(\d+ levels\) in /
+        method = method.sub(/^block \(\d+ levels\) in /, '')
+    end
+    if method =~ /rescue in block in /
+        method = method.sub(/rescue in block in/, '') + "- rescue block(#{line_number})"
+    end
+    #return "<class_name>.<method_name>(<file_name> line <line_number>)"
+    #return "%s.%s (%s line %d)" % [target_class, method, file_name, line_number]
+    return "%s.%s" % [target_class, method]
+  end
+
+  def exception_context(exception)
+    stack_frames = caller(0)
+##
+##    puts "Exception context stack_frames to follow ..."
+##    ix = 0
+##    for frame in stack_frames.reverse do
+##      ix += 1
+##      path, line, method = frame.split(':', 3)
+##      path_elements = path.split('/')
+##      puts "%d) %s" % [ix, frame] unless path_elements.count('gems') > 1
+##    end
+##    puts "!- " * 25
+##    puts "(identified target frame as third to last)"
+##
+    target_frame = stack_frames[2]  # the third item in the stack
+    file_name, colon, line_number = target_frame.rpartition(':')
+    tattle = "%s line %s" % [file_name, line_number]
+    ex_class_name = exception.class.name
+    if ex_class_name.count(':') == 2
+      ex_module_name, ex_class_name = ex_class_name.split('::')
+    end
+    context = "#{ex_class_name} (#{tattle})"
+    return context
+  end
+  
+
+end