gorgon 0.2.0 → 0.3.0

data/spec/gem_service_spec.rb

@@ -0,0 +1,74 @@
+require 'gorgon/gem_service'
+
+describe GemService do
+  let(:configuration){ {:connection => {:host => "host"}, :originator_log_file => "file.log"}}
+  let(:protocol) { stub("OriginatorProtocol", :connect => nil,
+                        :receive_payloads => nil, :disconnect => nil,
+                        :send_message_to_listeners => nil)}
+  let(:logger){ stub("Originator Logger", :log => nil, :log_message => nil)}
+
+  before do
+    $stdout.stub!(:write)
+    GemService.any_instance.stub(:load_configuration_from_file).and_return configuration
+    EM.stub!(:run).and_yield
+    EM.stub!(:add_periodic_timer).and_yield
+    OriginatorLogger.stub!(:new).and_return logger
+    OriginatorProtocol.stub!(:new).and_return(protocol)
+    @service = GemService.new
+    @command = "install"
+  end
+
+  describe "#run" do
+    it "runs EventMachine loop and connect using configuration[:connection]" do
+      EM.should_receive(:run)
+      protocol.should_receive(:connect).once.ordered.with({:host => "host"}, anything)
+      @service.run @command
+    end
+
+    it "calls Protocol#send_message_to_listeners with version number" do
+      protocol.should_receive(:send_message_to_listeners).with(:gem_command, :gem_command => @command)
+      @service.run @command
+    end
+
+    it "adds a periodic timer that checks if there is any listener running command" do
+      EM.should_receive(:add_periodic_timer).with(GemService::TIMEOUT)
+      @service.run @command
+    end
+
+    context "when it receives an running_command message" do
+      before do
+        payload = {:type => "running_command", :hostname => "host"}
+        protocol.stub!(:receive_payloads).and_yield Yajl::Encoder.encode(payload)
+      end
+
+      it "writes to console" do
+        $stdout.should_receive(:write).with(/host/)
+        @service.run @command
+      end
+
+      it "won't diconnect as long as there is a host running_command" do
+        protocol.should_not_receive(:disconnect)
+        @service.run @command
+      end
+    end
+
+    context "when it receives an command_completed message" do
+      before do
+        running_command_payload = {:type => "running_command", :hostname => "host"}
+        complete_payload = {:type => "command_completed", :hostname => "host"}
+        protocol.stub!(:receive_payloads).and_yield(Yajl::Encoder.encode(running_command_payload))
+          .and_yield(Yajl::Encoder.encode(complete_payload))
+      end
+
+      it "writes to console" do
+        $stdout.should_receive(:write).at_least(:twice).with(/host/)
+        @service.run @command
+      end
+
+      it "disconnect since there is no host running command anymore" do
+        protocol.should_receive(:disconnect)
+        @service.run @command
+      end
+    end
+  end
+end

data/spec/job_state_spec.rb

@@ -123,13 +123,6 @@ describe JobState do
       end.should raise_error
     end
 
-    it "raises if job was cancelled" do
-      @job_state.cancel
-      lambda do
-        @job_state.file_finished payload
-      end.should raise_error
-    end
-
     it "tells to the proper HostState object that a file finished in that host" do
       HostState.stub!(:new).and_return host_state
       @job_state.file_started({:hostname => "hostname",

data/spec/listener_spec.rb

@@ -136,21 +136,45 @@ describe Listener do
 
       context "ping message pending on queue" do
         let(:ping_payload) {{
-            :payload => Yajl::Encoder.encode({:type => "ping", :reply_exchange_name => "name"}) }}
+            :payload => Yajl::Encoder.encode({:type => "ping", :reply_exchange_name => "name",
+                                               :body => {}}) }}
 
         before do
           queue.stub!(:pop => ping_payload)
-        end
+          listener.stub(:configuration).and_return({:worker_slots => 3})
+       end
 
         it "publishes ping_response message with Gorgon's version" do
           listener.should_not_receive(:run_job)
           bunny.should_receive(:exchange).with("name", anything).and_return(exchange)
           response = {:type => "ping_response", :hostname => Socket.gethostname,
-            :version => Gorgon::VERSION}
+            :version => Gorgon::VERSION, :worker_slots => 3}
           exchange.should_receive(:publish).with(Yajl::Encoder.encode(response))
           listener.poll
         end
       end
+
+      context "gem_command message pending on queue" do
+        let(:command) { "install" }
+
+        let(:payload) {
+            {:type => "gem_command", :reply_exchange_name => "name",
+              :body => {:command => command}}
+        }
+
+        let(:gem_command_handler) { stub("GemCommandHandler", :handle => nil)  }
+        let(:configuration) { {:worker_slots => 3} }
+        before do
+          queue.stub!(:pop => {:payload => Yajl::Encoder.encode(payload)})
+          listener.stub(:configuration).and_return(configuration)
+        end
+
+        it "calls GemCommandHandler#handle and pass payload" do
+          GemCommandHandler.should_receive(:new).with(bunny).and_return gem_command_handler
+          gem_command_handler.should_receive(:handle).with payload, configuration
+          listener.poll
+        end
+      end
     end
 
     describe "#run_job" do
@@ -194,23 +218,22 @@ describe Listener do
         end
 
         it "sends message to originator with output and errors from syncer" do
-          reply = {:type => :crash, :hostname => "hostname", :stdout => "some output", :stderr => "some errors"}
-          exchange.should_receive(:publish).with(Yajl::Encoder.encode(reply))
-          @listener.run_job(reply)
+          @listener.should_receive(:send_crash_message).with exchange, "some output", "some errors"
+          @listener.run_job(payload)
         end
       end
 
-      context "Worker Manager crahes" do
+      context "Worker Manager crashes" do
         before do
-          process_status.should_receive(:exitstatus).and_return 1
+          process_status.should_receive(:exitstatus).and_return 2, 2
         end
 
-        it "sends message to originator with output and errors from worker manager" do
-          stdout.should_receive(:read).and_return "some output"
-          stderr.should_receive(:read).and_return "some errors"
-          reply = {:type => :crash, :hostname => "hostname", :stdout => "some output", :stderr => "some errors"}
-          exchange.should_receive(:publish).with(Yajl::Encoder.encode(reply))
-          @listener.run_job(reply)
+        it "report_crash with pid, exitstatus, stdout and stderr outputs" do
+          @listener.should_receive(:report_crash).with(exchange,
+                                                       :out_file => WorkerManager::STDOUT_FILE,
+                                                       :err_file => WorkerManager::STDERR_FILE,
+                                                       :footer_text => Listener::ERROR_FOOTER_TEXT)
+          @listener.run_job(payload)
         end
       end
 
@@ -228,11 +251,6 @@ describe Listener do
         callback_handler.should_receive(:after_sync).once
         @listener.run_job(payload)
       end
-
-      it "uses Bundler#with_clean_env so the workers load new gems that could have been installed in after_sync" do
-        Bundler.should_receive(:with_clean_env).and_yield
-        @listener.run_job(payload)
-      end
     end
 
     private

data/spec/originator_protocol_spec.rb

@@ -4,7 +4,7 @@ describe OriginatorProtocol do
   let(:connection) { stub("Connection", :disconnect => nil, :on_closed => nil)}
   let(:queue) { stub("Queue", :bind => nil, :subscribe => nil, :name => "queue", :purge => nil,
                      :delete => nil) }
-  let(:exchange) { stub("Exchange", :publish => nil, :name => "exchange") }
+  let(:exchange) { stub("Exchange", :publish => nil, :name => "exchange", :delete => nil) }
   let(:channel) { stub("Channel", :queue => queue, :direct => exchange, :fanout => exchange,
                        :default_exchange => exchange) }
   let(:logger){ stub("Logger", :log => nil)}
@@ -39,13 +39,13 @@ describe OriginatorProtocol do
 
     it "opens a reply and exchange queue" do
       UUIDTools::UUID.stub!(:timestamp_create).and_return 1
-      channel.should_receive(:queue).once.with("1")
+      channel.should_receive(:queue).once.with("reply_queue_1")
       @originator_p.connect @conn_information
     end
 
     it "opens a reply exchange and binds reply queue to it" do
       UUIDTools::UUID.stub!(:timestamp_create).and_return 1
-      channel.should_receive(:direct).with("1")
+      channel.should_receive(:direct).with("reply_exchange_1")
       queue.should_receive(:bind).with(exchange)
       @originator_p.connect @conn_information
     end
@@ -82,16 +82,18 @@ describe OriginatorProtocol do
     end
   end
 
-  describe "#ping_listeners" do
+  describe "#send_message_to_listeners" do
     before do
       @originator_p.connect @conn_information
     end
 
-    it "adds reply_exchange_name to ping_messages and fanouts it using 'gorgon.jobs' exchange" do
-      expected_msg = {:type => "ping", :reply_exchange_name => "exchange"}
+    it "adds type and reply_exchange_name to message and fanouts it using 'gorgon.jobs' exchange" do
+      expected_msg = {:type => :msg_type, :reply_exchange_name => "exchange",
+        :body => {:data => 'data'}}
+      Yajl::Encoder.should_receive(:encode).with(expected_msg).and_return :msg
       channel.should_receive(:fanout).once.ordered.with("gorgon.jobs")
-      exchange.should_receive(:publish).once.ordered.with(Yajl::Encoder.encode(expected_msg))
-      @originator_p.ping_listeners
+      exchange.should_receive(:publish).once.ordered.with(:msg)
+      @originator_p.send_message_to_listeners :msg_type, :data => 'data'
     end
   end
 
@@ -136,9 +138,10 @@ describe OriginatorProtocol do
       @originator_p.connect @conn_information
     end
 
-    it "deletes reply and file queue" do
+    it "deletes reply_exchange and reply and file queues" do
       @originator_p.publish_files []
       queue.should_receive(:delete).twice
+      exchange.should_receive(:delete)
       @originator_p.disconnect
     end
 

data/spec/ping_service_spec.rb

@@ -5,7 +5,7 @@ describe "PingService" do
     let(:configuration){ {:connection => {:host => "host"}, :originator_log_file => "file.log"}}
     let(:protocol) { stub("OriginatorProtocol", :connect => nil, :ping => nil,
                           :receive_payloads => nil, :disconnect => nil,
-                          :ping_listeners => nil)}
+                          :send_message_to_listeners => nil)}
     let(:logger){ stub("Originator Logger", :log => nil, :log_message => nil)}
 
     before do
@@ -16,10 +16,10 @@ describe "PingService" do
       OriginatorLogger.stub!(:new).and_return logger
     end
 
-    it "connnects and calls OriginatorProtocol#ping_listeners" do
+    it "connnects and calls OriginatorProtocol#send_message_to_listeners" do
       OriginatorProtocol.should_receive(:new).once.ordered.and_return(protocol)
       protocol.should_receive(:connect).once.ordered.with({:host => "host"}, anything)
-      protocol.should_receive(:ping_listeners).once.ordered
+      protocol.should_receive(:send_message_to_listeners).once.ordered
       PingService.new.ping_listeners
     end
 

data/spec/pipe_forker_spec.rb

@@ -0,0 +1,53 @@
+require 'gorgon/pipe_forker'
+
+describe PipeForker do
+  let(:io_pipe) { stub("IO object", :close => nil)}
+  let(:pipe) {stub("Pipe", :write => io_pipe)}
+
+  let(:container_class) do
+    Class.new do
+      extend(PipeForker)
+    end
+  end
+
+  before do
+    IO.stub!(:pipe).and_return([io_pipe, io_pipe])
+    STDIN.stub!(:reopen)
+    container_class.stub!(:fork).and_yield.and_return(1)
+    container_class.stub!(:exit)
+  end
+
+  describe ".pipe_fork" do
+    it "creates a new pipe" do
+      IO.should_receive(:pipe).once.and_return ([io_pipe,io_pipe])
+      container_class.pipe_fork { }
+    end
+
+    it "forks once" do
+      container_class.should_receive(:fork).and_yield
+      container_class.pipe_fork { }
+    end
+
+    it "closes both side of pipe inside child and read in parent" do
+      io_pipe.should_receive(:close).exactly(3).times
+      container_class.pipe_fork { }
+    end
+
+    it "reopens stdin with a pipe" do
+      STDIN.should_receive(:reopen).with(io_pipe)
+      container_class.pipe_fork { }
+    end
+
+    it "yields" do
+      has_yielded = false
+      container_class.pipe_fork { has_yielded = true }
+      has_yielded.should be_true
+    end
+
+    it "returns pid of new process and a pipe" do
+      pid, stdin = container_class.pipe_fork { }
+      pid.should be 1
+      stdin.should == io_pipe
+    end
+  end
+end

data/spec/worker_manager_spec.rb

@@ -7,17 +7,46 @@ describe WorkerManager do
   let(:bunny) { stub("Bunny", :start => nil, :exchange => exchange,
                      :queue => queue, :stop => nil) }
   before do
-    Bunny.stub(:new).and_return(bunny)
-    STDIN.should_receive(:read).and_return '{"source_tree_path":"path/to/source",
-             "sync_exclude":["log"]}'
+    STDIN.stub!(:read).and_return "{}"
+    STDOUT.stub!(:reopen)
+    STDERR.stub!(:reopen)
+    STDOUT.stub!(:sync)
+    STDERR.stub!(:sync)
+    Bunny.stub!(:new).and_return(bunny)
+    Configuration.stub!(:load_configuration_from_file).and_return({})
+    EventMachine.stub!(:run).and_yield
   end
 
   describe ".build" do
     it "should load_configuration_from_file" do
-      Configuration.stub!(:load_configuration_from_file).and_return({})
-      Configuration.should_receive(:load_configuration_from_file).with("file.json")
+      STDIN.should_receive(:read).and_return '{"source_tree_path":"path/to/source",
+             "sync_exclude":["log"]}'
+
+      Configuration.should_receive(:load_configuration_from_file).with("file.json").and_return({})
 
       WorkerManager.build "file.json"
     end
+
+    it "redirect output to a file since writing to a pipe may block when pipe is full" do
+      File.should_receive(:open).with(WorkerManager::STDOUT_FILE, 'w').and_return(:file1)
+      STDOUT.should_receive(:reopen).with(:file1)
+      File.should_receive(:open).with(WorkerManager::STDERR_FILE, 'w').and_return(:file2)
+      STDERR.should_receive(:reopen).with(:file2)
+      WorkerManager.build ""
+    end
+
+    it "use STDOUT#sync to flush output immediately so if an exception happens, we can grab the last\
+few lines of output and send it to originator. Order matters" do
+      STDOUT.should_receive(:reopen).once.ordered
+      STDOUT.should_receive(:sync=).with(true).once.ordered
+      WorkerManager.build ""
+    end
+
+    it "use STDERR#sync to flush output immediately so if an exception happens, we can grab the last\
+few lines of output and send it to originator. Order matters" do
+      STDERR.should_receive(:reopen).once.ordered
+      STDERR.should_receive(:sync=).with(true).once.ordered
+      WorkerManager.build ""
+    end
   end
 end

data/spec/worker_spec.rb

@@ -18,6 +18,9 @@ describe Worker do
   let(:fake_amqp) { fake_amqp = FakeAmqp.new file_queue, reply_exchange }
   let(:test_runner) { double("Test Runner") }
   let(:callback_handler) { stub("Callback Handler", :before_start => nil, :after_complete => nil) }
+  let(:job_definition) {stub("JobDefinition", :callbacks => ["/path/to/callback"],
+                             :file_queue_name => "queue",
+                             :reply_exchange_name => "exchange")}
 
   let(:params) {
     {
@@ -26,11 +29,61 @@ describe Worker do
       :reply_exchange_name => "exchange",
       :worker_id => WORKER_ID,
       :test_runner => test_runner,
-      :callback_handler => callback_handler
+      :callback_handler => callback_handler,
+      :log_file => "path/to/log_file"
     }
   }
 
+  describe ".build" do
+    let(:config) { {:connection => "", :log_file => "path/to/log_file"} }
+    before do
+      stub_streams
+      AmqpService.stub!(:new).and_return fake_amqp
+      CallbackHandler.stub!(:new).and_return callback_handler
+      Worker.stub!(:new)
+    end
+
+    it "redirects output to a file since writing to a pipe may block when pipe is full" do
+      File.should_receive(:open).with(Worker.output_file(1, :out), 'w').and_return(:file1)
+      STDOUT.should_receive(:reopen).with(:file1)
+      File.should_receive(:open).with(Worker.output_file(1, :err), 'w').and_return(:file2)
+      STDERR.should_receive(:reopen).with(:file2)
+      Worker.build 1, config
+    end
+
+    it "use STDOUT#sync to flush output immediately so if an exception happens, we can grab the last\
+few lines of output and send it to originator. Order matters" do
+      STDOUT.should_receive(:reopen).once.ordered
+      STDOUT.should_receive(:sync=).with(true).once.ordered
+      Worker.build 1, config
+    end
+
+    it "use STDERR#sync to flush output immediately so if an exception happens, we can grab the last\
+few lines of output and send it to originator. Order matters" do
+      STDERR.should_receive(:reopen).once.ordered
+      STDERR.should_receive(:sync=).with(true).once.ordered
+      Worker.build 1, config
+    end
+
+    it "creates a JobDefinition using a payload written to stdin" do
+      STDIN.should_receive(:read).and_return '{ "key": "value" }'
+      JobDefinition.should_receive(:new).with({:key => "value"}).and_return job_definition
+      Worker.build 1, config
+    end
+
+    it "creates a new worker" do
+      JobDefinition.stub!(:new).and_return job_definition
+      stub_const("WorkUnit", test_runner)
+      Worker.should_receive(:new).with(params)
+      Worker.build 1, config
+    end
+  end
+
   describe '#work' do
+    before do
+      Worker.any_instance.stub(:initialize_logger)
+    end
+
     it 'should do nothing if the file queue is empty' do
       file_queue.should_receive(:pop).and_return(nil)
 
@@ -111,4 +164,13 @@ describe Worker do
 
   end
 
+  private
+
+  def stub_streams
+    STDIN.stub!(:read).and_return "{}"
+    STDOUT.stub!(:reopen)
+    STDERR.stub!(:reopen)
+    STDOUT.stub!(:sync)
+    STDERR.stub!(:sync)
+  end
 end