cognizant 0.0.1

data/lib/cognizant/server/commands.rb

@@ -0,0 +1,53 @@
+module Cognizant
+  module Server
+    module Commands
+      def self.load(config_file)
+        Cognizant::Server.daemon.load(config_file)
+        yield("OK")
+      end
+
+      def self.status(*args)
+        if process_name = args.shift
+          Cognizant::Server.daemon.processes.each do |name, process|
+            if process.name.eql?(process_name)
+              yield("#{process.name}: #{process.state}")
+              return yield("OK")
+            end
+          end  
+          yield("ERR: No such process")
+          return yield("OK")
+        end
+        yield("OK")
+      end
+
+      %w(monitor start stop restart unmonitor).each do |action|
+        class_eval <<-END
+          def self.#{action}(*args)
+            unless process_name = args.shift
+              yield("ERR: Missing process name")
+              return yield("OK")
+            end
+            Cognizant::Server.daemon.processes.each do |name, process|
+              if process.name.eql?(process_name)
+                process.#{action}
+                return yield("OK")
+              end
+            end
+            yield("ERR: No such process")
+            yield("OK")
+          end
+        END
+      end
+
+      def self.shutdown
+        Cognizant::Server.daemon.shutdown
+        yield("OK")
+      end
+
+      def self.method_missing(command, *args)
+        yield("ERR: Unknown command '#{command}'")
+        yield("OK")
+      end
+    end
+  end
+end

data/lib/cognizant/server/daemon.rb

@@ -0,0 +1,239 @@
+require "eventmachine"
+
+require "cognizant"
+require "cognizant/logging"
+require "cognizant/process"
+require "cognizant/server/interface"
+
+module Cognizant
+  module Server
+    class Daemon
+      include Cognizant::Logging
+
+      # Whether or not to the daemon in the background.
+      # @return [true, false] Defaults to true
+      attr_accessor :daemonize
+
+      # 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
+
+      # 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:
+      #   Logger::DEBUG, Logger::INFO, Logger::WARN, Logger::ERROR and
+      #   Logger::FATAL or 0, 1, 2, 3, 4 (respectively).
+      # @return [Logger::Severity] Defaults to Logger::INFO
+      attr_accessor :loglevel
+
+      # The socket lock file for the server. This file is ignored if valid
+      # bind address and port are given.
+      # e.g. /Users/Gurpartap/.cognizant/cognizant-server.sock
+      # @return [String] Defaults to /var/run/cognizant/cognizantd.sock
+      attr_accessor :socket
+
+      # The TCP address and port to start the server with. e.g. 8081,
+      # "127.0.0.1:8081", "0.0.0.0:8081".
+      # @return [String] Defaults to nil
+      attr_accessor :port
+
+      # Username for securing server access. e.g. "cognizant-user"
+      # @return [String] Defaults to nil
+      attr_accessor :username
+
+      # Password to accompany the username.
+      # e.g. "areallyverylongpasswordbecauseitmatters"
+      # @return [String] Defaults to nil
+      attr_accessor :password
+
+      # Directory to store the pid files of managed processes, when required.
+      # e.g. /Users/Gurpartap/.cognizant/pids/
+      # @return [String] Defaults to /var/run/cognizant/pids/
+      attr_accessor :pids_dir
+
+      # Directory to store the log files of managed processes, when required.
+      # e.g. /Users/Gurpartap/.cognizant/logs/
+      # @return [String] Defaults to /var/log/cognizant/logs/
+      attr_accessor :logs_dir
+
+      # Environment variables for managed processes to inherit.
+      # @return [Hash] Defaults to {}
+      attr_accessor :env
+
+      # The current working directory for the managed processes to start with.
+      # @return [String] Defaults to nil
+      attr_accessor :chdir
+
+      # Limit the permission modes for files and directories created by the
+      # daemon and the managed processes.
+      # @return [Integer] Defaults to nil
+      attr_accessor :umask
+
+      # Run the daemon and managed processes as the given user.
+      # e.g. "deploy", 1000
+      # @return [String] Defaults to nil
+      attr_accessor :user
+
+      # Run the daemon and managed processes as the given user group.
+      # e.g. "deploy"
+      # @return [String] Defaults to nil
+      attr_accessor :group
+
+      # Array of processes being managed.
+      # @private
+      # @return [Array]
+      attr_accessor :processes
+
+      # Initializes and starts the cognizant daemon with the given options
+      # as instance attributes.
+      # @param [Hash] options A hash of instance attributes and their values.
+      def initialize(options = {})
+        # Daemon config.
+        @daemonize = options.has_key?(:daemonize) ? options[:daemonize] : true
+        @pidfile   = options[:pidfile]       || "/var/run/cognizant/cognizantd.pid"
+        @logfile   = options[:logfile]       || "/var/log/cognizant/cognizantd.log"
+        @loglevel  = options[:loglevel].to_i || Logger::INFO
+        @socket    = options[:socket]        || "/var/run/cognizant/cognizantd.sock"
+        @port      = options[:port]          || nil
+        @username  = options[:username]      || nil
+        @password  = options[:password]      || nil
+        @trace     = options[:trace]         || nil
+
+        # Processes config.                            
+        @pids_dir = options[:pids_dir] || "/var/run/cognizant/pids/"
+        @logs_dir = options[:logs_dir] || "/var/log/cognizant/logs/"
+        @env      = options[:env]      || {}
+        @chdir    = options[:chdir]    || nil
+        @umask    = options[:umask]    || nil
+        @user     = options[:user]     || nil
+        @group    = options[:group]    || nil
+
+        # Expand paths.
+        @socket   = File.expand_path(@socket)
+        @pidfile  = File.expand_path(@pidfile)
+        @logfile  = File.expand_path(@logfile)
+        @pids_dir = File.expand_path(@pids_dir)
+        @logs_dir = File.expand_path(@logs_dir)
+
+        self.processes = {}
+
+        # # Only available through a config file/stdin.
+        # load_processes(options[:monitor]) if options.has_key?(:monitor)
+      end
+
+      def bootup
+        setup_prerequisites
+        trap_signals
+        log.info "Booting up cognizantd..."
+        EventMachine.run do
+          start_interface_server
+          start_periodic_ticks
+          daemonize
+        end
+      end
+
+      def load(config_file)
+        config_file = File.expand_path(config_file)
+        log.info "Loading config from #{config_file}..."
+        # config = YAML.load_file(config_file)
+        # config = config.inject({}) { |c,(k,v)| c[k.gsub("-", "_").to_sym] = v; c }
+        # load_processes(config[:monitor]) if config.has_key?(:monitor)
+        Kernel.load(config_file)
+      end
+
+      def monitor(process_name = nil, attributes = {}, &block)
+        process = Cognizant::Process.new(process_name, attributes, &block)
+        self.processes[process_name] = process
+        process.monitor
+      end
+
+      # Stops the TCP server and the tick loop, and performs cleanup.
+      def shutdown
+        log.info "Shutting down cognizantd..."
+
+        EventMachine.next_tick do
+          EventMachine.stop
+          logger.close
+        end
+      end
+
+      private
+
+      def load_processes(processes_to_load)
+        if processes_to_load
+          processes_to_load.each do |name, attributes|
+            monitor(name, attributes)
+          end
+        end
+      end
+
+      # Starts the TCP server with the set socket lock file or port.
+      def start_interface_server
+        if port = @port
+          log.info "Starting the TCP server at #{@port}..."
+          host = "127.0.0.1"
+          splitted = port.to_s.split(":")
+          host, port = splitted if splitted.size > 1
+          EventMachine.start_server(host, port, Server::Interface)
+        else  
+          log.info "Starting the UNIX domain server with socket #{@socket}..."
+          EventMachine.start_unix_domain_server(@socket, Server::Interface)
+        end
+      end
+
+      # Starts the loop that defines the time window for determining and acting upon process states.
+      def start_periodic_ticks
+        log.info "Starting the periodic tick..."
+        EventMachine.add_periodic_timer(1) do
+          self.processes.each do |group, process|
+            process.tick
+          end
+        end
+      end
+
+      def setup_prerequisites
+        # Create the require directories.
+        [File.dirname(@pidfile), File.dirname(@logfile), @pids_dir, @logs_dir, File.dirname(@socket)].each do |directory|
+          FileUtils.mkdir_p(directory)
+        end
+
+        # Setup logging.
+        add_log_adapter(File.open(@logfile, "a"))
+        add_log_adapter($stdout) unless @daemonize
+        log.level = if @trace then Logger::DEBUG else @loglevel end
+      end
+
+      def trap_signals
+        terminator = Proc.new do
+          log.info "Received signal to shutdown."
+          shutdown
+        end
+
+        Signal.trap('TERM', &terminator)
+        Signal.trap('INT',  &terminator)
+        Signal.trap('QUIT', &terminator)
+      end
+
+      # Daemonize the current process and save it pid in a file.
+      def daemonize
+        if @daemonize
+          log.info "Daemonizing into the background..."
+          ::Process.daemon
+
+          pid = ::Process.pid
+
+          if @pidfile
+            log.info "Writing the daemon pid (#{pid}) to the pidfile..."
+            File.open(@pidfile, "w") { |f| f.write(pid) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cognizant/server/interface.rb

@@ -0,0 +1,60 @@
+require "json"
+require "eventmachine"
+
+require "cognizant/server/commands"
+
+module Cognizant
+  module Server
+    class Interface < EventMachine::Connection
+      def post_init
+        # puts "-- someone connected to the server!"
+      end
+
+      def receive_data(args)
+        args = [*args.split]
+        command = args.shift.to_s.strip.downcase
+        if command.size > 0
+          begin
+            Commands.send(command, *args) do |response|
+              send_data "#{response.to_json}\r\n\r\n"
+            end
+          rescue => e
+            send_data "#{e.inspect.to_json}\r\n\r\n"
+          end
+        end
+        # close_connection_after_writing
+      end
+
+      def unbind
+        # puts "-- someone disconnected from the server!"
+      end
+    end
+  end
+end
+
+# module Cognizant
+#   module Server
+#     class Interface < EventMachine::Connection
+#       include EventMachine::Protocols::ObjectProtocol
+#       # include EventMachine::Protocols::SASLauth
+# 
+#       def post_init
+#         @obj = Hash.new
+#         puts "-- someone connected to the echo server!"
+#       end
+# 
+#       def receive_object(method)
+#         send_object @obj.send(*method)
+#       end
+# 
+#       def unbind
+#         @obj = nil
+#         puts "-- someone disconnected from the echo server!"
+#       end
+# 
+#       # def validate(usr, psw, sys, realm)
+#       #   usr == TestUser and psw == TestPsw
+#       # end
+#     end
+#   end
+# end

data/lib/cognizant/server.rb

@@ -0,0 +1,14 @@
+require "cognizant/server/daemon"
+
+module Cognizant
+  module Server
+    def self.start(options = {})
+      @daemon = Cognizant::Server::Daemon.new(options)
+      @daemon.bootup
+    end
+
+    def self.daemon
+      @daemon
+    end
+  end
+end

data/lib/cognizant/validations.rb

@@ -0,0 +1,142 @@
+module Cognizant
+  module Validations
+    class ValidationError < StandardError; end
+
+    # Validations the user/group ownership to the given file. Attempts to
+    # create the directory+file if it doesn't already exist.
+    # @param [String] file Path to a file
+    def self.validate_file_writable(file, type = "file")
+      file = File.expand_path(file)
+
+      begin
+        filetype = File.ftype(file)
+
+        unless filetype.eql?(type)
+          raise ValidationError, "\"#{file}\" is a #{filetype}. File required."
+        end
+      rescue Errno::ENOENT
+        self.validate_directory_writable(File.dirname(file))
+
+        begin
+          unless File.open(file, "w")
+            raise ValidationError, "The file \"#{file}\" is not writable."
+          end
+        rescue Errno::EACCES
+          raise ValidationError, "The file \"#{file}\" could not be created due to the lack of privileges."
+        end
+      end
+
+      unless File.owned?(file) or File.grpowned?(file)
+        raise ValidationError, "The file \"#{file}\" is not owned by the process user."
+      end
+
+      begin
+        unless File.open(file, "w")
+          raise ValidationError, "The file \"#{file}\" is not writable."
+        end  
+      rescue Errno::EACCES
+        raise ValidationError, "The file \"#{file}\" is not accessible due to the lack of privileges."
+      rescue
+        raise ValidationError, "The file \"#{file}\" is not writable."
+      end
+    end
+
+    # Validations the user/group ownership to the given directory. Attempts to
+    # create the directory if it doesn't already exist.
+    # @param [String] directory Path to a directory
+    def self.validate_directory_writable(directory)
+      directory = File.expand_path(directory)
+
+      begin
+        filetype = File.ftype(directory)
+
+        unless filetype.eql?("directory")
+          raise ValidationError, "\"#{directory}\" is a #{filetype}. Directory required."
+        end
+      rescue Errno::ENOENT
+        begin
+          FileUtils.mkdir_p(directory)
+        rescue Errno::EACCES
+          raise ValidationError, "The directory \"#{directory}\" could not be created due to the lack of privileges."
+        end
+      end
+
+      unless File.owned?(directory) or File.grpowned?(directory)
+        raise ValidationError, "The directory \"#{directory}\" is not owned by the process user."
+      end
+
+      begin
+        unless File.open(File.join(directory, ".testfile"), "w")
+          raise ValidationError, "The directory \"#{directory}\" is not writable."
+        end  
+      rescue Errno::EACCES
+        raise ValidationError, "The directory \"#{directory}\" is not accessible due to the lack of privileges."
+      rescue
+        raise ValidationError, "The directory \"#{directory}\" is not writable."
+      ensure
+        File.delete(directory, ".testfile") rescue nil
+      end
+    end
+
+    # Validates the inclusion of a value in an array.
+    # @param [Object] value The value to validate.
+    # @param [Array] array The array of allowed values.
+    def self.validate_includes(value, array)
+      unless [*array].include?(value)
+        raise ValidationError, "#{value} is an invalid option type. It must be one of the following: #{[*array].join(', ')}."
+      end
+    end
+
+    # Validates the env variable to be a hash.
+    # @param [Object] env The value to validate.
+    def self.validate_env(env)
+      return unless env
+      if not env.respond_to?(:is_a?) or not env.is_a?(Hash)
+        raise Validations::ValidationError, %{"env" needs to be a hash. e.g. { "PATH" => "/usr/local/bin" }}
+      end
+    end
+
+    # Validates the umask variable to be a number.
+    # @param [Object] umask The value to validate.
+    def self.validate_umask(umask)
+      return unless umask
+      Float(umask) rescue raise Validations::ValidationError, %{The umask "#{umask}" is invalid.}
+    end
+
+    # Validates the existence of the user in the system.
+    # @param [String, Integer] user The user ID or name to validate.
+    def self.validate_user(user)
+      return unless user
+      begin
+        if self.is_number?(user)
+          Etc.getpwuid(user)
+        else
+          Etc.getpwnam(user)
+        end
+      rescue ArgumentError
+        raise Validations::ValidationError, %{The user "#{user}" does not exist.}
+      end
+    end
+    
+    # Validates the existence of the user group in the system.
+    # @param [String, Integer] group The user group ID or name to validate.
+    def self.validate_user_group(group)
+      return unless group
+      begin
+        if self.is_number?(group)
+          Etc.getgrgid(group)
+        else
+          Etc.getgrname(group)
+        end
+      rescue ArgumentError
+        raise Validations::ValidationError, %{The group "#{group}" does not exist.}
+      end
+    end
+
+    private
+
+    def self.is_number?(value)
+      true if Float(value) rescue false
+    end
+  end
+end

data/lib/cognizant/version.rb

@@ -0,0 +1,3 @@
+module Cognizant
+  VERSION = "0.0.1"
+end

data/lib/cognizant.rb

@@ -0,0 +1,7 @@
+require "cognizant/server"
+
+module Cognizant
+  def self.monitor(process_name, &block)
+    Cognizant::Server.daemon.monitor(process_name, &block)
+  end
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: cognizant
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gurpartap Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Process monitoring and management framework
+email:
+- contact@gurpartap.com
+executables:
+- cognizant
+- cognizantd
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/cognizant
+- bin/cognizantd
+- cognizant.gemspec
+- examples/cognizantd.yml
+- examples/redis-server.rb
+- examples/resque.rb
+- images/logo-small.png
+- images/logo.png
+- images/logo.pxm
+- lib/cognizant.rb
+- lib/cognizant/client/cli.rb
+- lib/cognizant/client/interface.rb
+- lib/cognizant/logging.rb
+- lib/cognizant/process.rb
+- lib/cognizant/process/actions.rb
+- lib/cognizant/process/actions/restart.rb
+- lib/cognizant/process/actions/start.rb
+- lib/cognizant/process/actions/stop.rb
+- lib/cognizant/process/attributes.rb
+- lib/cognizant/process/execution.rb
+- lib/cognizant/process/pid.rb
+- lib/cognizant/process/status.rb
+- lib/cognizant/server.rb
+- lib/cognizant/server/commands.rb
+- lib/cognizant/server/daemon.rb
+- lib/cognizant/server/interface.rb
+- lib/cognizant/validations.rb
+- lib/cognizant/version.rb
+homepage: http://gurpartap.github.com/cognizant/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2933141880858945843
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2933141880858945843
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Cognizant is an advanced and efficient process monitoring and management
+  framework.
+test_files: []
+has_rdoc: