invoker 0.0.3 → 0.1.1.pre

data/.travis.yml

@@ -2,5 +2,6 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+
 script: bundle exec rake spec
 

data/invoker.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |s|
   s.add_dependency("slop")
   s.add_dependency("iniparse")
   s.add_dependency("colored")
+  s.add_dependency("formatador")
   s.add_development_dependency("bacon")
   s.add_development_dependency("mocha")
   s.add_development_dependency("mocha-on-bacon")

data/lib/invoker/command_listener/client.rb

@@ -7,26 +7,37 @@ module Invoker
       end
 
       def read_and_execute
-        command_info = client_socket.read()
+        command_info = client_socket.gets()
+        command_info && command_info.strip!
+
         if command_info && !command_info.empty?
           worker_command, command_label, rest_args = command_info.strip.split(" ")
-          if worker_command && command_label
+          worker_command.strip!
+          if worker_command
             run_command(worker_command, command_label, rest_args)
           end
         end
-        client_socket.close()
       end
 
       def run_command(worker_command, command_label, rest_args = nil)
         case worker_command
         when 'add'
-          Invoker::COMMANDER.add_command_by_label(command_label)
+          Invoker::COMMANDER.on_next_tick(command_label) { |b_command_label|
+            add_command_by_label(b_command_label)
+          }
+        when 'list'
+          json = Invoker::COMMANDER.list_commands()
+          client_socket.puts(json)
         when 'remove'
-          Invoker::COMMANDER.remove_command(command_label, rest_args)
+          Invoker::COMMANDER.on_next_tick(command_label, rest_args) { |b_command_label,b_rest_args|
+            remove_command(b_command_label, b_rest_args)
+          }
         when 'reload'
-          Invoker::COMMANDER.reload_command(command_label)
+          Invoker::COMMANDER.on_next_tick(command_label, rest_args) { |b_command_label, b_rest_args|
+            reload_command(b_command_label, b_rest_args)
+          }
         else
-          $stdout.puts("\n Invalid command".red)
+          Invoker::Logger.puts("\n Invalid command".red)
         end
       end
     end

data/lib/invoker/command_listener/server.rb

@@ -6,13 +6,13 @@ module Invoker
       SOCKET_PATH = "/tmp/invoker"
       def initialize
         @open_clients = []
-        clean_old_socket()
-        UNIXServer.open(SOCKET_PATH) do |client|
-          loop do
-            client_socket = client.accept
-            process_client(client_socket)
+        Socket.unix_server_loop(SOCKET_PATH) {|sock, client_addrinfo|
+          begin
+            process_client(sock)
+          ensure
+            sock.close
           end
-        end
+        }
       end
 
       def clean_old_socket

data/lib/invoker/command_worker.rb

@@ -19,12 +19,16 @@ module Invoker
     end
 
     def unbind
-      # $stdout.print(".")
+      Invoker::Logger.print(".")
     end
 
     # Print the lines received over the network
     def receive_line(line)
-      $stdout.puts "#{@command_label.send(color)} : #{line}"
+      Invoker::Logger.puts "#{@command_label.send(color)} : #{line}"
+    end
+
+    def to_h
+      {:command_label => command_label, :pid => pid.to_s}
     end
   end
 end

data/lib/invoker/commander.rb

@@ -1,11 +1,13 @@
 require "io/console"
 require 'pty'
+require "json"
 
 module Invoker
   class Commander
     MAX_PROCESS_COUNT = 10
     LABEL_COLORS = ['green', 'yellow', 'blue', 'magenta', 'cyan']
     attr_accessor :reactor, :workers, :thread_group, :open_pipes
+    attr_accessor :event_manager, :runnables
     
     def initialize
       # mapping between open pipes and worker classes
@@ -16,10 +18,16 @@ module Invoker
       
       @thread_group = ThreadGroup.new()
       @worker_mutex = Mutex.new()
+
+      @event_manager = Invoker::Event::Manager.new()
+      @runnables = []
+
       @reactor = Invoker::Reactor.new
       Thread.abort_on_exception = true
     end
 
+    # Start the invoker process supervisor. This method starts a unix server
+    # in separate thread that listens for incoming commands.
     def start_manager
       if !Invoker::CONFIG.processes || Invoker::CONFIG.processes.empty?
         raise Invoker::Errors::InvalidConfig.new("No processes configured in config file")
@@ -28,9 +36,12 @@ module Invoker
       unix_server_thread = Thread.new { Invoker::CommandListener::Server.new() }
       thread_group.add(unix_server_thread)
       Invoker::CONFIG.processes.each { |process_info| add_command(process_info) }
-      reactor.start
+      start_event_loop()
     end
 
+    # Start given command and start a background thread to wait on the process
+    #
+    # @param process_info [OpenStruct(command, directory)]
     def add_command(process_info)
       m, s = PTY.open
       s.raw! # disable newline conversion.
@@ -39,14 +50,20 @@ module Invoker
 
       s.close()
 
-      selected_color = LABEL_COLORS.shift()
-      LABEL_COLORS.push(selected_color)
-      worker = Invoker::CommandWorker.new(process_info.label, m, pid, selected_color)
+      worker = Invoker::CommandWorker.new(process_info.label, m, pid, select_color())
 
       add_worker(worker)
       wait_on_pid(process_info.label,pid)
     end
 
+    # List currently running commands
+    def list_commands
+      Invoker::ProcessPrinter.to_json(workers)
+    end
+
+    # Start executing given command by their label name.
+    #
+    # @param command_label [String] Command label of process specified in config file.
     def add_command_by_label(command_label)
       process_info = Invoker::CONFIG.processes.detect {|pconfig|
         pconfig.label == command_label
@@ -56,30 +73,86 @@ module Invoker
       end
     end
 
-    def reload_command(command_label)
-      remove_command(command_label)
-      add_command_by_label(command_label)
+    # Reload a process given by command label
+    #
+    # @params command_label [String] Command label of process specified in config file.
+    def reload_command(command_label, rest_args)
+      if remove_command(command_label, rest_args)
+        event_manager.schedule_event(command_label, :worker_removed) {
+          add_command_by_label(command_label) 
+        }
+      else
+        add_command_by_label(command_label) 
+      end
     end
 
+    # Remove a process from list of processes managed by invoker supervisor.It also
+    # kills the process before removing it from the list.
+    #
+    # @param command_label [String] Command label of process specified in config file
+    # @param rest_args [Array] Additional option arguments, such as signal that can be used.
+    # @return [Boolean] if process existed and was removed else false
     def remove_command(command_label, rest_args)
       worker = workers[command_label]
+      return false unless worker
       signal_to_use = rest_args ? Array(rest_args).first : 'INT'
 
-      if worker
-        $stdout.puts("Removing #{command_label} with signal #{signal_to_use}".red)
-        process_kill(worker.pid, signal_to_use)
-      end
+      Invoker::Logger.puts("Removing #{command_label} with signal #{signal_to_use}".red)
+      kill_or_remove_process(worker.pid, signal_to_use, command_label)
     end
 
+    # Given a file descriptor returns the worker object
+    #
+    # @param fd [IO] an IO object with valid file descriptor
+    # @return [Invoker::CommandWorker] The worker object which is associated with this fd
     def get_worker_from_fd(fd)
       open_pipes[fd.fileno]
     end
 
+    # Given a command label returns the associated worker object
+    #
+    # @param label [String] Command label of the command
+    # @return [Invoker::CommandWorker] The worker object which is associated with this command
     def get_worker_from_label(label)
       workers[label]
     end
+
+    def on_next_tick(*args, &block)
+      @worker_mutex.synchronize do
+        @runnables << OpenStruct.new(:args => args, :block => block)
+      end
+    end
+
+    def run_runnables
+      @runnables.each do |runnable|
+        instance_exec(*runnable.args, &runnable.block)
+      end
+      @runnables = []
+    end
     
     private
+    def start_event_loop
+      loop do
+        reactor.watch_on_pipe()
+        run_runnables()
+        run_scheduled_events()
+      end
+    end
+
+    def run_scheduled_events
+      event_manager.run_scheduled_events do |event|
+        event.block.call()
+      end
+    end
+
+    def kill_or_remove_process(pid, signal_to_use, command_label)
+      process_kill(pid, signal_to_use)
+      true
+    rescue Errno::ESRCH
+      remove_worker(command_label, false)
+      false
+    end
+    
     def process_kill(pid, signal_to_use)
       if signal_to_use.to_i == 0
         Process.kill(signal_to_use, pid)
@@ -87,29 +160,37 @@ module Invoker
         Process.kill(signal_to_use.to_i, pid)
       end
     end
+
+    def select_color
+      selected_color = LABEL_COLORS.shift()
+      LABEL_COLORS.push(selected_color)
+      selected_color
+    end
     
     # Remove worker from all collections
-    def remove_worker(command_label)
-      @worker_mutex.synchronize do
-        worker = @workers[command_label]
-        if worker
-          @open_pipes.delete(worker.pipe_end.fileno)
-          @reactor.remove_from_monitoring(worker.pipe_end)
-          @workers.delete(command_label)
-        end
+    def remove_worker(command_label, trigger_event = true)
+      worker = @workers[command_label]
+      if worker
+        @open_pipes.delete(worker.pipe_end.fileno)
+        @workers.delete(command_label)
+      end
+      if trigger_event
+        event_manager.trigger(command_label, :worker_removed)
       end
     end
 
     # add worker to global collections
     def add_worker(worker)
-      @worker_mutex.synchronize do
-        @open_pipes[worker.pipe_end.fileno] = worker
-        @workers[worker.command_label] = worker
-        @reactor.add_to_monitor(worker.pipe_end)
-      end
+      @open_pipes[worker.pipe_end.fileno] = worker
+      @workers[worker.command_label] = worker
+      @reactor.add_to_monitor(worker.pipe_end)
     end
 
     def run_command(process_info, write_pipe)
+      command_label = process_info.label
+
+      event_manager.schedule_event(command_label, :exit) { remove_worker(command_label) }
+
       if defined?(Bundler)
         Bundler.with_clean_env do
           spawn(process_info.cmd, 
@@ -125,12 +206,13 @@ module Invoker
 
     def wait_on_pid(command_label,pid)
       raise Invoker::Errors::ToomanyOpenConnections if @thread_group.enclosed?
+
       thread = Thread.new do
         Process.wait(pid)
         message = "Process with command #{command_label} exited with status #{$?.exitstatus}"
-        $stdout.puts("\n#{message}".red)
+        Invoker::Logger.puts("\n#{message}".red)
         notify_user(message)
-        remove_worker(command_label)
+        event_manager.trigger(command_label, :exit)
       end
       @thread_group.add(thread)
     end

data/lib/invoker/event/manager.rb

@@ -0,0 +1,79 @@
+module Invoker
+  module Event
+    class Manager
+      attr_accessor :scheduled_events, :triggered_events
+
+      def initialize
+        @scheduled_events = Hash.new {|h,k| h[k] = [] }
+        @triggered_events = []
+        @trigger_mutex = Mutex.new()
+      end
+
+      # Trigger an event. The event is not triggered immediately, but is just scheduled to be
+      # triggered.
+      #
+      # @param command_label [String] Command for which event should be triggered
+      # @param event_name [Symbol, nil] The optional event name
+      def trigger(command_label, event_name = nil)
+        @trigger_mutex.synchronize do
+          triggered_events << OpenStruct.new(
+            :command_label => command_label, 
+            :event_name => event_name)
+        end
+      end
+
+      # Schedule an Event. The event will only trigger when a scheduled event matches
+      # a triggered event.
+      #
+      # @param command_label [String] Command for which the event should be triggered
+      # @param event_name [String, nil] Optional event name
+      # @param block The block to execute when event actually triggers
+      def schedule_event(command_label, event_name = nil, &block)
+        @trigger_mutex.synchronize do
+          scheduled_events[command_label] << OpenStruct.new(:event_name => event_name, :block => block)
+        end
+      end
+
+      # On next iteration of event loop, this method is called and we try to match
+      # scheduled events with events that were triggered. 
+      def run_scheduled_events
+        filtered_events_by_name_and_command = []
+
+        triggered_events.each_with_index do |triggered_event, index|
+          matched_events = scheduled_events[triggered_event.command_label]
+          if matched_events && !matched_events.empty?
+            filtered_events_by_name_and_command, unmatched_events = 
+              filter_matched_events(matched_events, triggered_event)
+            triggered_events[index] = nil
+            remove_scheduled_event(unmatched_events, triggered_event.command_label)
+          end
+        end
+        triggered_events.compact!
+
+        filtered_events_by_name_and_command.each {|event| yield event }
+      end
+
+      private
+      def filter_matched_events(matched_events, event)
+        matched_filtered_events = []
+        
+        matched_events.each_with_index do |matched_event, index|
+          if !event.event_name || event.event_name == matched_event.event_name
+            matched_filtered_events << matched_event
+            matched_events[index] = nil
+          end
+        end
+        [matched_filtered_events, matched_events.compact]
+      end
+
+      def remove_scheduled_event(matched_events, command_label)
+        if !matched_events || matched_events.empty?
+          scheduled_events.delete(command_label)
+        else
+          scheduled_events[command_label] = matched_events
+        end
+      end
+
+    end
+  end
+end

data/lib/invoker/logger.rb

@@ -0,0 +1,13 @@
+module Invoker
+  class Logger
+    def self.puts(message)
+      return if ENV["INVOKER_TESTS"]
+      $stdout.puts(message)
+    end
+
+    def self.print(message)
+      return if ENV["INVOKER_TESTS"]
+      $stdout.print(message)
+    end
+  end
+end

data/lib/invoker/parsers/config.rb

@@ -0,0 +1,29 @@
+require 'iniparse'
+
+module Invoker
+  module Parsers
+    class Config
+      attr_accessor :processes
+      def initialize(filename)
+        @ini_content = File.read(filename)
+        @processes = process_ini(@ini_content)
+      end
+
+      private
+      def process_ini(ini_content)
+        document = IniParse.parse(ini_content)
+        document.map do |section|
+          check_directory(section["directory"])
+          OpenStruct.new(label: section.key, dir: section["directory"], cmd: section["command"])
+        end
+      end
+
+      def check_directory(app_dir)
+        if app_dir && !app_dir.empty? && !File.directory?(app_dir)
+          raise Invoker::Errors::InvalidConfig.new("Invalid directory #{app_dir}")
+        end
+      end
+    end
+  end
+end
+

data/lib/invoker/parsers/option_parser.rb

@@ -0,0 +1,86 @@
+require "slop"
+require "ostruct"
+
+module Invoker
+  module Parsers
+    class OptionParser
+      def self.parse(args)
+        selected_command = nil
+        
+        opts = Slop.parse(args, help: true) do
+          on :v, "Print the version" do
+            Invoker::Logger.puts Invoker::VERSION
+          end
+
+          command 'start' do
+            banner "Usage : invoker start config.ini \n Start Invoker Process Manager"
+            run do |cmd_opts, cmd_args|
+              selected_command = OpenStruct.new(:command => 'start', :file => cmd_args.first)
+            end
+          end
+
+          command 'list' do
+            banner "Usage : invoker list\n List processes managed by invoker"
+            run do |cmd_opts, cmd_args|
+              selected_command = OpenStruct.new(:command => 'list')
+            end
+          end
+
+          command 'add' do
+            banner "Usage : invoker add process_label \n Start the process with given process_label"
+            run do |cmd_opts, cmd_args|
+              selected_command = OpenStruct.new(:command => 'add', :command_key => cmd_args.first)
+            end
+          end
+
+          command 'remove' do
+            banner "Usage : invoker remove process_label \n Stop the process with given label"
+            on :s, :signal=, "Signal to send for killing the process, default is SIGINT", as: String
+
+            run do |cmd_opts, cmd_args|
+              signal_to_use = cmd_opts.to_hash[:signal] || 'INT'
+              selected_command = OpenStruct.new(
+                :command => 'remove', 
+                :command_key => cmd_args.first,
+                :signal => signal_to_use
+              )
+            end
+          end
+
+          command 'reload' do
+            banner "Usage : invoker reload process_label \n Restart the process with given label"
+            on :s, :signal=, "Signal to send for killing the process, default is SIGINT", as: String
+
+            run do |cmd_opts, cmd_args|
+              signal_to_use = cmd_opts.to_hash[:signal] || 'INT'
+              selected_command = OpenStruct.new(
+                :command => 'reload', 
+                :command_key => cmd_args.first,
+                :signal => signal_to_use
+              )
+            end
+          end
+        end
+
+        selected_command || create_default_command(args, opts)
+      end
+
+      
+      # If user specifies no command either show help message or start the invoker
+      # process supervisor.
+      #
+      # @param args [Array] command line arguments
+      # @param opts [Slop::Options] Processed slop options
+      # @return [OpenStruct, false] returns default command or nil
+      def self.create_default_command(args, opts)
+        if args.first && File.exists?(args.first) && File.file?(args.first)
+          OpenStruct.new(:command => "start", :file => args.first)
+        else
+          Invoker::Logger.puts opts.inspect
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/invoker/process_printer.rb

@@ -0,0 +1,53 @@
+module Invoker
+  class ProcessPrinter
+    MAX_COLUMN_WIDTH = 40
+    def self.to_json(workers)
+      final_json = []
+      Invoker::CONFIG.processes.each do |process|
+        if worker = workers[process.label]
+          final_json << {
+            :command => process.cmd, :command_label => process.label, 
+            :dir => process.dir, :pid => worker.pid
+          }
+        else
+          final_json << {
+            :command => process.cmd, :command_label => process.label, 
+            :dir => process.dir
+          }
+        end
+      end
+
+      final_json.to_json
+    end
+
+    def self.print_table(json_data)
+      final_json = JSON.parse(json_data)
+      if final_json && !final_json.empty?
+        json_for_printing = []
+        final_json.each do |json_row|
+          if json_row["pid"]
+            json_for_printing << colorize_hash(json_row, "green")
+          else
+            json_row["pid"] = "[light_black]not running[/]"
+            json_for_printing << colorize_hash(json_row, "light_black")
+          end
+        end
+        Formatador.display_compact_table(json_for_printing)
+      end
+    end
+
+    private
+    def self.colorize_hash(hash, color)
+      hash.inject({}) do |mem,(key,obj)|
+        if obj.to_s.length > MAX_COLUMN_WIDTH
+          short_command = "#{obj.to_s[0..MAX_COLUMN_WIDTH]}.."
+          mem[key] = "[#{color}]#{short_command}[/]"
+        else
+          mem[key] = "[#{color}]#{obj}[/]"
+        end
+        mem
+      end
+    end
+
+  end
+end

data/lib/invoker/reactor.rb

@@ -13,12 +13,6 @@ module Invoker
       @monitored_fds.delete(fd)
     end
 
-    def start
-      loop do
-        watch_on_pipe
-      end
-    end
-
     def watch_on_pipe
       ready_read_fds,ready_write_fds,read_error_fds = select(monitored_fds,[],[],0.05)
 
@@ -38,6 +32,7 @@ module Invoker
         data = read_data(ready_fd)
         command_worker.receive_data(data)
       rescue Invoker::Errors::ProcessTerminated
+        remove_from_monitoring(command_worker.pipe_end)
         command_worker.unbind()
       end
     end

data/lib/invoker/runner.rb

@@ -5,45 +5,8 @@ require "socket"
 module Invoker
   class Runner
     def self.run(args)
-
-      selected_command = nil
-      
-      opts = Slop.parse(args, help: true) do
-        on :v, "Print the version" do
-          $stdout.puts Invoker::VERSION
-        end
-
-        command 'start' do
-          banner "Usage : invoker start config.ini \n Start Invoker Process Manager"
-          run do |cmd_opts, cmd_args|
-            selected_command = OpenStruct.new(:command => 'start', :file => cmd_args.first)
-          end
-        end
-
-        command 'add' do
-          banner "Usage : invoker add process_label \n Start the process with given process_label"
-          run do |cmd_opts, cmd_args|
-            selected_command = OpenStruct.new(:command => 'add', :command_key => cmd_args.first)
-          end
-        end
-
-        command 'remove' do
-          banner "Usage : invoker remove process_label \n Stop the process with given label"
-          on :s, :signal=, "Signal to send for killing the process, default is SIGINT", as: String
-
-          run do |cmd_opts, cmd_args|
-            signal_to_use = cmd_opts.to_hash[:signal] || 'INT'
-            selected_command = OpenStruct.new(
-              :command => 'remove', 
-              :command_key => cmd_args.first,
-              :signal => signal_to_use
-            )
-          end
-        end
-      end
-      unless selected_command
-        $stdout.puts opts.inspect
-      else
+      selected_command = Invoker::Parsers::OptionParser.parse(args)
+      if selected_command
         run_command(selected_command)
       end
     end
@@ -55,15 +18,19 @@ module Invoker
         start_server(selected_command)
       when 'add'
         add_command(selected_command)
+      when 'reload'
+        refresh_command(selected_command)
+      when 'list'
+        list_commands(selected_command)
       when 'remove'
         remove_command(selected_command)
       else
-        $stdout.puts "Invalid command"
+        Invoker::Logger.puts "Invalid command"
       end
     end
 
     def self.start_server(selected_command)
-      config = Invoker::Config.new(selected_command.file)
+      config = Invoker::Parsers::Config.new(selected_command.file)
       Invoker.const_set(:CONFIG, config)
       warn_about_terminal_notifier()
       commander = Invoker::Commander.new()
@@ -72,31 +39,39 @@ module Invoker
     end
 
     def self.add_command(selected_command)
-      socket = UNIXSocket.open(Invoker::CommandListener::Server::SOCKET_PATH)
-      socket.puts("add #{selected_command.command_key}")
-      socket.flush()
-      socket.close()
+      Socket.unix(Invoker::CommandListener::Server::SOCKET_PATH) do |socket|
+        socket.puts("add #{selected_command.command_key}")
+        socket.flush()
+      end
     end
 
     def self.remove_command(selected_command)
-      socket = UNIXSocket.open(Invoker::CommandListener::Server::SOCKET_PATH)
-      socket.puts("remove #{selected_command.command_key} #{selected_command.signal}")
-      socket.flush()
-      socket.close()
+      Socket.unix(Invoker::CommandListener::Server::SOCKET_PATH) do |socket|
+        socket.puts("remove #{selected_command.command_key} #{selected_command.signal}")
+        socket.flush()
+      end
     end
 
     def self.refresh_command(selected_command)
-      socket = UNIXSocket.open(Invoker::CommandListener::Server::SOCKET_PATH)
-      socket.puts("reload #{selected_command.command_key}")
-      socket.flush()
-      socket.close()
+      Socket.unix(Invoker::CommandListener::Server::SOCKET_PATH) do |socket|
+        socket.puts("reload #{selected_command.command_key} #{selected_command.signal}")
+        socket.flush()
+      end
+    end
+
+    def self.list_commands(selected_command)
+      Socket.unix(Invoker::CommandListener::Server::SOCKET_PATH) {|sock|
+        sock.puts("list")
+        data = sock.gets()
+        Invoker::ProcessPrinter.print_table(data)
+      }
     end
 
     def self.warn_about_terminal_notifier
       if RUBY_PLATFORM.downcase.include?("darwin")
         command_path = `which terminal-notifier`
         if !command_path || command_path.empty?
-          $stdout.puts("You can enable OSX notification for processes by installing terminal-notification gem".red)
+          Invoker::Logger.puts("You can enable OSX notification for processes by installing terminal-notifier gem".red)
         end
       end
     end

data/lib/invoker/version.rb

@@ -1,3 +1,3 @@
 module Invoker
-  VERSION = "0.0.3"
+  VERSION = "0.1.1.pre"
 end

data/lib/invoker.rb

@@ -1,16 +1,18 @@
 $: << File.dirname(__FILE__) unless $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require "colored"
-require_relative "invoker/version"
-require_relative "invoker/runner"
-require_relative "invoker/command_listener"
-require_relative "invoker/errors"
-require_relative "invoker/config"
-require_relative "invoker/commander"
-require_relative "invoker/command_worker"
-require_relative "invoker/reactor"
-
-
-
-
-
+require "formatador"
+require "ostruct"
+require "invoker/version"
+require "invoker/logger"
+require "invoker/runner"
+require "invoker/command_listener/server"
+require "invoker/command_listener/client"
+require "invoker/errors"
+require "invoker/parsers/config"
+require "invoker/parsers/option_parser"
+require "invoker/commander"
+require "invoker/command_worker"
+require "invoker/reactor"
+require "invoker/event/manager"
+require "invoker/process_printer"

data/readme.md

@@ -22,7 +22,6 @@ You need to start by creating a `ini` file which will define processes you want
     directory = /home/gnufied/god_particle
     command = zsh -c 'bundle exec ruby script/delayed_job'
     
-    
     [events]
     directory = /home/gnufied/god_particle
     command = zsh -c 'bundle exec ruby script/event_server'
@@ -44,7 +43,16 @@ Now additionally you can control individual process by,
     # add and start running
     ~> invoker add dj
     
-You can also enable OSX notifications for crashed processes by installing `terminal-notification` gem. It is not a dependency, but can be useful if something crashed and you weren't paying attention.   
+    # List currently running processes managed by invoker
+    ~> invoker list
+
+    # Restart process given by command Label
+    ~> invoker reload dj
+
+    # Restart process given by command label using specific signal for killing
+    ~> invoker reload dj -s 9
+    
+You can also enable OSX notifications for crashed processes by installing `terminal-notifier` gem. It is not a dependency, but can be useful if something crashed and you weren't paying attention.   
 
 ## Using with rbenv or rvm ##
 
@@ -58,7 +66,7 @@ If you are running `invoker` with Ruby version x, but your application requires
 * Unless version of Ruby using which you are running `invoker` command and version of Ruby you are using in the application is same, you almost always will want to use 
 `zsh -c` or `bash -c`. `RVM` in particular requires a login shell and hence sometimes you may have to use `bash -lc`. For example:
 
-        command = bash -lc "rvm use 2.0.0-p0 && bundle exec rails s"
+        command = bash -lc "rvm 2.0.0-p0 do bundle exec rails s"
     
 
 ## Bug reports and Feature requests

data/spec/invoker/command_listener/client_spec.rb

@@ -8,9 +8,8 @@ describe Invoker::CommandListener::Client do
     end
     
     it "should run if read from socket" do
-      invoker_commander.expects(:add_command_by_label).with("foo")
-      @client_socket.expects(:read).returns("add foo\n")
-      @client_socket.expects(:close)
+      invoker_commander.expects(:on_next_tick).with("foo")
+      @client_socket.expects(:gets).returns("add foo\n")
 
       @client.read_and_execute()
     end
@@ -23,17 +22,15 @@ describe Invoker::CommandListener::Client do
     end
 
     it "with specific signal" do
-      invoker_commander.expects(:remove_command).with("foo", "9")
-      @client_socket.expects(:read).returns("remove foo 9\n")
-      @client_socket.expects(:close)
+      invoker_commander.expects(:on_next_tick).with("foo", "9")
+      @client_socket.expects(:gets).returns("remove foo 9\n")
 
       @client.read_and_execute()
     end
 
     it "with default signal" do
-      invoker_commander.expects(:remove_command).with("foo",nil)
-      @client_socket.expects(:read).returns("remove foo\n")
-      @client_socket.expects(:close)
+      invoker_commander.expects(:on_next_tick).with("foo",nil)
+      @client_socket.expects(:gets).returns("remove foo\n")
 
       @client.read_and_execute()
     end
@@ -46,10 +43,8 @@ describe Invoker::CommandListener::Client do
     end
 
     it "should print error if read from socket" do
-      invoker_commander.expects(:remove_command).never()
-      invoker_commander.expects(:add_command_by_label).never()
-      @client_socket.expects(:read).returns("eugh foo\n")
-      @client_socket.expects(:close)
+      invoker_commander.expects(:on_next_tick).never()
+      @client_socket.expects(:gets).returns("eugh foo\n")
 
       @client.read_and_execute
     end

data/spec/invoker/command_worker_spec.rb

@@ -1,4 +1,15 @@
 require "spec_helper"
 
 describe "Command Worker" do
+  describe "converting workers hash to json" do
+    before do
+      @workers = {}
+      @workers["foo"] = Invoker::CommandWorker.new("foo", 89, 1023, "red")
+      @workers["bar"] = Invoker::CommandWorker.new("bar", 99, 1024, "blue")
+    end
+
+    it "should print json" do
+      @workers.values.map {|worker| worker.to_h }.to_json.should.not.be.empty
+    end
+  end
 end

data/spec/invoker/commander_spec.rb

@@ -39,16 +39,27 @@ describe "Invoker::Commander" do
       describe "if a signal is specified" do
         it "should use that signal to kill the worker" do
           @commander.expects(:process_kill).with("bogus", "HUP").returns(true)
-          @commander.remove_command("resque", "HUP")
+          @commander.remove_command("resque", "HUP").should.be.true
         end
       end
 
       describe "if no signal is specified" do
         it "should use INT signal" do
           @commander.expects(:process_kill).with("bogus", "INT").returns(true)
-          @commander.remove_command("resque", nil)
+          @commander.remove_command("resque", nil).should.be.true
         end
       end
+
+      # describe "when a worker is not found" do
+      #   before do
+      #     @commander = Invoker::Commander.new()
+      #     @commander.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
+      #   end
+
+      #   it "should return false" do
+          
+      #   end
+      # end
     end
 
     describe "when no worker is found" do
@@ -69,10 +80,15 @@ describe "Invoker::Commander" do
     before do
       invoker_config.stubs(:processes).returns([OpenStruct.new(:label => "sleep", :cmd => "sleep 4", :dir => ENV['HOME'])])
       @commander = Invoker::Commander.new()
+      Invoker.const_set(:COMMANDER, @commander)
+    end
+
+    after do
+      Invoker.send(:remove_const,:COMMANDER)
     end
 
     it "should populate workers and open_pipes" do
-      @commander.reactor.expects(:start).returns(true)
+      @commander.expects(:start_event_loop)
       @commander.start_manager()
       @commander.open_pipes.should.not.be.empty
       @commander.workers.should.not.be.empty
@@ -89,4 +105,30 @@ describe "Invoker::Commander" do
     end
   end
 
+  describe "#runnables" do
+    before do
+      @commander = Invoker::Commander.new()
+    end
+
+    it "should run runnables in reactor tick with one argument" do
+      @commander.on_next_tick("foo") { |cmd| add_command_by_label(cmd) }
+      @commander.expects(:add_command_by_label).returns(true)
+      @commander.run_runnables()
+    end
+
+    it "should run runnables with multiple args" do
+      @commander.on_next_tick("foo", "bar", "baz") { |t1,*rest|
+        remove_command(t1, rest)
+      }
+      @commander.expects(:remove_command).with("foo", ["bar", "baz"]).returns(true)
+      @commander.run_runnables()
+    end
+
+    it "should run runnable with no args" do
+      @commander.on_next_tick() { hello() }
+      @commander.expects(:hello).returns(true)
+      @commander.run_runnables()
+    end
+  end
+
 end

data/spec/invoker/config_spec.rb

@@ -16,7 +16,7 @@ command = ruby try_sleep.rb
         file.write(config_data)
         file.close
         lambda {
-          Invoker::Config.new(file.path)
+          Invoker::Parsers::Config.new(file.path)
         }.should.raise(Invoker::Errors::InvalidConfig)
       ensure
         file.unlink()

data/spec/invoker/event/manager_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+describe Invoker::Event::Manager do
+  describe "Run scheduled events" do
+    before do
+      @event_manager = Invoker::Event::Manager.new()
+    end
+
+    it "should run matched events" do
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.trigger("foo", :exit)
+
+      @event_manager.run_scheduled_events do |event|
+        event.block.call.should.equal("exit foo")
+      end
+
+      @event_manager.scheduled_events.should.be.empty
+      @event_manager.triggered_events.should.be.empty
+    end
+
+    it "should remove triggrered and scheduld events on run" do
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.schedule_event("bar", :entry) { "entry bar"}
+      @event_manager.trigger("foo", :exit)
+      @event_manager.trigger("baz", :exit)
+
+      @event_manager.run_scheduled_events do |event|
+        event.block.call.should.equal("exit foo")
+      end
+
+      @event_manager.scheduled_events.should.not.be.empty
+      @event_manager.triggered_events.should.not.be.empty
+
+      baz_containing_event = lambda do |events| 
+        events.detect {|event| event.command_label == "baz" }
+      end
+
+      bar_containing_scheduled_event = lambda do |events|
+        events.keys.detect {|event_key| event_key == "bar" }
+      end
+
+      @event_manager.triggered_events.should.be.a baz_containing_event
+      @event_manager.scheduled_events.should.be.a bar_containing_scheduled_event
+    end
+
+    it "should handle multiple events for same command" do
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.schedule_event("foo", :entry) { "entry bar"}
+      @event_manager.trigger("foo", :exit)
+
+      @event_manager.run_scheduled_events { |event| }
+
+
+      @event_manager.schedule_event("foo", :exit) { 'exit foo' }
+      @event_manager.trigger("foo", :exit)
+
+      @event_manager.scheduled_events.should.not.be.empty
+      @event_manager.triggered_events.should.not.be.empty
+    end
+
+    it "should not run unmatched events" do
+      @event_manager.schedule_event("bar", :entry) { "entry bar"}
+      @event_manager.trigger("foo", :exit)
+
+      events_ran = false
+      @event_manager.run_scheduled_events do |event|
+        events_ran = true
+      end
+      events_ran.should.be.false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ $: << __LIB_PATH__
 require "pry"
 require "invoker"
 
+ENV["INVOKER_TESTS"] = "true"
 
 def invoker_config
   if Invoker.const_defined?(:CONFIG)

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: invoker
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.1.pre
+  prerelease: 6
 platform: ruby
 authors:
 - Hemant Kumar
@@ -11,99 +12,129 @@ cert_chain: []
 date: 2013-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  name: slop
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: iniparse
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  name: iniparse
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  name: colored
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: formatador
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
-  name: bacon
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  name: mocha-on-bacon
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: mocha-on-bacon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -123,13 +154,16 @@ files:
 - bin/invoker
 - invoker.gemspec
 - lib/invoker.rb
-- lib/invoker/command_listener.rb
 - lib/invoker/command_listener/client.rb
 - lib/invoker/command_listener/server.rb
 - lib/invoker/command_worker.rb
 - lib/invoker/commander.rb
-- lib/invoker/config.rb
 - lib/invoker/errors.rb
+- lib/invoker/event/manager.rb
+- lib/invoker/logger.rb
+- lib/invoker/parsers/config.rb
+- lib/invoker/parsers/option_parser.rb
+- lib/invoker/process_printer.rb
 - lib/invoker/reactor.rb
 - lib/invoker/runner.rb
 - lib/invoker/version.rb
@@ -138,35 +172,37 @@ files:
 - spec/invoker/command_worker_spec.rb
 - spec/invoker/commander_spec.rb
 - spec/invoker/config_spec.rb
+- spec/invoker/event/manager_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/code-mancers/invoker
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Something small for Process management
 test_files:
 - spec/invoker/command_listener/client_spec.rb
 - spec/invoker/command_worker_spec.rb
 - spec/invoker/commander_spec.rb
 - spec/invoker/config_spec.rb
+- spec/invoker/event/manager_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MGY0NmQ0YjY1MzZiOWNiYjJkNzE3NjI1YTQxOTI3YTEwMGQxM2FhZQ==
-  data.tar.gz: !binary |-
-    NGNiZDNlMTgxZjliOWVmMTdlNjI0YmFkNjUyODcwNjViNGQ5MTJlMA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MGQxYzdhY2MxYWRhMjExM2NlNDdiYTM0OTc1YjAxZmIyYTFjMjM2YWJiMmUx
-    NTE3OWFiMWNiZDEwOGE0NTA2ZmUyOGI1NGYwYTAxYzYwNjM2ZTQzMzU2ODkw
-    Yjc5MGQxZDg4ZmQ2MTRlYWJjMTE3ZDkwODIzODYxOTkyYjM2ZmE=
-  data.tar.gz: !binary |-
-    NmIxY2Q3NzkzM2Y0OTYxMTk4ZmJmZTIxMmI2NGRjZTkyZjdkOGU2NGZiZjhh
-    YmNlZDZmODdmYjE4OWIxMzY5ZDUyNDhjODU2NmIwYTA0ZjQ5YmQxNzQxZTM2
-    MjUyMjI1MTAyYTZlZGVjZjRkYmEwMjRjOTgwNWE4ZjBmYjIwYTE=

data/lib/invoker/command_listener.rb

@@ -1,3 +0,0 @@
-require_relative "command_listener/server"
-require_relative "command_listener/client"
-

data/lib/invoker/config.rb

@@ -1,28 +0,0 @@
-require "yaml"
-require 'iniparse'
-
-module Invoker
-  class Config
-    attr_accessor :processes
-    def initialize(filename)
-      @ini_content = File.read(filename)
-      @processes = process_ini(@ini_content)
-    end
-
-    private
-    def process_ini(ini_content)
-      document = IniParse.parse(ini_content)
-      document.map do |section|
-        check_directory(section["directory"])
-        OpenStruct.new(label: section.key, dir: section["directory"], cmd: section["command"])
-      end
-    end
-
-    def check_directory(app_dir)
-      if app_dir && !app_dir.empty? && !File.directory?(app_dir)
-        raise Invoker::Errors::InvalidConfig.new("Invalid directory #{app_dir}")
-      end
-    end
-
-  end
-end