rcs-common 9.6.0

data/lib/rcs-common/stats.rb

@@ -0,0 +1,94 @@
+#
+# Class to keep statistics by minute, hour, day, week and so on...
+# to be subclassed and customized
+#
+
+module RCS
+
+class Stats
+
+  def initialize
+    @stats = {}
+
+    # the template can be provided by the subclass
+    @template ||= Hash.new(0)
+
+    # total statistics ever
+    @stats[:total] = @template.dup
+
+    # remember the time when the total count was started
+    @stats[:total][:start] = Time.now.getutc
+
+    # sections to keep stats for
+    # the values are the tipping point
+    @sections ||= {:minutes => 0, :hours => 60, :days => 24, :weeks => 7}
+
+    # create the templates for each section
+    @sections.each_key do |section|
+      @stats[section] = {}
+      @stats[section][:last] = Array.new(5) { @template.dup }
+      @stats[section][:average] = @template.dup
+      @stats[section][:average][:samples] = 0
+    end
+
+  end
+
+  def stats(section = nil)
+    section ? @stats[section] : @stats
+  end
+
+  def add(hash)
+    # for each key sum up the counters in the total and in the current minute
+    hash.each_pair do |k, v|
+      next if @stats[:total][k].nil? or v.nil?
+      @stats[:total][k] += v
+      @sections.keys.each do |section|
+        add_to_section section, k, v
+      end
+    end
+  end
+
+  def add_to_section(section, k, v)
+    @stats[section][:last][0][k] ||= 0
+    @stats[section][:last][0][k] += v
+  end
+
+  def calculate
+    calculate_section @sections.keys.first
+
+    # each value in the @sections is the number of element of the previous section
+    # needed to form the current section
+    @sections.keys.each_with_index do |section, index|
+      calculate_section(section) if sample_limit(index)
+    end
+  end
+
+  def calculate_section(section)
+    # calculate the average for this section
+    @stats[section][:last].first.each_pair do |k, v|
+      @stats[section][:average][k] = ((@stats[section][:average][k].to_f * @stats[section][:average][:samples] + v) / (@stats[section][:average][:samples] + 1)).round(2)
+    end
+    @stats[section][:average][:samples] += 1
+    # initialize a new element for the current section
+    @stats[section][:last].insert(0, @template.dup)
+    # remove the last one
+    @stats[section][:last].pop
+  end
+
+  def sample_limit(index)
+    # tipping point of 0 means never tip
+    return false if @sections[@sections.keys[index]] == 0
+
+    # all the previous must be on the tipping point
+    values = []
+    index.downto(1) do |i|
+      prev = @sections.keys[i - 1]
+      values[i] = @stats[prev][:average][:samples] != 0 && @stats[prev][:average][:samples] % @sections[@sections.keys[i]] == 0
+    end
+
+    values.compact.inject(:&)
+  end
+
+end
+
+end #RCS

data/lib/rcs-common/symbolize.rb

@@ -0,0 +1,10 @@
+# here we are re-opening the ruby Hash class,
+# the namespace must not be specified
+
+class Hash
+
+  def symbolize
+    self.inject({}){|out,(k,v)| out[(k.class.eql? String) ? k.to_sym : k] = v; out}
+  end
+
+end

data/lib/rcs-common/systemstatus.rb

@@ -0,0 +1,136 @@
+require 'sys/filesystem'
+require 'sys/cpu'
+
+include Sys
+
+module RCS
+  module SystemStatusCodes
+    OK = "OK"
+    WARN = "WARN"
+    ERROR = "ERROR"
+  end
+
+  module SystemStatusMixin
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def change_status(*args); SystemStatus.set(*args); end
+    end
+
+    def change_status(*args); SystemStatus.set(*args); end
+  end
+
+  # Status of the process and system
+  class SystemStatus
+    include SystemStatusCodes
+
+    DEFAULT = {status: OK, message: "Idle"}
+
+    @@prev_cpu = {}
+    @@prev_time = {}
+    @@current = DEFAULT
+    @@windowsOS = RUBY_PLATFORM.downcase.include?("mingw")
+    @@filesystem_stat_path = nil
+
+    def self.reset
+      @@current = DEFAULT
+    end
+
+    def self.set(status, message)
+      @@current = {status: status.to_s.upcase, message: message}
+    end
+
+    def self.status
+      @@current[:status]
+    end
+
+    def self.message
+      @@current[:message]
+    end
+
+    def self.windows?
+      @@windowsOS
+    end
+
+    def self.filesystem_stat(path)
+      Filesystem.stat(path) rescue nil
+    end
+
+    def self.filesystem_stat_path
+      return @@filesystem_stat_path if @@filesystem_stat_path
+
+      pwd = Dir.pwd
+
+      if !windows?
+        return @@filesystem_stat_path = pwd
+      end
+
+      loop do
+        stat = filesystem_stat(pwd+"\\")
+        return @@filesystem_stat_path = stat.path if stat
+        pwd = File.dirname(pwd.gsub('\\', '/')).gsub('/', '\\')
+        raise "Unable to find a valid mount point" if pwd == "."
+      end
+    end
+
+    # returns the percentage of free space
+    def self.disk_free
+      stat = Filesystem.stat(filesystem_stat_path)
+      # get the free and total blocks
+      free = stat.blocks_free.to_f
+      total = stat.blocks.to_f
+      # return the percentage (pessimistic)
+      return (free / total * 100).floor
+    end
+
+    # returns an indicator of the CPU usage in the last minute
+    # not exactly the CPU usage percentage, but very close to it
+    def self.cpu_load
+      # cpu load in the last minute
+      avg = CPU.load_avg
+      if avg.is_a? Array
+        # under unix like, there are 3 values (1, 15 and 15 minutes)
+        load_last_minute = avg.first
+        # default values for systems where the number is not reported (linux)
+        num_cpu = 1
+        num_cpu = CPU.num_cpu if CPU.num_cpu
+        # on multi core systems we have to divide by the number of CPUs
+        percentage = (load_last_minute / num_cpu * 100).floor
+      else
+        # under windows there is only one value that is the percentage
+        percentage = avg
+        # sometimes it returns nil under windows
+        percentage ||= 0
+      end
+
+      return percentage
+    end
+
+    # returns the CPU usage of the current process
+    def self.my_cpu_load(me)
+
+      # the first call to it, keep track of different thread calling the method
+      @@prev_cpu[me] ||= Process.times
+      @@prev_time[me] ||= Time.now
+
+      # calculate the current cpu time
+      current_cpu = Process.times
+
+      # diff them and divide by the call interval
+      cpu_time = (current_cpu.utime + current_cpu.stime) - (@@prev_cpu[me].utime + @@prev_cpu[me].stime)
+      time_diff = Time.now - @@prev_time[me]
+      # prevent division by zero on low res systems
+      time_diff = (time_diff == 0) ? 1 : time_diff
+      # calculate the percentage
+      cpu_percent = cpu_time / time_diff
+
+      # remember it for the next iteration
+      @@prev_cpu[me] = Process.times
+      @@prev_time[me] = Time.now
+
+      return cpu_percent.ceil
+    end
+  end
+end

data/lib/rcs-common/temporary.rb

@@ -0,0 +1,13 @@
+
+module RCS
+
+class Temporary
+  def self.file(dir, filename)
+    Dir.mkdir(dir) unless Dir.exists? dir
+    tempfilename = File.join(dir, filename)
+    f = File.new(tempfilename, 'wb+')
+    return f
+   end
+end
+
+end # ::RCS

data/lib/rcs-common/time.rb

@@ -0,0 +1,24 @@
+#
+# Helper methods for decoding Windows FILETIME structs.
+#
+
+class Time
+  # Convert the time to the FILETIME format, a 64-bit value representing the
+  # number of 100-nanosecond intervals since January 1, 1601 (UTC).
+  def to_filetime
+    t = self.to_f + 11644473600
+    t *= 10000000
+    t = t.to_i
+    return (t & 0xFFFFFFFF), (t & 0xFFFFFFFF00000000) >> 32
+  end
+  
+  # Create a time object from the FILETIME format, a 64-bit value representing
+  # the number of 100-nanosecond intervals since January 1, 1601 (UTC).
+  def self.from_filetime(high, low)
+    wtime = Float((high << 32) | low)
+    unix_hundreds_nanosec = wtime - 116_444_736_000_000_000
+    seconds_with_frac = unix_hundreds_nanosec / 10_000_000
+    
+    return Time.at(seconds_with_frac).getutc
+  end
+end

data/lib/rcs-common/trace.rb

@@ -0,0 +1,138 @@
+#
+# The logging module
+#
+
+# System
+require 'log4r'
+require 'log4r/yamlconfigurator'
+require 'log4r/outputter/datefileoutputter'
+
+module RCS
+module Tracer
+  include Log4r
+
+  TRACE_YAML_NAME = 'trace.yaml'
+
+  # Ensures that the log directories exists
+  def trace_ensure_log_folders
+    pwd = File.expand_path(Dir.pwd)
+
+    ["#{pwd}/log", "#{pwd}/log/err"].each do |path|
+      Dir.mkdir(path) unless File.directory?(path)
+    end
+  end
+
+  def trace_setup
+    pwd = File.expand_path(Dir.pwd)
+
+    raise "FATAL: Invalid execution directory." unless File.directory?("#{pwd}/lib")
+
+    trace_file_path = File.exist?(TRACE_YAML_NAME) ? TRACE_YAML_NAME : "#{pwd}/config/#{TRACE_YAML_NAME}"
+    raise "FATAL: Unable to find #{TRACE_YAML_NAME} file" unless File.exist?(trace_file_path)
+
+    trace_ensure_log_folders
+
+    trace_cfg = YamlConfigurator
+
+    # the only parameter in the YAML, our HOME directory
+    trace_cfg['HOME'] = pwd
+
+    # load the YAML file with this
+    trace_cfg.load_yaml_file(trace_file_path)
+  rescue Exception => ex
+    raise "FATAL: Unable to load #{TRACE_YAML_NAME}: #{ex.message}"
+  end
+
+  # needed to initialize the trace subsystem.
+  # the path provided is the path where the 'trace.yaml' resides
+  # the configuration inside the yaml can be changed at will
+  # and the trace system will reflect it
+  # 
+  # @deprecated Please use {#trace_setup} instead
+  def trace_init(path = '.', file = 'trace.yaml')
+    # the configuration file is YAML
+    # the file must be called trace.yaml and put in the working directory
+    # of the module that wants to use the 'trace' function
+    trace_cfg = YamlConfigurator 
+    
+    # the only parameter in the YAML, our HOME directory
+    trace_cfg['HOME'] = path
+
+    # load the YAML file with this
+    begin
+      trace_cfg.load_yaml_file(file)
+    rescue
+      raise "FATAL: cannot find trace.yaml file. aborting."
+    end
+
+  end
+
+  # http://log4r.rubyforge.org/manual.html#ndc
+  def trace_nested_push(msg)
+    # push the context
+    # the %x tag should appear in the YAML file if you want to see this traces
+    NDC.push(msg)
+  end
+
+  def trace_nested_pop
+    # pop the last context
+    NDC.pop
+  end
+
+  # http://log4r.rubyforge.org/manual.html#mdc
+  def trace_named_put(name, msg)
+    # create the named context
+    # the %X{name} tag should appear in the YAML file if you want to see this traces
+    MDC.put(name, msg)
+  end
+
+  def trace_named_remove(name)
+    # remove the specified context
+    MDC.remove(name)
+  end
+
+  def thread_name
+    (Thread.current[:name] || Thread.current.object_id.to_s(32)).to_s
+  end
+
+  # the actual method used to output a trace
+  def trace(level, msg)
+    thread_info = "[Thread:#{thread_name}] " if ENV['TRACE_SHOW_THREAD_NAME']
+    msg = "#{thread_info}#{msg}"
+
+    log = Logger['rcslogger']
+    log.send(level, "#{msg}") unless log.nil?
+
+    # fallback if the logger is not initialized
+    puts "#{Time.now} [#{level.to_s.upcase}]: #{msg}" if log.nil? and not ENV['no_trace']
+  end
+
+end # Tracer::
+end # RCS::
+
+if __FILE__ == $0
+  include RCS::Tracer
+ 
+  trace_init Dir.pwd
+  
+  [:debug, :info, :warn, :error, :fatal].each do |level|
+    trace level, "this is a test"
+  end
+  
+  trace_nested_push("level1")
+  trace :info, "test string"
+  
+  trace_nested_push("level2")
+  trace :info, "test string"
+  
+  trace_nested_pop
+  trace_nested_pop
+  trace :info, "test string"
+  
+  trace_named_put(:test, "named tag")
+  trace :info, "test string"
+  
+  trace_named_remove(:test)
+  trace :info, "test string"
+  
+end

data/lib/rcs-common/trace.yaml

@@ -0,0 +1,42 @@
+
+# *** YAML2LOG4R ***
+log4r_config:
+  # define all pre config ...
+  pre_config:
+    global:
+      level: DEBUG
+    root  :
+      level: DEBUG
+
+  # define all loggers ...
+  loggers:
+    - name      : rcslogger
+      level     : DEBUG
+      additive  : 'false'
+      trace     : 'false'      
+      outputters:
+        - stderr
+#        - logfile
+
+  # define all outputters (incl. formatters)      
+  outputters:
+    - type     : StderrOutputter
+      name     : stderr 
+      level    : DEBUG
+      formatter:
+      # take a look at this: http://log4r.rubyforge.org/rdoc/Log4r/PatternFormatter.html
+        date_pattern: '%Y-%m-%d %H:%M:%S'
+        pattern     : '%d [%l]: %X{:test} %x\t %m '
+        type        : PatternFormatter
+
+#    - type        : DateFileOutputter
+#      name        : logfile
+#      level       : DEBUG
+#      date_pattern: '%Y-%m-%d'
+#      trunc       : 'false'
+#      dirname     : "#{HOME}/logs"
+#      formatter   :
+#        date_pattern: '%Y-%m-%d %H:%M:%S'
+#        pattern     : '%d [%l]: %x %m'
+#        type        : PatternFormatter
+