servolux 0.10.0 → 0.11.0

data/lib/servolux/version.rb

@@ -0,0 +1,8 @@
+module Servolux
+  VERSION = "0.11.0".freeze
+
+  # Returns the version string for the library.
+  def self.version
+    VERSION
+  end
+end

data/script/bootstrap

@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+
+gem list -i bones >/dev/null 2>&1
+rc=$?
+if [[ $rc != 0 ]]; then
+  gem install bones
+fi
+
+rake gem:install_dependencies

data/spec/child_spec.rb

@@ -2,7 +2,6 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe Servolux::Child do
-
   before :all do
     @child = Servolux::Child.new
   end
@@ -12,22 +11,22 @@ describe Servolux::Child do
   end
 
   it 'has some sensible defaults' do
-    @child.command.should be_nil
-    @child.timeout.should be_nil
-    @child.signals.should be == %w[TERM QUIT KILL]
-    @child.suspend.should be == 4
-    @child.pid.should be_nil
-    @child.io.should be_nil
+    expect(@child.command).to be_nil
+    expect(@child.timeout).to be_nil
+    expect(@child.signals).to eq(%w[TERM QUIT KILL])
+    expect(@child.suspend).to eq(4)
+    expect(@child.pid).to be_nil
+    expect(@child.io).to be_nil
   end
 
   it 'starts a child process' do
     @child.command = 'echo `pwd`'
     @child.start
 
-    @child.pid.should_not be_nil
+    expect(@child.pid).to_not be_nil
     @child.wait
-    @child.io.read.strip.should be == Dir.pwd
-    @child.success?.should be_true
+    expect(@child.io.read.strip).to eq(Dir.pwd)
+    expect(@child.success?).to be true
   end
 
   it 'kills a child process after some timeout' do
@@ -35,16 +34,14 @@ describe Servolux::Child do
     @child.timeout = 0.25
     @child.start
 
-    @child.pid.should_not be_nil
+    expect(@child.pid).to_not be_nil
     @child.wait
 
-    @child.io.read.strip.should be_empty
+    expect(@child.io.read.strip).to be_empty
 
-    @child.signaled?.should be_true
-    @child.exited?.should be_false
-    @child.exitstatus.should be_nil
-    @child.success?.should be_nil
+    expect(@child.signaled?).to be true
+    expect(@child.exited?).to be false
+    expect(@child.exitstatus).to be_nil
+    expect(@child.success?).to be_nil
   end
-
 end
-

data/spec/daemon_spec.rb

@@ -1,12 +1,9 @@
-
 require File.expand_path('../spec_helper', __FILE__)
 require 'logger'
 require 'fileutils'
 
 if Servolux.fork?
-
 describe Servolux::Daemon do
-
   TestServer = Module.new {
     def before_starting() @counter = 0; end
     def after_stopping() exit!(0); end
@@ -35,7 +32,7 @@ describe Servolux::Daemon do
     @daemon = Servolux::Daemon.new(:server => server, :log_file => log_fn, :timeout => 8)
 
     @daemon.startup false
-    @daemon.should be_alive
+    expect(@daemon).to be_alive
   end
 
   it 'waits for a particular line to appear in the log file' do
@@ -44,7 +41,7 @@ describe Servolux::Daemon do
     @daemon = Servolux::Daemon.new(:server => server, :log_file => log_fn, :look_for => 'executing run loop [2]', :timeout => 8)
 
     @daemon.startup false
-    @daemon.should be_alive
+    expect(@daemon).to be_alive
   end
 
   it 'raises an error if the startup timeout is exceeded' do
@@ -52,10 +49,7 @@ describe Servolux::Daemon do
     server.extend TestServer
     @daemon = Servolux::Daemon.new(:server => server, :log_file => log_fn, :look_for => 'executing run loop [42]', :timeout => 4)
 
-    lambda { @daemon.startup }.should raise_error(Servolux::Daemon::Timeout)
+    expect { @daemon.startup }.to raise_error(Servolux::Daemon::Timeout)
   end
-
 end
-
 end  # if Servolux.fork?
-

data/spec/piper_spec.rb

@@ -1,10 +1,7 @@
-
 require File.expand_path('../spec_helper', __FILE__)
 
 if Servolux.fork?
-
 describe Servolux::Piper do
-
   before :each do
     @piper = nil
   end
@@ -18,15 +15,16 @@ describe Servolux::Piper do
 
   it 'only understands three file modes' do
     %w[r w rw].each do |mode|
-      lambda {
+      expect {
         piper = Servolux::Piper.new(mode)
         piper.child { piper.close; exit! }
         piper.parent { piper.close }
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
-    lambda { Servolux::Piper.new('f') }.should raise_error(
-        ArgumentError, 'Unsupported mode "f"')
+    expect {
+      Servolux::Piper.new('f')
+    }.to raise_error(ArgumentError, 'Unsupported mode "f"')
   end
 
   it 'enables communication between parents and children' do
@@ -45,23 +43,23 @@ describe Servolux::Piper do
 
     @piper.parent {
       @piper.puts 'foo bar baz'
-      @piper.gets.should be == 'foo bar baz'
+      expect(@piper.gets).to eq('foo bar baz')
 
       @piper.puts %w[one two three]
-      @piper.gets.should be == %w[one two three]
+      expect(@piper.gets).to eq(%w[one two three])
 
-      @piper.puts('Returns # of bytes written').should be > 0
-      @piper.gets.should be == 'Returns # of bytes written'
+      expect(@piper.puts('Returns # of bytes written')).to be > 0
+      expect(@piper.gets).to eq('Returns # of bytes written')
 
       @piper.puts 1
       @piper.puts 2
       @piper.puts 3
-      @piper.gets.should be == 1
-      @piper.gets.should be == 2
-      @piper.gets.should be == 3
+      expect(@piper.gets).to eq(1)
+      expect(@piper.gets).to eq(2)
+      expect(@piper.gets).to eq(3)
 
       @piper.timeout = 0.1
-      @piper.readable?.should be_false
+      expect(@piper).not_to be_readable
     }
   end
 
@@ -82,13 +80,13 @@ describe Servolux::Piper do
     }
 
     @piper.parent {
-      @piper.gets.should be == :ready
+      expect(@piper.gets).to eq(:ready)
 
       @piper.signal 'USR2'
-      @piper.gets.should be == "'USR2' was received"
+      expect(@piper.gets).to eq("'USR2' was received")
 
       @piper.signal 'INT'
-      @piper.gets.should be == "'INT' was received"
+      expect(@piper.gets).to eq("'INT' was received")
     }
   end
 
@@ -102,10 +100,9 @@ describe Servolux::Piper do
     }
 
     @piper.parent {
-      @piper.gets.should_not == Process.pid
+      expect(@piper.gets).not_to eq(Process.pid)
     }
   end
-
 end
 end  # if Servolux.fork?
 

data/spec/prefork_spec.rb

@@ -1,13 +1,10 @@
-
 require File.expand_path('../spec_helper', __FILE__)
 require 'tempfile'
 require 'fileutils'
 require 'enumerator'
 
 if Servolux.fork?
-
 describe Servolux::Prefork do
-
   def pids
     workers.map! { |w| w.pid }
   end
@@ -34,17 +31,17 @@ describe Servolux::Prefork do
 
   before :all do
     tmp = Tempfile.new 'servolux-prefork'
-    @path = path = tmp.path; tmp.unlink
+    @path = tmp.path; tmp.unlink
     @glob = @path + '/*.txt'
     FileUtils.mkdir @path
 
-    @worker = Module.new {
-      define_method(:before_executing) { @fd = File.open(path + "/#$$.txt", 'w') }
+    @worker = Module.new do
+      def before_executing() @fd = File.open("#{config[:path]}/#$$.txt", 'w'); end
       def after_executing() @fd.close; FileUtils.rm_f @fd.path; end
       def execute() @fd.puts Time.now; sleep 2; end
       def hup() @thread.wakeup; end
       alias :term :hup
-    }
+    end
   end
 
   after :all do
@@ -65,51 +62,51 @@ describe Servolux::Prefork do
   end
 
   it "starts up a single worker" do
-    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 1
     ary = workers
     sleep 0.1 until ary.all? { |w| w.alive? }
     sleep 0.1 until worker_count >= 1
 
     ary = Dir.glob(@glob)
-    ary.length.should be == 1
-    File.basename(ary.first).to_i.should be == pids.first
+    expect(ary.length).to eq(1)
+    expect(File.basename(ary.first).to_i).to eq(pids.first)
   end
 
   it "starts up a number of workers" do
-    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 8
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
     sleep 0.250 until worker_count >= 8
 
     ary = Dir.glob(@glob)
-    ary.length.should be == 8
+    expect(ary.length).to eq(8)
 
     ary.map! { |fn| File.basename(fn).to_i }.sort!
-    ary.should be == pids.sort
+    expect(ary).to eq(pids.sort)
   end
 
   it "stops workers gracefullly" do
-    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 3
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
     sleep 0.250 until worker_count >= 3
 
     ary = Dir.glob(@glob)
-    ary.length.should be == 3
+    expect(ary.length).to eq(3)
 
     @prefork.stop
     sleep 0.250 until Dir.glob(@glob).length == 0
     workers.each { |w| w.wait rescue nil }
 
     rv = workers.all? { |w| !w.alive? }
-    rv.should be == true
+    expect(rv).to be true
   end
 
   it "restarts a worker via SIGHUP" do
-    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
@@ -120,11 +117,11 @@ describe Servolux::Prefork do
     @prefork.reap until !alive? pid
     sleep 0.250 until ary.all? { |w| w.alive? }
 
-    pid.should_not == pids.last
+    expect(pid).not_to eq(pids.last)
   end
 
   it "starts up a stopped worker" do
-    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
@@ -138,11 +135,11 @@ describe Servolux::Prefork do
       worker.start unless worker.alive?
     end
     sleep 0.250 until ary.all? { |w| w.alive? }
-    pid.should_not == pids.last
+    expect(pid).not_to eq(pids.last)
   end
 
   it "adds a new worker to the worker pool" do
-    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
@@ -151,11 +148,11 @@ describe Servolux::Prefork do
 
     @prefork.add_workers( 2 )
     sleep 0.250 until worker_count >= 4
-    workers.size.should == 4
+    expect(workers.size).to eq(4)
   end
 
   it "only adds workers up to the max_workers value" do
-    @prefork = Servolux::Prefork.new :module => @worker, :max_workers => 3
+    @prefork = Servolux::Prefork.new :module => @worker, :max_workers => 3, :config => {:path => @path}
     @prefork.start 2
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
@@ -163,11 +160,11 @@ describe Servolux::Prefork do
 
     @prefork.add_workers( 2 )
     sleep 0.250 until worker_count >= 3
-    workers.size.should == 3
+    expect(workers.size).to eq(3)
   end
 
   it "prunes workers that are no longer running" do
-    @prefork = Servolux::Prefork.new :module => @worker
+    @prefork = Servolux::Prefork.new :module => @worker, :config => {:path => @path}
     @prefork.start 2
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
@@ -175,17 +172,17 @@ describe Servolux::Prefork do
 
     @prefork.add_workers( 2 )
     sleep 0.250 until worker_count >= 3
-    workers.size.should be == 4
+    expect(workers.size).to eq(4)
 
     workers[0].stop
     sleep 0.250 while workers[0].alive?
 
     @prefork.prune_workers
-    workers.size.should be == 3
+    expect(workers.size).to eq(3)
   end
 
   it "ensures that there are minimum number of workers" do
-    @prefork = Servolux::Prefork.new :module => @worker, :min_workers => 3
+    @prefork = Servolux::Prefork.new :module => @worker, :min_workers => 3, :config => {:path => @path}
     @prefork.start 1
     ary = workers
     sleep 0.250 until ary.all? { |w| w.alive? }
@@ -193,8 +190,7 @@ describe Servolux::Prefork do
 
     @prefork.ensure_worker_pool_size
     sleep 0.250 until worker_count >= 3
-    workers.size.should be == 3
+    expect(workers.size).to eq(3)
   end
 end
 end  # Servolux.fork?
-

data/spec/server_spec.rb

@@ -26,54 +26,54 @@ describe Servolux::Server do
   end
 
   it 'generates a PID file' do
-    test(?e, @server.pid_file).should be_false
+    expect(test(?e, @server.pid_file)).to be false
 
     t = Thread.new {@server.startup}
     wait_until { @server.running? and t.status == 'sleep' }
-    test(?e, @server.pid_file).should be_true
+    expect(test(?e, @server.pid_file)).to be true
 
     @server.shutdown
     wait_until { t.status == false }
-    test(?e, @server.pid_file).should be_false
+    expect(test(?e, @server.pid_file)).to be false
   end
 
   it 'generates a PID file with mode rw-r----- by default' do
     t = Thread.new {@server.startup}
     wait_until { @server.running? and t.status == 'sleep' }
-    test(?e, @server.pid_file).should be_true
+    expect(test(?e, @server.pid_file)).to be true
 
-    @log_output.readline.chomp.should be == %q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid")
-    @log_output.readline.chomp.should be == %q(DEBUG  Servolux : Starting)
-    (File.stat(@server.pid_file).mode & 0777).should be == 0640
+    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid"))
+    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Starting))
+    expect(File.stat(@server.pid_file).mode & 0777).to eq(0640)
 
     @server.shutdown
     wait_until { t.status == false }
-    test(?e, @server.pid_file).should be_false
+    expect(test(?e, @server.pid_file)).to be false
   end
 
   it 'generates PID file with the specified permissions' do
     @server.pid_file_mode = 0400
     t = Thread.new {@server.startup}
     wait_until { @server.running? and t.status == 'sleep' }
-    test(?e, @server.pid_file).should be_true
+    expect(test(?e, @server.pid_file)).to be true
 
-    @log_output.readline.chomp.should be == %q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid")
-    @log_output.readline.chomp.should be == %q(DEBUG  Servolux : Starting)
-    (File.stat(@server.pid_file).mode & 0777).should be == 0400
+    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Server "Test Server" creating pid file "test_server.pid"))
+    expect(@log_output.readline.chomp).to eq(%q(DEBUG  Servolux : Starting))
+    expect(File.stat(@server.pid_file).mode & 0777).to eq(0400)
 
     @server.shutdown
     wait_until { t.status == false }
-    test(?e, @server.pid_file).should be_false
+    expect(test(?e, @server.pid_file)).to be false
   end
 
   it 'shuts down gracefully when signaled' do
     t = Thread.new {@server.startup}
     wait_until { @server.running? and t.status == 'sleep' }
-    @server.should be_running
+    expect(@server).to be_running
 
     `kill -SIGINT #{$$}`
     wait_until { t.status == false }
-    @server.should_not be_running
+    expect(@server).to_not be_running
   end
 
   it 'responds to signals that have defined handlers' do
@@ -86,29 +86,50 @@ describe Servolux::Server do
     t = Thread.new {@server.startup}
     wait_until { @server.running? and t.status == 'sleep' }
     @log_output.readline
-    @log_output.readline.strip.should be == 'DEBUG  Servolux : Starting'
+    expect(@log_output.readline.strip).to eq('DEBUG  Servolux : Starting')
 
     line = nil
     Process.kill 'SIGUSR1', $$
     wait_until { line = @log_output.readline }
-    line.should_not be_nil
-    line.strip.should be == 'INFO  Servolux : usr1 was called'
+    expect(line).to_not be_nil
+    expect(line.strip).to eq('INFO  Servolux : usr1 was called')
 
     line = nil
     Process.kill 'SIGHUP', $$
     wait_until { line = @log_output.readline }
-    line.should_not be_nil
-    line.strip.should be == 'INFO  Servolux : hup was called'
+    expect(line).to_not be_nil
+    expect(line.strip).to eq('INFO  Servolux : hup was called')
 
     line = nil
     Process.kill 'SIGUSR2', $$
     wait_until { line = @log_output.readline }
-    line.should_not be_nil
-    line.strip.should be == 'INFO  Servolux : usr2 was called'
+    expect(line).to_not be_nil
+    expect(line.strip).to eq('INFO  Servolux : usr2 was called')
 
     Process.kill 'SIGTERM', $$
     wait_until { t.status == false }
-    @server.should_not be_running
+    expect(@server).to_not be_running
   end
-end
 
+  it 'captures exceptions raised by the signal handlers' do
+    class << @server
+      def usr2() raise 'Ooops!'; end
+    end
+
+    t = Thread.new {@server.startup}
+    wait_until { @server.running? and t.status == 'sleep' }
+    @log_output.readline
+    expect(@log_output.readline.strip).to eq('DEBUG  Servolux : Starting')
+
+    line = nil
+    Process.kill 'SIGUSR2', $$
+    wait_until { line = @log_output.readline }
+    expect(line).to_not be_nil
+    expect(line.strip).to eq('ERROR  Servolux : Exception in signal handler: usr2')
+
+    line = nil
+    wait_until { line = @log_output.readline }
+    expect(line).to_not be_nil
+    expect(line.strip).to eq('ERROR  Servolux : <RuntimeError> Ooops!')
+  end
+end