eye 0.8.1 → 0.9.pre

data/lib/eye/process/config.rb

@@ -24,7 +24,7 @@ module Eye::Process::Config
 
     auto_update_pidfile_grace: 30.seconds,
     revert_fuckup_pidfile_grace: 120.seconds
-  }
+  }.freeze
 
   def prepare_config(new_config)
     h = DEFAULTS.merge(new_config)
@@ -46,6 +46,7 @@ module Eye::Process::Config
     h[:stdall] = Eye::System.normalized_file(h[:stdall], h[:working_dir]) if h[:stdall]
 
     h[:environment] = Eye::System.prepare_env(h)
+    h[:stop_signals] = [:TERM, 0.5, :KILL] unless h[:stop_command] || h[:stop_signals]
 
     h
   end

data/lib/eye/process/controller.rb

@@ -1,8 +1,7 @@
 module Eye::Process::Controller
 
-  def send_command(command, *args)
-    schedule command, *args, Eye::Reason::User.new(command)
-  end
+  # scheduled actions
+  # :update_config, :start, :stop, :restart, :unmonitor, :monitor, :break_chain, :delete, :signal, :user_command
 
   def start
     if load_external_pid_file == :ok
@@ -26,12 +25,10 @@ module Eye::Process::Controller
   def monitor
     if self[:auto_start]
       start
+    elsif load_external_pid_file == :ok
+      switch :already_running
     else
-      if load_external_pid_file == :ok
-        switch :already_running
-      else
-        schedule :unmonitor, Eye::Reason.new(:'not found')
-      end
+      schedule command: :unmonitor, reason: 'not found'
     end
   end
 
@@ -62,8 +59,4 @@ module Eye::Process::Controller
     end
   end
 
-  def freeze
-    scheduler_freeze
-  end
-
 end

data/lib/eye/process/data.rb

@@ -9,7 +9,7 @@ module Eye::Process::Data
   end
 
   def group_name
-    (self[:group] == '__default__') ? nil : self[:group]
+    self[:group] == '__default__' ? nil : self[:group]
   end
 
   def group_name_pure
@@ -46,13 +46,21 @@ module Eye::Process::Data
 
     h[:debug] = debug_data if opts[:debug]
     h[:procline] = Eye::SystemResources.args(self.pid) if opts[:procline]
-    h[:current_command] = current_scheduled_command if current_scheduled_command
+    h[:current_command] = scheduler_current_command if scheduler_current_command
 
     h
   end
 
   def debug_data
-    { queue: scheduler_actions_list, watchers: @watchers.keys }
+    { queue: scheduler_actions_list, watchers: @watchers.keys, timers: timers_data }
+  end
+
+  def timers_data
+    if actor = Thread.current[:celluloid_actor]
+      actor.timers.timers.map(&:interval)
+    end
+  rescue
+    []
   end
 
   def sub_object?(obj)

data/lib/eye/process/monitor.rb

@@ -39,7 +39,7 @@ private
       notify :info, 'crashed!'
       clear_pid_file(true) if control_pid?
 
-      switch :crashed, Eye::Reason.new(:crashed)
+      switch :crashed, reason: :crashed
     end
   end
 
@@ -83,7 +83,7 @@ private
   def check_identity
     if compare_identity == :fail
       notify :info, 'crashed by identity!'
-      switch :crashed, Eye::Reason.new(:crashed_by_identity)
+      switch :crashed, reason: :crashed_by_identity
       clear_pid_file if self[:clear_pid]
       false
     else
@@ -101,13 +101,13 @@ private
       warn 'check crashed: process is down'
 
       if self[:restore_in]
-        schedule_in self[:restore_in].to_f, :restore, Eye::Reason.new(:crashed)
+        schedule in: self[:restore_in].to_f, command: :restore, reason: :crashed
       else
-        schedule :restore, Eye::Reason.new(:crashed)
+        schedule command: :restore, reason: :crashed
       end
     else
       warn 'check crashed: process without keep_alive'
-      schedule :unmonitor, Eye::Reason.new(:crashed)
+      schedule command: :unmonitor, reason: :crashed
     end
   end
 

data/lib/eye/process/notify.rb

@@ -5,7 +5,7 @@ module Eye::Process::Notify
   # 2) checker bounded to restart process [:warn]
   # 3) flapping + switch to unmonitored [:error]
 
-  LEVELS = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }
+  LEVELS = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 }.freeze
 
   def notify(level, msg)
     # logging it

data/lib/eye/process/scheduler.rb

@@ -1,11 +1,54 @@
 module Eye::Process::Scheduler
 
-  # ex: schedule :update_config, config, "reason: update_config"
-  def schedule(command, *args, &block)
-    return unless scheduler.alive?
+  # Call params:
+  # :command
+  # :args
+  # :by
+  # :reason
+  # :block
+  # :signal
+  # :at
+  # :in
+
+  # :update_config, :start, :stop, :restart, :unmonitor, :monitor, :break_chain, :delete, :signal, :user_command
+  def send_call(call)
+    user_schedule(call)
+  end
+
+  def user_schedule(call)
+    call[:by] ||= :user
+    internal_schedule(call)
+  end
+
+  # 2 Forms of schedule:
+  # schedule command: 'bla', args: [1, 2, 3]
+  # schedule :bla, 1, 2, 3
+  def schedule(*args)
+    if args[0].is_a?(Hash)
+      internal_schedule(args[0])
+    else
+      internal_schedule(command: args[0], args: args[1..-1])
+    end
+  end
+
+  def internal_schedule(call)
+    if interval = call[:in]
+      debug { "schedule_in #{interval} :#{call[:command]}" }
+      after(interval.to_f) do
+        debug { "scheduled_in #{interval} :#{call[:command]}" }
+        call[:in] = nil
+        internal_schedule(call)
+      end
+      return
+    end
+
+    call[:at] ||= Time.now.to_i
+    command = call[:command]
+
+    @scheduler_freeze = false if call[:freeze] == false
 
-    if scheduler_freeze?
-      warn ":#{command} ignoring to schedule, because scheduler is freeze"
+    if @scheduler_freeze
+      warn ":#{command} ignoring to schedule, because scheduler is freezed"
       return
     end
 
@@ -14,95 +57,107 @@ module Eye::Process::Scheduler
       return
     end
 
-    reason = args.pop if args.present? && args[-1].is_a?(Eye::Reason)
-
-    info "schedule :#{command} #{reason ? "(reason: #{reason})" : nil}"
-
-    if reason.class == Eye::Reason
-      # for auto reasons
-      # skip already running commands and all in chain
-      scheduler.add_wo_dups_current(:scheduled_action, command, args: args, reason: reason, block: block)
+    if filter_call(call)
+      info "schedule :#{command} (#{reason_from_call(call)})"
+      scheduler_add(call)
     else
-      # for manual, or without reason
-      # skip only for last in chain
-      scheduler.add_wo_dups(:scheduled_action, command, args: args, reason: reason, block: block)
+      info "not scheduled: #{command} (#{reason_from_call(call)})"
     end
-  end
 
-  def schedule_in(interval, command, *args, &block)
-    debug { "schedule_in #{interval} :#{command} #{args}" }
-    after(interval.to_f) do
-      debug { "scheduled_in #{interval} :#{command} #{args}" }
-      schedule(command, *args, &block)
-    end
+    @scheduler_freeze = true if call[:freeze] == true
   end
 
-  def scheduled_action(command, h = {})
-    reason = h[:reason]
-    info "=> #{command} #{h[:args].present? ? "#{h[:args] * ','}" : nil} #{reason ? "(reason: #{reason})" : nil}"
+  def scheduler_consume(call)
+    args = call[:args]
+    reason_str = reason_from_call(call)
+    info "=> #{call[:command]} #{args.present? ? args.join(',') : nil} (#{reason_str})"
+    send(call[:command], *args, &call[:block])
 
-    @current_scheduled_command = command
-    @last_scheduled_command = command
-    @last_scheduled_reason = reason
-    @last_scheduled_at = Time.now
+    history_cmd = is_a?(Eye::ChildProcess) ? "#{call[:command]}_child" : call[:command]
+    scheduler_history.push(history_cmd, reason_str, call[:at])
 
-    send(command, *h[:args], &h[:block])
-    @current_scheduled_command = nil
-    info "<= #{command}"
+  rescue Object => ex
+    raise(ex) if ex.class == Celluloid::TaskTerminated
+    log_ex(ex)
 
-    schedule_history.push(command, reason, @last_scheduled_at.to_i)
+  ensure
+    # signaling to waiter
+    call[:signal].try :signal
 
-    if parent = self.try(:parent)
-      parent.schedule_history.push("#{command}_child", reason, @last_scheduled_at.to_i)
-    end
+    info "<= #{call[:command]}"
   end
 
-  def execute_proc(*_args, &block)
-    self.instance_exec(&block)
-  rescue Object => ex
-    log_ex(ex)
+  def filter_call(call)
+    # for auto reasons, compare call with current @scheduled_call
+    return false if call[:by] != :user && equal_action_call?(@scheduled_call, call)
+
+    # check any equal call in queue scheduler_calls
+    !scheduler_calls.any? { |c| equal_action_call?(c, call) }
   end
 
-  def scheduler_actions_list
-    scheduler.list.map { |c| c[:args].first rescue nil }.compact
+  def equal_action_call?(call1, call2)
+    call1 && call2 && (call1[:command] == call2[:command]) && (call1[:args] == call2[:args]) && (call1[:block] == call2[:block])
   end
 
-  def scheduler_clear_pending_list
-    scheduler.clear_pending_list
+  def scheduler_calls
+    @scheduler_calls ||= []
   end
 
-  def self.included(base)
-    base.finalizer :remove_scheduler
-    base.execute_block_on_receiver :schedule
+  def scheduler_history
+    @scheduler_history ||= Eye::Process::StatesHistory.new(50)
   end
 
-  attr_accessor :current_scheduled_command
-  attr_accessor :last_scheduled_command, :last_scheduled_reason, :last_scheduled_at
+  def scheduler_add(call)
+    scheduler_calls << call
+    ensure_scheduler_process
+  end
 
-  def schedule_history
-    @schedule_history ||= Eye::Process::StatesHistory.new(50)
+  def ensure_scheduler_process
+    unless @scheduler_running
+      @scheduler_running = true
+      async.scheduler_run
+    end
   end
 
-  def scheduler_freeze
-    @scheduler_freeze = true
+  def scheduler_run
+    while @scheduled_call = scheduler_calls.shift
+      @scheduler_running = true
+      @last_scheduled_call = @scheduled_call
+      scheduler_consume(@scheduled_call)
+    end
+    @scheduler_running = false
   end
 
-  def scheduler_unfreeze
-    @scheduler_freeze = nil
+  def scheduler_commands_list
+    scheduler_calls.map { |c| c[:command] }
   end
 
-  def scheduler_freeze?
-    @scheduler_freeze
+  def scheduler_clear_pending_list
+    scheduler_calls.clear
   end
 
-private
+  def scheduler_last_command
+    @last_scheduled_call.try :[], :command
+  end
+
+  def scheduler_last_reason
+    reason_from_call(@last_scheduled_call)
+  end
 
-  def remove_scheduler
-    @scheduler.terminate if @scheduler && @scheduler.alive?
+  def scheduler_current_command
+    @scheduled_call.try :[], :command
   end
 
-  def scheduler
-    @scheduler ||= Eye::Utils::CelluloidChain.new(current_actor)
+private
+
+  def reason_from_call(call)
+    return unless call
+
+    if msg = call[:reason]
+      msg.to_s
+    elsif call[:by]
+      "#{call[:command]} by #{call[:by]}"
+    end
   end
 
 end

data/lib/eye/process/states.rb

@@ -1,13 +1,13 @@
-require 'state_machine'
-require 'state_machine/version'
+require 'state_machines'
+require 'state_machines/version'
 
 class Eye::Process
 
-  class StateError < Exception; end
+  class StateError < RuntimeError; end
 
   # do transition
-  def switch(name, reason = nil)
-    @state_reason = reason || last_scheduled_reason
+  def switch(name, call = {})
+    @state_call = @last_scheduled_call ? @last_scheduled_call.merge(call) : call
     self.send("#{name}!")
   end
 
@@ -71,7 +71,7 @@ class Eye::Process
 
   def on_crashed
     self.pid = nil
-    schedule :check_crash, Eye::Reason.new(:crashed)
+    schedule command: :check_crash, reason: :crashed
   end
 
   def on_unmonitored
@@ -79,9 +79,10 @@ class Eye::Process
   end
 
   def log_transition(transition)
-    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}] #{"(reason: #{@state_reason})" if @state_reason}"
+    if transition.to_name != transition.from_name || @state_call[:by] == :user
+      reason_str = reason_from_call(@state_call)
+      @states_history.push transition.to_name, reason_str
+      info "switch :#{transition.event} [:#{transition.from_name} => :#{transition.to_name}] #{reason_str}"
     end
   end
 

data/lib/eye/process/states_history.rb

@@ -13,7 +13,7 @@ class Eye::Process::StatesHistory < Eye::Utils::Tail
     tm = [tm, from_time].max if from_time
     tm = tm.to_f
     if block
-      self.each { |s| block.call(s) if s[:at] >= tm }
+      self.each { |s| yield(s) if s[:at] >= tm }
     else
       self.select { |s| s[:at] >= tm }.map { |c| c[:state] }
     end

data/lib/eye/process/system.rb

@@ -48,7 +48,7 @@ module Eye::Process::System
     if (id1 - st1).abs > self[:check_identity_grace]
       args = Eye::SystemResources.args(pid)
       msg = "pid_file: '#{Eye::Utils.human_time2(id)}', process: '#{Eye::Utils.human_time2(st)}' (#{args})"
-      res = (id1 < st1) ? :fail : :touched
+      res = id1 < st1 ? :fail : :touched
       warn "compare_identity: #{res}, #{msg}"
       res
     else

data/lib/eye/process/trigger.rb

@@ -9,7 +9,7 @@ module Eye::Process::Trigger
   end
 
   def check_triggers(transition)
-    self.triggers.each { |trigger| trigger.notify(transition, state_reason) }
+    self.triggers.each { |trigger| trigger.notify(transition, @state_call) }
   end
 
   # conditional start, used in triggers, to start only from unmonitored state, and only if special reason
@@ -19,9 +19,10 @@ module Eye::Process::Trigger
       return
     end
 
-    previous_reason = state_reason
-    if last_scheduled_reason && previous_reason && last_scheduled_reason.class != previous_reason.class
-      warn "skip, last_scheduled_reason(#{last_scheduled_reason.inspect}) != previous_reason(#{previous_reason})"
+    state_by = @state_call.try(:[], :by)
+    current_by = @scheduled_call.try(:[], :by)
+    if state_by && current_by && state_by != current_by
+      warn "skip, state_by(#{state_by}) != current_by(#{current_by})"
       return
     end
 

data/lib/eye/process/validate.rb

@@ -3,7 +3,7 @@ require 'etc'
 
 module Eye::Process::Validate
 
-  class Error < Exception; end
+  class Error < RuntimeError; end
 
   def validate(config, localize = true)
     if (str = config[:start_command])