cognizant 0.0.2 → 0.0.3

data/lib/cognizant/application/dsl_proxy.rb

@@ -0,0 +1,23 @@
+require 'cognizant/util/dsl_proxy_methods_handler'
+
+module Cognizant
+  class Application
+    class DSLProxy
+      include Cognizant::Util::DSLProxyMethodsHandler
+
+      def initialize(application, &dsl_block)
+        super
+        @application = application
+        instance_eval(&dsl_block)
+      end
+
+      def monitor(process_name = nil, attributes = {}, &block)
+        @application.monitor(process_name, attributes, &block)
+      end
+
+      def process(process_name = nil, attributes = {}, &block)
+        @application.process(process_name, attributes, &block)
+      end
+    end
+  end
+end

data/lib/cognizant/client.rb

@@ -0,0 +1,61 @@
+require 'uri'
+require 'yaml'
+require 'socket'
+
+module Cognizant
+  class Client
+    # Keep this in this file so client can be loaded entirely
+    # standalone by user code.
+    module Transport
+      def self.send_message(socket, message)
+        line = serialize_message(message)
+        socket.write(line)
+      end
+
+      def self.receive_message(socket)
+        line = socket.readline
+        deserialize_message(line)
+      end
+
+      def self.serialize_message(message)
+        serialized = YAML.dump(message)
+        escaped = URI.escape(serialized, "%\n")
+        escaped + "\n"
+      end
+
+      def self.deserialize_message(line)
+        serialized = URI.unescape(line)
+        YAML.load(serialized)
+      end
+    end
+
+    @@responseless_commands = ["shutdown"]
+
+    def self.for_port(hostname = "127.0.0.1", port)
+      socket = TCPSocket.open(hostname, port)
+      self.new(socket)
+    end
+
+    def self.for_path(path_to_socket)
+      socket = UNIXSocket.open(path_to_socket)
+      self.new(socket)
+    end
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def command(command_hash)
+      Transport.send_message(@socket, command_hash)
+      Transport.receive_message(@socket) if expect_response?(command_hash)
+    end
+
+    def expect_response?(command_hash)
+      !@@responseless_commands.include?(command_hash['command'])
+    end
+
+    def close
+      @socket.close
+    end
+  end
+end

data/lib/cognizant/commands.rb

@@ -0,0 +1,164 @@
+require "json"
+require "cognizant/client"
+require "cognizant/system"
+
+module Cognizant
+  module Commands
+    @@commands = {}
+
+    def self.command(name, description = nil, &block)
+      @@commands[name] = { :description => description, :block => block }
+    end
+
+    def self.process_command(connection, command)
+      response = generate_response(connection, command)
+      if !response.nil?
+        send_message(connection, response)
+      else
+        Log[self].debug("Got back nil response, so not responding to command.")
+      end
+      # connection.close_connection_after_writing
+    end
+
+    def self.send_message(connection, response)
+      if response.kind_of?(String)
+        response = { 'message' => response }
+      end
+      serialized_message = Cognizant::Client::Transport.serialize_message(response)
+      connection.send_data(serialized_message)
+    end
+
+    def self.generate_response(connection, command)
+      begin
+        request = Cognizant::Client::Transport.deserialize_message(command)
+      rescue ArgumentError => e
+        return { 'message' => "Could not parse command: #{e}" }
+      end
+
+      unless command_name = request['command']
+        return { 'message' => 'No "command" parameter provided; not sure what you want me to do.' }
+      end
+
+      run_command(connection, request, command, command_name)
+    end
+
+    def self.run_command(connection, request, command, command_name)
+      if command_spec = @@commands[command_name]
+        # Log[self].debug("Received command: #{command.inspect}")
+        begin
+          return command_spec[:block].call(connection, request)
+        rescue StandardError => e
+          msg = "Error while processing command #{command_name.inspect}: #{e} (#{e.class})\n  #{e.backtrace.join("\n  ")}"
+          Log[self].error(msg)
+          return msg
+        end
+      else
+        Log[self].debug("Received unrecognized command: #{command.inspect}")
+        return unrecognized_command(connection, request)
+      end
+    end
+
+    def self.command_descriptions
+      command_specs = @@commands.select do |_, spec|
+        spec[:description]
+      end.sort_by {|name, _| name}
+
+      command_specs.map do |name, spec|
+        "#{name}: #{spec[:description]}"
+      end.join("\n")
+    end
+
+    def self.unrecognized_command(connection, request)
+      <<EOF
+Unrecognized command: #{request['command'].inspect}
+
+#{command_descriptions}
+EOF
+    end
+
+    # Used by cognizant shell.
+    command '_ehlo' do |conn, request|
+      if request["app"].to_s.size > 0 and Cognizant::Controller.daemon.applications.has_key?(request["app"].to_sym)
+        use = request["app"]
+      else
+        use = Cognizant::Controller.daemon.applications.keys.first
+      end
+
+      message = <<EOF
+Welcome #{request['user']}! You are speaking to the Cognizant Monitoring Daemon.
+EOF
+
+      { "message" => message, "use" => use }
+    end
+
+    # Used by cognizant shell.
+    command '_autocomplete_keywords' do |conn, request|
+      keywords = []
+      keywords += @@commands.keys.reject { |c| c =~ /^\_.+/ }
+      keywords += Cognizant::Controller.daemon.applications.keys
+      keywords += Cognizant::Controller.daemon.applications[request["app"].to_sym].processes.keys if request.has_key?("app") and request["app"].to_s.size > 0
+      keywords
+    end
+
+    # command('reload', 'Reload Cognizant') do |connection, _|
+    #   # TODO: make reload actually work (command socket reopening is
+    #   # an issue). Would also be nice if user got a confirmation that
+    #   # the reload completed, though that's not strictly necessary.
+    # 
+    #   # In the normal case, this will do a write
+    #   # synchronously. Otherwise, the bytes will be stuck into the
+    #   # buffer and lost upon reload.
+    #   send_message(connection, 'Reloading, as commanded')
+    #   Cognizant.reload
+    # 
+    #   # Reload should not return
+    #   raise "Not reachable"
+    # end
+
+    def self.processes_for_name_or_group(app, args)
+      processes = []
+      if app.to_s.size > 0
+        Cognizant::Controller.daemon.applications[app.to_sym].processes.values.each do |process|
+          processes << process if args.include?(process.name) or args.include?(process.group)
+        end
+      end
+      processes
+    end
+
+    def self.send_process_or_group_status(app, args = [])
+      output_processes = []
+      if args.size > 0
+        output_processes = processes_for_name_or_group(app, args)
+        return %Q{No such process or group: #{args.join(', ')}} if output_processes.size == 0
+      else
+        output_processes = Cognizant::Controller.daemon.applications[app.to_sym].processes.values
+      end
+
+      format_process_or_group_status(output_processes)
+    end
+
+    def self.format_process_or_group_status(output_processes)
+      output = []
+      output_processes.each do |process|
+        pid = process.cached_pid
+        output << {
+          "Process" => process.name,
+          "PID"     => pid,
+          "Group"   => process.group,
+          "State"   => process.state,
+          "Since"   => process.last_transition_time,
+          "% CPU"   => Cognizant::System.cpu_usage(pid).to_f,
+          "Memory"  => Cognizant::System.memory_usage(pid).to_f # in KBs.
+        }
+      end
+      output
+    end
+  end
+end
+
+require "cognizant/commands/actions"
+require "cognizant/commands/help"
+require "cognizant/commands/load"
+require "cognizant/commands/shutdown"
+require "cognizant/commands/status"
+require "cognizant/commands/use"

data/lib/cognizant/commands/actions.rb

@@ -0,0 +1,30 @@
+module Cognizant
+  module Commands
+    [
+      ["monitor",   "Monitor the specified process or group"],
+      ["unmonitor", "Unmonitor the specified process or group"],
+      ["start",     "Start the specified process or group"],
+      ["stop",      "Stop the specified process or group"],
+      ["restart",   "Restart the specified process or group"]
+    ].each do |(name, description)|
+      command(name, description) do |connection, request|
+        args = request["args"]
+        unless args.size > 0
+          "Missing process name"
+        else
+          output_processes = []
+          output_processes = processes_for_name_or_group(request["app"], args)
+          if output_processes.size == 0
+            %Q{No such process or group: #{args.join(', ')}}
+          else
+            output_processes.each do |process|
+              process.handle_user_command(name)
+            end
+            # send_process_or_group_status(request["app"], args)
+            "OK"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cognizant/commands/help.rb

@@ -0,0 +1,10 @@
+module Cognizant
+  module Commands
+    command('help', 'Print out available commands') do
+"You are speaking to the Cognizant command socket. You can run the following commands:
+
+#{command_descriptions}
+"
+    end
+  end
+end

data/lib/cognizant/commands/load.rb

@@ -0,0 +1,10 @@
+module Cognizant
+  module Commands
+    command("load", "Loads the process information from specified Ruby file") do |connection, request|
+      request["args"].each do |file|
+        Cognizant::Controller.daemon.load_file(file)
+      end
+      "OK"
+    end
+  end
+end

data/lib/cognizant/commands/shutdown.rb

@@ -0,0 +1,7 @@
+module Cognizant
+  module Commands
+    command("shutdown", "Stop the monitoring daemon without affecting managed processes") do |connection, _|
+      Cognizant::Controller.daemon.shutdown!
+    end
+  end
+end

data/lib/cognizant/commands/status.rb

@@ -0,0 +1,11 @@
+module Cognizant
+  module Commands
+    command("status", "Display status of managed process(es) or group(s)") do |connection, request|
+      if request.has_key?("app") and request["app"].to_s.size > 0 and Cognizant::Controller.daemon.applications.has_key?(request["app"].to_sym)
+        send_process_or_group_status(request["app"], request["args"])
+      else
+        %Q{No such application: "#{request['app']}"}
+      end
+    end
+  end
+end

data/lib/cognizant/commands/use.rb

@@ -0,0 +1,15 @@
+module Cognizant
+  module Commands
+    command("use", "Switch the current application for use with process maintenance commands") do |connection, request|
+      puts "Cognizant::Controller.daemon.applications.keys: #{Cognizant::Controller.daemon.applications.keys}"
+      if request["args"].size > 0 and request["args"].first.to_s.size > 0 and Cognizant::Controller.daemon.applications.has_key?(request["args"].first.to_sym)
+        app = request["args"].first
+        message = "OK"
+      else
+        app = request["app"]
+        message = %Q{No such application: "#{request['args'].first}"}
+      end
+      { "use" => app, "message" => message }
+    end
+  end
+end

data/lib/cognizant/controller.rb

@@ -0,0 +1,17 @@
+require "cognizant/daemon"
+
+module Cognizant
+  module Controller
+    class << self
+      attr_accessor :daemon
+    end
+
+    def self.daemon
+      @daemon ||= Cognizant::Daemon.new
+    end
+
+    def self.start_daemon(options = {})
+      self.daemon.start(options)
+    end
+  end
+end

data/lib/cognizant/daemon.rb

@@ -0,0 +1,279 @@
+require "eventmachine"
+
+require "cognizant"
+require "cognizant/log"
+require "cognizant/process"
+require "cognizant/application"
+require "cognizant/system"
+require "cognizant/util/transform_hash_keys"
+
+module Cognizant
+  class Daemon
+    # Whether or not to the daemon in the background.
+    # @return [true, false] Defaults to true
+    attr_accessor :daemonize
+
+    attr_accessor :sockfile
+
+    # The pid lock file for the daemon.
+    # e.g. /Users/Gurpartap/.cognizant/cognizantd.pid
+    # @return [String] Defaults to /var/run/cognizant/cognizantd.pid
+    attr_accessor :pidfile
+
+    # The file to log the daemon's operations information into.
+    # e.g. /Users/Gurpartap/.cognizant/cognizantd.log
+    # @return [String] Defaults to /var/log/cognizant/cognizantd.log
+    attr_accessor :logfile
+
+    # Whether or not to log to syslog daemon instead of file.
+    # @return [true, false] Defaults to true
+    attr_accessor :syslog
+
+    # The level of information to log. This does not affect the log
+    # level of managed processes.
+    # @note The possible values must be one of the following:
+    #   DEBUG, INFO, WARN, ERROR and FATAL or 0, 1, 2, 3, 4 (respectively).
+    # @return [Logger::Severity] Defaults to Logger::INFO
+    attr_accessor :loglevel
+
+    # Hash of applications being managed.
+    # @private
+    # @return [Hash]
+    attr_accessor :applications
+
+    # @private
+    attr_accessor :socket
+
+    def start(options = {})
+      self.reset!
+
+      load_files = []
+      rb_files   = []
+      yml_files  = []
+      apps       = []
+
+      load_files = [*options.delete(:load)] if options and options.has_key?(:load)
+      load_files.each do |include|
+        Dir[File.expand_path(include)].each do |file|
+          Log[self].info "Including config from #{file}."
+          if file.end_with?(".yml")
+            yml_files << file
+          else
+            rb_files << file
+          end
+        end
+      end
+      apps << options.delete(:applications) if options and options.has_key?(:applications)
+
+      yml_files.each do |file|
+        file_opts = YAML.load_file(file)
+        if file_opts
+          file_opts.deep_symbolize_keys!
+          apps << file_opts.delete(:applications) if file_opts.has_key?(:applications)
+        end
+      end
+
+      # Attributes.
+      options.each do |key, value|
+        self.send("#{key}=", options.delete(key)) if self.respond_to?("#{key}=")
+      end
+
+      self.sockfile = File.expand_path(self.sockfile)
+      self.pidfile  = File.expand_path(self.pidfile)
+      self.logfile  = File.expand_path(self.logfile)
+
+      Log[self].info "Booting up Cognizant daemon..."
+      setup_directories
+      setup_logging
+      stop_previous_daemon
+      stop_previous_socket
+      trap_signals
+      daemonize_process
+      write_pid
+
+      EventMachine.run do
+        # Applications.
+        Log[self].info "Cognizant daemon running successfully."
+
+        apps.each do |app|
+          app.each do |key, value|
+            self.create_application(key, value)
+          end
+        end
+
+        [*rb_files].each do |rb_file|
+          load_file(rb_file)
+        end
+
+        EventMachine.start_unix_domain_server(self.sockfile, Cognizant::Interface)
+
+        EventMachine.add_periodic_timer(1) do
+          Cognizant::System.reset_data!
+          self.applications.values.each(&:tick)
+        end
+      end
+    end
+
+    def load_file(file)
+      if file.end_with?(".yml")
+        yml_config = YAML.load_file(file)
+        if yml_config
+          yml_config.deep_symbolize_keys!
+          yml_config_apps = yml_config.delete(:applications) if yml_config.has_key?(:applications)
+          yml_config_apps.each { |key, value| self.create_application(key, value) }
+        end
+      else
+        rb_file = File.expand_path(file)
+        Kernel.load(rb_file) if File.exists?(rb_file)
+      end
+    end
+
+    def reset!
+      self.daemonize    = true
+      self.sockfile     = "/var/run/cognizant/cognizantd.sock"
+      self.pidfile      = "/var/run/cognizant/cognizantd.pid"
+      self.syslog       = false
+      self.logfile      = "/var/log/cognizant/cognizantd.log"
+      self.loglevel     = Logging::LEVELS["INFO"]
+      self.applications.values.each(&:reset!) if self.applications.is_a?(Hash)
+      self.applications = {}
+    end
+
+    def create_application(name, options = {}, &block)
+      app = Cognizant::Application.new(name, options, &block)
+      self.applications[app.name.to_sym] = app
+      app
+    end
+
+    def setup_logging
+      Cognizant::Log.logger.root.level = self.loglevel
+
+      unless self.daemonize
+        stdout_appender = Cognizant::Log.stdout
+        Cognizant::Log.logger.root.add_appenders(stdout_appender)
+      end
+
+      if self.syslog
+        # TODO: Choose a non-default facility? (default: LOG_USR).
+        syslog_appender = Cognizant::Log.syslog("cognizantd")
+        Cognizant::Log.logger.root.add_appenders(syslog_appender)
+      elsif self.logfile
+        logfile_appender = Cognizant::Log.file(self.logfile)
+        Cognizant::Log.logger.root.add_appenders(logfile_appender)
+      end
+    end
+
+    def setup_directories
+      # Create the require directories.
+      System.mkdir(File.dirname(self.sockfile), File.dirname(self.pidfile), File.dirname(self.logfile))
+    end
+
+    # Stops the socket server and the tick loop, and performs cleanup.
+    def shutdown!
+      Log[self].info "Shutting down Cognizant daemon..."
+      EventMachine.next_tick do
+        EventMachine.add_shutdown_hook do
+          self.applications.values.each(&:shutdown!)
+          unlink_pid
+          # TODO: Close logger?
+        end
+        EventMachine.stop
+      end
+    end
+
+    def trap_signals
+      terminator = Proc.new do
+        Log[self].info "Received signal to shutdown."
+        shutdown!
+      end
+
+      Signal.trap('TERM', &terminator)
+      Signal.trap('INT',  &terminator)
+      Signal.trap('QUIT', &terminator)
+    end
+
+    def stop_previous_daemon
+      if self.pidfile and File.exists?(self.pidfile)
+        if previous_daemon_pid = File.read(self.pidfile).to_i
+          # Only attempt to stop automatically if the daemon will run in background.
+          if self.daemonize and Cognizant::System.pid_running?(previous_daemon_pid)
+            # Ensure that the process stops within 5 seconds or force kill.
+            signals = ["TERM", "KILL"]
+            timeout = 2
+            catch :stopped do
+              signals.each do |stop_signal|
+                # Send the stop signal and wait for it to stop.
+                Cognizant::System.signal(stop_signal, previous_daemon_pid)
+
+                # Poll to see if it has stopped yet. Minimum 2 so that we check at least once again.
+                ([timeout / signals.size, 2].max).times do
+                  throw :stopped unless Cognizant::System.pid_running?(previous_daemon_pid)
+                  sleep 1
+                end
+              end
+            end
+          end
+        end
+
+        # Alert the user to manually stop the previous daemon, if it is [still] alive.
+        if Cognizant::System.pid_running?(previous_daemon_pid)
+          raise "There is already a daemon running with pid #{previous_daemon_pid}."
+        else
+          unlink_pid # This will be overwritten anyways.
+        end
+      end
+    end
+
+    def stop_previous_socket
+      # Socket isn't actually owned by anyone.
+      begin
+        sock = UNIXSocket.new(self.sockfile)
+      rescue Errno::ECONNREFUSED
+        # This happens with non-socket files and when the listening
+        # end of a socket has exited.
+      rescue Errno::ENOENT
+        # Socket doesn't exist.
+        return
+      else
+        # Rats, it's still active.
+        sock.close
+        raise Errno::EADDRINUSE.new("Another process or application is likely already listening on the socket at #{self.sockfile}.")
+      end
+    
+      # Socket should still exist, so don't need to handle error.
+      stat = File.stat(self.sockfile)
+      unless stat.socket?
+        raise Errno::EADDRINUSE.new("Non-socket file present at socket file path #{self.sockfile}. Either remove that file and restart Cognizant, or change the socket file path.")
+      end
+    
+      Log[self].info("Blowing away old socket file at #{self.sockfile}. This likely indicates a previous Cognizant application which did not shutdown gracefully.")
+
+      # Whee, blow it away.
+      unlink_sockfile
+    end
+
+    # Daemonize the current process and save it pid in a file.
+    def daemonize_process
+      if self.daemonize
+        Log[self].info "Daemonizing into the background..."
+        ::Process.daemon
+      end
+    end
+
+    def write_pid
+      pid = ::Process.pid
+      if self.pidfile
+        Log[self].info "Writing the daemon pid (#{pid}) to the pidfile..."
+        File.open(self.pidfile, "w") { |f| f.write(pid) }
+      end
+    end
+
+    def unlink_pid
+      Cognizant::System.unlink_file(self.pidfile) if self.pidfile
+    end
+
+    def unlink_sockfile
+      Cognizant::System.unlink_file(self.sockfile) if self.sockfile
+    end
+  end
+end