eye 0.5.2 → 0.6

data/lib/eye/dsl/pure_opts.rb

@@ -79,7 +79,7 @@ class Eye::Dsl::PureOpts
     self.instance_eval(&block) if cond && block
   end
 
-  def include(proc, *args)
+  def use(proc, *args)
     if proc.is_a?(String)
       self.class.with_parsed_file(proc) do |path|
         if File.exists?(path)

data/lib/eye/dsl/validation.rb

@@ -25,16 +25,31 @@ module Eye::Dsl::Validation
 
       validates[param] = types
       should_bes << param if should_be
-      defaults[param] = default
+      param_default(param, default)
       variants[param] = _variants
 
       return if param == :do
 
       define_method "#{param}" do
-        @options[param] || default
+        value = @options[param]
+        value.nil? ? default : value
       end
     end
 
+    def param_default(param, default)
+      param = param.to_sym
+      defaults[param] = default
+    end
+
+    def del_param(param)
+      param = param.to_sym
+      validates.delete(param)
+      should_bes.delete(param)
+      defaults.delete(param)
+      variants.delete(param)
+      remove_method(param)
+    end
+
     def validate(options = {})
       options.each do |param, value|
         param = param.to_sym

data/lib/eye/local.rb

@@ -1,71 +1,100 @@
 require 'fileutils'
 
 module Eye::Local
-  module_function
+  class << self
+    def dir
+      @dir ||= begin
+        if root?
+        '/var/run/eye'
+        else
+          File.expand_path(File.join(home, '.eye'))
+        end
+      end
+    end
 
-  def dir
-    if root?
-      '/var/run/eye'
-    else
-      File.expand_path(File.join(home, '.eye'))
+    def dir=(d)
+      @dir = d
     end
-  end
 
-  def eyeconfig
-    if root?
-      '/etc/eye.conf'
-    else
-      File.expand_path(File.join(home, '.eyeconfig'))
+    def eyeconfig
+      if root?
+        '/etc/eye.conf'
+      else
+        File.expand_path(File.join(home, '.eyeconfig'))
+      end
     end
-  end
 
-  def root?
-    Process::UID.eid == 0
-  end
+    def root?
+      Process::UID.eid == 0
+    end
 
-  def home
-    h = ENV['EYE_HOME'] || ENV['HOME']
-    raise "HOME undefined, should be HOME or EYE_HOME environment" unless h
-    h
-  end
+    def home
+      h = ENV['EYE_HOME'] || ENV['HOME']
+      raise "HOME undefined, should be HOME or EYE_HOME environment" unless h
+      h
+    end
 
-  def path(path)
-    File.join(dir, path)
-  end
+    def path(path)
+      File.join(dir, path)
+    end
 
-  def ensure_eye_dir
-    FileUtils.mkdir_p( dir )
-  end
+    def ensure_eye_dir
+      FileUtils.mkdir_p( dir )
+    end
 
-  def socket_path
-    path(ENV['EYE_SOCK'] || "sock#{ENV['EYE_V']}")
-  end
+    def socket_path
+      path(ENV['EYE_SOCK'] || "sock#{ENV['EYE_V']}")
+    end
 
-  def pid_path
-    path(ENV['EYE_PID'] || "pid#{ENV['EYE_V']}")
-  end
+    def pid_path
+      path(ENV['EYE_PID'] || "pid#{ENV['EYE_V']}")
+    end
 
-  def cache_path
-    path("processes#{ENV['EYE_V']}.cache")
-  end
+    def cache_path
+      path("processes#{ENV['EYE_V']}.cache")
+    end
 
-  def client_timeout
-    5
-  end
+    def client_timeout
+      @client_timeout ||= 5
+    end
 
-  def supported_setsid?
-    RUBY_VERSION >= '2.0'
-  end
+    def client_timeout=(cl)
+      @client_timeout = cl
+    end
 
-  def host
-    @host ||= begin
-      require 'socket'
-      Socket.gethostname
+    def supported_setsid?
+      RUBY_VERSION >= '2.0'
     end
-  end
 
-  def host=(hostname)
-    @host = hostname
-  end
+    def host
+      @host ||= begin
+        require 'socket'
+        Socket.gethostname
+      end
+    end
+
+    def host=(hostname)
+      @host = hostname
+    end
+
+    def eyefile
+      @eyefile ||= find_eyefile('.')
+    end
+
+    def find_eyefile(start_from_dir)
+      fromenv = ENV['EYEFILE']
+      return fromenv if fromenv && !fromenv.empty? && File.exist?(fromenv)
 
+      previous = nil
+      current  = File.expand_path(start_from_dir)
+
+      until !File.directory?(current) || current == previous
+        filename = File.join(current, 'Eyefile')
+        return filename if File.file?(filename)
+        current, previous = File.expand_path('..', current), current
+      end
+    end
+
+    attr_accessor :local_runner
+  end
 end

data/lib/eye/notify.rb

@@ -1,3 +1,5 @@
+require 'celluloid'
+
 class Eye::Notify
   include Celluloid
   include Eye::Dsl::Validation
@@ -10,7 +12,7 @@ class Eye::Notify
   def self.get_class(type)
     klass = eval("Eye::Notify::#{TYPES[type]}") rescue nil
     raise "unknown notifier :#{type}" unless klass
-    if deps = klass.depends_on
+    if deps = klass.requires
       Array(deps).each { |d| require d }
     end
     klass
@@ -48,7 +50,7 @@ class Eye::Notify
     log_ex(ex)
   end
 
-  TIMEOUT = 1.minute
+  TIMEOUT = 1 * 60
 
   def initialize(options = {}, message_h = {})
     @message_h = message_h
@@ -95,7 +97,7 @@ class Eye::Notify
     Eye::Dsl::ConfigOpts.add_notify(type)
   end
 
-  def self.depends_on
+  def self.requires
   end
 
   class Custom < Eye::Notify

data/lib/eye/notify/mail.rb

@@ -15,6 +15,8 @@ class Eye::Notify::Mail < Eye::Notify
   param :password, String
   param :auth, Symbol, nil, nil, [:plain, :login, :cram_md5]
 
+  param :starttls, [TrueClass, FalseClass]
+
   param :from_mail, String
   param :from_name, String, nil, 'eye'
 
@@ -25,9 +27,11 @@ class Eye::Notify::Mail < Eye::Notify
   def smtp
     args = [host, port, domain, user, password, auth]
     debug "called smtp with #{args}"
+    smtp = Net::SMTP.new host, port
+    smtp.enable_starttls if starttls
 
-    Net::SMTP.start(*args) do |smtp|
-      smtp.send_message(message, from_mail || user, contact)
+    smtp.start(domain, user, password, auth) do |s|
+      s.send_message(message, from_mail || user, contact)
     end
   end
 

data/lib/eye/process.rb

@@ -18,7 +18,8 @@ class Eye::Process
   autoload :Validate,         'eye/process/validate'
 
   attr_accessor :pid, :watchers, :config, :states_history,
-                :children, :triggers, :name, :state_reason, :flapping_times
+                :children, :triggers, :name, :state_reason, :flapping_times,
+                :parent_pid
 
   def initialize(config)
     raise 'you must supply a pid_file location' unless config[:pid_file]
@@ -29,6 +30,7 @@ class Eye::Process
     @children = {}
     @triggers = []
     @name = @config[:name]
+
     @flapping_times = 0
 
     @states_history = Eye::Process::StatesHistory.new(100)

data/lib/eye/process/children.rb

@@ -31,7 +31,7 @@ module Eye::Process::Children
 
     if new_children.present?
       new_children.each do |child_pid|
-        self.children[child_pid] = Eye::ChildProcess.new(child_pid, self[:monitor_children], logger.prefix)
+        self.children[child_pid] = Eye::ChildProcess.new(child_pid, self[:monitor_children], logger.prefix, self.pid)
       end
     end
 

data/lib/eye/process/commands.rb

@@ -31,7 +31,7 @@ module Eye::Process::Commands
 
     result
 
-  rescue StateMachine::InvalidTransition => e
+  rescue StateMachine::InvalidTransition, Eye::Process::StateError => e
     warn "wrong switch '#{e.message}'"
 
     :state_error
@@ -58,7 +58,7 @@ module Eye::Process::Commands
       true
     end
 
-  rescue StateMachine::InvalidTransition => e
+  rescue StateMachine::InvalidTransition, Eye::Process::StateError => e
     warn "wrong switch '#{e.message}'"
     nil
   end
@@ -80,7 +80,7 @@ module Eye::Process::Commands
 
     true
 
-  rescue StateMachine::InvalidTransition => e
+  rescue StateMachine::InvalidTransition, Eye::Process::StateError => e
     warn "wrong switch '#{e.message}'"
     nil
   end
@@ -173,7 +173,7 @@ private
     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]}, <#{res[:pid]}>"
+    info "daemonizing: `#{self[:start_command]}` with start_grace: #{self[:start_grace].to_f}s, env: '#{environment_string}', <#{res[:pid]}> (in #{self[:working_dir]})"
 
     if res[:error]
 
@@ -200,7 +200,18 @@ private
       return {:error => :not_really_running}
     end
 
-    unless failsafe_save_pid
+    # if we using leaf child stratedy, pid should be used as last child process
+    if self[:use_leaf_child]
+      if lpid = Eye::SystemResources.leaf_child(self.pid)
+        info "leaf child for <#{self.pid}> found: <#{lpid}>, accepting it!"
+        self.parent_pid = self.pid
+        self.pid = lpid
+      else
+        warn "leaf child not found for <#{self.pid}>, skipping it"
+      end
+    end
+
+    if control_pid? && !failsafe_save_pid
       return {:error => :cant_write_pid}
     end
 
@@ -208,7 +219,7 @@ private
   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]}"
+    info "executing: `#{self[:start_command]}` with start_timeout: #{config[:start_timeout].to_f}s, start_grace: #{self[:start_grace].to_f}s, env: '#{environment_string}' (in #{self[:working_dir]})"
     time_before = Time.now
 
     res = execute(self[:start_command], config.merge(:timeout => config[:start_timeout]))

data/lib/eye/process/config.rb

@@ -16,7 +16,10 @@ module Eye::Process::Config
     :auto_start => true, # auto start on monitor action
 
     :children_update_period => 30.seconds,
-    :clear_pid => true # by default clear pid on stop
+    :clear_pid => true, # by default clear pid on stop
+
+    :auto_update_pidfile_grace => 30.seconds,
+    :revert_fuckup_pidfile_grace => 120.seconds,
   }
 
   def prepare_config(new_config)
@@ -35,6 +38,8 @@ module Eye::Process::Config
     h[:stdout] = Eye::System.normalized_file(h[:stdout], h[:working_dir]) if h[:stdout]
     h[:stderr] = Eye::System.normalized_file(h[:stderr], h[:working_dir]) if h[:stderr]
 
+    h[:environment] = Eye::System.prepare_env(h)
+
     h
   end
 

data/lib/eye/process/data.rb

@@ -12,6 +12,10 @@ module Eye::Process::Data
     (self[:group] == '__default__') ? nil : self[:group]
   end
 
+  def group_name_pure
+    self[:group]
+  end
+
   def full_name
     @full_name ||= [app_name, group_name, self[:name]].compact.join(':')
   end
@@ -55,4 +59,20 @@ module Eye::Process::Data
     false
   end
 
+  def environment_string
+    s = []
+    @config[:environment].each { |k, v| s << "#{k}=#{v}" }
+    s * ' '
+  end
+
+  def shell_string(dir = true)
+    str = ''
+    str += "cd #{self[:working_dir]} && " if dir
+    str += environment_string
+    str += ' '
+    str += self[:start_command]
+    str += ' &' if self[:daemonize]
+    str
+  end
+
 end

data/lib/eye/process/monitor.rb

@@ -31,8 +31,6 @@ private
     end
   end
 
-  REWRITE_FACKUP_PIDFILE_PERIOD = 2.minutes
-
   def check_alive
     if up?
 
@@ -55,16 +53,24 @@ private
               msg += ", pid_file write failed! O_o"
             end
           else
+            changed_ago_s = Time.now - pid_file_ctime
+
             if ppid == nil
               msg += ", reverting to <#{self.pid}> (the pid_file is empty)"
               unless failsafe_save_pid
                 msg += ", pid_file write failed! O_o"
               end
-            elsif (Time.now - pid_file_ctime > REWRITE_FACKUP_PIDFILE_PERIOD)
-              msg += " over #{REWRITE_FACKUP_PIDFILE_PERIOD}s ago, reverting to <#{self.pid}>"
+
+            elsif (changed_ago_s > self[:auto_update_pidfile_grace]) && process_pid_running?(ppid)
+              msg += ", trusting this change, and now monitor <#{ppid}>"
+              self.pid = ppid
+
+            elsif (changed_ago_s > self[:revert_fuckup_pidfile_grace])
+              msg += " over #{self[:revert_fuckup_pidfile_grace]}s ago, reverting to <#{self.pid}>, because <#{ppid}> not alive"
               unless failsafe_save_pid
                 msg += ", pid_file write failed! O_o"
               end
+
             else
               msg += ', ignoring self-managed pid change'
             end

data/lib/eye/process/states.rb

@@ -2,6 +2,7 @@ require 'state_machine'
 require 'state_machine/version'
 
 class Eye::Process
+  class StateError < Exception; end
 
   # do transition
   def switch(name, reason = nil)
@@ -76,8 +77,10 @@ class Eye::Process
   end
 
   def log_transition(transition)
-    @states_history.push transition.to_name, @state_reason
-    info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{@state_reason ? "(reason: #{@state_reason})" : nil}"
+    if transition.to_name != transition.from_name || @state_reason.is_a?(Eye::Reason::User)
+      @states_history.push transition.to_name, @state_reason
+      info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{@state_reason ? "(reason: #{@state_reason})" : nil}"
+    end
   end
 
 end