invoker 1.0.4 → 1.1.0

data/lib/invoker/process_printer.rb

@@ -1,53 +1,42 @@
 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
+    attr_accessor :list_response
 
-      final_json.to_json
+    def initialize(list_response)
+      self.list_response = list_response
     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
+    def print_table
+      hash_with_colors = []
+      list_response.processes.each do |process|
+        if process.pid
+          hash_with_colors << colorize_hash(process, "green")
+        else
+          hash_with_colors << colorize_hash(process, "light_black")
         end
-        Formatador.display_compact_table(json_for_printing)
       end
+      Formatador.display_compact_table(hash_with_colors)
     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
+
+    def colorize_hash(process, color)
+      hash_with_colors = {}
+
+      hash_with_colors['dir'] = colored_string(process.dir, color)
+      hash_with_colors['pid'] = colored_string(process.pid || 'Not Running', color)
+      hash_with_colors['shell_command'] = colored_string(process.shell_command, color)
+      hash_with_colors['process_name'] = colored_string(process.process_name, color)
+      hash_with_colors
     end
 
+    def colored_string(string, color)
+      string = string.to_s
+      if string.length > MAX_COLUMN_WIDTH
+        string = "#{string[0..MAX_COLUMN_WIDTH]}.."
+      end
+      "[#{color}]#{string}[/]"
+    end
   end
 end

data/lib/invoker/reactor.rb

@@ -1,56 +1,37 @@
 module Invoker
   class Reactor
-    attr_accessor :monitored_fds
+    attr_accessor :reader
+
     def initialize
-      @monitored_fds = []
+      @reader = Invoker::Reactor::Reader.new
     end
 
-    def add_to_monitor(fd)
-      @monitored_fds << fd
+    def watch_for_read(fd)
+      reader.watch_for_read(fd)
     end
 
-    def remove_from_monitoring(fd)
-      @monitored_fds.delete(fd)
+    # Writes data to client socket and raises error if errors
+    # while writing
+    def send_data(socket, data)
+      socket.write(data)
+    rescue
+      raise Invoker::Errors::ClientDisconnected
     end
 
-    def watch_on_pipe
-      ready_read_fds,ready_write_fds,read_error_fds = select(monitored_fds,[],[],0.05)
+    def monitor_for_fd_events
+      ready_read_fds, _ , _ = select(*options_for_select)
 
       if ready_read_fds && !ready_read_fds.empty?
-        handle_read_event(ready_read_fds)
+        reader.handle_read_event(ready_read_fds)
       end
     end
 
-    def handle_read_event(ready_read_fds)
-      ready_fds = ready_read_fds.flatten.compact
-      ready_fds.each {|ready_fd| process_read(ready_fd) }
-    end
-
-    def process_read(ready_fd)
-      command_worker = Invoker::COMMANDER.get_worker_from_fd(ready_fd)
-      begin
-        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
+    private
 
-    def read_data(ready_fd)
-      sock_data = []
-      begin
-        while(t_data = ready_fd.read_nonblock(64))
-          sock_data << t_data
-        end
-      rescue Errno::EAGAIN
-        return sock_data.join
-      rescue Errno::EWOULDBLOCK
-        return sock_data.join
-      rescue
-        raise Invoker::Errors::ProcessTerminated.new(ready_fd,sock_data.join)
-      end
+    def options_for_select
+      [reader.read_array, [], [], 0.05]
     end
-
   end
 end
+
+require "invoker/reactor/reader"

data/lib/invoker/reactor/reader.rb

@@ -0,0 +1,53 @@
+module Invoker
+  class Reactor::Reader
+    attr_accessor :read_array
+
+    def initialize
+      @read_array = []
+    end
+
+    def watch_for_read(socket)
+      @read_array << socket
+    end
+
+    def handle_read_event(read_ready_fds)
+      ready_fds = read_ready_fds.flatten.compact
+      ready_fds.each { |ready_fd| process_read(ready_fd) }
+    end
+
+    private
+
+    def process_read(ready_fd)
+      command_worker = Invoker.commander.get_worker_from_fd(ready_fd)
+      begin
+        data = read_data(ready_fd)
+        command_worker.receive_data(data)
+      rescue Invoker::Errors::ProcessTerminated
+        remove_from_read_monitoring(command_worker.pipe_end, command_worker)
+      end
+    end
+
+    def remove_from_read_monitoring(fd, command_worker)
+      read_array.delete(fd)
+      command_worker.unbind
+    rescue StandardError => error
+      Invoker::Logger.puts(error.message)
+      Invoker::Logger.puts(error.backtrace)
+    end
+
+    def read_data(ready_fd)
+      sock_data = []
+      begin
+        while(t_data = ready_fd.read_nonblock(64))
+          sock_data << t_data
+        end
+      rescue Errno::EAGAIN
+        return sock_data.join
+      rescue Errno::EWOULDBLOCK
+        return sock_data.join
+      rescue
+        raise Invoker::Errors::ProcessTerminated.new(ready_fd,sock_data.join)
+      end
+    end
+  end
+end

data/lib/invoker/version.rb

@@ -1,3 +1,3 @@
 module Invoker
-  VERSION = "1.0.4"
+  VERSION = "1.1.0"
 end

data/readme.md

@@ -1,7 +1,7 @@
 Invoker is a gem for managing processes in development environment.
 
 [![Build Status](https://travis-ci.org/code-mancers/invoker.png)](https://travis-ci.org/code-mancers/invoker)
-[![Code Climate](https://codeclimate.com/repos/51d3bfb9c7f3a3777b060155/badges/7e150ca223f6bc8935f7/gpa.png)](https://codeclimate.com/repos/51d3bfb9c7f3a3777b060155/feed)
+[![Code Climate](https://codeclimate.com/github/code-mancers/invoker.png)](https://codeclimate.com/github/code-mancers/invoker)
 [![Coverage Status](https://coveralls.io/repos/code-mancers/invoker/badge.png)](https://coveralls.io/r/code-mancers/invoker)
 [![Dependency Status](https://gemnasium.com/code-mancers/invoker.png)](https://gemnasium.com/code-mancers/invoker)
 

data/spec/invoker/cli/pinger_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Invoker::CLI::Pinger do
+  let(:unix_client) { Invoker::IPC::UnixClient.new }
+  let(:pinger) { Invoker::CLI::Pinger.new(unix_client) }
+  let(:pong) { MM::Pong.new(status: 'pong') }
+
+  context "If Invoker is running" do
+    it "should return true" do
+      unix_client.expects(:send_and_receive).returns(pong)
+      expect(pinger.invoker_running?).to be_true
+    end
+  end
+
+  context "if Invoker is not running" do
+    it "should return false" do
+      unix_client.expects(:send_and_receive).returns(nil)
+      unix_client.expects(:abort).never
+      expect(pinger.invoker_running?).to be_false
+    end
+  end
+end

data/spec/invoker/cli/tail_watcher_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe  Invoker::CLI::TailWatcher do
+  let(:tail_watcher) { Invoker::CLI::TailWatcher.new }
+
+  describe "Adding processes to watch list" do
+    it "should allow add" do
+      tail_watcher.add(["rails"], "socket")
+      expect(tail_watcher.tail_watchers).to_not be_empty
+      expect(tail_watcher["rails"]).to eql ["socket"]
+    end
+  end
+
+  describe "removing processes from watch list" do
+    context "when process has only one watcher" do
+      before do
+        tail_watcher.add(["rails"], "socket")
+      end
+      it "should remove and purge process watch list" do
+        expect(tail_watcher.tail_watchers).to_not be_empty
+        tail_watcher.remove("rails", "socket")
+        expect(tail_watcher.tail_watchers).to be_empty
+      end
+    end
+    context "when process multiple watchers" do
+      before do
+        tail_watcher.add(["rails"], "socket")
+        tail_watcher.add(["rails"], "socket2")
+      end
+
+      it "should remove only related socket" do
+        expect(tail_watcher.tail_watchers).to_not be_empty
+        tail_watcher.remove("rails", "socket")
+        expect(tail_watcher.tail_watchers).to_not be_empty
+        expect(tail_watcher["rails"]).to eql ["socket2"]
+      end
+    end
+  end
+end

data/spec/invoker/cli_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Invoker::CLI do
+  describe "default start command" do
+    it "should use default if no other command specified" do
+      Invoker::CLI.any_instance.expects(:start).with("dummy")
+      Invoker::CLI.start(["dummy"])
+    end
+
+    it "should use proper command if it exists" do
+      Invoker::CLI.any_instance.expects(:list)
+      Invoker::CLI.start(["list"])
+    end
+
+    it "should list version" do
+      Invoker::CLI.any_instance.expects(:version)
+      Invoker::CLI.start(["-v"])
+    end
+  end
+
+  describe "stop command" do
+    it "should stop the daemon" do
+      Invoker.daemon.expects(:stop).once
+      Invoker::CLI.start(["stop"])
+    end
+  end
+end

data/spec/invoker/command_worker_spec.rb

@@ -1,6 +1,9 @@
 require "spec_helper"
 
 describe "Command Worker" do
+  let(:pipe_end) { StringIO.new }
+  let(:command_worker) { Invoker::CommandWorker.new('rails', pipe_end, 100, :red) }
+
   describe "converting workers hash to json" do
     before do
       @workers = {}
@@ -12,4 +15,31 @@ describe "Command Worker" do
       expect(@workers.values.map {|worker| worker.to_h }.to_json).not_to be_empty
     end
   end
+
+  describe "sending json responses" do
+    before do
+      @socket = StringIO.new
+      Invoker.tail_watchers = Invoker::CLI::TailWatcher.new
+      Invoker.tail_watchers.add(['rails'], @socket)
+    end
+
+    after do
+      Invoker.tail_watchers = nil
+    end
+
+    context "when there is a error encoding the message" do
+      it "should send nothing to the socket" do
+        MM::TailResponse.any_instance.expects(:encoded_message).raises(StandardError, "encoding error")
+        command_worker.receive_line('hello_world')
+        expect(@socket.string).to be_empty
+      end
+    end
+
+    context "when there is successful delivery" do
+      it "should return json data to client if tail watchers" do
+        command_worker.receive_line('hello_world')
+        expect(@socket.string).to match(/hello_world/)
+      end
+    end
+  end
 end

data/spec/invoker/commander_spec.rb

@@ -1,132 +1,108 @@
 require "spec_helper"
 
 describe "Invoker::Commander" do
-
   describe "With no processes configured" do
     before do
-      @commander = Invoker::Commander.new()
+      @commander = Invoker::Commander.new
     end
 
     it "should throw error" do
       invoker_config.stubs(:processes).returns([])
 
       expect {
-        @commander.start_manager()
+        @commander.start_manager
       }.to raise_error(Invoker::Errors::InvalidConfig)
     end
   end
 
-  describe "#add_command_by_label" do
-    before do
-      @commander = Invoker::Commander.new()
-    end
-
-    it "should find command by label and start it, if found" do
-      invoker_config.stubs(:processes).returns([OpenStruct.new(:label => "resque", :cmd => "foo", :dir => "bar")])
-      invoker_config.expects(:process).returns(OpenStruct.new(:label => "resque", :cmd => "foo", :dir => "bar"))
-      @commander.expects(:add_command).returns(true)
-
-      @commander.add_command_by_label("resque")
-    end
-
-    it "should not start already running process" do
-      @commander.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
-      expect(@commander.add_command_by_label("resque")).to be_false
-    end
-  end
-
-  describe "#remove_command" do
-    describe "when a worker is found" do
+  describe "#start_process" do
+    describe "when not daemonized" do
       before do
-        @commander = Invoker::Commander.new()
-        @commander.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
+        invoker_config.stubs(:processes).returns(
+          [OpenStruct.new(:label => "foobar", :cmd => "foobar_command", :dir => ENV['HOME'])]
+        )
+        @commander = Invoker::Commander.new
+        Invoker.commander = @commander
       end
 
-      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)
-          expect(@commander.remove_command("resque", "HUP")).to be_true
-        end
+      after do
+        Invoker.commander = nil
       end
 
-      describe "if no signal is specified" do
-        it "should use INT signal" do
-          @commander.expects(:process_kill).with("bogus", "INT").returns(true)
-          expect(@commander.remove_command("resque", nil)).to be_true
-        end
-      end
+      it "should populate workers and open_pipes" do
+        @commander.expects(:start_event_loop)
+        @commander.process_manager.expects(:load_env).returns({})
+        @commander.process_manager.expects(:spawn).returns(100)
+        @commander.process_manager.expects(:wait_on_pid)
+        @commander.expects(:at_exit)
+        @commander.start_manager
+        expect(@commander.process_manager.open_pipes).not_to be_empty
+        expect(@commander.process_manager.workers).not_to be_empty
 
-      # describe "when a worker is not found" do
-      #   before do
-      #     @commander = Invoker::Commander.new()
-      #     @commander.workers.expects(:[]).returns(OpenStruct.new(:pid => "bogus"))
-      #   end
+        worker = @commander.process_manager.workers['foobar']
 
-      #   it "should return false" do
+        expect(worker).not_to be_nil
+        expect(worker.command_label).to eq('foobar')
 
-      #   end
-      # end
+        pipe_end_worker = @commander.process_manager.open_pipes[worker.pipe_end.fileno]
+        expect(pipe_end_worker).not_to be_nil
+      end
     end
 
-    describe "when no worker is found" do
+    describe "when daemonized" do
       before do
-        @commander = Invoker::Commander.new()
-        @commander.workers.expects(:[]).returns(nil)
+        invoker_config.stubs(:processes).returns(
+          [OpenStruct.new(:label => "foobar", :cmd => "foobar_command", :dir => ENV['HOME'])]
+        )
+        @commander = Invoker::Commander.new
+        Invoker.commander = @commander
+        Invoker.daemonize = true
       end
 
-      it "should not kill anything" do
-        @commander.expects(:process_kill).never()
-        @commander.remove_command("resque", "HUP")
+      after do
+        Invoker.commander = nil
+        Invoker.daemonize = false
       end
-    end
-
-  end
-
-  describe "#add_command" 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 daemonize the process and populate workers and open_pipes" do
+        @commander.expects(:start_event_loop)
+        @commander.process_manager.expects(:load_env).returns({})
+        Invoker.daemon.expects(:start).once
+        @commander.process_manager.expects(:spawn).returns(100)
+        @commander.process_manager.expects(:wait_on_pid)
+        @commander.expects(:at_exit)
+        @commander.start_manager
 
-    it "should populate workers and open_pipes" do
-      @commander.expects(:start_event_loop)
-      @commander.expects(:load_env).returns({})
-      @commander.start_manager()
-      expect(@commander.open_pipes).not_to be_empty
-      expect(@commander.workers).not_to be_empty
+        expect(@commander.process_manager.open_pipes).not_to be_empty
+        expect(@commander.process_manager.workers).not_to be_empty
 
-      worker = @commander.workers['sleep']
+        worker = @commander.process_manager.workers['foobar']
 
-      expect(worker).not_to be_nil
-      expect(worker.command_label).to eq('sleep')
-      expect(worker.color).to eq(:green)
+        expect(worker).not_to be_nil
+        expect(worker.command_label).to eq('foobar')
 
-      pipe_end_worker = @commander.open_pipes[worker.pipe_end.fileno]
-      expect(pipe_end_worker).not_to be_nil
+        pipe_end_worker = @commander.process_manager.open_pipes[worker.pipe_end.fileno]
+        expect(pipe_end_worker).not_to be_nil
+      end
     end
   end
 
   describe "#runnables" do
     before do
-      @commander = Invoker::Commander.new()
+      @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.on_next_tick("foo") { |cmd| start_process_by_name(cmd) }
+      @commander.expects(:start_process_by_name).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)
+        stop_process(t1, rest)
       }
-      @commander.expects(:remove_command).with("foo", ["bar", "baz"]).returns(true)
+      @commander.expects(:stop_process).with("foo", ["bar", "baz"]).returns(true)
       @commander.run_runnables()
     end
 
@@ -136,50 +112,4 @@ describe "Invoker::Commander" do
       @commander.run_runnables()
     end
   end
-
-  describe "#load_env" do
-    before do
-      @commander = Invoker::Commander.new()
-    end
-
-    it "should load .env file from the specified directory" do
-      dir = "/tmp"
-      begin
-        env_file = File.new("#{dir}/.env", "w")
-        env_data =<<-EOD
-FOO=foo
-BAR=bar
-        EOD
-        env_file.write(env_data)
-        env_file.close
-        env_options = @commander.load_env(dir)
-        expect(env_options).to include("FOO" => "foo", "BAR" => "bar")
-      ensure
-        File.delete(env_file.path)
-      end
-    end
-
-    it "should default to current directory if no directory is specified" do
-      dir = ENV["HOME"]
-      ENV.stubs(:[]).with("PWD").returns(dir)
-      begin
-        env_file = File.new("#{dir}/.env", "w")
-        env_data =<<-EOD
-FOO=bar
-BAR=foo
-        EOD
-        env_file.write(env_data)
-        env_file.close
-        env_options = @commander.load_env
-        expect(env_options).to include("FOO" => "bar", "BAR" => "foo")
-      ensure
-        File.delete(env_file.path)
-      end
-    end
-
-    it "should return empty hash if there is no .env file" do
-      dir = "/tmp"
-      expect(@commander.load_env(dir)).to eq({})
-    end
-  end
 end