tork 19.4.0 → 19.5.0

data/bin/tork

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin =======================================================================
 
-# TORK 1 2013-11-25 19.4.0
+# TORK 1 2013-11-30 19.5.0
 
 ## NAME
 
@@ -13,7 +13,8 @@ tork - Continuous testing tool for Ruby
 
 ## DESCRIPTION
 
-This program is a simple command-line user interface for tork-driver(1).
+This program can be thought of as an interactive version of tork-runner(1).
+It functions as a rudimentary command-line user interface to tork-driver(1).
 
 First, it applies the given *CONFIG* values, which are either (1) paths to
 directories that contain configuration files or (2) names of configuration
@@ -111,7 +112,7 @@ This program can be controlled remotely by multiple tork-remote(1) instances.
 
 ## SEE ALSO
 
-tork(1), tork-driver(1), tork-master(1)
+tork-runner(1), tork-driver(1), tork-master(1)
 
 [factory_girl]: https://github.com/thoughtbot/factory_girl
 [memory_test_fix]: https://github.com/stepahn/memory_test_fix

data/bin/tork-driver

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin =======================================================================
 
-# TORK-DRIVER 1 2013-11-25 19.4.0
+# TORK-DRIVER 1 2013-11-30 19.5.0
 
 ## NAME
 
@@ -20,7 +20,10 @@ This program can be controlled remotely by multiple tork-remote(1) instances.
 ### Input
 
 This program reads the following commands, which are single-line JSON arrays,
-from stdin and performs the actions described respectively.
+from stdin and then performs the associated actions.  For lines read from
+stdin that are single-line JSON arrays, it splits each of them into an array
+of words, using the same word-splitting algorithm as sh(1), before processing
+them.  For example, the line `a "b c"` is split into the `["a", "b c"]` array.
 
 `["run_all_test_files"]`
   Runs all test files found within and beneath the current working directory.

data/bin/tork-engine

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin =======================================================================
 
-# TORK-ENGINE 1 2013-11-25 19.4.0
+# TORK-ENGINE 1 2013-11-30 19.5.0
 
 ## NAME
 
@@ -20,7 +20,10 @@ This program can be controlled remotely by multiple tork-remote(1) instances.
 ### Input
 
 This program reads the following commands, which are single-line JSON arrays,
-from stdin and performs the actions described respectively.
+from stdin and then performs the associated actions.  For lines read from
+stdin that are single-line JSON arrays, it splits each of them into an array
+of words, using the same word-splitting algorithm as sh(1), before processing
+them.  For example, the line `a "b c"` is split into the `["a", "b c"]` array.
 
 `["reabsorb_overhead"]`
   Stops any test files that are currently running, reabsorbs the test

data/bin/tork-herald

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin =======================================================================
 
-# TORK-HERALD 1 2013-11-25 19.4.0
+# TORK-HERALD 1 2013-11-30 19.5.0
 
 ## NAME
 
@@ -37,7 +37,7 @@ require 'json'
 STDOUT.sync = true # flush puts() output immediately after writing
 
 require 'listen'
-Listen.to('.', :relative_paths => true) do |modified, added, removed|
+Listen.to! '.', :relative_paths => true do |modified, added, removed|
   files = modified + added
   puts JSON.dump(files) unless files.empty?
-end.start
+end

data/bin/tork-master

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin =======================================================================
 
-# TORK-MASTER 1 2013-11-25 19.4.0
+# TORK-MASTER 1 2013-11-30 19.5.0
 
 ## NAME
 
@@ -23,7 +23,10 @@ This program can be controlled remotely by multiple tork-remote(1) instances.
 ### Input
 
 This program reads the following commands, which are single-line JSON arrays,
-from stdin and performs the actions described respectively.
+from stdin and then performs the associated actions.  For lines read from
+stdin that are single-line JSON arrays, it splits each of them into an array
+of words, using the same word-splitting algorithm as sh(1), before processing
+them.  For example, the line `a "b c"` is split into the `["a", "b c"]` array.
 
 `["test",` *test_file*`,` *line_numbers*`]`
   Forks a worker process to run tests that correspond to the given

data/bin/tork-notify

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 =begin =======================================================================
 
-# TORK-NOTIFY 1 2013-11-25 19.4.0
+# TORK-NOTIFY 1 2013-11-30 19.5.0
 
 ## NAME
 
@@ -58,7 +58,8 @@ IO.popen('tork-remote tork-engine', 'r+') do |remote|
       statistics = File.readlines(log_file).grep(/^\d+ \w+,/).join.
         gsub(/\e\[\d+(;\d+)?m/, '') # strip ANSI SGR escape codes
 
-      Thread.new do # run in background
+      # run in background; see http://stackoverflow.com/q/16745840
+      Thread.new(icon, title, statistics) do |icon, title, statistics|
         system 'notify-send', '-i', icon, title, statistics or
         system 'growlnotify', '-a', 'Xcode', '-m', statistics, title or
         system 'xmessage', '-timeout', '5', '-title', title, statistics or

data/bin/tork-remote

@@ -13,15 +13,10 @@ tork-remote - controls tork(1) programs
 
 ## DESCRIPTION
 
-This program sends single-line JSON messages read from its stdin to the given
-*PROGRAM* which is already running in the same working directory as this one.
-
-If lines read from stdin are not single-line JSON messages, then they are
-split into an array of words, using the same word-splitting algorithm as
-sh(1), before being sent to the *PROGRAM* as a single-line JSON message.
-
-If the *PROGRAM* sends any messages in response, then they are printed to
-stdout if they are valid single-line JSON messages or to stderr otherwise.
+This program reads lines from its stdin and sends them to the given *PROGRAM*,
+which must already be running in the same working directory as this program.
+It also prints lines, received in response, from the given *PROGRAM* either
+to stdout if they are valid single-line JSON arrays or to stderr otherwise.
 
 ## OPTIONS
 

data/bin/tork-runner

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+=begin =======================================================================
+
+# TORK-RUNNER 1 2013-11-30 19.5.0
+
+## NAME
+
+tork-runner - runs tests once, non-interactively
+
+## SYNOPSIS
+
+`tork-runner` [*OPTION*]... [*TEST\_FILE\_GLOB*]...
+
+## DESCRIPTION
+
+This program can be thought of as a non-interactive version of tork(1).  It
+runs all test files that match the given *TEST\_FILE\_GLOB*s and then exits
+with a nonzero status if any tests failed.  If none are given, it runs all
+test files known to `Tork::Driver::TEST_FILE_GLOBBERS` in tork-driver(1).
+
+### Output
+
+This program prints the following messages to stdout.
+
+`>>` *failed\_test\_log\_file* `<<`
+  This message will be followed by the content of *failed\_test\_log\_file*.
+
+*T* `tested,` *P* `passed,` *F* `failed`
+  *T* test files were tested and *P* of them passed but *F* of them failed.
+
+## OPTIONS
+
+`-h`, `--help`
+  Show this help manual.
+
+## EXIT STATUS
+
+0
+  All test files passed.
+
+1
+  One or more test files failed.
+
+## ENVIRONMENT
+
+See tork(1).
+
+## SEE ALSO
+
+tork(1), tork-driver(1)
+
+=end =========================================================================
+
+$0 = File.basename(__FILE__) # for easier identification in ps(1) output
+
+require 'binman'
+BinMan.help
+
+require 'json'
+IO.popen('tork-driver', 'w+') do |driver|
+  # tell tork to run the given test files
+  # or run known test files if none given
+  test_files = Dir[*ARGV]
+  command =
+    if test_files.empty?
+      [:run_all_test_files]
+    else
+      [:run_test_files, test_files]
+    end
+  driver.puts JSON.dump(command)
+
+  # track test runs & exit when finished
+  tested, passed, failed = 0, 0, []
+  while line = driver.gets
+    response = JSON.load(line)
+    case response.first.to_sym
+    when :test then tested += 1
+    when :pass then passed += 1
+    when :fail then failed << response[3]
+    when :idle then
+      puts failed.map {|log| [nil, ">> #{log} <<", File.read(log)] }, nil,
+           "#{tested} tested, #{passed} passed, #{failed.count} failed"
+      exit failed.empty?
+    end
+  end
+end

data/lib/tork/bridge.rb

@@ -0,0 +1,66 @@
+module Tork
+# Wrapper for IO.popen() that automatically re-establishes itself
+# whenever the child process terminates extraneously, on its own.
+class Bridge
+
+  def initialize command
+    @command = command
+    connect
+  end
+
+  def disconnect
+    return unless @guardian.alive?
+
+    # prevent guardian from reconnecting bridge while we disconnect it
+    @guardian.exit
+
+    # this should be enough to stop programs that use Tork::Server#loop
+    # because their IO.select() loop terminates on the closing of STDIN
+    @io.close_write
+
+    # but some programs like tork-herald(1) need to be killed explicitly
+    # because they do not follow our convention of exiting on STDIN close
+    Process.kill :SIGTERM, @io.pid
+    Process.waitpid @io.pid
+
+    # this will block until the child process has exited so we must kill it
+    # explicitly (as above) to ensure that this program does not hang here
+    @io.close_read
+
+  rescue IOError, SystemCallError
+    # IOError happens if the child process' pipes are already closed
+    # SystemCallError happens if the child process is already dead
+  end
+
+  def reconnect
+    disconnect
+    connect
+  end
+
+  # Allows this object to be passed directly
+  # into IO.select() and Tork::Server#tell().
+  def to_io
+    @io
+  end
+
+  # Allows this object to be treated as IO.
+  def method_missing *args, &block
+    @io.__send__ *args, &block
+  end
+
+private
+
+  def connect
+    @io = IO.popen(@command, 'r+')
+
+    # automatically reconnect the bridge when the child process terminates
+    @guardian = Thread.new do
+      Process.waitpid @io.pid
+      warn "#{$0}: repairing collapsed bridge: #{@command} #{$?}"
+      sleep 1 # avoid spamming the CPU by waiting a bit before reconnecting
+      connect # no need to disconnect because child process is already dead
+    end
+  end
+
+end
+end

data/lib/tork/cliapp.rb

@@ -24,6 +24,11 @@ class CLIApp < Server
 
 protected
 
+  def join client
+    super
+    help client
+  end
+
   def recv client, message
     case client
     when @driver
@@ -51,23 +56,26 @@ protected
         tell @clients, message, false
       end
     else
-      key, *args = message
-      key &&= key.lstrip[0,1].downcase
-
-      if cmd = COMMANDS[key]
-        quit if cmd == :quit
-        call = Array(cmd) + args
-        tell @clients, "Sending #{call.inspect} command...", false
-        send @driver, call
+      key = message.shift.lstrip[0,1].downcase
+      cmd = Array(COMMANDS.fetch(key, [:help, client])) + message
+      if respond_to? cmd.first, true
+        __send__(*cmd)
       else
-        # user typed an invalid command so help them along
-        COMMANDS.each do |key, cmd|
-          desc = Array(cmd).join(' with ').to_s.tr('_', ' ')
-          tell @client, "Type #{key} then ENTER to #{desc}.", false
-        end
+        tell @clients, "Sending #{cmd.inspect} command...", false
+        send @driver, cmd
       end
     end
   end
 
+private
+
+  def help client
+    COMMANDS.each do |key, cmd|
+      desc = Array(cmd).join(' with ').to_s.tr('_', ' ')
+      tell client, "Type #{key} then ENTER to #{desc}.", false
+    end
+    tell client, 'Type h then ENTER to see this message.', false
+  end
+
 end
 end

data/lib/tork/config/rails/worker.rb

@@ -10,7 +10,7 @@ if defined? ActiveRecord::Base
     elsif base.respond_to? :connection_pool     # rails >= 2.2.1
       base.connection_pool.spec.config
     else
-      warn "#{$0}: config/rails/worker: couldn't read connection information"
+      warn "#{$0}: config/rails/worker: could not read connection information"
       {}
     end
 

data/lib/tork/engine.rb

@@ -17,15 +17,14 @@ class Engine < Server
   end
 
   def loop
-    create_master
+    @master = popen('tork-master')
     super
   ensure
-    destroy_master
+    pclose @master
   end
 
   def reabsorb_overhead
-    destroy_master
-    create_master
+    @master.reconnect
 
     # re-dispatch the previously dispatched files to the new master
     previous = @queued_test_files.to_a
@@ -122,13 +121,5 @@ private
       map {|change| change.position + 1 }.uniq
   end
 
-  def create_master
-    @master = popen('tork-master')
-  end
-
-  def destroy_master
-    pclose @master
-  end
-
 end
 end

data/lib/tork/server.rb

@@ -2,6 +2,7 @@ require 'socket'
 require 'json'
 require 'shellwords'
 require 'set'
+require 'tork/bridge'
 
 module Tork
 class Server
@@ -11,46 +12,42 @@ class Server
   end
 
   def initialize
+    begin
+      @welcome = UNIXServer.open(address = Server.address)
+      # UNIX domain socket files are not automatically deleted on close
+      at_exit { File.delete address if File.socket? address }
+    rescue Errno::EADDRINUSE
+      # another instance of this program is already running in the same
+      # directory so become a remote control for it rather than exiting
+      warn "#{$0}: remotely controlling existing instance..."
+      exec 'tork-remote', $0
+    end
+
     # only JSON messages are supposed to be emitted on STDOUT
     # so make puts() in the user code write to STDERR instead
     @stdout = STDOUT.dup
     STDOUT.reopen STDERR
 
-    @clients = Set.new.add(STDIN)
-    @servers = Set.new
-    @address = Server.address
+    @servers = Set.new.add(@welcome)
+    @clients = Set.new; join STDIN # parent process connected on STDIN
   end
 
   def loop
-    begin
-      server = UNIXServer.open(@address)
-    rescue SystemCallError => error
-      warn "#{$0}: #{error}; retrying in #{timeout = 1 + rand(10)} seconds..."
-      sleep timeout
-      retry
-    end
-
     catch :quit do
-      @servers.add server
       while @clients.include? STDIN
         IO.select((@servers + @clients).to_a).first.each do |stream|
-          @client = stream
-
-          if stream == server
-            @clients.add stream.accept
+          if stream == @welcome
+            join stream.accept
 
           elsif (stream.eof? rescue true)
-            @clients.delete stream
+            part stream
 
-          elsif @command = hear(stream, stream.gets)
+          elsif @command = hear(stream, stream.gets) and not @command.empty?
             recv stream, @command
           end
         end
       end
     end
-  ensure
-    # UNIX domain socket files are not deleted automatically upon closing
-    File.delete @address if File.socket? @address
   end
 
   def quit
@@ -59,6 +56,14 @@ class Server
 
 protected
 
+  def join client
+    @clients.add client
+  end
+
+  def part client
+    @clients.delete client
+  end
+
   # Returns nil if the message received was not meant for processing.
   def hear sender, message
     JSON.load message
@@ -73,7 +78,9 @@ protected
     end
   end
 
+  # Sets the @client variable to the client we are currently serving.
   def recv client, command
+    @client = client
     __send__(*command)
   rescue => error
     tell client, error
@@ -93,7 +100,7 @@ protected
     end
 
     targets =
-      if one_or_more_clients.kind_of? IO
+      if one_or_more_clients.respond_to? :to_io
         [one_or_more_clients]
       else
         Array(one_or_more_clients)
@@ -113,26 +120,13 @@ protected
   end
 
   def popen command
-    child = IO.popen(command, 'r+')
+    child = Bridge.new(command)
     @servers.add child
     child
   end
 
   def pclose child
-    return unless @servers.delete? child
-
-    # this should be enough to stop programs that use Tork::Server#loop
-    # because their IO.select() loop terminates on the closing of STDIN
-    child.close_write
-
-    # but some programs like tork-herald(1) need to be killed explicitly
-    # because they do not follow our convention of exiting on STDIN close
-    Process.kill :SIGTERM, child.pid
-    Process.waitpid child.pid
-
-    # this will block until the child process has exited so we must kill it
-    # explicitly (as above) to ensure that this program does not hang here
-    child.close_read
+    child.disconnect if @servers.delete? child
   end
 
 end