jcukeforker 0.2.10 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dd7b0bab63b0a31ff939c6d804000f387beab5b
-  data.tar.gz: 055701eb73582facab03d86e85876d39f3256a4c
+  metadata.gz: eacfc36a1e04a32f288f0a1bc87c226983276fb6
+  data.tar.gz: 424e070d33ef9f5e2ff838c78d518db25a346532
 SHA512:
-  metadata.gz: 2dc47ae20ae4366c34fb3f31d16cff0d2f322d782e2aa474bcfff6c2af6fb4f38afa3a67480d5a70f15bea3645cf1ef55ddd6f07c448f5a6baaaae80d3ffd92c
-  data.tar.gz: 6abf7baa8bf13fb1d030e4b5495199acaeb8909847e06cf2fe2edc9f9d39a4107e127a1ea10d51a8f41a84e064291f2947df211bd98f97e003b114ff9f687b35
+  metadata.gz: 9ce41ed903f5ab5e56b4c4ac9bc71042d31f1f6cdf32f87ab1474f925d8ac387dde784188264d9eb95c7abf5067fd3fc26b7233e52d5a80a583562bcc20eb75c
+  data.tar.gz: af3f360b1638b2760cf5efe60ca9120da8b0b40adf57b0f54aff97d1dad64c37a27753f098d7c330065ef8a3a4851dccf9fdce402c7418fc31ec1e0394459613

data/README.mdown

@@ -2,7 +2,7 @@
 
 Forking cukes and VNC displays.
 
-Jcukeforker is a fork of cukeforker desgined for jruby.
+Jcukeforker is a fork of cukeforker desgined for jruby and windows.  Jcukeforker > 0.3 should work on windows.
 
 [![Gem Version](https://badge.fury.io/rb/jcukeforker.svg)](http://badge.fury.io/rb/jcukeforker)
 [![Build Status](https://secure.travis-ci.org/jesg/jcukeforker.png)](http://travis-ci.org/jesg/jcukeforker)

data/jcukeforker.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |s|
   s.authors     = ["Jason Gowan", "Jari Bakken"]
   s.email       = ["gowanjason@gmail.com"]
   s.homepage    = ""
-  s.summary     = %q{Library to maintain a forking queue of Cucumber processes, for JRuby}
-  s.description = %q{Library to maintain a forking queue of Cucumber processes, with optional VNC displays. Designed for JRuby.}
+  s.summary     = %q{CukeForker, for JRuby and Windows}
+  s.description = %q{Library to maintain a forking queue of Cucumber processes, with optional VNC displays. Designed for JRuby and Windows.}
 
   s.rubyforge_project = "jcukeforker"
 

data/lib/jcukeforker/logging_listener.rb

@@ -44,7 +44,7 @@ module JCukeForker
     end
 
     def worker_id(worker_path)
-      /\-(\d+)$/.match(worker_path).captures[0]
+      worker_path
     end
 
     def log

data/lib/jcukeforker/runner.rb

@@ -19,8 +19,6 @@ module JCukeForker
   #   :format     => Symbol            format passed to `cucumber --format` (default: html)
   #   :extra_args => Array             extra arguments passed to cucumber
   #   :delay      => Numeric           seconds to sleep between each worker is started (default: 0)
-  #   :port       => String            port that the event server runs on
-  #   (default: 6333)
 
   class Runner
     include Observable
@@ -34,7 +32,6 @@ module JCukeForker
       :log    => true,
       :format => :html,
       :delay  => 0,
-      :port   => '6333'
     }
 
     def self.run(features, opts = {})
@@ -47,23 +44,30 @@ module JCukeForker
       max        = opts[:max]
       raise ':max must be >= 1' if max < 1
       format     = opts[:format]
-      out        = File.join opts[:out]
+      out        = File.expand_path(File.join(opts[:out]))
       listeners  = Array(opts[:notify])
       extra_args = Array(opts[:extra_args])
       delay      = opts[:delay]
-      port       = opts[:port]
+      puts "The port option is deprecated in jcukeforker > 0.2.10" if opts[:port]
 
       if opts[:log]
         listeners << LoggingListener.new
       end
 
+      FileUtils.mkdir_p out
+      io_in = File.join out, 'in'
+      io_out = File.join out, 'out'
+      # truncate
+      File.open(io_in, 'w') {}
+      File.open(io_out, 'w') {}
+
       task_opts = {format: format,out: out,extra_args: extra_args}
-      task_manager = TaskManager.new features, task_opts
+      io_out_file = File.open(io_out, 'a')
+      io_out_file.sync = true
+      task_manager = TaskManager.new features, io_out_file, task_opts
 
       listeners << task_manager
-      status_server = StatusServer.new port
-      worker_dir = "/tmp/jcukeforker-#{SecureRandom.hex 4}"
-      FileUtils.mkdir_p worker_dir
+      status_server = StatusServer.new io_in
 
       vnc_pool = nil
       if vnc = opts[:vnc]
@@ -76,9 +80,9 @@ module JCukeForker
        end
       end
 
-      processes = create_processes(max, status_server.port, worker_dir, vnc_pool, opts[:record])
+      processes = create_processes(max, io_in, io_out, vnc_pool, opts[:record])
 
-      runner = Runner.new status_server, processes, worker_dir, vnc_pool, delay, task_manager
+      runner = Runner.new status_server, processes, vnc_pool, delay, task_manager
 
       listeners.each { |l|
         status_server.add_observer l
@@ -88,10 +92,9 @@ module JCukeForker
       runner
     end
 
-    def initialize(status_server, processes, worker_dir, vnc_pool, delay, task_manager)
+    def initialize(status_server, processes, vnc_pool, delay, task_manager)
       @status_server = status_server
       @processes = processes
-      @worker_dir = worker_dir
       @vnc_pool = vnc_pool
       @delay = delay
       @task_manager = task_manager
@@ -113,11 +116,11 @@ module JCukeForker
 
     private
 
-    def self.create_processes(max, status_path, worker_dir, vnc_pool = nil, record = false)
+    def self.create_processes(max, io_in, io_out, vnc_pool = nil, record = false)
       worker_file = "#{File.expand_path File.dirname(__FILE__)}/worker_script.rb"
 
       (1..max).inject([]) do |l, i|
-        process_args = %W[ruby #{worker_file} #{status_path} #{worker_dir}/worker-#{i}]
+        process_args = %W[ruby #{worker_file} #{io_in} #{io_out} #{i}]
         if vnc_pool && record
           if record.kind_of? Hash
             process_args << record.to_json
@@ -128,6 +131,7 @@ module JCukeForker
         process = ChildProcess.build(*process_args)
         process.io.inherit!
         process.environment['DISPLAY'] = vnc_pool.get.display if vnc_pool
+        process.environment['JCUKEFORKER_WORKER'] = i
         l << process
       end
     end
@@ -150,7 +154,6 @@ module JCukeForker
       @status_server.shutdown
     ensure # catch potential second Interrupt
       @vnc_pool.stop if @vnc_pool
-      FileUtils.rm_r @worker_dir
       fire :on_run_finished, @task_manager.has_failures?
     end
 

data/lib/jcukeforker/status_server.rb

@@ -1,41 +1,35 @@
-require 'socket'
 
 module JCukeForker
   class StatusServer
     include Observable
 
-    attr_reader :port
+    attr_reader :io_in
 
-    def initialize(port = '6333')
-      @server = ::TCPServer.new 'localhost', port
-      @port = @server.connect_address.ip_port
-      @thread_pool = []
+    def initialize(io_in)
+      @io_in = File.open(io_in, 'r')
+      @io_in.sync = true
     end
 
     def run
       @master_thread = Thread.new do
         loop do
-          socket = @server.accept
-          @thread_pool << Thread.new { handle_connection(socket) }
+          raw_message = @io_in.gets(sep=$-0)
+          next if raw_message.nil?
+          handle_message(raw_message)
         end
       end
     end
 
     def shutdown
-      if @server
-        @server.close
+      if @io_in
+        @io_in.close
         @master_thread.terminate
-        @thread_pool.each(&:terminate)
       end
     end
 
-    def handle_connection(socket)
-      until socket.eof? do
-        raw_message = socket.gets
-        json_obj = JSON.parse raw_message
-        fire json_obj.first, *json_obj[1..-1]
-      end
-      socket.close
+    def handle_message(raw_message)
+      json_obj = JSON.parse raw_message
+      fire json_obj.first, *json_obj[1..-1]
     end
 
     private

data/lib/jcukeforker/task_manager.rb

@@ -2,16 +2,14 @@
 module JCukeForker
   class TaskManager < AbstractListener
 
-    def initialize(features, opts={})
+    def initialize(features, io_out, opts={})
       @features = features
       @opts = opts
-      @worker_sockets = {}
+      @io_out = io_out
       @failures = false
-      @mutex = Mutex.new
     end
 
     def on_worker_register(worker_path)
-      @worker_sockets[worker_path] = UNIXSocket.open worker_path
       pop_task worker_path
     end
 
@@ -20,13 +18,8 @@ module JCukeForker
       pop_task worker_path
     end
 
-    def on_worker_dead(worker_path)
-     socket = @worker_sockets.delete worker_path
-     socket.close
-    end
-
     def close
-      @worker_sockets.each {|k, v| v.close}
+      io_out.close
     end
 
     def has_failures?
@@ -36,14 +29,12 @@ module JCukeForker
     private
 
     def pop_task(worker_path)
-        task = '__KILL__'
-        @mutex.synchronize do
-          if feature = @features.shift
-            task = @opts.merge(feature: feature).to_json
-          end
-        end
-
-      @worker_sockets[worker_path].puts(task)
+      task = {action: '__KILL__', worker: worker_path}.to_json
+      if feature = @features.shift
+        task = @opts.merge(worker: worker_path, feature: feature, action: :feature).to_json
+      end
+
+      @io_out.write("#{task}#{$-0}")
     end
   end
 end

data/lib/jcukeforker/version.rb

@@ -1,3 +1,3 @@
 module JCukeForker
-  VERSION = "0.2.10"
+  VERSION = "0.3.1"
 end

data/lib/jcukeforker/worker.rb

@@ -1,4 +1,3 @@
-require 'socket'
 require 'securerandom'
 require 'json'
 require 'fileutils'
@@ -16,40 +15,43 @@ module JCukeForker
 
     attr_reader :feature, :format, :out, :basename
 
-    def initialize(status_path, task_path, recorder = nil)
+    def initialize(status_path, task_path, worker_num, recorder = nil)
       @status_path = status_path
       @task_path = task_path
+      @worker_num = worker_num
       if ENV['DISPLAY'] && recorder
         config = JSON.parse(recorder)
         add_observer JCukeForker::RecordingVncListener.new(self, config)
       end
-      @status_socket = TCPSocket.new 'localhost', status_path
+      @status_file = File.open(status_path, 'a')
+      @status_file.sync = true
       @status = nil
     end
 
     def register
-      @worker_server = UNIXServer.new @task_path
+      @event_file = File.open(@task_path, 'r')
       update_status :on_worker_register
     end
 
     def close
-      @worker_server.close
-      @status_socket.close
+      @event_file.close
+      @status_file.close
     end
 
     def run
-      worker_socket = @worker_server.accept
       loop do
-        raw_message = worker_socket.gets
+        raw_message = @event_file.gets(sep=$-0)
         if raw_message.nil? then
-          sleep 0.3
+          sleep 0.1
           next
         end
-        if raw_message.strip == '__KILL__'
+        json_obj = JSON.parse raw_message
+        next unless json_obj['worker'] == @worker_num
+        if json_obj['action'] == '__KILL__'
           update_status :on_worker_dead
           break
         end
-        set_state raw_message
+        set_state json_obj
         update_status :on_task_starting, feature
         status = execute_cucumber
         update_status :on_task_finished, feature, status
@@ -57,12 +59,13 @@ module JCukeForker
     end
 
     def update_status(meth, *args)
-      message = [meth, @task_path]
+      message = [meth, @worker_num]
+
       message += args
 
       changed
       notify_observers *message
-      @status_socket.puts(message.to_json)
+      @status_file.write("#{message.to_json}#{$-0}")
     end
 
     def failed?
@@ -91,9 +94,8 @@ module JCukeForker
 
     private
 
-    def set_state(raw_message)
+    def set_state(json_obj)
       @status = nil
-      json_obj = JSON.parse raw_message
       @format = json_obj['format']
       @feature = json_obj['feature']
       @extra_args = json_obj['extra_args']

data/lib/jcukeforker.rb

@@ -1,7 +1,3 @@
-unless RUBY_PLATFORM =~ /darwin|linux|java/
-  raise "CukeForker only supported on *nix"
-end
-
 
 require "cucumber/cli/main"
 require "vnctools"

data/spec/jcukeforker/logging_listener_spec.rb

@@ -8,8 +8,8 @@ module JCukeForker
     it "logs all events" do
       Time.stub(:now => Time.now)
 
-      mock_worker = {:path => '/tmp/12sd3-1', :feature => 'foo/bar', :status => true }
-      mock_worker2 = {:path => '/tmp/12sd3-15', :feature => 'foo/baz', :status => false}
+      mock_worker = {:path => '1', :feature => 'foo/bar', :status => true }
+      mock_worker2 = {:path => '15', :feature => 'foo/baz', :status => false}
 
       listener.on_run_starting
       listener.on_worker_register mock_worker[:path]
@@ -27,14 +27,14 @@ module JCukeForker
 
       stdout.string.should == <<-OUTPUT
 I, [#{timestamp}]  INFO -- : [    run           ] starting
-I, [#{timestamp}]  INFO -- : [    worker  1     ] register: /tmp/12sd3-1
+I, [#{timestamp}]  INFO -- : [    worker  1     ] register: 1
 I, [#{timestamp}]  INFO -- : [    worker  1     ] starting: foo/bar
-I, [#{timestamp}]  INFO -- : [    worker  15    ] register: /tmp/12sd3-15
+I, [#{timestamp}]  INFO -- : [    worker  15    ] register: 15
 I, [#{timestamp}]  INFO -- : [    worker  15    ] starting: foo/baz
 I, [#{timestamp}]  INFO -- : [    worker  1     ] passed  : foo/bar
 I, [#{timestamp}]  INFO -- : [    worker  15    ] failed  : foo/baz
-I, [#{timestamp}]  INFO -- : [    worker  1     ] dead    : /tmp/12sd3-1
-I, [#{timestamp}]  INFO -- : [    worker  15    ] dead    : /tmp/12sd3-15
+I, [#{timestamp}]  INFO -- : [    worker  1     ] dead    : 1
+I, [#{timestamp}]  INFO -- : [    worker  15    ] dead    : 15
 I, [#{timestamp}]  INFO -- : [    run           ] interrupted - please wait
 I, [#{timestamp}]  INFO -- : [    run           ] finished, passed
       OUTPUT

data/spec/jcukeforker/runner_spec.rb

@@ -17,10 +17,14 @@ module JCukeForker
 
         mock_task_manager = double(TaskManager, :update => nil, :has_failures? => false)
         mock_status_server = double(StatusServer, :port => nil)
+        mock_io_out = double(IO, :sync= => nil)
         mock_tasks = Array.new(2) { |n| double("Worker-#{n}") }
 
-        TaskManager.should_receive(:new).with(features, {format: format, out: out, extra_args: []}).and_return mock_task_manager
-        StatusServer.should_receive(:new).with('6333').and_return mock_status_server
+        TaskManager.should_receive(:new).with(features, mock_io_out, {format: format, out: out, extra_args: []}).and_return mock_task_manager
+        StatusServer.should_receive(:new).with('/tmp/in').and_return mock_status_server
+        File.should_receive(:open).with('/tmp/in', 'w').and_return mock_io_out
+        File.should_receive(:open).with('/tmp/out', 'w').and_return mock_io_out
+        File.should_receive(:open).with('/tmp/out', 'a').and_return mock_io_out
 
         mock_status_server.should_receive(:add_observer).with listeners.first
         mock_status_server.should_receive(:add_observer).with mock_task_manager
@@ -52,7 +56,7 @@ module JCukeForker
       let(:work_dir) { '/tmp/jcukeforker-testdir' }
       let(:vnc_pool) { double(VncTools::ServerPool, :stop => nil) }
       let(:mock_task_manager) { double(TaskManager, :update => nil, :has_failures? => false) }
-      let(:runner)   { Runner.new(status_server, [process], work_dir, vnc_pool, 0, mock_task_manager) }
+      let(:runner)   { Runner.new(status_server, [process], vnc_pool, 0, mock_task_manager) }
 
 
       it "processes the queue" do
@@ -62,7 +66,6 @@ module JCukeForker
         process.should_receive(:start)
         process.should_receive(:wait)
 #        listener.should_receive(:update).with(:on_run_finished, false)
-        FileUtils.should_receive(:rm_r).with(work_dir)
 
         runner.run
       end

data/spec/jcukeforker/status_server_spec.rb

@@ -2,15 +2,8 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 module JCukeForker
   describe StatusServer do
-    it "initializes at designated port" do
-      mock_tcp_server = double(TCPServer).as_null_object
 
-      TCPServer.should_receive(:new).with('localhost', '4444').and_return mock_tcp_server
-
-      StatusServer.new '4444'
-    end
-
-    it "can handle a connection" do
+    it "can handle a message" do
 
       status = :on_worker_register
       worker_path = 'worker-path'
@@ -19,16 +12,15 @@ module JCukeForker
       # register a listener, just do an end to end test
       mock_listener = double(AbstractListener, :update => nil)
       mock_listener.should_receive(:update).with(status.to_s, worker_path)
+			mock_io = double(IO, :sync= => nil)
+			File.should_receive(:open).with('/tmp/in', 'r').and_return(mock_io)
 
       # expect the worker to register
-      status_server = StatusServer.new
+      io_in = '/tmp/in'
+      status_server = StatusServer.new io_in
       status_server.add_observer mock_listener
 
-      socket = TCPSocket.new 'localhost', '6333'
-      socket.puts raw_message
-      socket.close
-
-      status_server.handle_connection( status_server.instance_variable_get(:@server).accept )
+      status_server.handle_message(raw_message)
 
    end
   end

data/spec/jcukeforker/task_manager_spec.rb

@@ -5,45 +5,34 @@ module JCukeForker
     let(:worker_path) { '/tmp/jcukeforker-test-socket' }
     let(:feature) { 'feature:1' }
     let(:mock_socket) { double('socket', :puts => nil) }
+    let(:mock_file) { double(IO, :puts => nil) }
 
     it "can register a worker" do
 
-      UNIXSocket.stub(:open).and_return(mock_socket)
-      mock_socket.should_receive(:puts).with({feature: feature}.to_json)
+      mock_file.should_receive(:write).with("{\"worker\":\"/tmp/jcukeforker-test-socket\",\"feature\":\"feature:1\",\"action\":\"feature\"}#{$-0}")
 
-      task_manager = TaskManager.new [feature]
+      task_manager = TaskManager.new [feature], mock_file
       task_manager.on_worker_register worker_path
     end
 
     it "can finish task" do
 
-      mock_socket.should_receive(:puts).with({feature: feature}.to_json)
+      mock_file.should_receive(:write).with("{\"worker\":\"/tmp/jcukeforker-test-socket\",\"feature\":\"feature:1\",\"action\":\"feature\"}#{$-0}")
 
-      task_manager = TaskManager.new [feature]
-      task_manager.instance_variable_get(:@worker_sockets)[worker_path] = mock_socket
+      task_manager = TaskManager.new [feature], mock_file
       task_manager.on_task_finished worker_path, nil, nil
     end
 
-    it "can close dead worker" do
-
-      mock_socket.should_receive(:close)
-
-      task_manager = TaskManager.new [feature]
-      task_manager.instance_variable_get(:@worker_sockets)[worker_path] = mock_socket
-      task_manager.on_worker_dead worker_path
-    end
-
     it "can send '__KILL__' when there are no tasks left" do
 
-      mock_socket.should_receive(:puts).with('__KILL__')
+      mock_file.should_receive(:write).with("{\"action\":\"__KILL__\",\"worker\":\"/tmp/jcukeforker-test-socket\"}#{$-0}")
 
-      task_manager = TaskManager.new []
-      task_manager.instance_variable_get(:@worker_sockets)[worker_path] = mock_socket
+      task_manager = TaskManager.new [], mock_file
       task_manager.on_task_finished worker_path, nil, nil
     end
 
     it "can detect failure" do
-      task_manager = TaskManager.new []
+      task_manager = TaskManager.new [], mock_file
       def task_manager.pop_task(*args); end
       task_manager.on_task_finished worker_path, feature, false
       task_manager.has_failures?.should == true

data/spec/jcukeforker/worker_spec.rb

@@ -3,13 +3,14 @@ require File.expand_path("../../spec_helper", __FILE__)
 module JCukeForker
   describe Worker do
     let(:worker_path) { '/tmp/jcukeforker-test-socket' }
-    let(:status_path) { '6333' }
-    let(:mock_status_socket) { double(TCPSocket, :close => nil) }
+    let(:status_path) { '/tmp/in' }
+    let(:mock_status_file) { double(IO, :close => nil) }
     let(:mock_worker_server) { double(UNIXServer, :close => nil) }
     let(:mock_worker_socket) { double(UNIXSocket, :close => nil) }
     let(:worker) do
-      TCPSocket.should_receive(:new).with('localhost', status_path).and_return(mock_status_socket)
-      Worker.new status_path, worker_path
+      File.should_receive(:open).with('/tmp/in', 'a').and_return(mock_status_file)
+      mock_status_file.should_receive(:sync=).with(true)
+      Worker.new status_path, worker_path, '1'
     end
 
     it "can create worker" do
@@ -17,9 +18,10 @@ module JCukeForker
     end
 
     it "can register worker" do
-      UNIXServer.should_receive(:new).with(worker_path).and_return(mock_worker_server)
 
-      mock_status_socket.should_receive(:puts).with("[\"on_worker_register\",\"/tmp/jcukeforker-test-socket\"]")
+      mock_status_file.should_receive(:write).with("[\"on_worker_register\",\"1\"]#{$-0}")
+      mock_event_file = double(IO)
+      File.should_receive(:open).with(worker_path, 'r').and_return(mock_event_file)
 
       worker.register
     end
@@ -29,7 +31,7 @@ module JCukeForker
       path = "some/path"
 
       it "has an output file for each format specified" do
-        json_str = {'format' => formats, 'feature' => 'some/feature:51', 'extra_args' => [], 'out' => path}.to_json
+        json_str = {'format' => formats, 'feature' => 'some/feature:51', 'extra_args' => [], 'out' => path}
         worker.send :set_state, json_str
         expected_args = formats.flat_map do |f|
           %W[--format #{f} --out #{path}/some_feature_51.#{f}]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jcukeforker
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.3.1
 platform: ruby
 authors:
 - Jason Gowan
@@ -102,7 +102,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10'
 description: Library to maintain a forking queue of Cucumber processes, with optional
-  VNC displays. Designed for JRuby.
+  VNC displays. Designed for JRuby and Windows.
 email:
 - gowanjason@gmail.com
 executables:
@@ -161,10 +161,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: jcukeforker
-rubygems_version: 2.4.5
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
-summary: Library to maintain a forking queue of Cucumber processes, for JRuby
+summary: CukeForker, for JRuby and Windows
 test_files:
 - spec/jcukeforker/formatters/scenario_line_logger_spec.rb
 - spec/jcukeforker/logging_listener_spec.rb