cukeforker 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+\#*
+.\#*

data/.rspec

@@ -0,0 +1 @@
+--color -fs

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cukeforker.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Jari Bakken
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+

data/README.mdown

@@ -0,0 +1,26 @@
+cukeforker
+==========
+
+Forking cukes and VNC displays.
+
+Usage
+=============
+
+TODO.
+
+Note on Patches/Pull Requests
+=============================
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Copyright
+=========
+
+Copyright (c) 2011 Jari Bakken. See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new

data/bin/cukeforker

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'cukeforker'
+
+split      = ARGV.index("--")
+extra_args = ARGV[0..(split-1)]
+features   = ARGV[(split+1)..-1]
+
+CukeForker::Runner.run(features, :extra_args => extra_args)

data/cukeforker.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cukeforker/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cukeforker"
+  s.version     = CukeForker::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jari Bakken"]
+  s.email       = ["jari.bakken@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Library to maintain a forking queue of Cucumber processes}
+  s.description = %q{Library to maintain a forking queue of Cucumber processes, with optional VNC displays.}
+
+  s.rubyforge_project = "cukeforker"
+
+  s.add_dependency "cucumber"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/cukeforker.rb

@@ -0,0 +1,20 @@
+unless RUBY_PLATFORM =~ /darwin|linux/
+  raise "CukeForker only supported on *nix/MRI"
+end
+
+
+require "cucumber/cli/main"
+require "fileutils"
+require "observer"
+
+module CukeForker
+end
+
+require 'cukeforker/vnc_server_pool'
+require 'cukeforker/vnc_server'
+require 'cukeforker/abstract_listener'
+require 'cukeforker/vnc_listener'
+require 'cukeforker/logging_listener'
+require 'cukeforker/worker'
+require 'cukeforker/worker_queue'
+require 'cukeforker/runner'

data/lib/cukeforker/abstract_listener.rb

@@ -0,0 +1,39 @@
+module CukeForker
+  class AbstractListener
+
+    def on_run_starting
+    end
+
+    def on_worker_starting(worker)
+    end
+
+    def on_worker_finished(worker)
+    end
+
+    def on_run_interrupted
+    end
+
+    def on_run_finished(failed)
+    end
+
+    def on_display_fetched(server)
+    end
+
+    def on_display_released(server)
+    end
+
+    def on_display_starting(server)
+    end
+
+    def on_display_stopping(server)
+    end
+
+    def on_eta(time, remaining, finished)
+    end
+
+    def update(meth, *args)
+      __send__(meth, *args)
+    end
+
+  end # AbstractListener
+end # CukeForker

data/lib/cukeforker/logging_listener.rb

@@ -0,0 +1,65 @@
+require "logger"
+
+module CukeForker
+  class LoggingListener < AbstractListener
+    TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+    def initialize(io = STDOUT)
+      @io = io
+    end
+
+    def on_run_starting
+      log.info "[    run           ] starting"
+    end
+
+    def on_worker_starting(worker)
+      log.info "[    worker(#{worker.id})     ] starting: #{worker.feature}"
+    end
+
+    def on_worker_finished(worker)
+      log.info "[    worker(#{worker.id})     ] finished: #{worker.feature}"
+    end
+
+    def on_run_finished(failed)
+      log.info "[    run           ] finished, #{failed ? 'failed' : 'passed'}"
+    end
+
+    def on_run_interrupted
+      puts "\n"
+      log.info "[    run           ] interrupted - please wait"
+    end
+
+    def on_display_fetched(server)
+      log.info "[    display(#{server.display.to_s.ljust(2)})   ] fetched"
+    end
+
+    def on_display_released(server)
+      log.info "[    display(#{server.display.to_s.ljust(2)})   ] released"
+    end
+
+    def on_display_starting(server)
+      log.info "[    display(#{server.display.to_s.ljust(2)})   ] starting"
+    end
+
+    def on_display_stopping(server)
+      log.info "[    display(#{server.display.to_s.ljust(2)})   ] stopping"
+    end
+
+    def on_eta(eta, remaining, finished)
+      counts = "(#{remaining}/#{finished})".ljust(11)
+      log.info "[    eta#{counts}] #{eta.strftime TIME_FORMAT}"
+    end
+
+    private
+
+    def log
+      @log ||= (
+        log = Logger.new @io
+        log.datetime_format = TIME_FORMAT
+
+        log
+      )
+    end
+  end # LoggingListener
+
+end # CukeForker

data/lib/cukeforker/runner.rb

@@ -0,0 +1,104 @@
+module CukeForker
+
+  #
+  # Runner.run(features, opts)
+  #
+  # where 'features' is an Array of file:line
+  # and 'opts' is a Hash of options:
+  #
+  #   :max        => Fixnum       number of workers (default: 2)
+  #   :vnc        => true/false   children are launched with DISPLAY set from a VNC server pool,
+  #                               where the size of the pool is equal to :max
+  #   :notify     => object       (or array of objects) implementing the AbstractListener API
+  #   :out        => path         directory to dump output to (default: current working dir)
+  #   :log        => true/false   wether or not to log to stdout (default: true)
+  #   :format     => Symbol       format passed to `cucumber --format` (default: html)
+  #   :extra_args => Array        extra arguments passed to cucumber
+  #
+
+  class Runner
+    include Observable
+
+    DEFAULT_OPTIONS = {
+      :max    => 2,
+      :vnc    => false,
+      :notify => [],
+      :out    => Dir.pwd,
+      :log    => true,
+      :format => :html
+    }
+
+    def self.run(features, opts = {})
+      create(features, opts).run
+    end
+
+    def self.create(features, opts = {})
+      opts = DEFAULT_OPTIONS.dup.merge(opts)
+
+      max        = opts[:max]
+      format     = opts[:format]
+      out        = File.join opts[:out], Process.pid.to_s
+      listeners  = Array(opts[:notify])
+      extra_args = Array(opts[:extra_args])
+
+      if opts[:log]
+        listeners << LoggingListener.new
+      end
+
+      if opts[:vnc]
+        vnc_pool = VncServerPool.new(max)
+        listeners << VncListener.new(vnc_pool)
+      end
+
+      queue = WorkerQueue.new max
+      features.each do |feature|
+        queue.add Worker.new(feature, format, out, extra_args)
+      end
+
+      runner = Runner.new queue
+
+      listeners.each { |listener|
+        queue.add_observer listener
+        runner.add_observer listener
+        vnc_pool.add_observer listener if opts[:vnc]
+      }
+
+      runner
+    end
+
+    def initialize(queue)
+      @queue = queue
+    end
+
+    def run
+      start
+      process
+      stop
+    rescue Interrupt
+      fire :on_run_interrupted
+      stop
+    end
+
+    private
+
+    def start
+      fire :on_run_starting
+    end
+
+    def process
+      @queue.process 0.2
+    end
+
+    def stop
+      @queue.wait_until_finished 0.5
+    ensure # catch potential second Interrupt
+      fire :on_run_finished, @queue.has_failures?
+    end
+
+    def fire(*args)
+      changed
+      notify_observers(*args)
+    end
+
+  end # Runner
+end # CukeForker

data/lib/cukeforker/version.rb

@@ -0,0 +1,3 @@
+module CukeForker
+  VERSION = "0.0.1"
+end

data/lib/cukeforker/vnc_listener.rb

@@ -0,0 +1,21 @@
+module CukeForker
+  class VncListener < AbstractListener
+    def initialize(pool)
+      @pool = pool
+    end
+
+    def on_worker_starting(worker)
+      worker.vnc = @pool.get
+    end
+
+    def on_worker_finished(worker)
+      @pool.release worker.vnc
+      worker.vnc = nil
+    end
+
+    def on_run_finished(failed)
+      @pool.stop
+    end
+
+  end # VncListener
+end # CukeForker

data/lib/cukeforker/vnc_server.rb

@@ -0,0 +1,62 @@
+require "socket"
+
+module CukeForker
+  class VncServer
+
+    class Error < StandardError
+    end
+
+    class << self
+      def displays
+        Dir[File.expand_path("~/.vnc/*.pid")].map { |e| e[/(\d+)\.pid/, 1] }.compact
+      end
+
+      def all
+        displays.map { |display| new ":#{display}" }
+      end
+    end
+
+    attr_reader :display
+
+    def initialize(display = nil)
+      @display = display
+    end
+
+    def start
+      if display
+        server display
+      else
+        output = server
+        @display = output[/desktop is #{host}(\S+)/, 1]
+      end
+    end
+
+    def stop
+      server "-kill", display.to_s
+    end
+
+    private
+
+    def server(*args)
+      cmd = ['tightvncserver', args, '2>&1'].flatten.compact
+      out = `#{cmd.join ' '}`
+
+      unless last_status.success?
+        raise Error, "could not run tightvncserver: #{out.inspect}"
+      end
+
+      out
+    end
+
+    def last_status
+      $?
+    end
+
+    def host
+      @host ||= Socket.gethostname
+    end
+  end # VncServer
+end # CukeForker
+
+
+

data/lib/cukeforker/vnc_server_pool.rb

@@ -0,0 +1,68 @@
+module CukeForker
+  class VncServerPool
+    include Observable
+
+    def initialize(capacity, klass = VncServer)
+      @capacity = capacity
+      @servers  = Array.new(capacity) { klass.new }
+      @running  = []
+    end
+
+    def stop
+      running.each do |s|
+        fire :on_display_stopping, s
+        s.stop
+      end
+    end
+
+    def size
+      @servers.size
+    end
+
+    def get
+      raise OutOfDisplaysError if @servers.empty?
+
+      server = next_server
+      fire :on_display_fetched, server
+
+      server
+    end
+
+    def release(server)
+      raise TooManyDisplaysError if size == @capacity
+      fire :on_display_released, server
+
+      @servers.unshift server
+    end
+
+    private
+
+    def fire(*args)
+      changed
+      notify_observers(*args)
+    end
+
+    def running
+      @running
+    end
+
+    def next_server
+      server = @servers.shift
+
+      if server.display.nil?
+        fire :on_display_starting, server
+        server.start
+        @running << server
+      end
+
+      server
+    end
+
+    class TooManyDisplaysError < StandardError
+    end
+
+    class OutOfDisplaysError < StandardError
+    end
+
+  end # DisplayPool
+end # CukeForker