eye 0.8.1 → 0.9.pre

data/lib/eye/controller.rb

@@ -19,14 +19,14 @@ class Eye::Controller
   autoload :Helpers,        'eye/controller/helpers'
   autoload :Commands,       'eye/controller/commands'
   autoload :Status,         'eye/controller/status'
-  autoload :SendCommand,    'eye/controller/send_command'
+  autoload :Apply,          'eye/controller/apply'
   autoload :Options,        'eye/controller/options'
 
   include Eye::Controller::Load
   include Eye::Controller::Helpers
   include Eye::Controller::Commands
   include Eye::Controller::Status
-  include Eye::Controller::SendCommand
+  include Eye::Controller::Apply
   include Eye::Controller::Options
 
   attr_reader :applications, :current_config

data/lib/eye/controller/{send_command.rb → apply.rb}

@@ -1,45 +1,40 @@
-module Eye::Controller::SendCommand
+module Eye::Controller::Apply
 
-  def send_command(command, *args)
-    matched_objects(*args) do |obj|
-      if command.to_sym == :delete
+  def apply(masks, call)
+    res = matched_objects(*masks) do |obj|
+      if call[:command].to_sym == :delete
         remove_object_from_tree(obj)
-
         set_proc_line
       end
-
-      obj.send_command(command)
     end
+
+    objs = res.delete(:objects)
+    async.apply_to_objects(objs, call) if objs
+    res
   end
 
   def match(*args)
     matched_objects(*args)
   end
 
-  def signal(signal, *args)
-    matched_objects(*args) do |obj|
-      obj.send_command :signal, signal || 0
-    end
-  end
+private
 
-  def user_command(cmd, *args)
-    matched_objects(*args) do |obj|
-      obj.send_command :user_command, cmd
+  def apply_to_objects(objs, call)
+    # TODO: if signal, create multiple signals?
+    objs.each do |obj|
+      obj.send_call(call)
     end
   end
 
-private
-
-  class Error < Exception; end
+  class Error < RuntimeError; end
 
   def matched_objects(*args, &block)
     objs = find_objects(*args)
     res = objs.map(&:full_name)
     objs.each { |obj| block[obj] } if block
-    { result: res }
+    { result: res, objects: objs }
 
   rescue Error => ex
-    log_ex(ex)
     { error: ex.message }
 
   rescue Celluloid::DeadActorError => ex
@@ -69,17 +64,15 @@ private
   # find object to action, restart ... (app, group or process)
   # nil if not found
   def find_objects(*args)
+    # TODO, why h? for what?
     h = args.extract_options!
     obj_strs = args
 
     return [] if obj_strs.blank?
 
     if obj_strs.size == 1 && (obj_strs[0].to_s.strip == 'all' || obj_strs[0].to_s.strip == '*')
-      if h[:application]
-        return @applications.select { |app| app.name == h[:application] }
-      else
-        return @applications.dup
-      end
+      return @applications.dup unless h[:application]
+      return @applications.select { |app| app.name == h[:application] }
     end
 
     res = Eye::Utils::AliveArray.new
@@ -127,7 +120,7 @@ private
         end
       end
 
-      return apps if apps.size > 0
+      return apps unless apps.empty?
 
       if !mask.start_with?('*') && objs.map(&:app_name).uniq.size > 1
         raise Error, "cannot match targets from different applications: #{res.map(&:full_name)}"
@@ -156,12 +149,12 @@ private
           res << p if p.name =~ r || p.full_name =~ r
 
           # children matching
-          if (ch = p.children) && (!ch.empty?)
-            ch.values.each do |ch|
-              name = ch.name rescue ''
-              full_name = ch.full_name rescue ''
-              res << ch if name =~ r || full_name =~ r
-            end
+          ch = p.children
+          next if ch.empty?
+          ch.values.each do |child|
+            name = child.name rescue ''
+            full_name = child.full_name rescue ''
+            res << child if name =~ r || full_name =~ r
           end
         end
       end

data/lib/eye/controller/commands.rb

@@ -1,10 +1,11 @@
 module Eye::Controller::Commands
 
   NOT_IMPORTANT_COMMANDS = [:info_data, :short_data, :debug_data, :history_data, :ping,
-                            :logger_dev, :match, :explain, :check]
+                            :logger_dev, :match, :explain, :check].freeze
 
   # Main method, answer for the client command
   def command(cmd, *args)
+    opts = args.extract_options!
     msg = "command: #{cmd} #{args * ', '}"
 
     log_str = "=> #{msg}"
@@ -14,14 +15,16 @@ module Eye::Controller::Commands
     cmd = cmd.to_sym
 
     res = case cmd
+
+      # scheduled command
       when :start, :stop, :restart, :unmonitor, :monitor, :break_chain
-        send_command(cmd, *args)
+        apply(args, command: cmd, signal: opts[:signal])
       when :delete
-        exclusive { send_command(cmd, *args) }
-      when :signal
-        signal(*args)
-      when :user_command
-        user_command(*args)
+        exclusive { apply(args, command: cmd, signal: opts[:signal]) }
+      when :signal, :user_command
+        apply(args[1..-1], command: cmd, args: args[0...1], signal: opts[:signal])
+
+      # inline command
       when :load
         exclusive { load(*args) }
       when :quit
@@ -72,10 +75,10 @@ private
 
   # stop all processes and wait
   def stop_all(timeout = nil)
+    # TODO: rewrite with signal
     exclusive do
-      send_command :break_chain, 'all'
-      send_command :stop, 'all'
-      send_command :freeze, 'all'
+      apply(%w[all], command: :break_chain)
+      apply(%w[all], command: :stop, freeze: true)
     end
 
     # wait until all processes goes to unmonitored

data/lib/eye/controller/load.rb

@@ -33,7 +33,7 @@ module Eye::Controller::Load
 private
 
   # regexp for clean backtrace to show for user
-  BT_REGX = %r[/lib/eye/|lib/celluloid|internal:prelude|logger.rb:|active_support/core_ext|shellwords.rb|kernel/bootstrap].freeze
+  BT_REGX = %r[/lib/eye/|lib/celluloid|internal:prelude|logger.rb:|active_support/core_ext|shellwords.rb|kernel/bootstrap]
 
   def catch_load_error(filename = nil, &_block)
     { error: false, config: yield }
@@ -114,17 +114,33 @@ private
     @applications.sort_by!(&:name)
   end
 
+  class AppDiff
+
+    attr_reader :old_groups, :old_processes, :added_groups, :added_processes
+
+    def initialize
+      @old_groups = {}
+      @old_processes = {}
+      @added_groups = []
+      @added_processes = []
+    end
+
+    def remove_added_processes(processes)
+      @added_processes -= processes
+    end
+
+  end
+
   def update_or_create_application(app_name, app_config)
-    @old_groups = {}
-    @old_processes = {}
+    diff = AppDiff.new
 
     app = @applications.detect { |c| c.name == app_name }
 
     if app
       app.groups.each do |group|
-        @old_groups[group.name] = group
+        diff.old_groups[group.name] = group
         group.processes.each do |proc|
-          @old_processes[group.name + ':' + proc.name] = proc
+          diff.old_processes[group.name + ':' + proc.name] = proc
         end
       end
 
@@ -136,86 +152,81 @@ private
     end
 
     app = Eye::Application.new(app_name, app_config)
-    @applications << app
-    @added_groups = []
-    @added_processes = []
 
     new_groups = app_config.delete(:groups) || {}
     new_groups.each do |group_name, group_cfg|
-      group = update_or_create_group(group_name, group_cfg.clone)
+      group = update_or_create_group(group_name, group_cfg.clone, diff)
       app.add_group(group)
       group.resort_processes
     end
 
-    # now, need to clear @old_groups, and @old_processes
-    @old_groups.each do |_, group|
+    diff.old_groups.each do |_, group|
       group.clear
-      group.send_command(:delete)
+      group.send_call(command: :delete, reason: 'load by user')
+    end
+
+    diff.old_processes.each do |_, process|
+      process.send_call(command: :delete, reason: 'load by user') if process.alive?
     end
-    @old_processes.each { |_, process| process.send_command(:delete) if process.alive? }
 
     # schedule monitoring for new groups, processes
     added_fully_groups = []
-    @added_groups.each do |group|
-      if group.processes.size > 0 && (group.processes.pure - @added_processes).size == 0
+    diff.added_groups.each do |group|
+      if !group.processes.empty? && (group.processes.pure - diff.added_processes).empty?
         added_fully_groups << group
-        @added_processes -= group.processes.pure
+        diff.remove_added_processes(group.processes.pure)
       end
     end
 
-    added_fully_groups.each { |group| group.send_command :monitor }
-    @added_processes.each { |process| process.send_command :monitor }
-
-    # remove links to prevent memory leaks
-    @old_groups = nil
-    @old_processes = nil
-    @added_groups = nil
-    @added_processes = nil
+    added_fully_groups.each { |group| group.send_call command: :monitor, reason: 'load by user' }
+    diff.added_processes.each { |process| process.send_call command: :monitor, reason: 'load by user' }
 
     app.resort_groups
 
+    @applications << app
+
     app
   end
 
-  def update_or_create_group(group_name, group_config)
-    group = if @old_groups[group_name]
+  def update_or_create_group(group_name, group_config, diff)
+    group = if diff.old_groups[group_name]
       debug { "updating group: #{group_name}" }
-      group = @old_groups.delete(group_name)
-      group.schedule :update_config, group_config, Eye::Reason::User.new(:'load config')
+      group = diff.old_groups.delete(group_name)
+      group.send_call command: :update_config, args: [group_config], reason: 'load by user'
       group.clear
       group
     else
       debug { "creating group: #{group_name}" }
       gr = Eye::Group.new(group_name, group_config)
-      @added_groups << gr
+      diff.added_groups << gr
       gr
     end
 
     processes = group_config.delete(:processes) || {}
     processes.each do |process_name, process_cfg|
-      process = update_or_create_process(process_name, process_cfg.clone)
+      process = update_or_create_process(process_name, process_cfg.clone, diff)
       group.add_process(process)
     end
 
     group
   end
 
-  def update_or_create_process(process_name, process_cfg)
+  def update_or_create_process(process_name, process_cfg, diff)
     postfix = ':' + process_name
     name = process_cfg[:group] + postfix
-    key = @old_processes[name] ? name : @old_processes.keys.detect { |n| n.end_with?(postfix) }
+    key = diff.old_processes[name] ? name : diff.old_processes.keys.detect { |n| n.end_with?(postfix) }
 
-    if @old_processes[key]
+    if diff.old_processes[key]
       debug { "updating process: #{name}" }
-      process = @old_processes.delete(key)
-      process.schedule :update_config, process_cfg, Eye::Reason::User.new(:'load config')
-      process
+      process = diff.old_processes.delete(key)
+      process.send_call command: :update_config, args: [process_cfg], reason: 'load by user'
     else
       debug { "creating process: #{name}" }
       process = Eye::Process.new(process_cfg)
-      @added_processes << process
-      process
+      diff.added_processes << process
     end
+
+    process
   end
 
 end

data/lib/eye/controller/status.rb

@@ -9,7 +9,7 @@ module Eye::Controller::Status
       about: Eye::ABOUT,
       resources: Eye::SystemResources.resources($$),
       ruby: RUBY_DESCRIPTION,
-      gems: %w[Celluloid Celluloid::IO StateMachine NIO Timers Sigar].map { |c| gem_version(c) },
+      gems: %w[Celluloid Celluloid::IO StateMachines NIO Timers Sigar].map { |c| gem_version(c) },
       logger: Eye::Logger.args.present? ? [Eye::Logger.dev.to_s, *Eye::Logger.args] : Eye::Logger.dev.to_s,
       home: Eye::Local.home,
       dir: Eye::Local.dir,
@@ -35,7 +35,7 @@ module Eye::Controller::Status
   def history_data(*args)
     res = {}
     history_objects(*args).each do |process|
-      res[process.full_name] = process.schedule_history.reject { |c| c[:state] == :check_crash }
+      res[process.full_name] = process.scheduler_history.reject { |c| c[:state] == :check_crash }
     end
     res
   end

data/lib/eye/dsl.rb

@@ -15,7 +15,7 @@ class Eye::Dsl
   autoload :ConfigOpts,           'eye/dsl/config_opts'
   autoload :Validation,           'eye/dsl/validation'
 
-  class Error < Exception; end
+  class Error < RuntimeError; end
 
   class << self
 

data/lib/eye/dsl/application_opts.rb

@@ -34,7 +34,7 @@ class Eye::Dsl::ApplicationOpts < Eye::Dsl::Opts
     res
   end
 
-  alias_method :xgroup, :nop
-  alias_method :xprocess, :nop
+  alias xgroup nop
+  alias xprocess nop
 
 end

data/lib/eye/dsl/child_process_opts.rb

@@ -8,6 +8,6 @@ class Eye::Dsl::ChildProcessOpts < Eye::Dsl::Opts
   def triggers(*_args)
     raise Eye::Dsl::Error, 'triggers not allowed in monitor_children'
   end
-  alias_method :trigger, :triggers
+  alias trigger triggers
 
 end

data/lib/eye/dsl/config_opts.rb

@@ -10,7 +10,7 @@ class Eye::Dsl::ConfigOpts < Eye::Dsl::PureOpts
       @config[:logger] = args
     end
   end
-  alias_method :logger=, :logger
+  alias logger= logger
 
   def syslog(name = 'eye', *args)
     require 'syslog/logger'

data/lib/eye/dsl/group_opts.rb

@@ -25,8 +25,8 @@ class Eye::Dsl::GroupOpts < Eye::Dsl::Opts
     opts
   end
 
-  alias_method :xprocess, :nop
-  alias_method :application, :parent
-  alias_method :app, :application
+  alias xprocess nop
+  alias application parent
+  alias app application
 
 end

data/lib/eye/dsl/main.rb

@@ -20,8 +20,8 @@ module Eye::Dsl::Main
     Eye::Dsl.debug { "<= app: #{name}" }
   end
 
-  alias_method :project, :application
-  alias_method :app, :application
+  alias project application
+  alias app application
 
   def load(glob = '')
     return if glob.blank?
@@ -54,7 +54,7 @@ module Eye::Dsl::Main
     Eye::Dsl.debug { '<= config' }
   end
 
-  alias_method :settings, :config
+  alias settings config
 
   def shared
     require 'ostruct'

data/lib/eye/dsl/opts.rb

@@ -1,16 +1,16 @@
 class Eye::Dsl::Opts < Eye::Dsl::PureOpts
 
   STR_OPTIONS = [:pid_file, :working_dir, :stdout, :stderr, :stdall, :stdin, :start_command,
-                 :stop_command, :restart_command, :uid, :gid]
+                 :stop_command, :restart_command, :uid, :gid].freeze
   create_options_methods(STR_OPTIONS, String)
 
   BOOL_OPTIONS = [:daemonize, :keep_alive, :auto_start, :stop_on_delete, :clear_pid, :preserve_fds, :use_leaf_child,
-                  :clear_env, :check_identity]
+                  :clear_env, :check_identity].freeze
   create_options_methods(BOOL_OPTIONS, [TrueClass, FalseClass])
 
   INTERVAL_OPTIONS = [:check_alive_period, :start_timeout, :restart_timeout, :stop_timeout, :start_grace,
                       :restart_grace, :stop_grace, :children_update_period, :restore_in,
-                      :auto_update_pidfile_grace, :revert_fuckup_pidfile_grace, :check_identity_period, :check_identity_grace]
+                      :auto_update_pidfile_grace, :revert_fuckup_pidfile_grace, :check_identity_period, :check_identity_grace].freeze
   create_options_methods(INTERVAL_OPTIONS, [Fixnum, Float])
 
   create_options_methods([:environment], Hash)
@@ -62,10 +62,10 @@ class Eye::Dsl::Opts < Eye::Dsl::PureOpts
     @config[:triggers].try :delete, nac[:name]
   end
 
-  alias_method :check, :checks
-  alias_method :nocheck, :nochecks
-  alias_method :trigger, :triggers
-  alias_method :notrigger, :notriggers
+  alias check checks
+  alias nocheck nochecks
+  alias trigger triggers
+  alias notrigger notriggers
 
   def command(cmd, arg)
     @config[:user_commands] ||= {}
@@ -119,8 +119,8 @@ class Eye::Dsl::Opts < Eye::Dsl::PureOpts
     @config[:environment].merge!(value)
   end
 
-  alias_method :dir, :working_dir
-  alias_method :env, :environment
+  alias dir working_dir
+  alias env environment
 
   def set_stdall(value)
     super
@@ -182,20 +182,16 @@ class Eye::Dsl::Opts < Eye::Dsl::PureOpts
   def load_env(filename = '~/.env', raise_when_no_file = true)
     fnames = [File.expand_path(filename, @config[:working_dir]),
               File.expand_path(filename)].uniq
-    filenames = fnames.select { |f| File.exist?(f) }
-
-    if filenames.size < 1
-      if raise_when_no_file
-        raise Eye::Dsl::Error, "load_env not found in #{fnames}"
-      else
-        warn "load_env not found file: '#{filenames.first}'"
-        return
-      end
+    file = fnames.detect { |f| File.exist?(f) }
+
+    unless file
+      raise Eye::Dsl::Error, "load_env not found in #{fnames}" if raise_when_no_file
+      warn "load_env not found file: '#{filename}'"
+      return
     end
-    raise Eye::Dsl::Error, "load_env conflict filenames: #{filenames}" if filenames.size > 1
 
-    info "load_env from '#{filenames.first}'"
-    Eye::Utils.load_env(filenames.first).each { |k, v| env k => v }
+    info "load_env from '#{file}'"
+    Eye::Utils.load_env(file).each { |k, v| env k => v }
   end
 
   def skip_group_action(act, val = true)