connect failure scenarios

tests/check_bitset.c

@@ -140,17 +140,53 @@ START_TEST(test_bitset)
 }
 END_TEST
 
+
+START_TEST( test_bitset_set )
+{
+	struct bitset_mapping* map;
+	uint64_t *num;
+	
+	map = bitset_alloc(64, 1);
+	num = (uint64_t*) map->bits;
+
+	ck_assert_int_eq( 0x0000000000000000, *num );
+	bitset_set( map );
+	ck_assert_int_eq( 0xffffffffffffffff, *num );
+}
+END_TEST
+
+
+START_TEST( test_bitset_clear )
+{
+	struct bitset_mapping* map;
+	uint64_t *num;
+	
+	map = bitset_alloc(64, 1);
+	num = (uint64_t*) map->bits;
+
+	ck_assert_int_eq( 0x0000000000000000, *num );
+	bitset_set( map );
+	bitset_clear( map );
+	ck_assert_int_eq( 0x0000000000000000, *num );
+}
+END_TEST
+
+
 Suite* bitset_suite(void)
 {
 	Suite *s = suite_create("bitset");
-	TCase *tc_core = tcase_create("bitset");
-	tcase_add_test(tc_core, test_bit_set);
-	tcase_add_test(tc_core, test_bit_clear);
-	tcase_add_test(tc_core, test_bit_tests);
-	tcase_add_test(tc_core, test_bit_ranges);
-	tcase_add_test(tc_core, test_bit_runs);
-	tcase_add_test(tc_core, test_bitset);
-	suite_add_tcase(s, tc_core);
+	TCase *tc_bit = tcase_create("bit");
+	TCase *tc_bitset = tcase_create("bitset");
+	tcase_add_test(tc_bit, test_bit_set);
+	tcase_add_test(tc_bit, test_bit_clear);
+	tcase_add_test(tc_bit, test_bit_tests);
+	tcase_add_test(tc_bit, test_bit_ranges);
+	tcase_add_test(tc_bit, test_bit_runs);
+	tcase_add_test(tc_bitset, test_bitset);
+	tcase_add_test(tc_bitset, test_bitset_set);
+	tcase_add_test(tc_bitset, test_bitset_clear);
+	suite_add_tcase(s, tc_bit);
+	suite_add_tcase(s, tc_bitset);
 	
 	return s;
 }

tests/check_status.c

@@ -0,0 +1,139 @@
+#include "status.h"
+#include "serve.h"
+#include "ioutil.h"
+#include "util.h"
+
+#include <check.h>
+
+START_TEST( test_status_create )
+{
+	struct server server;
+	struct status *status = NULL;
+
+	status = status_create( &server );
+
+	fail_if( NULL == status, "Status wasn't allocated" );
+	status_destroy( status );
+}
+END_TEST
+
+START_TEST( test_gets_has_control )
+{
+	struct server server;
+	struct status * status;
+
+	server.has_control = 1;
+	status = status_create( &server );
+
+	fail_unless( status->has_control == 1, "has_control wasn't copied" );
+	status_destroy( status );
+}
+END_TEST
+
+
+START_TEST( test_gets_is_mirroring )
+{
+	struct server server;
+	struct status * status;
+
+	server.mirror = NULL;
+	status = status_create( &server );
+	fail_if( status->is_mirroring, "is_mirroring was set" );
+	status_destroy( status );
+
+	server.mirror = (struct mirror_status *)xmalloc( sizeof( struct mirror_status ) );
+	status = status_create( &server );
+	fail_unless( status->is_mirroring, "is_mirroring wasn't set" );
+	status_destroy( status );
+}
+END_TEST
+
+
+START_TEST( test_renders_has_control )
+{
+	struct status status;
+	int fds[2];
+	pipe(fds);
+	char buf[1024] = {0};
+
+	status.has_control = 1;
+	status_write( &status, fds[1] );
+
+	fail_unless( read_until_newline( fds[0], buf, 1024 ) > 0,
+			"Couldn't read the result" );
+
+	char *found = strstr( buf, "has_control=true" );
+	fail_if( NULL == found, "has_control=true not found" );
+
+	status.has_control = 0;
+	status_write( &status, fds[1] );
+
+	fail_unless( read_until_newline( fds[0], buf, 1024 ) > 0,
+			"Couldn't read the result" );
+	found = strstr( buf, "has_control=false" );
+	fail_if( NULL == found, "has_control=false not found" );
+
+}
+END_TEST
+
+
+START_TEST( test_renders_is_mirroring )
+{
+	struct status status;
+	int fds[2];
+	pipe(fds);
+	char buf[1024] = {0};
+
+	status.is_mirroring = 1;
+	status_write( &status, fds[1] );
+
+	fail_unless( read_until_newline( fds[0], buf, 1024 ) > 0,
+			"Couldn't read the result" );
+
+	char *found = strstr( buf, "is_mirroring=true" );
+	fail_if( NULL == found, "is_mirroring=true not found" );
+
+	status.is_mirroring = 0;
+	status_write( &status, fds[1] );
+
+	fail_unless( read_until_newline( fds[0], buf, 1024 ) > 0,
+			"Couldn't read the result" );
+	found = strstr( buf, "is_mirroring=false" );
+	fail_if( NULL == found, "is_mirroring=false not found" );
+
+}
+END_TEST
+
+
+Suite *status_suite(void)
+{
+	Suite *s = suite_create("status");
+	TCase *tc_create = tcase_create("create");
+	TCase *tc_render = tcase_create("render");
+
+	tcase_add_test(tc_create, test_status_create);
+	tcase_add_test(tc_create, test_gets_has_control);
+	tcase_add_test(tc_create, test_gets_is_mirroring);
+
+	tcase_add_test(tc_render, test_renders_has_control);
+	tcase_add_test(tc_render, test_renders_is_mirroring);
+
+	suite_add_tcase(s, tc_create);
+	suite_add_tcase(s, tc_render);
+
+	return s;
+}
+
+int main(void)
+{
+	int number_failed;
+	
+	Suite *s = status_suite();
+	SRunner *sr = srunner_create(s);
+	srunner_run_all(sr, CK_NORMAL);
+	number_failed = srunner_ntests_failed(sr);
+	srunner_free(sr);
+	return (number_failed == 0) ? 0 : 1;
+}
+
+

tests/fakes/dest/close_after_hello.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+# Wait for a sender connection, send a correct hello, then disconnect.
+# Simulate a server which crashes after sending the hello.  We then
+# reopen the server socket to check that the sender retries: since the
+# command-line has gone away, and can't feed an error back to the
+# user, we have to keep trying.
+
+addr, port = *ARGV
+
+require 'socket'
+require 'timeout'
+
+sock = TCPServer.new( addr, port )
+client_sock = nil
+
+begin
+  Timeout.timeout(2) do
+    client_sock = sock.accept
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out waiting for a connection"
+  exit 1
+end
+
+
+client_sock.write( "NBDMAGIC" )
+client_sock.write( "\x00\x00\x42\x02\x81\x86\x12\x53" )
+client_sock.write( "\x00\x00\x00\x00\x00\x00\x10\x00" )
+client_sock.write( "\x00" * 128 )
+
+client_sock.close
+
+new_sock = nil
+begin
+  Timeout.timeout(60) do
+    new_sock = sock.accept
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out waiting for a reconnection"
+  exit 1
+end
+
+new_sock.close
+sock.close
+
+exit 0

tests/fakes/dest/hang_after_connect.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+# Will open a server, accept a single connection, then sleep for 5
+# seconds.  After that time, the client should have disconnected,
+# which we can can't effectively check.
+#
+# This allows the test runner to check that the command-line sees the
+# right error message after the timeout time.
+
+require 'socket'
+require 'timeout'
+require 'flexnbd/constants'
+
+addr, port = *ARGV
+
+serve_sock = TCPServer.new( addr, port )
+client_sock = nil
+
+begin
+  # A failure here means a more serious issue with flexnbd
+  Timeout.timeout( 2 ) do
+    client_sock = serve_sock.accept
+  end
+rescue Timeout::Error
+  $stderr.puts "Client didn't make connection"
+  exit 1
+end
+
+# Sleep for one second past the timeout (a bit of slop in case ruby
+# doesn't launch things quickly)
+sleep(FlexNBD::MS_HELLO_TIME_SECS + 1)
+
+client_sock.close  if client_sock
+serve_sock.close

tests/fakes/dest/hello_wrong_magic.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+# Simulate a destination which sends the wrong magic.
+# We expect the sender to disconnect and reconnect.
+
+addr, port = *ARGV
+
+require 'socket'
+require 'timeout'
+require 'flexnbd/constants'
+
+sock = TCPServer.new( addr, port )
+client_sock = nil
+
+begin
+  Timeout.timeout(2) do
+    client_sock = sock.accept
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out waiting for a connection"
+  exit 1
+end
+
+
+t = Thread.new do
+  begin
+    Timeout.timeout(FlexNBD::MS_RETRY_DELAY_SECS + 1) do
+      client_sock2 = sock.accept
+    end
+  rescue Timeout::Error
+    $stderr.puts "Timed out waiting for a reconnection"
+    exit 1
+  end
+end
+
+client_sock.write( "NBDMAGIC" )
+# We're off in the last byte, should be \x53
+client_sock.write( "\x00\x00\x42\x02\x81\x86\x12\x52" )
+# 4096 is the right size; this is defined in nbd_scenarios
+client_sock.write( "\x00\x00\x00\x00\x00\x00\x10\x00" )
+client_sock.write( "\x00" * 128 )
+
+
+t.join
+
+exit 0

tests/fakes/dest/hello_wrong_size.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+# Simulate a server which has a disc of the wrong size attached: send
+# a valid NBD hello with a random size, then check that we have see an
+# EOF on read.
+
+addr, port = *ARGV
+
+require 'socket'
+require 'timeout'
+require 'flexnbd/constants'
+
+sock = TCPServer.new( addr, port )
+client_sock = nil
+
+begin
+  Timeout.timeout(2) do
+    client_sock = sock.accept
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out waiting for a connection"
+  exit 1
+end
+
+t = Thread.new do
+  begin
+    Timeout.timeout(FlexNBD::MS_RETRY_DELAY_SECS + 1) do
+      client_sock2 = sock.accept
+    end
+  rescue Timeout::Error
+    $stderr.puts "Timed out waiting for a reconnection"
+    exit 1
+  end
+end
+
+client_sock.write( "NBDMAGIC" )
+client_sock.write( "\x00\x00\x42\x02\x81\x86\x12\x53" )
+8.times do client_sock.write rand(256).chr end
+client_sock.write( "\x00" * 128 )
+
+
+t.join
+
+exit 0

tests/fakes/dest/reject_acl.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+# Accept a connection, then immediately close it.  This simulates an ACL rejection.
+
+addr, port = *ARGV
+require 'socket'
+require 'timeout'
+
+serve_sock = TCPServer.open( addr, port )
+
+begin
+  Timeout.timeout( 2 ) do
+    serve_sock.accept.close
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out waiting for a connection"
+  exit 1
+end
+
+serve_sock.close
+
+exit(0)

tests/fakes/source/close_after_connect.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# Connects to the destination server, then immediately disconnects,
+# simulating a source crash.
+#
+# It then connects again, to check that the destination is still
+# listening.
+
+addr, port = *ARGV
+require 'socket'
+require 'timeout'
+
+begin
+  Timeout.timeout( 2 ) do
+    sock = TCPSocket.open( addr, port.to_i )
+    sock.close
+  end
+rescue Timeout::Error
+  $stderr.puts "Failed to connect"
+  exit 1
+end
+
+Timeout.timeout( 2 ) do
+  sock = TCPSocket.open( addr, port.to_i )
+  sock.close
+end
+
+exit 0

tests/fakes/source/close_after_hello.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+# Connect, read the hello, then immediately disconnect.  This
+# simulates a sender which dislikes something in the hello message - a
+# wrong size, for instance.
+
+# After the disconnect, we reconnect to be sure that the destination
+# is still alive.
+
+
+require 'socket'
+require "timeout"
+require 'flexnbd/constants'
+
+addr, port = *ARGV
+
+client_sock = nil
+begin
+  Timeout.timeout(2) do
+    client_sock = TCPSocket.open( addr, port )
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out connecting."
+  exit 1
+end
+
+begin
+  Timeout.timeout( FlexNBD::MS_HELLO_TIME_SECS ) do
+    fail "No hello." unless (hello = client_sock.read( 152 )) &&
+      hello.length==152
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out waiting for hello."
+  exit 1
+end
+
+client_sock.close
+
+sleep(0.2)
+begin
+  Timeout.timeout(2) do
+    client_sock = TCPSocket.open( addr, port )
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out reconnecting."
+  exit 1
+end
+
+exit(0)

tests/fakes/source/hang_after_hello.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+# Simulate the hello message going astray, or the source hanging after
+# receiving it.
+#
+# We then connect again, to confirm that the destination is still
+# listening for an incoming migration.
+
+addr, port = *ARGV
+require 'socket'
+require 'timeout'
+
+require "flexnbd/constants"
+
+
+client_sock=nil
+begin
+  Timeout.timeout(2) do
+    client_sock = TCPSocket.open( addr, port )
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out connecting"
+  exit 1
+end
+
+begin
+  Timeout.timeout(FlexNBD::MS_HELLO_TIME_SECS) do
+    client_sock.read(152)
+  end
+rescue Timeout::Error
+  $stderr.puts "Timed out reading hello"
+  exit 1
+end
+
+# Now we do two things:
+
+# - In the parent process, we sleep for CLIENT_MAX_WAIT_SECS+5, which
+#   will make the destination give up and close the connection.
+# - In the child process, we sleep for CLIENT_MAX_WAIT_SECS+1, which
+#   should be able to reconnect despite the parent process not having
+#   closed its end yet.
+
+kidpid = fork do
+  client_sock.close
+  new_sock = nil
+  sleep( FlexNBD::CLIENT_MAX_WAIT_SECS + 1 )
+  begin
+    Timeout.timeout( 2 ) do
+      new_sock = TCPSocket.open( addr, port )
+    end
+    Timeout.timeout( FlexNBD::MS_HELLO_TIME_SECS ) do
+      fail "No hello." unless (hello = new_sock.read( 152 )) &&
+          hello.length==152
+    end
+    new_sock.close
+  rescue Timeout::Error
+    $stderr.puts "Timed out reconnecting"
+    exit 1
+  end
+  exit 0
+end
+
+# Sleep for longer than the child, to give the flexnbd process a bit
+# of slop
+sleep( FlexNBD::CLIENT_MAX_WAIT_SECS + 3 )
+client_sock.close
+
+_,status = Process.waitpid2( kidpid )
+exit status.exitstatus

tests/flexnbd.rb

@@ -1,5 +1,7 @@
 require 'socket'
 require 'thread'
+require 'open3'
+require 'timeout'
 require 'rexml/document'
 require 'rexml/streamlistener'
 
@@ -138,7 +140,7 @@ class ValgrindExecutor
   def launch_watch_thread(pid, io_r)
     Thread.start do
       io_source = REXML::IOSource.new( io_r )
-      listener = ErrorListener.new( self )
+      listener = DebugErrorListener.new( self )
       REXML::Document.parse_stream( io_source, listener )
     end
   end
@@ -190,6 +192,17 @@ class FlexNBD
   end
 
 
+  def listen_cmd( file, acl )
+    "#{@bin} listen "\
+      "--addr #{ip} "\
+      "--port #{port} "\
+      "--file #{file} "\
+      "--sock #{ctrl} "\
+      "#{@debug} "\
+      "#{acl.join(' ')}"
+  end
+
+
   def read_cmd( offset, length )
     "#{bin} read "\
       "--addr #{ip} "\
@@ -218,9 +231,16 @@ class FlexNBD
       "#{@debug} "
   end
 
-  def serve(file, *acl)
+
+  def status_cmd
+    "#{@bin} status "\
+      "--sock #{ctrl} "\
+      "#{@debug}"
+  end
+
+
+  def run_serve_cmd(cmd)
     File.unlink(ctrl) if File.exists?(ctrl)
-    cmd =serve_cmd( file, acl )
     debug( cmd )
 
     @pid = @executor.run( cmd )
@@ -233,33 +253,49 @@ class FlexNBD
     end
     at_exit { kill }
   end
+  private :run_serve_cmd
+
+
+  def serve( file, *acl)
+    run_serve_cmd( serve_cmd( file, acl ) )
+  end
+
+  def listen(file, *acl)
+    run_serve_cmd( listen_cmd( file, acl ) )
+  end
+
 
   def start_wait_thread( pid )
-    Thread.start do
-      Process.waitpid2( pid )
+    @wait_thread = Thread.start do
+      _, status = Process.waitpid2( pid )
+
       if @kill
-        fail "flexnbd quit with a bad status #{$?.exitstatus}" unless
-          $?.exitstatus == @kill
+        fail "flexnbd quit with a bad status: #{status.to_i}" unless
+          @kill.include? status.to_i
       else
-        $stderr.puts "flexnbd quit"
-        fail "flexnbd quit early"
+        $stderr.puts "flexnbd #{self.pid} quit"
+        fail "flexnbd #{self.pid} quit early with status #{status.to_i}"
       end
     end
   end
 
 
-  def can_die(status=0)
+  def can_die(*status)
+    status << 0 if status.empty?
     @kill = status
   end
 
   def kill
-    can_die()
-    begin
-      Process.kill("INT", @pid)
-    rescue Errno::ESRCH => e
-      # already dead.  Presumably this means it went away after a
-      # can_die() call.
+    can_die(2)
+    if @pid
+      begin
+        Process.kill("INT", @pid)
+      rescue Errno::ESRCH => e
+        # already dead.  Presumably this means it went away after a
+        # can_die() call.
+      end
     end
+    @wait_thread.join if @wait_thread
   end
 
   def read(offset, length)
@@ -284,21 +320,55 @@ class FlexNBD
     nil
   end
 
-  def mirror(dest_ip, dest_port, bandwidth=nil, action=nil)
+
+  def mirror_unchecked( dest_ip, dest_port, bandwidth=nil, action=nil, timeout=nil )
     cmd = mirror_cmd( dest_ip, dest_port)
     debug( cmd )
-    system cmd
-    raise IOError.new( "Migrate command failed") unless $?.success?
-    nil
+
+    maybe_timeout( cmd, timeout )
+  end
+
+  def maybe_timeout(cmd, timeout=nil )
+    stdout, stderr = "",""
+    run = Proc.new do
+      Open3.popen3( cmd ) do |io_in, io_out, io_err|
+        io_in.close
+        stdout.replace io_out.read
+        stderr.replace io_err.read
+      end
+    end
+
+    if timeout
+      Timeout.timeout(timeout, &run)
+    else
+      run.call
+    end
+
+    [stdout, stderr]
+  end
+
+
+  def mirror(dest_ip, dest_port, bandwidth=nil, action=nil)
+    stdout, stderr = mirror_unchecked( dest_ip, dest_port, bandwidth, action )
+    raise IOError.new( "Migrate command failed\n" + stderr) unless $?.success?
+
+    stdout
   end
 
   def acl(*acl)
     control_command("acl", *acl)
   end
 
-  def status
+
+  def status( timeout = nil )
+    cmd = status_cmd()
+    debug( cmd )
+
+    maybe_timeout( cmd, timeout )
+
   end
 
+
   protected
   def control_command(*args)
     raise "Server not running" unless @pid

tests/flexnbd/constants.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module FlexNBD
+
+  # eeevil is his one and only name...
+  def self.read_constants
+    parents = []
+    current = File.expand_path(".")
+    while current != "/"
+      parents << current
+      current = File.expand_path( File.join( current, ".." ) )
+    end
+
+    source_root = parents.find do |dirname|
+      File.directory?( File.join( dirname, "src" ) )
+    end
+
+    fail "No source root!" unless source_root
+
+    headers = Dir[File.join( source_root, "src", "*.h" ) ]
+
+    headers.each do |header_filename|
+      txt_lines = File.readlines( header_filename )
+      txt_lines.each do |line|
+        if line =~ /^#\s*define\s+([A-Z0-9_]+)\s+(\d+)\s*$/
+          const_set($1, $2.to_i)
+        end
+      end
+    end
+
+  end
+
+  read_constants()
+end # module FlexNBD
+
+

tests/nbd_scenarios

@@ -4,88 +4,25 @@ require 'test/unit'
 require 'flexnbd'
 require 'test_file_writer'
 
-class NBDScenarios < Test::Unit::TestCase
-  def setup
+class Environment
+  attr_reader( :blocksize, :filename1, :filename2, :ip,
+               :port1, :port2, :nbd1, :nbd2, :file1, :file2 )
+
+  def initialize
     @blocksize = 1024
-    @filename1 = ".flexnbd.test.#{$$}.#{Time.now.to_i}.1"
-    @filename2 = ".flexnbd.test.#{$$}.#{Time.now.to_i}.2"
+    @filename1 = "/tmp/.flexnbd.test.#{$$}.#{Time.now.to_i}.1"
+    @filename2 = "/tmp/.flexnbd.test.#{$$}.#{Time.now.to_i}.2"
     @ip = "127.0.0.1"
     @available_ports = [*40000..41000] - listening_ports
     @port1 = @available_ports.shift
     @port2 = @available_ports.shift
     @nbd1 = FlexNBD.new("../build/flexnbd", @ip, @port1)
     @nbd2 = FlexNBD.new("../build/flexnbd", @ip, @port2)
-  end
 
-  def teardown
-    [@filename1, @filename2].each do |f|
-      File.unlink(f) if File.exists?(f)
-    end
-  end
-
-  def test_read1
-    writefile1("f"*64)
-    serve1
-
-    [0, 12, 63].each do |num|
-
-      assert_equal(
-        @nbd1.read(num*@blocksize, @blocksize),
-        @file1.read(num*@blocksize, @blocksize)
-      )
-    end
-
-    [124, 1200, 10028, 25488].each do |num|
-      assert_equal(@nbd1.read(num, 4), @file1.read(num, 4))
-    end
-  end
-
-  # Check that we're not
-  #
-  def test_writeread1
-    writefile1("0"*64)
-    serve1
-
-    [0, 12, 63].each do |num|
-      data = "X"*@blocksize
-      @nbd1.write(num*@blocksize, data)
-      assert_equal(data, @file1.read(num*@blocksize, data.size))
-      assert_equal(data, @nbd1.read(num*@blocksize, data.size))
-    end
-  end
-
-  # Check that we're not overstepping or understepping where our writes end
-  # up.
-  #
-  def test_writeread2
-    writefile1("0"*1024)
-    serve1
-
-    d0 = "\0"*@blocksize
-    d1 = "X"*@blocksize
-    (0..63).each do |num|
-      @nbd1.write(num*@blocksize*2, d1)
-    end
-    (0..63).each do |num|
-      assert_equal(d0, @nbd1.read(((2*num)+1)*@blocksize, d0.size))
-    end
+    @fake_pid = nil
   end
 
 
-  def test_mirror
-    writefile1( "f"*4 )
-    serve1
-
-    writefile2( "0"*4 )
-    serve2
-
-    @nbd1.can_die
-    mirror12
-    assert_equal(@file1.read_original( 0, @blocksize ),
-                 @file2.read( 0, @blocksize ) )
-  end
-
-  protected
   def serve1(*acl)
     @nbd1.serve(@filename1, *acl)
   end
@@ -94,10 +31,60 @@ class NBDScenarios < Test::Unit::TestCase
     @nbd2.serve(@filename2, *acl)
   end
 
+
+  def listen1( *acl )
+    @nbd1.listen( @filename1, *acl )
+  end
+
+  def listen2( *acl )
+    @nbd2.listen( @filename2, *acl )
+  end
+
+
+  def parse_status( status )
+    hsh = {}
+
+    status.split(" ").each do |part|
+      next if part.strip.empty?
+      a,b = part.split("=")
+      b.strip!
+      b = true if b == "true"
+      b = false if b == "false"
+
+      hsh[a.strip] = b
+    end
+
+    hsh
+  end
+
+
+  def status( nbd )
+    stdout, stderr = nbd.status
+    [parse_status(stdout), stderr]
+  end
+
+  def status1
+    status( @nbd1 )
+  end
+
+  def status2
+    puts "Getting status"
+    result = status( @nbd2 )
+    puts "Got status"
+    return result
+  end
+
+
+
   def mirror12
     @nbd1.mirror( @nbd2.ip, @nbd2.port )
   end
 
+  def mirror12_unchecked
+    @nbd1.mirror_unchecked( @nbd2.ip, @nbd2.port, nil, nil, 10 )
+  end
+
+
   def writefile1(data)
     @file1 = TestFileWriter.new(@filename1, @blocksize).write(data)
   end
@@ -114,5 +101,232 @@ class NBDScenarios < Test::Unit::TestCase
       map { |x| x.split(/\s+/) }[2..-1].
       map { |l| l[3].split(":")[-1].to_i }
   end
+
+
+  def cleanup
+    if @fake_pid
+      begin
+        Process.waitpid2( @fake_pid )
+      rescue Errno::ESRCH
+      end
+    end
+
+
+    @nbd1.kill
+    @nbd2.kill
+
+    [@filename1, @filename2].each do |f|
+      File.unlink(f) if File.exists?(f)
+    end
+  end
+
+
+  def run_fake( name, addr, port )
+    fakedir = File.join( File.dirname( __FILE__ ), "fakes" )
+    fake = Dir[File.join( fakedir, name ) + "*"].sort.find { |fn|
+      File.executable?( fn )
+    }
+
+    raise "no fake executable" unless fake
+    raise "no addr" unless addr
+    raise "no port" unless port
+    @fake_pid = fork do
+      exec fake + " " + addr.to_s + " " + port.to_s
+    end
+    sleep(0.5)
+  end
+
+
+  def fake_reports_success
+    _,status = Process.waitpid2( @fake_pid )
+    @fake_pid = nil
+    status.success?
+  end
+
+
+end # class Environment
+
+
+class NBDScenarios < Test::Unit::TestCase
+  def setup
+    @env = Environment.new
+  end
+
+  def teardown
+    @env.cleanup
+  end
+
+
+  def test_read1
+    @env.writefile1("f"*64)
+    @env.serve1
+
+    [0, 12, 63].each do |num|
+
+      assert_equal(
+        @env.nbd1.read(num*@env.blocksize, @env.blocksize),
+        @env.file1.read(num*@env.blocksize, @env.blocksize)
+      )
+    end
+
+    [124, 1200, 10028, 25488].each do |num|
+      assert_equal(@env.nbd1.read(num, 4), @env.file1.read(num, 4))
+    end
+  end
+
+  # Check that we're not
+  #
+  def test_writeread1
+    @env.writefile1("0"*64)
+    @env.serve1
+
+    [0, 12, 63].each do |num|
+      data = "X"*@env.blocksize
+      @env.nbd1.write(num*@env.blocksize, data)
+      assert_equal(data, @env.file1.read(num*@env.blocksize, data.size))
+      assert_equal(data, @env.nbd1.read(num*@env.blocksize, data.size))
+    end
+  end
+
+  # Check that we're not overstepping or understepping where our writes end
+  # up.
+  #
+  def test_writeread2
+    @env.writefile1("0"*1024)
+    @env.serve1
+
+    d0 = "\0"*@env.blocksize
+    d1 = "X"*@env.blocksize
+    (0..63).each do |num|
+      @env.nbd1.write(num*@env.blocksize*2, d1)
+    end
+    (0..63).each do |num|
+      assert_equal(d0, @env.nbd1.read(((2*num)+1)*@env.blocksize, d0.size))
+    end
+  end
+
+
+  def test_mirror
+    @env.writefile1( "f"*4 )
+    @env.serve1
+
+    @env.writefile2( "0"*4 )
+    @env.listen2
+
+    @env.nbd1.can_die
+    stdout, stderr = @env.mirror12
+
+    assert_equal(@env.file1.read_original( 0, @env.blocksize ),
+                 @env.file2.read( 0, @env.blocksize ) )
+    assert @env.status2['has_control'], "destination didn't take control"
+  end
+
 end
 
+
+class NBDConnectSourceFailureScenarios < Test::Unit::TestCase
+  def setup
+    @env = Environment.new
+    @env.writefile1( "f" * 4 )
+    @env.serve1
+
+  end
+
+  def teardown
+    @env.cleanup
+  end
+
+
+  def test_failure_to_connect_reported_in_mirror_cmd_response
+    stdout, stderr = @env.mirror12_unchecked
+    assert_match( /failed to connect/, stderr )
+  end
+
+
+  def test_destination_hangs_after_connect_reports_error_at_source
+    @env.run_fake( "dest/hang_after_connect", @env.ip, @env.port2 )
+
+    stdout, stderr = @env.mirror12_unchecked
+    assert_match( /Remote server failed to respond/, stderr )
+    assert @env.fake_reports_success
+  end
+
+
+  def test_destination_rejects_connection_reports_error_at_source
+    @env.run_fake( "dest/reject_acl", @env.ip, @env.port2 )
+
+    stdout, stderr = @env.mirror12_unchecked
+    assert_match /Mirror was rejected/, stderr
+    assert @env.fake_reports_success
+  end
+
+  def test_wrong_size_causes_disconnect
+    @env.run_fake( "dest/hello_wrong_size", @env.ip, @env.port2 )
+    stdout, stderr = @env.mirror12_unchecked
+    assert_match /Remote size does not match local size/, stderr
+    assert @env.fake_reports_success
+  end
+
+
+  def test_wrong_magic_causes_disconnect
+    @env.run_fake( "dest/hello_wrong_magic", @env.ip, @env.port2 )
+    stdout, stderr = @env.mirror12_unchecked
+    assert_match /Mirror was rejected/, stderr
+    assert @env.fake_reports_success, "dest/hello_wrong_magic fake failed"
+  end
+
+
+  def test_disconnect_after_hello_causes_retry
+    @env.run_fake( "dest/close_after_hello", @env.ip, @env.port2 )
+    stdout, stderr = @env.mirror12_unchecked
+    assert_match( /Mirror started/, stdout )
+
+    assert @env.fake_reports_success
+  end
+end
+
+
+class NBDConnectDestFailureScenarios < Test::Unit::TestCase
+
+  def setup
+    @env = Environment.new
+    @env.writefile1( "0" * 4 )
+    @env.listen1
+  end
+
+  def teardown
+    @env.cleanup
+  end
+
+
+  def test_hello_blocked_by_disconnect_causes_error_not_fatal
+    run_fake( "source/close_after_connect" )
+    assert_no_control
+  end
+
+
+  def test_hello_goes_astray_causes_timeout_error
+    run_fake( "source/hang_after_hello" )
+    assert_no_control
+  end
+
+
+  def test_disconnect_after_hello_causes_error_not_fatal
+    run_fake( "source/close_after_hello" )
+    assert_no_control
+  end
+
+
+  private
+  def run_fake( name )
+    @env.run_fake( name, @env.ip, @env.port1 )
+    assert @env.fake_reports_success
+  end
+
+  def assert_no_control
+    status, stderr = @env.status1
+    assert !status['has_control'],  "Thought it had control"
+  end
+
+
+end # class NBDConnectDestFailureScenarios