cukeforker 0.0.1

data/lib/cukeforker/worker.rb

@@ -0,0 +1,87 @@
+module CukeForker
+  class Worker
+    class << self
+       attr_writer :id
+       def id; @id ||= -1; end
+     end
+
+    attr_reader :status, :feature, :pid, :format, :out, :id
+    attr_accessor :vnc
+
+    def initialize(feature, format, out, extra_args = [])
+      @feature      = feature
+      @format       = format
+      @extra_args   = extra_args
+      @out          = out
+      @status, @vnc = nil
+
+      @id = self.class.id += 1
+    end
+
+    def finished?
+      wait_pid, @status = Process.waitpid2(pid, Process::WNOHANG)
+      !!wait_pid
+    rescue Errno::ECHILD, Errno::ESRCH
+      true
+    end
+
+    def failed?
+      status.nil? || status.exitstatus != 0
+    end
+
+    def start
+      @pid = Process.fork { execute_cucumber }
+    end
+
+    def args
+      args = %W[--format #{format} --out #{output}]
+      args += @extra_args
+      args << feature
+
+      args
+    end
+
+    def text
+      "[
+        #{pid}
+        #{feature}
+        #{status.inspect}
+        #{out}
+        #{vnc && vnc.display}
+       ]"
+    end
+
+    def output
+      File.join out, "#{basename}.#{format}"
+    end
+
+    def stdout
+      File.join out, "#{basename}.stdout"
+    end
+
+    def stderr
+      File.join out, "#{basename}.stderr"
+    end
+
+    private
+
+    def execute_cucumber
+      FileUtils.mkdir_p(out) unless File.exist? out
+
+      $stdout.reopen stdout
+      $stderr.reopen stderr
+
+      if @vnc
+        ENV['DISPLAY'] = @vnc.display
+      end
+
+      failed = Cucumber::Cli::Main.execute args
+      exit failed ? 1 : 0
+    end
+
+    def basename
+      @basename ||= feature.gsub(/\W/, '_')
+    end
+
+  end # Worker
+end # CukeForker

data/lib/cukeforker/worker_queue.rb

@@ -0,0 +1,113 @@
+module CukeForker
+  class WorkerQueue
+    include Observable
+
+    def initialize(max)
+      @max = max
+
+      @pending = []
+      @running = []
+      @finished = []
+    end
+
+    def backed_up?
+      @pending.any?
+    end
+
+    def add(worker)
+      @pending << worker
+    end
+
+    def process(poll_interval = nil)
+      @start_time = Time.now
+
+      while backed_up?
+        fill
+        eta
+        poll poll_interval while full?
+      end
+
+      # yay, no more pending workers
+    end
+
+    def wait_until_finished(poll_interval = nil)
+      until empty?
+        poll poll_interval
+        eta
+      end
+    end
+
+    def fill
+      while backed_up? and not full?
+        worker = @pending.shift
+        start worker
+      end
+    end
+
+    def poll(seconds = nil)
+      finished = @running.select { |w| w.finished? }
+
+      if finished.empty?
+        sleep seconds if seconds
+      else
+        finished.each { |w| finish w }
+      end
+    end
+
+    def size
+      @running.size
+    end
+
+    def full?
+      size == @max
+    end
+
+    def empty?
+      @running.empty?
+    end
+
+    def has_failures?
+      @finished.any? { |w| w.failed? }
+    end
+
+    private
+
+    def start(worker)
+      fire :on_worker_starting, worker
+
+      worker.start
+      @running << worker
+    end
+
+    def finish(worker)
+      @running.delete worker
+      @finished << worker
+
+      fire :on_worker_finished, worker
+    end
+
+    def eta
+      return Time.now if @finished.empty?
+
+      pending = @pending.size
+      finished = @finished.size
+
+      seconds_per_child = (Time.now - start_time) / finished
+      eta = Time.now + (seconds_per_child * pending)
+
+      fire :on_eta, eta, pending + size, finished
+    end
+
+    def fire(*args)
+      changed
+      notify_observers(*args)
+    end
+
+    def start_time
+      @start_time or raise NotStartedError
+    end
+
+    class NotStartedError < StandardError; end
+
+  end # WorkerQueue
+end # CukeForker

data/spec/cukeforker/logging_listener_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module CukeForker
+  describe LoggingListener do
+    let(:stdout)   { StringIO.new }
+    let(:listener) { LoggingListener.new stdout }
+
+    it "logs all events" do
+      Time.stub(:now => Time.now)
+
+      mock_worker = mock(Worker,     :id => "1", :feature => "foo/bar")
+      mock_display = mock(VncServer)
+      mock_display.stub(:display).and_return(nil, ":5")
+
+      listener.on_run_starting
+      listener.on_display_starting mock_display
+      listener.on_display_fetched mock_display
+      listener.on_worker_starting mock_worker
+      listener.on_eta Time.now, 10, 255
+      listener.on_worker_finished mock_worker
+      listener.on_display_released mock_display
+      listener.on_run_interrupted
+      listener.on_run_finished false
+      listener.on_display_stopping mock_display
+
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S##{Process.pid}")
+
+      stdout.string.should == <<-OUTPUT
+I, [#{timestamp}]  INFO -- : [    run           ] starting
+I, [#{timestamp}]  INFO -- : [    display(  )   ] starting
+I, [#{timestamp}]  INFO -- : [    display(:5)   ] fetched
+I, [#{timestamp}]  INFO -- : [    worker(1)     ] starting: foo/bar
+I, [#{timestamp}]  INFO -- : [    eta(10/255)   ] #{Time.now.strftime "%Y-%m-%d %H:%M:%S"}
+I, [#{timestamp}]  INFO -- : [    worker(1)     ] finished: foo/bar
+I, [#{timestamp}]  INFO -- : [    display(:5)   ] released
+I, [#{timestamp}]  INFO -- : [    run           ] interrupted - please wait
+I, [#{timestamp}]  INFO -- : [    run           ] finished, passed
+I, [#{timestamp}]  INFO -- : [    display(:5)   ] stopping
+      OUTPUT
+    end
+
+
+
+  end # Worker
+end # CukeForker

data/spec/cukeforker/runner_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module CukeForker
+  describe Runner do
+
+    context "creating" do
+      it "sets up a new instance" do
+        # sigh.
+
+        max       = 4
+        format    = :json
+        out       = "/tmp"
+        listeners = [mock(AbstractListener, :update => nil)]
+        log       = false
+        features  = %w[a b]
+
+        mock_queue = mock(WorkerQueue)
+        mock_workers = Array.new(2) { |n| mock("Worker-#{n}") }
+
+        Process.stub(:pid => 1234)
+
+        WorkerQueue.should_receive(:new).with(max).and_return mock_queue
+        Worker.should_receive(:new).with("a", :json, "/tmp/1234", []).and_return mock_workers[0]
+        Worker.should_receive(:new).with("b", :json, "/tmp/1234", []).and_return mock_workers[1]
+
+        mock_queue.should_receive(:add_observer).once.with listeners.first
+        mock_queue.should_receive(:add).with mock_workers[0]
+        mock_queue.should_receive(:add).with mock_workers[1]
+
+        Runner.create(features,
+          :max    => max,
+          :notify => listeners,
+          :format => format,
+          :log    => false,
+          :out    => out
+        ).should be_kind_of(Runner)
+      end
+
+      it "sets up the VNC pool if :vnc => true" do
+        mock_pool = mock(VncServerPool, :add_observer => nil)
+        VncServerPool.should_receive(:new).with(2).and_return mock_pool
+        VncListener.should_receive(:new).with(mock_pool).and_return mock(:update => nil)
+
+        Runner.create([], :max => 2, :vnc => true)
+      end
+
+      it "creates and runs a new runner" do
+        r = mock(Runner)
+        Runner.should_receive(:create).with(%w[a b], {}).and_return(r)
+        r.should_receive(:run)
+
+        Runner.run(%w[a b])
+      end
+    end
+
+    context "running" do
+      let(:listener) { mock(AbstractListener, :update => nil) }
+      let(:queue)    { mock(Queue, :has_failures? => false) }
+      let(:runner)   { Runner.new(queue) }
+
+      it "processes the queue" do
+        runner.add_observer listener
+
+        listener.should_receive(:update).with(:on_run_starting)
+        queue.should_receive(:process).with 0.2 # poll interval
+        queue.should_receive(:wait_until_finished)
+        listener.should_receive(:update).with(:on_run_finished, false)
+
+        runner.run
+      end
+
+      it "fires on_run_interrupted and shuts down if the run is interrupted" do
+        runner.add_observer listener
+
+        queue.stub(:process).and_raise(Interrupt)
+        runner.stub(:stop)
+        listener.should_receive(:update).with(:on_run_interrupted)
+
+        runner.run
+      end
+    end
+
+  end # Runner
+end # CukeForker

data/spec/cukeforker/vnc_listener_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module CukeForker
+  describe VncListener do
+    let(:server)    { mock(VncServer)       }
+    let(:pool)      { mock(VncServerPool)   }
+    let(:worker)    { mock(Worker)          }
+    let(:listener)  { VncListener.new pool }
+
+    it "fetches a display from the pool and assings it to the worker" do
+      pool.should_receive(:get).and_return(server)
+      worker.should_receive(:vnc=).with server
+
+      listener.on_worker_starting worker
+    end
+
+    it "releases the display and removes it from the worker" do
+      worker.should_receive(:vnc).and_return server
+      pool.should_receive(:release).with server
+      worker.should_receive(:vnc=).with(nil)
+
+      listener.on_worker_finished worker
+    end
+
+    it "stops the pool when the run finishes" do
+      pool.should_receive(:stop)
+
+      listener.on_run_finished(true)
+    end
+
+  end # VncListenerServer
+end # CukeForker

data/spec/cukeforker/vnc_server_pool_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module CukeForker
+  describe VncServerPool do
+    let(:pool)  { VncServerPool.new(3, SpecHelper::FakeVnc) }
+
+    it "creates 3 instances of the given display class" do
+      SpecHelper::FakeVnc.should_receive(:new).exactly(3).times
+
+      pool = VncServerPool.new(3, SpecHelper::FakeVnc)
+      pool.size.should == 3
+    end
+
+    it "can fetch a server from the pool" do
+      pool.get.should be_kind_of(SpecHelper::FakeVnc)
+      pool.size.should == 2
+    end
+
+    it "can release a server" do
+      obj = pool.get
+      pool.size.should == 2
+
+      pool.release obj
+    end
+
+    it "can stop the pool" do
+      mock_server = mock(VncServer)
+
+      pool.stub(:running => [mock_server])
+      mock_server.should_receive(:stop)
+
+      pool.stop
+    end
+
+    it "raises a TooManyDisplaysError if the pool is over capacity" do
+      lambda { pool.release "foo" }.should raise_error(VncServerPool::TooManyDisplaysError)
+    end
+
+    it "raises a OutOfDisplaysError if the pool is empty" do
+      3.times { pool.get }
+      lambda { pool.get }.should raise_error(VncServerPool::OutOfDisplaysError)
+    end
+
+    it "notifies observers" do
+      server   = mock(VncServer, :start => nil, :stop => nil)
+      observer = mock(AbstractListener)
+
+      SpecHelper::FakeVnc.stub :new => server
+
+      observer.should_receive(:update).with :on_display_fetched , server
+      observer.should_receive(:update).with :on_display_released, server
+      observer.should_receive(:update).with :on_display_starting, server
+      observer.should_receive(:update).with :on_display_stopping , server
+
+      pool.add_observer observer
+
+      pool.release pool.get
+      pool.stop
+    end
+
+  end # VncServerPool
+end # CukeForker

data/spec/cukeforker/vnc_server_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module CukeForker
+  describe VncServer do
+
+    context "managing new displays" do
+      let(:server) { VncServer.new }
+
+      it "starts a new server" do
+        server.should_receive(:`).with("tightvncserver 2>&1").and_return("desktop is #{Socket.gethostname}:1")
+        server.start
+        server.display.should == ":1"
+      end
+
+      it "stops the server" do
+        server.should_receive(:`).with("tightvncserver -kill :5 2>&1")
+        server.stub :display => ":5"
+        server.stop
+      end
+
+      it "raises VncServer::Error if the server could not be started" do
+        server.should_receive(:`).and_return("oops")
+        server.stub :last_status => mock(:success? => false)
+
+        lambda { server.start }.should raise_error(VncServer::Error, /oops/)
+      end
+    end
+
+    context "controlling an existing display" do
+      let(:server) { VncServer.new ":5" }
+
+      it "starts the server on the given display" do
+        server.should_receive(:`).with("tightvncserver :5 2>&1").and_return("desktop is #{Socket.gethostname}:5")
+        server.start
+        server.display.should == ":5"
+      end
+    end
+
+    it "returns an instance for all existing displays" do
+      Dir.stub(:[]).and_return [".vnc/qa1:1.pid", ".vnc/qa1:2.pid", ".vnc/qa1:3.pid"]
+
+      all = VncServer.all
+      all.size.should == 3
+      all.map { |e| e.display }.should == [":1", ":2", ":3"]
+    end
+
+  end # VncServer
+end # CukeForker