eye 0.1.11

data/lib/eye/io/unix_server.rb

@@ -0,0 +1,44 @@
+require 'socket'
+
+module Celluloid
+  module IO
+    # UNIXServer with combined blocking and evented support
+    class UNIXServer
+      extend Forwardable
+      def_delegators :@server, :listen, :sysaccept, :close, :closed?
+
+      def self.open(socket_path)
+        self.new(socket_path)
+      end
+
+      def initialize(socket_path)
+        @server = ::UNIXServer.new(socket_path)
+      end
+
+      def accept
+        actor = Thread.current[:actor]
+
+        if evented?
+          Celluloid.current_actor.wait_readable @server
+          accept_nonblock
+        else
+          Celluloid::IO::UNIXSocket.from_ruby_socket @server.accept
+        end
+      end
+
+      def accept_nonblock
+        Celluloid::IO::UNIXSocket.from_ruby_socket @server.accept_nonblock
+      end
+
+      def to_io
+        @server
+      end
+
+      # Are we inside a Celluloid ::IO actor?
+      def evented?
+        actor = Thread.current[:actor]
+        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
+      end
+    end
+  end
+end

data/lib/eye/io/unix_socket.rb

@@ -0,0 +1,39 @@
+require 'socket'
+
+module Celluloid
+  module IO
+    # UNIXSocket with combined blocking and evented support
+    class UNIXSocket
+      include CommonMethods
+      extend Forwardable
+
+      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?, :readline, :puts, :addr
+
+      # Convert a Ruby UNIXSocket into a Celluloid::IO::UNIXSocket
+      def self.from_ruby_socket(ruby_socket)
+        # Some hax here, but whatever ;)
+        socket = allocate
+        socket.instance_variable_set(:@socket, ruby_socket)
+        socket
+      end
+
+      # Open a UNIX connection.
+      def self.open(socket_path, &block)
+        self.new(socket_path, &block)
+      end
+
+      # Open a UNIX connection.
+      def initialize(socket_path, &block)
+        @socket = if block
+          ::UNIXSocket.open(socket_path, &block)
+        else
+          ::UNIXSocket.new(socket_path)
+        end
+      end
+
+      def to_io
+        @socket
+      end
+    end
+  end
+end

data/lib/eye/loader.rb

@@ -0,0 +1,13 @@
+# mini bundler, for embedded server gem installation
+
+gem 'celluloid',     '~> 0.12.0'
+gem 'celluloid-io',  '~> 0.12.0'
+gem 'nio4r'
+gem 'facter'
+gem 'timers'
+
+gem 'state_machine'
+gem 'activesupport', '~> 3.2.0'
+
+gem 'i18n' # for as
+gem 'multi_json' # for as

data/lib/eye/logger.rb

@@ -0,0 +1,80 @@
+require 'logger'
+
+class Eye::Logger
+  attr_accessor :prefix, :subprefix
+
+  class InnerLogger < Logger
+    FORMAT = '%d.%m.%Y %H:%M:%S'
+
+    def initialize(*args)
+      super
+
+      self.formatter = Proc.new do |s, d, p, m|
+        "#{d.strftime(FORMAT)} #{s.ljust(5)} -- #{m}\n"
+      end      
+    end
+  end
+
+  module Helpers
+    attr_reader :logger
+
+    Logger::Severity.constants.each do |level|
+      method_name = level.to_s.downcase
+      define_method method_name do |msg|
+        @logger.send(method_name, msg)
+      end
+    end
+  end
+
+  Logger::Severity.constants.each do |level|
+    method_name = level.to_s.downcase
+    define_method method_name do |msg|
+      self.class.inner_logger.send(method_name, "#{prefix_str}#{msg}")
+    end
+  end
+
+  def initialize(prefix = nil, subprefix = nil)
+    @prefix = prefix
+    @subprefix = subprefix
+  end
+
+  class << self
+    attr_reader :dev, :log_level
+
+    def link_logger(dev)
+      @dev = dev ? dev.to_s.downcase : nil
+      @dev_fd = @dev
+
+      @dev_fd = STDOUT if @dev == 'stdout'
+      @dev_fd = STDERR if @dev == 'stderr'
+      
+      @inner_logger = InnerLogger.new(@dev_fd)
+      @inner_logger.level = self.log_level || Logger::INFO
+    end
+
+    def log_level=(level)
+      @log_level = level
+      @inner_logger.level = self.log_level if @inner_logger
+    end
+
+    def inner_logger
+      @inner_logger ||= InnerLogger.new(nil)
+    end
+  end
+
+private
+
+  def prefix_str
+    @pref_string ||= begin
+      pref_string = ''
+
+      if @prefix
+        pref_string = "[#{@prefix}] "
+        pref_string += "#{@subprefix} " if @subprefix
+      end
+
+      pref_string
+    end
+  end
+
+end

data/lib/eye/process.rb

@@ -0,0 +1,83 @@
+require 'celluloid'
+
+class Eye::Process
+  include Celluloid
+  
+  autoload :Config,           'eye/process/config'
+  autoload :Commands,         'eye/process/commands'
+  autoload :Data,             'eye/process/data'
+  autoload :Watchers,         'eye/process/watchers'
+  autoload :Monitor,          'eye/process/monitor'
+  autoload :System,           'eye/process/system'
+  autoload :Controller,       'eye/process/controller'
+  autoload :StatesHistory,    'eye/process/states_history'
+  autoload :Child,            'eye/process/child'
+  autoload :Trigger,          'eye/process/trigger'
+  autoload :Notify,           'eye/process/notify'
+  autoload :Scheduler,        'eye/process/scheduler'
+
+  attr_accessor :pid, :watchers, :config, :states_history, 
+                :childs, :triggers, :flapping, :name
+  
+  def initialize(config)
+    raise 'pid file should be' unless config[:pid_file]
+
+    @config = prepare_config(config)
+    @logger = Eye::Logger.new(full_name)
+    
+    @watchers = {}
+    @childs = {}
+    @triggers = []
+    @flapping = false
+    @name = @config[:name]
+
+    @states_history = Eye::Process::StatesHistory.new(100)
+    @states_history << :unmonitored
+
+    debug "create with config: #{@config.inspect}"
+
+    add_triggers
+
+    super() # for statemachine
+  end
+
+  # c(), self[]  
+  include Eye::Process::Config
+  
+  # full_name, status_data
+  include Eye::Process::Data
+  
+  # commands:
+  # start_process, stop_process, restart_process
+  include Eye::Process::Commands
+
+  # start, stop, restart, monitor, unmonit, delete
+  include Eye::Process::Controller
+  
+  # add_watchers, remove_watchers:
+  include Eye::Process::Watchers
+  
+  # check alive, crush methods:
+  include Eye::Process::Monitor
+
+  # system methods:
+  include Eye::Process::System
+
+  # manage childs methods
+  include Eye::Process::Child
+
+  # manage triggers methods
+  include Eye::Process::Trigger
+
+  # manage notify methods
+  include Eye::Process::Notify
+
+  # logger methods
+  include Eye::Logger::Helpers
+
+  # scheduler
+  include Eye::Process::Scheduler
+end
+
+# include state_machine states
+require_relative 'process/states'

data/lib/eye/process/child.rb

@@ -0,0 +1,61 @@
+module Eye::Process::Child
+
+  def add_childs
+    add_or_update_childs
+  end
+
+  def add_or_update_childs
+    return unless self[:monitor_children]
+
+    return unless self.up?
+
+    unless self.pid
+      warn 'Cant add childs, because no pid'
+      return
+    end
+
+    now_childs = Eye::SystemResources.childs(self.pid)
+    new_childs = []
+    exist_childs = []
+
+    now_childs.each do |child_pid|
+      if self.childs[child_pid]
+        exist_childs << child_pid
+      else
+        new_childs << child_pid
+      end
+    end
+
+    removed_childs = self.childs.keys - now_childs
+
+    if new_childs.present?
+      new_childs.each do |child_pid|
+        self.childs[child_pid] = Eye::ChildProcess.new(child_pid, self[:monitor_children], logger.prefix)
+      end      
+    end
+
+    if removed_childs.present?
+      removed_childs.each do |child_pid|
+        child = self.childs.delete(child_pid)
+        child.delete if child && child.alive?
+      end      
+    end
+
+    h = {:new => new_childs.size, :removed => removed_childs.size, :exists => exist_childs.size }
+    debug "childs info: #{ h.inspect }"
+
+    h
+  end
+
+  def remove_childs
+    if childs.present?
+      childs.keys.each do |child_pid|
+        child = childs.delete(child_pid)
+        child.delete if child && child.alive?
+      end
+    else
+      debug 'No childs to clear'
+    end
+  end
+
+end

data/lib/eye/process/commands.rb

@@ -0,0 +1,256 @@
+module Eye::Process::Commands
+
+  def start_process
+    debug 'start_process command'
+
+    switch :starting
+
+    unless self[:start_command]
+      warn 'no start command, so unmonitoring'
+      switch :unmonitoring
+      return :no_start_command
+    end
+
+    result = self[:daemonize] ? daemonize_process : execute_process
+
+    if !result[:error]
+      debug "process (#{self.pid}) ok started"
+      switch :started
+    else
+      debug "process (#{self.pid}) failed to start (#{result[:error].inspect})"
+      if self.pid && Eye::System.pid_alive?(self.pid)
+        warn "kill, what remains from process (#{self.pid}), because its failed to start (without pid_file impossible to monitoring)"
+        send_signal(:KILL)
+        sleep 0.2 # little grace
+      end
+
+      self.pid = nil
+      switch :crushed
+    end
+
+    result
+
+  rescue StateMachine::InvalidTransition => e
+    warn "wrong switch '#{e.message}'"
+
+    :state_error
+  end
+  
+  def stop_process
+    debug 'stop_process command'
+
+    switch :stopping
+
+    kill_process
+
+    if process_realy_running?
+      warn 'NOT STOPPED, check command/signals, or tune stop_timeout/stop_grace, seems it was really soft'
+
+      switch :unmonitoring
+      nil
+
+    else
+      switch :stopped
+
+      if control_pid?
+        info "delete pid_file: #{self[:pid_file]}"
+        clear_pid_file 
+      end
+      
+      true
+
+    end
+
+  rescue StateMachine::InvalidTransition => e
+    warn "wrong switch '#{e.message}'"
+    nil
+  end
+
+  def restart_process
+    debug 'restart_process command'
+
+    switch :restarting
+
+    if self[:restart_command]
+      cmd = prepare_command(self[:restart_command])
+      info "executing: `#{cmd}` with restart_timeout: #{self[:restart_timeout].to_f}s and restart_grace: #{self[:restart_grace].to_f}s"
+
+      res = execute(cmd, config.merge(:timeout => self[:restart_timeout]))
+
+      if res[:error]
+        error "restart raised with #{res[:error].inspect}"
+
+        if res[:error].class == Timeout::Error
+          error 'you should tune restart_timeout setting'
+        end
+      end
+
+      sleep self[:restart_grace].to_f
+
+      result = check_alive_with_refresh_pid_if_needed
+      switch(result ? :restarted : :crushed)
+    else
+      stop_process
+      start_process
+    end
+
+    true
+
+  rescue StateMachine::InvalidTransition => e
+    warn "wrong switch '#{e.message}'"
+    nil
+  end
+
+private
+
+  def kill_process
+    return unless self.pid
+
+    if self[:stop_command]
+      cmd = prepare_command(self[:stop_command])
+      res = execute(cmd, config.merge(:timeout => self[:stop_timeout]))
+      info "executing: `#{cmd}` with stop_timeout: #{self[:stop_timeout].to_f}s and stop_grace: #{self[:stop_grace].to_f}s"
+
+      if res[:error]
+        error "raised with #{res[:error].inspect}"
+
+        if res[:error].class == Timeout::Error
+          error 'you should tune stop_timeout setting'
+        end
+      end
+
+      sleep self[:stop_grace].to_f
+
+    elsif self[:stop_signals]
+      info "executing signals `#{self[:stop_signals].inspect}`"
+      stop_signals = self[:stop_signals].clone
+
+      signal = stop_signals.shift
+      send_signal(signal)
+
+      while stop_signals.present?
+        delay = stop_signals.shift
+        signal = stop_signals.shift
+
+        sleep(delay.to_f)
+        unless process_realy_running?
+          info 'has terminated'
+          break
+        end
+
+        send_signal(signal)
+      end
+
+      sleep self[:stop_grace].to_f
+
+    else # default command
+      info "executing: `kill -TERM #{self.pid}` with stop_grace: #{self[:stop_grace].to_f}s"
+      send_signal(:TERM)
+      
+      sleep self[:stop_grace].to_f
+
+      # if process not die here, by default we kill it force
+      if process_realy_running?
+        warn "process not die after TERM and stop_grace #{self[:stop_grace].to_f}s, so send KILL"
+        send_signal(:KILL)
+        sleep 0.1 # little grace
+      end
+    end
+  end
+  
+  def daemonize_process
+    time_before = Time.now
+    res = Eye::System.daemonize(self[:start_command], config)
+    start_time = Time.now - time_before
+
+    info "daemonizing: `#{self[:start_command]}` with start_grace: #{self[:start_grace].to_f}s, env: #{self[:environment].inspect}, working_dir: #{self[:working_dir]}"
+    
+
+    if res[:error]
+      error "raised with #{res[:error].inspect}"
+
+      if res[:error].message == 'Permission denied - open'
+        error 'seems stdout/err/all files is not writable'
+      end
+
+      return {:error => res[:error].inspect}
+    end
+    
+    self.pid = res[:pid]
+
+    unless self.pid
+      error 'returned empty pid, WTF O_o'
+      return {:error => :empty_pid}
+    end
+
+    sleep self[:start_grace].to_f
+
+    unless process_realy_running?
+      error "process with pid (#{self.pid}) not found, may be crushed (#{check_logs_str})"
+      return {:error => :not_realy_running}
+    end
+
+    begin
+      save_pid_to_file
+    rescue => ex
+      error "save pid to file raised with #{ex.inspect}"
+      return {:error => :cant_write_pid}
+    end
+
+    res
+  end
+
+  def execute_process
+    info "executing: `#{self[:start_command]}` with start_timeout: #{config[:start_timeout].to_f}s, start_grace: #{self[:start_grace].to_f}s, env: #{self[:environment].inspect}, working_dir: #{self[:working_dir]}"
+    time_before = Time.now
+
+    res = execute(self[:start_command], config.merge(:timeout => config[:start_timeout]))
+    start_time = Time.now - time_before    
+
+    if res[:error]
+      error "raised with #{res[:error].inspect}"
+
+      if res[:error].message == 'Permission denied - open'
+        error 'seems stdout/err/all files is not writable'
+      end
+
+      if res[:error].class == Timeout::Error
+        error "try to increase start_timeout interval (current #{self[:start_timeout]} seems too small, for process self-daemonization)"
+      end
+
+      return {:error => res[:error].inspect}
+    end
+
+    sleep self[:start_grace].to_f
+
+    unless set_pid_from_file
+      error "pid_file(#{self[:pid_file]}) does not appears after start_grace #{self[:start_grace].to_f}, check start_command, or tune start_grace (eye dont know what to monitor without pid)"
+      return {:error => :pid_not_found}
+    end
+
+    unless process_realy_running?
+      error "process in pid_file(#{self[:pid_file]})(#{self.pid}) not found, maybe process do not write there actual pid, or just crushed (#{check_logs_str})"
+      return {:error => :not_realy_running}
+    end
+
+    res[:pid] = self.pid
+    res
+  end
+
+  def check_logs_str
+    if !self[:stdout] && !self[:stderr]
+      'maybe should add stdout/err/all logs'
+    else
+      "check also it stdout/err/all logs #{[self[:stdout], self[:stderr]].inspect}"
+    end    
+  end
+
+  def prepare_command(command)
+    if self.pid
+      command.to_s.gsub('{{PID}}', self.pid.to_s).gsub('{PID}', self.pid.to_s)
+    else
+      command
+    end
+  end
+
+end