mcproc 2016.2.20

data/lib/god/registry.rb

@@ -0,0 +1,32 @@
+module God
+  def self.registry
+    @registry ||= Registry.new
+  end
+
+  class Registry
+    def initialize
+      @storage = {}
+    end
+
+    def add(item)
+      # raise TypeError unless item.is_a? God::Process
+      @storage[item.name] = item
+    end
+
+    def remove(item)
+      @storage.delete(item.name)
+    end
+
+    def size
+      @storage.size
+    end
+
+    def [](name)
+      @storage[name]
+    end
+
+    def reset
+      @storage.clear
+    end
+  end
+end

data/lib/god/simple_logger.rb

@@ -0,0 +1,59 @@
+module God
+
+  class SimpleLogger
+    DEBUG = 2
+    INFO = 4
+    WARN = 8
+    ERROR = 16
+    FATAL = 32
+
+    SEV_LABEL = {DEBUG => 'DEBUG',
+                 INFO => 'INFO',
+                 WARN => 'WARN',
+                 ERROR => 'ERROR',
+                 FATAL => 'FATAL'}
+
+    CONSTANT_TO_SYMBOL = { DEBUG => :debug,
+                           INFO => :info,
+                           WARN => :warn,
+                           ERROR => :error,
+                           FATAL => :fatal }
+
+    attr_accessor :datetime_format, :level
+
+    def initialize(io)
+      @io = io
+      @level = INFO
+      @datetime_format = "%Y-%m-%d %H:%M:%S"
+    end
+
+    def output(level, msg)
+      return if level < self.level
+
+      time = Time.now.strftime(self.datetime_format)
+      label = SEV_LABEL[level]
+      @io.print("#{label[0..0]} [#{time}] #{label.rjust(5)}: #{msg}\n")
+    end
+
+    def fatal(msg)
+      self.output(FATAL, msg)
+    end
+
+    def error(msg)
+      self.output(ERROR, msg)
+    end
+
+    def warn(msg)
+      self.output(WARN, msg)
+    end
+
+    def info(msg)
+      self.output(INFO, msg)
+    end
+
+    def debug(msg)
+      self.output(DEBUG, msg)
+    end
+  end
+
+end

data/lib/god/socket.rb

@@ -0,0 +1,113 @@
+require 'drb'
+
+module God
+
+  # The God::Server oversees the DRb server which dishes out info on this God daemon.
+  class Socket
+    attr_reader :port
+
+    # The location of the socket for a given port
+    #   +port+ is the port number
+    #
+    # Returns String (file location)
+    def self.socket_file(port)
+      "/tmp/god.#{port}.sock"
+    end
+
+    # The address of the socket for a given port
+    #   +port+ is the port number
+    #
+    # Returns String (drb address)
+    def self.socket(port)
+      "drbunix://#{self.socket_file(port)}"
+    end
+
+    # The location of the socket for this Server
+    #
+    # Returns String (file location)
+    def socket_file
+      self.class.socket_file(@port)
+    end
+
+    # The address of the socket for this Server
+    #
+    # Returns String (drb address)
+    def socket
+      self.class.socket(@port)
+    end
+
+    # Create a new Server and star the DRb server
+    #   +port+ is the port on which to start the DRb service (default nil)
+    def initialize(port = nil, user = nil, group = nil, perm = nil)
+      @port  = port
+      @user  = user
+      @group = group
+      @perm  = perm
+      start
+    end
+
+    # Returns true
+    def ping
+      true
+    end
+
+    # Forward API calls to God
+    #
+    # Returns whatever the forwarded call returns
+    def method_missing(*args, &block)
+      God.send(*args, &block)
+    end
+
+    # Stop the DRb server and delete the socket file
+    #
+    # Returns nothing
+    def stop
+      DRb.stop_service
+      FileUtils.rm_f(self.socket_file)
+    end
+
+    private
+
+    # Start the DRb server. Abort if there is already a running god instance
+    # on the socket.
+    #
+    # Returns nothing
+    def start
+      begin
+        @drb ||= DRb.start_service(self.socket, self)
+        applog(nil, :info, "Started on #{DRb.uri}")
+      rescue Errno::EADDRINUSE
+        applog(nil, :info, "Socket already in use")
+        server = DRbObject.new(nil, self.socket)
+
+        begin
+          Timeout.timeout(5) do
+            server.ping
+          end
+          abort "Socket #{self.socket} already in use by another instance of god"
+        rescue StandardError, Timeout::Error
+          applog(nil, :info, "Socket is stale, reopening")
+          File.delete(self.socket_file) rescue nil
+          @drb ||= DRb.start_service(self.socket, self)
+          applog(nil, :info, "Started on #{DRb.uri}")
+        end
+      end
+
+      if File.exists?(self.socket_file)
+        if @user
+          user_method = @user.is_a?(Integer) ? :getpwuid : :getpwnam
+          uid = Etc.send(user_method, @user).uid
+          gid = Etc.send(user_method, @user).gid
+        end
+        if @group
+          group_method = @group.is_a?(Integer) ? :getgrgid : :getgrnam
+          gid = Etc.send(group_method, @group).gid
+        end
+
+        File.chmod(Integer(@perm), socket_file) if @perm
+        File.chown(uid, gid, socket_file) if uid or gid
+      end
+    end
+  end
+
+end

data/lib/god/sugar.rb

@@ -0,0 +1,62 @@
+class Numeric
+  # Public: Units of seconds.
+  def seconds
+    self
+  end
+
+  # Public: Units of seconds.
+  alias :second :seconds
+
+  # Public: Units of minutes (60 seconds).
+  def minutes
+    self * 60
+  end
+
+  # Public: Units of minutes (60 seconds).
+  alias :minute :minutes
+
+  # Public: Units of hours (3600 seconds).
+  def hours
+    self * 3600
+  end
+
+  # Public: Units of hours (3600 seconds).
+  alias :hour :hours
+
+  # Public: Units of days (86400 seconds).
+  def days
+    self * 86400
+  end
+
+  # Public: Units of days (86400 seconds).
+  alias :day :days
+
+  # Units of kilobytes.
+  def kilobytes
+    self
+  end
+
+  # Units of kilobytes.
+  alias :kilobyte :kilobytes
+
+  # Units of megabytes (1024 kilobytes).
+  def megabytes
+    self * 1024
+  end
+
+  # Units of megabytes (1024 kilobytes).
+  alias :megabyte :megabytes
+
+  # Units of gigabytes (1,048,576 kilobytes).
+  def gigabytes
+    self * (1024 ** 2)
+  end
+
+  # Units of gigabytes (1,048,576 kilobytes).
+  alias :gigabyte :gigabytes
+
+  # Units of percent. e.g. 50.percent.
+  def percent
+    self
+  end
+end

data/lib/god/sys_logger.rb

@@ -0,0 +1,45 @@
+begin
+  require 'syslog'
+
+  # Ensure that Syslog is open
+  begin
+    Syslog.open('god')
+  rescue RuntimeError
+    Syslog.reopen('god')
+  end
+
+  Syslog.info("Syslog enabled.")
+
+  module God
+
+    class SysLogger
+      SYMBOL_EQUIVALENTS = { :fatal => Syslog::LOG_CRIT,
+                             :error => Syslog::LOG_ERR,
+                             :warn => Syslog::LOG_WARNING,
+                             :info => Syslog::LOG_INFO,
+                             :debug => Syslog::LOG_DEBUG }
+
+      # Set the log level
+      #   +level+ is the Symbol level to set as maximum. One of:
+      #           [:fatal | :error | :warn | :info | :debug ]
+      #
+      # Returns Nothing
+      def self.level=(level)
+        Syslog.mask = Syslog::LOG_UPTO(SYMBOL_EQUIVALENTS[level])
+      end
+
+      # Log a message to syslog.
+      #   +level+ is the Symbol level of the message. One of:
+      #           [:fatal | :error | :warn | :info | :debug ]
+      #   +text+ is the String text of the message
+      #
+      # Returns Nothing
+      def self.log(level, text)
+        Syslog.log(SYMBOL_EQUIVALENTS[level], '%s', text)
+      end
+    end
+
+  end
+rescue Object => e
+  puts "Syslog could not be enabled: #{e.message}"
+end

data/lib/god/system/portable_poller.rb

@@ -0,0 +1,42 @@
+module God
+  module System
+    class PortablePoller
+      def initialize(pid)
+        @pid = pid
+      end
+      # Memory usage in kilobytes (resident set size)
+      def memory
+        ps_int('rss')
+      end
+
+      # Percentage memory usage
+      def percent_memory
+        ps_float('%mem')
+      end
+
+      # Percentage CPU usage
+      def percent_cpu
+        ps_float('%cpu')
+      end
+
+      private
+
+      def ps_int(keyword)
+        `ps -o #{keyword}= -p #{@pid}`.to_i
+      end
+
+      def ps_float(keyword)
+        `ps -o #{keyword}= -p #{@pid}`.to_f
+      end
+
+      def ps_string(keyword)
+        `ps -o #{keyword}= -p #{@pid}`.strip
+      end
+
+      def time_string_to_seconds(text)
+        _, minutes, seconds, useconds = *text.match(/(\d+):(\d{2}).(\d{2})/)
+        (minutes.to_i * 60) + seconds.to_i
+      end
+    end
+  end
+end

data/lib/god/system/process.rb

@@ -0,0 +1,50 @@
+module God
+  module System
+
+    class Process
+      def self.fetch_system_poller
+        @@poller ||= if SlashProcPoller.usable?
+		       SlashProcPoller
+		     else
+		       PortablePoller
+		     end
+      end
+
+      def initialize(pid)
+        @pid = pid.to_i
+        @poller = self.class.fetch_system_poller.new(@pid)
+      end
+
+      # Return true if this process is running, false otherwise
+      def exists?
+        !!::Process.kill(0, @pid) rescue false
+      end
+
+      # Memory usage in kilobytes (resident set size)
+      def memory
+        @poller.memory
+      end
+
+      # Percentage memory usage
+      def percent_memory
+        @poller.percent_memory
+      end
+
+      # Percentage CPU usage
+      def percent_cpu
+        @poller.percent_cpu
+      end
+
+      private
+
+      def fetch_system_poller
+        if SlashProcPoller.usable?
+          SlashProcPoller
+        else
+          PortablePoller
+        end
+      end
+    end
+
+  end
+end

data/lib/god/system/slash_proc_poller.rb

@@ -0,0 +1,92 @@
+module God
+  module System
+    class SlashProcPoller < PortablePoller
+      @@kb_per_page = 4 # TODO: Need to make this portable
+      @@hertz = 100
+      @@total_mem = nil
+
+      MeminfoPath = '/proc/meminfo'
+      UptimePath = '/proc/uptime'
+
+      RequiredPaths = [MeminfoPath, UptimePath]
+
+      # FreeBSD has /proc by default, but nothing mounted there!
+      # So we should check for the actual required paths!
+      # Returns true if +RequiredPaths+ are readable.
+      def self.usable?
+        RequiredPaths.all? do |path|
+          test(?r, path) && readable?(path)
+        end
+      end
+
+      def initialize(pid)
+        super(pid)
+
+        unless @@total_mem # in K
+          File.open(MeminfoPath) do |f|
+            @@total_mem = f.gets.split[1]
+          end
+        end
+      end
+
+      def memory
+        stat[:rss].to_i * @@kb_per_page
+      rescue # This shouldn't fail is there's an error (or proc doesn't exist)
+        0
+      end
+
+      def percent_memory
+        (memory / @@total_mem.to_f) * 100
+      rescue # This shouldn't fail is there's an error (or proc doesn't exist)
+        0
+      end
+
+      # TODO: Change this to calculate the wma instead
+      def percent_cpu
+        stats = stat
+        total_time = stats[:utime].to_i + stats[:stime].to_i # in jiffies
+        seconds = uptime - stats[:starttime].to_i / @@hertz
+        if seconds == 0
+          0
+        else
+          ((total_time * 1000 / @@hertz) / seconds) / 10
+        end
+      rescue # This shouldn't fail is there's an error (or proc doesn't exist)
+        0
+      end
+
+      private
+
+      # Some systems (CentOS?) have a /proc, but they can hang when trying to
+      # read from them. Try to use this sparingly as it is expensive.
+      def self.readable?(path)
+        begin
+          timeout(1) { File.read(path) }
+        rescue Timeout::Error
+          false
+        end
+      end
+
+      # in seconds
+      def uptime
+        File.read(UptimePath).split[0].to_f
+      end
+
+      def stat
+        stats = {}
+        stats[:pid], stats[:comm], stats[:state], stats[:ppid], stats[:pgrp],
+        stats[:session], stats[:tty_nr], stats[:tpgid], stats[:flags],
+        stats[:minflt], stats[:cminflt], stats[:majflt], stats[:cmajflt],
+        stats[:utime], stats[:stime], stats[:cutime], stats[:cstime],
+        stats[:priority], stats[:nice], _, stats[:itrealvalue],
+        stats[:starttime], stats[:vsize], stats[:rss], stats[:rlim],
+        stats[:startcode], stats[:endcode], stats[:startstack], stats[:kstkesp],
+        stats[:kstkeip], stats[:signal], stats[:blocked], stats[:sigignore],
+        stats[:sigcatch], stats[:wchan], stats[:nswap], stats[:cnswap],
+        stats[:exit_signal], stats[:processor], stats[:rt_priority],
+        stats[:policy] = File.read("/proc/#{@pid}/stat").scan(/\(.*?\)|\w+/)
+        stats
+      end
+    end
+  end
+end