invoker_ruby34 2.0.0

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

data/spec/invoker/config_spec.rb

@@ -0,0 +1,361 @@
+require "spec_helper"
+
+require "tempfile"
+
+describe "Invoker::Config" do
+  describe "with invalid directory" do
+    it "should raise error during startup" do
+      begin
+        file = Tempfile.new(["invalid_config", ".ini"])
+
+        config_data =<<-EOD
+[try_sleep]
+directory = /Users/gnufied/foo
+command = ruby try_sleep.rb
+      EOD
+        file.write(config_data)
+        file.close
+        expect {
+          Invoker::Parsers::Config.new(file.path, 9000)
+        }.to raise_error(Invoker::Errors::InvalidConfig)
+      ensure
+        file.unlink()
+      end
+    end
+  end
+
+  describe "with relative directory path" do
+    it "should expand path in commands" do
+      begin
+        file = Tempfile.new(["config", ".ini"])
+
+        config_data =<<-EOD
+[pwd_home]
+directory = ~
+command = pwd
+
+[pwd_parent]
+directory = ../
+command = pwd
+      EOD
+        file.write(config_data)
+        file.close
+
+        config = Invoker::Parsers::Config.new(file.path, 9000)
+        command1 = config.processes.first
+
+        expect(command1.dir).to match(File.expand_path('~'))
+
+        command2 = config.processes[1]
+
+        expect(command2.dir).to match(File.expand_path('..'))
+      ensure
+        file.unlink()
+      end
+    end
+  end
+
+  describe "for ports" do
+    it "should replace port in commands" do
+      begin
+        file = Tempfile.new(["invalid_config", ".ini"])
+
+        config_data =<<-EOD
+[try_sleep]
+directory = /tmp
+command = ruby try_sleep.rb -p $PORT
+
+[ls]
+directory = /tmp
+command = ls -p $PORT
+
+[noport]
+directory = /tmp
+command = ls
+      EOD
+        file.write(config_data)
+        file.close
+
+        config = Invoker::Parsers::Config.new(file.path, 9000)
+        command1 = config.processes.first
+
+        expect(command1.port).to eq(9000)
+        expect(command1.cmd).to match(/9000/)
+
+        command2 = config.processes[1]
+
+        expect(command2.port).to eq(9001)
+        expect(command2.cmd).to match(/9001/)
+
+        command2 = config.processes[2]
+
+        expect(command2.port).to be_nil
+      ensure
+        file.unlink()
+      end
+    end
+
+    it "should use port from separate option" do
+      begin
+        file = Tempfile.new(["invalid_config", ".ini"])
+        config_data =<<-EOD
+[try_sleep]
+directory = /tmp
+command = ruby try_sleep.rb -p $PORT
+
+[ls]
+directory = /tmp
+port = 3000
+command = pwd
+
+[noport]
+directory = /tmp
+command = ls
+      EOD
+        file.write(config_data)
+        file.close
+
+        config = Invoker::Parsers::Config.new(file.path, 9000)
+        command1 = config.processes.first
+
+        expect(command1.port).to eq(9000)
+        expect(command1.cmd).to match(/9000/)
+
+        command2 = config.processes[1]
+
+        expect(command2.port).to eq(3000)
+
+        command2 = config.processes[2]
+
+        expect(command2.port).to be_nil
+      ensure
+        file.unlink()
+      end
+    end
+  end
+
+  describe "loading power config", fakefs: true do
+    before do
+      FileUtils.mkdir_p('/tmp')
+      FileUtils.mkdir_p(inv_conf_dir)
+      File.open("/tmp/foo.ini", "w") { |fl| fl.write("") }
+    end
+
+    it "does not load config if platform is darwin but there is no power config file" do
+      Invoker::Power::Config.expects(:load_config).never
+      Invoker::Parsers::Config.new("/tmp/foo.ini", 9000)
+    end
+
+    it "loads config if platform is darwin and power config file exists" do
+      File.open(Invoker::Power::Config.config_file, "w") { |fl| fl.puts "sample" }
+      Invoker::Power::Config.expects(:load_config).once
+      Invoker::Parsers::Config.new("/tmp/foo.ini", 9000)
+    end
+  end
+
+  describe "Procfile" do
+    it "should load Procfiles and create config object" do
+      File.open("/tmp/Procfile", "w") {|fl|
+        fl.write <<-EOD
+web: bundle exec rails s -p $PORT
+          EOD
+      }
+      config = Invoker::Parsers::Config.new("/tmp/Procfile", 9000)
+      command1 = config.processes.first
+
+      expect(command1.port).to eq(9000)
+      expect(command1.cmd).to match(/bundle exec rails/)
+    end
+  end
+
+  describe "Copy of DNS information" do
+    it "should allow copy of DNS information" do
+      File.open("/tmp/Procfile", "w") {|fl|
+        fl.write <<-EOD
+web: bundle exec rails s -p $PORT
+          EOD
+      }
+      Invoker.load_invoker_config("/tmp/Procfile", 9000)
+      dns_cache = Invoker::DNSCache.new(Invoker.config)
+
+      expect(dns_cache.dns_data).to_not be_empty
+      expect(dns_cache.dns_data['web']).to_not be_empty
+      expect(dns_cache.dns_data['web']['port']).to eql 9000
+    end
+  end
+
+  describe "#autorunnable_processes" do
+    it "returns a list of processes that can be autorun" do
+      begin
+        file = Tempfile.new(["config", ".ini"])
+        config_data =<<-EOD
+[postgres]
+command = postgres -D /usr/local/var/postgres
+
+[redis]
+command = redis-server /usr/local/etc/redis.conf
+disable_autorun = true
+
+[memcached]
+command = /usr/local/opt/memcached/bin/memcached
+disable_autorun = false
+
+[panda-api]
+command = bundle exec rails s
+disable_autorun = true
+
+[panda-auth]
+command = bundle exec rails s -p $PORT
+      EOD
+        file.write(config_data)
+        file.close
+
+        config = Invoker::Parsers::Config.new(file.path, 9000)
+        expect(config.autorunnable_processes.map(&:label)).to eq(['postgres', 'memcached', 'panda-auth'])
+      ensure
+        file.unlink()
+      end
+    end
+
+    it "returns a list of processes that can by index" do
+      begin
+        file = Tempfile.new(["config", ".ini"])
+        config_data =<<-EOD
+[postgres]
+command = postgres -D /usr/local/var/postgres
+index = 2
+sleep = 5
+
+[redis]
+command = redis-server /usr/local/etc/redis.conf
+disable_autorun = true
+index = 3
+
+[memcached]
+command = /usr/local/opt/memcached/bin/memcached
+disable_autorun = false
+index = 5
+
+[panda-api]
+command = bundle exec rails s
+disable_autorun = true
+index = 4
+
+[panda-auth]
+command = bundle exec rails s -p $PORT
+index = 1
+      EOD
+        file.write(config_data)
+        file.close
+
+        config = Invoker::Parsers::Config.new(file.path, 9000)
+        processes = config.autorunnable_processes
+        expect(processes.map(&:label)).to eq(['panda-auth', 'postgres', 'memcached'])
+        expect(processes[0].sleep_duration).to eq(0)
+        expect(processes[1].sleep_duration).to eq(5)
+      ensure
+        file.unlink()
+      end
+    end
+  end
+
+  describe "global config file" do
+    it "should use global config file if available" do
+      begin
+        FileUtils.mkdir_p(Invoker::Power::Config.config_dir)
+        filename = "#{Invoker::Power::Config.config_dir}/foo.ini"
+        file = File.open(filename, "w")
+        config_data =<<-EOD
+[try_sleep]
+directory = /tmp
+command = ruby try_sleep.rb
+        EOD
+        file.write(config_data)
+        file.close
+        config = Invoker::Parsers::Config.new("foo", 9000)
+        expect(config.filename).to eql(filename)
+      ensure
+        File.unlink(filename)
+      end
+    end
+  end
+
+  describe "config file autodetection" do
+    context "no config file given" do
+
+      def create_invoker_ini
+        file = File.open("invoker.ini", "w")
+        config_data =<<-EOD
+[some_process]
+command = some_command
+        EOD
+        file.write(config_data)
+        file.close
+
+        file
+      end
+
+      def create_procfile
+        file = File.open("Procfile", "w")
+        config_data =<<-EOD
+some_other_process: some_other_command
+        EOD
+        file.write(config_data)
+        file.close
+
+        file
+      end
+
+      context "directory has invoker.ini" do
+        it "autodetects invoker.ini" do
+          begin
+            file = create_invoker_ini
+
+            config = Invoker::Parsers::Config.new(nil, 9000)
+            expect(config.process("some_process").cmd).to eq("some_command")
+          ensure
+            File.delete(file)
+          end
+        end
+      end
+
+      context "directory has Procfile" do
+        it "autodetects Procfile" do
+          begin
+            file = create_procfile
+
+            config = Invoker::Parsers::Config.new(nil, 9000)
+            expect(config.process("some_other_process").cmd).to eq("some_other_command")
+          ensure
+            File.delete(file)
+          end
+        end
+      end
+
+      context "directory has both invoker.ini and Procfile" do
+        it "prioritizes invoker.ini" do
+          begin
+            invoker_ini = create_invoker_ini
+            procfile = create_procfile
+
+            config = Invoker::Parsers::Config.new(nil, 9000)
+            expect(config.process("some_process").cmd).to eq("some_command")
+            processes = config.autorunnable_processes
+            process_1 = processes[0]
+            expect(process_1.sleep_duration).to eq(0)
+            expect(process_1.index).to eq(0)
+          ensure
+            File.delete(invoker_ini)
+            File.delete(procfile)
+          end
+        end
+      end
+
+      context "directory doesn't have invoker.ini or Procfile" do
+        it "aborts" do
+          expect { Invoker::Parsers::Config.new(nil, 9000) }.to raise_error(SystemExit)
+        end
+      end
+    end
+  end
+end

data/spec/invoker/daemon_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Invoker::Daemon do
+  let(:daemon) { Invoker::Daemon.new}
+
+  describe "#start" do
+    context "when daemon is aleady running" do
+      it "exits without any error" do
+        daemon.expects(:running?).returns(true)
+        begin
+          daemon.start
+        rescue SystemExit => e
+          expect(e.status).to be(0)
+        end
+      end
+    end
+
+    context "when daemon is not running" do
+      it "starts the daemon" do
+        daemon.expects(:dead?).returns(false)
+        daemon.expects(:running?).returns(false)
+        daemon.expects(:daemonize)
+        daemon.start
+      end
+    end
+  end
+
+  describe "#stop" do
+    it "stops the daemon" do
+      daemon.expects(:kill_process)
+      daemon.stop
+    end
+  end
+end