eye 0.8.1 → 0.9.pre

data/lib/eye/dsl/process_opts.rb

@@ -7,13 +7,13 @@ class Eye::Dsl::ProcessOpts < Eye::Dsl::Opts
     Eye::Utils.deep_merge!(@config[:monitor_children], opts.config)
   end
 
-  alias_method :xmonitor_children, :nop
+  alias xmonitor_children nop
 
   def application
     parent.try(:parent)
   end
-  alias_method :app, :application
-  alias_method :group, :parent
+  alias app application
+  alias group parent
 
   def depend_on(names, opts = {})
     names = Array(names).map(&:to_s)

data/lib/eye/dsl/validation.rb

@@ -4,7 +4,7 @@ module Eye::Dsl::Validation
     base.extend(ClassMethods)
   end
 
-  class Error < Exception; end
+  class Error < RuntimeError; end
 
   module ClassMethods
 
@@ -43,7 +43,7 @@ module Eye::Dsl::Validation
 
       return if param == :do
 
-      define_method "#{param}" do
+      define_method param do
         value = @options[param]
         value.nil? ? self.class.defaults[param] : value
       end

data/lib/eye/group.rb

@@ -4,10 +4,14 @@ class Eye::Group
 
   include Celluloid
 
-  autoload :Chain, 'eye/group/chain'
+  autoload :Call,     'eye/group/call'
+  autoload :Chain,    'eye/group/chain'
+  autoload :Data,     'eye/group/data'
 
   include Eye::Process::Scheduler
+  include Eye::Group::Call
   include Eye::Group::Chain
+  include Eye::Group::Data
 
   attr_reader :processes, :name, :hidden, :config
 
@@ -31,11 +35,6 @@ class Eye::Group
     @full_name ||= "#{app_name}:#{@name}"
   end
 
-  def update_config(cfg)
-    @config = cfg
-    @full_name = nil
-  end
-
   def add_process(process)
     @processes << process
   end
@@ -45,99 +44,6 @@ class Eye::Group
     @processes = @processes.sort_by(&:name)
   end
 
-  def status_data(opts = {})
-    plist = @processes.map { |p| p.status_data(opts) }
-
-    h = { name: name, type: :group, subtree: plist }
-
-    h[:debug] = debug_data if opts[:debug]
-
-    # show current chain
-    if current_scheduled_command
-      h.update(current_command: current_scheduled_command)
-
-      if (chain_commands = scheduler_actions_list) && chain_commands.present?
-        h.update(chain_commands: chain_commands)
-      end
-
-      if @chain_processes_current && @chain_processes_count
-        h.update(chain_progress: [@chain_processes_current, @chain_processes_count])
-      end
-    end
-
-    h
-  end
-
-  def status_data_short
-    h = {}
-    @processes.each do |p|
-      state = p.state
-      h[state] ||= 0
-      h[state] += 1
-    end
-    { name: (@name == '__default__' ? 'default' : @name), type: :group, states: h }
-  end
-
-  def debug_data
-    { queue: scheduler_actions_list, chain: chain_status }
-  end
-
-  def send_command(command, *args)
-    info "send_command: #{command}"
-
-    case command
-      when :delete
-        delete(*args)
-      when :break_chain
-        break_chain(*args)
-      else
-        schedule command, *args, Eye::Reason::User.new(command)
-    end
-  end
-
-  def start
-    chain_command :start
-  end
-
-  def stop
-    async_schedule :stop
-  end
-
-  def restart
-    chain_command :restart
-  end
-
-  def delete
-    async_schedule :delete
-    terminate
-  end
-
-  def monitor
-    chain_command :monitor
-  end
-
-  def unmonitor
-    async_schedule :unmonitor
-  end
-
-  def signal(sig)
-    async_schedule :signal, sig
-  end
-
-  def user_command(cmd)
-    async_schedule :user_command, cmd
-  end
-
-  def break_chain
-    info 'break chain'
-    scheduler_clear_pending_list
-    @chain_breaker = true
-  end
-
-  def freeze
-    async_schedule :freeze
-  end
-
   def clear
     @processes = Eye::Utils::AliveArray.new
   end
@@ -150,22 +56,10 @@ class Eye::Group
   def <=>(other)
     if hidden
       1
+    elsif other.hidden
+      -1
     else
-      if other.hidden
-        -1
-      else
-        name <=> other.name
-      end
-    end
-  end
-
-private
-
-  def async_schedule(command, *args)
-    info "send to all processes #{command} #{args.present? ? args * ',' : nil}"
-
-    @processes.each do |process|
-      process.send_command(command, *args) unless process.skip_group_action?(command)
+      name <=> other.name
     end
   end
 

data/lib/eye/group/call.rb

@@ -0,0 +1,73 @@
+module Eye::Group::Call
+
+  # :update_config, :start, :stop, :restart, :unmonitor, :monitor, :break_chain, :delete, :signal, :user_command
+  def send_call(call)
+    info "call: #{call[:method]}"
+
+    case call[:command]
+      when :delete
+        delete
+      when :break_chain
+        break_chain
+      else
+        user_schedule(call)
+    end
+  end
+
+  def update_config(cfg)
+    @config = cfg
+    @full_name = nil
+  end
+
+  def start
+    chained_call command: :start
+  end
+
+  def stop
+    fast_call command: :stop
+  end
+
+  def restart
+    chained_call command: :restart
+  end
+
+  def delete
+    fast_call command: :delete
+    terminate
+  end
+
+  def monitor
+    chained_call command: :monitor
+  end
+
+  def unmonitor
+    fast_call command: :unmonitor
+  end
+
+  def signal(sig)
+    fast_call command: :signal, args: [sig]
+  end
+
+  def user_command(cmd)
+    fast_call command: :user_command, args: [cmd]
+  end
+
+  def break_chain
+    info 'break chain'
+    scheduler_clear_pending_list
+    @chain_breaker = true
+  end
+
+private
+
+  def fast_call(call)
+    command = call[:command]
+    args = call[:args]
+    info "send to all processes #{command} #{args.present? ? args * ',' : nil}"
+
+    @processes.each do |process|
+      process.send_call(call) unless process.skip_group_action?(command)
+    end
+  end
+
+end

data/lib/eye/group/chain.rb

@@ -2,7 +2,14 @@ module Eye::Group::Chain
 
 private
 
-  def chain_schedule(type, grace, command, *args)
+  def chained_call(call)
+    type, grace = chain_options(call[:command])
+    chain_schedule(type, grace, call)
+  end
+
+  def chain_schedule(type, grace, call)
+    command = call[:command]
+    args = call[:args]
     info "starting #{type} with #{grace}s chain #{command} #{args}"
 
     @chain_processes_count = @processes.size
@@ -17,7 +24,7 @@ private
         next
       end
 
-      chain_schedule_process(process, type, command, *args)
+      chain_schedule_process(process, type, call)
 
       @chain_processes_current = @chain_processes_current.to_i + 1
 
@@ -37,18 +44,18 @@ private
     @chain_processes_current = nil
   end
 
-  def chain_schedule_process(process, type, command, *args)
-    debug { "chain_schedule_process #{process.name} #{type} #{command}" }
+  def chain_schedule_process(process, type, call)
+    debug { "chain_schedule_process #{process.name} #{type} #{call[:command]}" }
 
     if type == :sync
       # sync command, with waiting
-      # this is very hackety, because call method of the process without its scheduler
-      # need to provide some scheduler future
-      process.last_scheduled_reason = last_scheduled_reason
-      process.send(command, *args)
+      Eye::Utils.wait_signal(call[:signal_timeout]) do |signal|
+        process.send_call(call.merge(signal: signal))
+      end
+
     else
       # async command
-      process.send_command(command, *args)
+      process.send_call(call)
     end
   end
 
@@ -58,11 +65,6 @@ private
     end
   end
 
-  def chain_command(command, *args)
-    chain_opts = chain_options(command)
-    chain_schedule(chain_opts[:type], chain_opts[:grace], command, *args)
-  end
-
   # with such delay will chained processes by default
   DEFAULT_CHAIN = 0.2
 
@@ -74,12 +76,12 @@ private
       type = [:async, :sync].include?(type) ? type : :async
 
       grace = @config[:chain][command].try :[], :grace
-      grace = grace ? (grace.to_f rescue DEFAULT_CHAIN) : DEFAULT_CHAIN
+      grace = (grace || DEFAULT_CHAIN).to_f rescue DEFAULT_CHAIN
 
-      { type: type, grace: grace }
+      [type, grace]
     else
       # default chain case
-      { type: :async, grace: DEFAULT_CHAIN }
+      [:async, DEFAULT_CHAIN]
     end
   end
 

data/lib/eye/group/data.rb

@@ -0,0 +1,40 @@
+module Eye::Group::Data
+
+  def status_data(opts = {})
+    plist = @processes.map { |p| p.status_data(opts) }
+
+    h = { name: name, type: :group, subtree: plist }
+
+    h[:debug] = debug_data if opts[:debug]
+
+    # show current chain
+    if scheduled_call = @scheduled_call
+      h[:current_command] = scheduled_call[:command]
+
+      if (chain_commands = scheduler_commands_list) && chain_commands.present?
+        h[:chain_commands] = chain_commands
+      end
+
+      if @chain_processes_current && @chain_processes_count
+        h[:chain_progress] = [@chain_processes_current, @chain_processes_count]
+      end
+    end
+
+    h
+  end
+
+  def status_data_short
+    h = {}
+    @processes.each do |p|
+      state = p.state
+      h[state] ||= 0
+      h[state] += 1
+    end
+    { name: (@name == '__default__' ? 'default' : @name), type: :group, states: h }
+  end
+
+  def debug_data
+    { queue: scheduler_commands_list, chain: chain_status }
+  end
+
+end

data/lib/eye/loader.rb

@@ -6,5 +6,5 @@ gem 'celluloid-io',  '~> 0.17.0'
 gem 'nio4r'
 gem 'timers'
 
-gem 'state_machine'
+gem 'state_machines'
 gem 'sigar', '~> 0.7.3'

data/lib/eye/logger.rb

@@ -6,7 +6,7 @@ class Eye::Logger
 
   class InnerLogger < Logger
 
-    FORMAT = '%d.%m.%Y %H:%M:%S'
+    FORMAT = '%d.%m.%Y %H:%M:%S'.freeze
 
     def initialize(*args)
       super
@@ -39,7 +39,7 @@ class Eye::Logger
     end
 
     def log_ex(ex)
-      error "#{ex.message} #{ex.backtrace}"
+      error "Exception: #{ex.message} #{ex.backtrace}"
       # notify here?
     end
 
@@ -73,8 +73,8 @@ class Eye::Logger
       if dev.nil?
         @inner_logger = InnerLogger.new(nil)
       elsif dev.is_a?(String)
-        @dev_fd = STDOUT if @dev.to_s.downcase == 'stdout'
-        @dev_fd = STDERR if @dev.to_s.downcase == 'stderr'
+        @dev_fd = STDOUT if @dev.to_s.casecmp('stdout') == 0
+        @dev_fd = STDERR if @dev.to_s.casecmp('stderr') == 0
         @inner_logger = InnerLogger.new(@dev_fd, *args)
       else
         @inner_logger = dev

data/lib/eye/process.rb

@@ -35,6 +35,8 @@ class Eye::Process
     @states_history = Eye::Process::StatesHistory.new(100)
     @states_history << :unmonitored
 
+    @state_call = {}
+
     debug { "creating with config: #{@config.inspect}" }
 
     add_triggers

data/lib/eye/process/commands.rb

@@ -7,7 +7,7 @@ module Eye::Process::Commands
 
     unless self[:start_command]
       warn 'no :start_command found, unmonitoring'
-      switch :unmonitoring, Eye::Reason.new(:no_start_command)
+      switch :unmonitoring, reason: 'no_start_command'
       return :no_start_command
     end
 
@@ -30,7 +30,7 @@ module Eye::Process::Commands
 
     result
 
-  rescue StateMachine::InvalidTransition, Eye::Process::StateError => e
+  rescue StateMachines::InvalidTransition, Eye::Process::StateError => e
     warn "wrong switch '#{e.message}'"
 
     :state_error
@@ -48,7 +48,7 @@ module Eye::Process::Commands
     if process_really_running?
       warn "process <#{self.pid}> was not stopped; try checking your command/signals or tuning the stop_timeout/stop_grace values"
 
-      switch :unmonitoring, Eye::Reason.new(:'not stopped (soft command)')
+      switch :unmonitoring, reason: 'not stopped (soft command)'
       nil
 
     else
@@ -59,7 +59,7 @@ module Eye::Process::Commands
       true
     end
 
-  rescue StateMachine::InvalidTransition, Eye::Process::StateError => e
+  rescue StateMachines::InvalidTransition, Eye::Process::StateError => e
     warn "wrong switch '#{e.message}'"
     nil
   end
@@ -83,7 +83,7 @@ module Eye::Process::Commands
 
     true
 
-  rescue StateMachine::InvalidTransition, Eye::Process::StateError => e
+  rescue StateMachines::InvalidTransition, Eye::Process::StateError => e
     warn "wrong switch '#{e.message}'"
     nil
   end
@@ -121,7 +121,7 @@ private
         delay = stop_signals.shift
         signal = stop_signals.shift
 
-        if wait_for_condition(delay.to_f, 0.3) { !process_really_running? }
+        if wait_for_condition(delay.to_f, 0.1) { !process_really_running? }
           info 'has terminated'
           break
         end
@@ -129,19 +129,11 @@ private
         send_signal(signal) if signal
       end
 
-      sleep_grace(:stop_grace)
-
-    else # default command
-      debug { "executing: `kill -TERM #{self.pid}` with stop_grace: #{self[:stop_grace].to_f}s" }
-      send_signal(:TERM)
-      sleep_grace(:stop_grace)
-
-      # if process not die here, by default we force kill it
-      if process_really_running?
-        warn "process <#{self.pid}> did not die after TERM, sending KILL"
-        send_signal(:KILL)
-        sleep 0.1 # little grace
-      end
+      # little grace
+      sleep 0.1
+    else
+      # TODO, notify here?
+      error 'stop_command or stop_signals should be'
     end
   end