meepo 1.5.2

data/lib/invoker/process_printer.rb

@@ -0,0 +1,43 @@
+module Invoker
+  class ProcessPrinter
+    MAX_COLUMN_WIDTH = 40
+    attr_accessor :list_response
+
+    def initialize(list_response)
+      self.list_response = list_response
+    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
+      end
+      Formatador.display_compact_table(hash_with_colors)
+    end
+
+    private
+
+    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['port'] = colored_string(process.port, 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

@@ -0,0 +1,37 @@
+module Invoker
+  class Reactor
+    attr_accessor :reader
+
+    def initialize
+      @reader = Invoker::Reactor::Reader.new
+    end
+
+    def watch_for_read(fd)
+      reader.watch_for_read(fd)
+    end
+
+    # 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 monitor_for_fd_events
+      ready_read_fds, _ , _ = select(*options_for_select)
+
+      if ready_read_fds && !ready_read_fds.empty?
+        reader.handle_read_event(ready_read_fds)
+      end
+    end
+
+    private
+
+    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,54 @@
+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)
+      return unless command_worker
+      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

@@ -0,0 +1,47 @@
+module Invoker
+  class Version
+    include Comparable
+    attr_reader :major, :minor, :patch
+
+    def initialize(number)
+      t_major, t_minor, t_patch = number.split('.')
+      @major = t_major.to_i
+      @minor = t_minor.to_i
+      @patch = t_patch.to_i
+    end
+
+    def to_a
+      [major, minor, patch].compact
+    end
+
+    def <=>(version)
+      (major.to_i <=> version.major.to_i).nonzero? ||
+        (minor.to_i <=> version.minor.to_i).nonzero? ||
+        patch.to_i <=> version.patch.to_i
+    end
+
+    def matches?(operator, number)
+      version = Version.new(number)
+      self == version
+
+      return self == version if operator == '='
+      return self > version  if operator == '>'
+      return self < version  if operator == '<'
+      return version <= self && version.next > self if operator  == '~>'
+    end
+
+    def next
+      next_splits = to_a
+
+      if next_splits.length == 1
+        next_splits[0] += 1
+      else
+        next_splits[-2] += 1
+        next_splits[-1] = 0
+      end
+
+      Version.new(next_splits.join('.'))
+    end
+  end
+  VERSION = "1.5.2"
+end

data/readme.md

@@ -0,0 +1,25 @@
+Invoker is a gem for managing processes in development environment.
+
+[![Build Status](https://travis-ci.org/code-mancers/invoker.svg)](https://travis-ci.org/code-mancers/invoker)
+[![Code Climate](https://codeclimate.com/github/code-mancers/invoker.svg)](https://codeclimate.com/github/code-mancers/invoker)
+[![Coverage Status](https://coveralls.io/repos/code-mancers/invoker/badge.svg)](https://coveralls.io/r/code-mancers/invoker)
+[![Dependency Status](https://gemnasium.com/code-mancers/invoker.svg)](https://gemnasium.com/code-mancers/invoker)
+
+## Usage ##
+
+First we need to install `invoker` gem to get command line utility called `invoker`, we can do that via:
+
+    gem install invoker
+
+Currently it only works with Ruby 1.9.3, 2.0 and 2.1.
+
+## Manual ##
+
+Information about configuring and using Invoker can be found on -  [Invoker Website](http://invoker.codemancers.com)
+
+Invoker documentation is maintained via `Jekyll` and hosted on `github`. If you would like to fix an error
+or update something - please submit a pull request against `gh-pages` branch of `Invoker`.
+
+## Bug reports and Feature requests
+
+Please use [Github Issue Tracker](https://github.com/code-mancers/invoker/issues) for feature requests or bug reports.

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_truthy
+    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_falsey
+    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

@@ -0,0 +1,45 @@
+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 = {}
+      @workers["foo"] = Invoker::CommandWorker.new("foo", 89, 1023, "red")
+      @workers["bar"] = Invoker::CommandWorker.new("bar", 99, 1024, "blue")
+    end
+
+    it "should print json" 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

@@ -0,0 +1,152 @@
+require "spec_helper"
+
+describe "Invoker::Commander" do
+  before(:each) do
+    @original_invoker_config = Invoker.config
+    Invoker.config = mock
+  end
+
+  after(:each) do
+    Invoker.config = @original_invoker_config
+  end
+
+  describe "With no processes configured" do
+    before(:each) do
+      @commander = Invoker::Commander.new
+    end
+
+    it "should throw error" do
+      Invoker.config.stubs(:processes).returns([])
+
+      expect {
+        @commander.start_manager
+      }.to raise_error(Invoker::Errors::InvalidConfig)
+    end
+  end
+
+  describe "#start_process" do
+    describe "when not daemonized" do
+      before do
+        processes = [OpenStruct.new(:label => "foobar", :cmd => "foobar_command", :dir => ENV['HOME'], :sleep_duration => 2)]
+        Invoker.config.stubs(:processes).returns(processes)
+        Invoker.config.stubs(:autorunnable_processes).returns(processes)
+        Invoker.stubs(:can_run_balancer?).returns(false)
+        @commander = Invoker::Commander.new
+        Invoker.commander = @commander
+      end
+
+      after do
+        Invoker.commander = nil
+      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
+
+        worker = @commander.process_manager.workers['foobar']
+
+        expect(worker).not_to be_nil
+        expect(worker.command_label).to eq('foobar')
+
+        pipe_end_worker = @commander.process_manager.open_pipes[worker.pipe_end.fileno]
+        expect(pipe_end_worker).not_to be_nil
+      end
+    end
+
+    describe "when daemonized" do
+      before do
+        processes = [OpenStruct.new(:label => "foobar", :cmd => "foobar_command", :dir => ENV['HOME'], :sleep_duration => 2)]
+        Invoker.config.stubs(:processes).returns(processes)
+        Invoker.config.stubs(:autorunnable_processes).returns(processes)
+        Invoker.stubs(:can_run_balancer?).returns(false)
+        @commander = Invoker::Commander.new
+        Invoker.commander = @commander
+        Invoker.daemonize = true
+      end
+
+      after do
+        Invoker.commander = nil
+        Invoker.daemonize = false
+      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
+
+        expect(@commander.process_manager.open_pipes).not_to be_empty
+        expect(@commander.process_manager.workers).not_to be_empty
+
+        worker = @commander.process_manager.workers['foobar']
+
+        expect(worker).not_to be_nil
+        expect(worker.command_label).to eq('foobar')
+
+        pipe_end_worker = @commander.process_manager.open_pipes[worker.pipe_end.fileno]
+        expect(pipe_end_worker).not_to be_nil
+      end
+    end
+  end
+
+  describe 'disable_autorun option' do
+    context 'autorun is disabled for a process' do
+      before do
+        @processes = [
+          OpenStruct.new(:label => "foobar", :cmd => "foobar_command", :dir => ENV['HOME'], :sleep_duration => 2),
+          OpenStruct.new(:label => "panda", :cmd => "panda_command", :dir => ENV['HOME'], :disable_autorun => true, :sleep_duration => 2)
+        ]
+        Invoker.config.stubs(:processes).returns(@processes)
+        Invoker.config.stubs(:autorunnable_processes).returns([@processes.first])
+
+        @commander = Invoker::Commander.new
+      end
+
+      it "doesn't run process" do
+        @commander.expects(:install_interrupt_handler)
+        @commander.process_manager.expects(:run_power_server)
+        @commander.expects(:at_exit)
+        @commander.expects(:start_event_loop)
+
+        @commander.process_manager.expects(:start_process).with(@processes[0])
+        @commander.process_manager.expects(:start_process).with(@processes[1]).never
+        @commander.start_manager
+      end
+    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| 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|
+        stop_process(t1, rest)
+      }
+      @commander.expects(:stop_process).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