flexnbd-c/tests/acceptance/fakes/dest/close_after_entrust.rb

#!/usr/bin/env ruby
# encoding: utf-8

# Open a server, accept a client, then we expect a single write
# followed by an entrust. Disconnect after the entrust. We expect a
# reconnection followed by a full mirror.

require 'flexnbd/fake_dest'
include FlexNBD

addr, port, src_pid = *ARGV
server = FakeDest.new( addr, port )
client = server.accept

client.write_hello
write_req = client.read_request
data = client.read_data( write_req[:len] )
client.write_reply( write_req[:handle], 0 )

entrust_req = client.read_request
fail "Not an entrust" unless entrust_req[:type] == 65536
client.close

client2 = server.accept
client2.receive_mirror


exit(0)
Free all possibly held mutexes in error handlers Now that we have 3 mutexes lying around, it's important that we check and free these if necessary if error() is called in any thread that can hold them. To do this, we now have flexthread.c, which defines a flexthread_mutex struct. This is a wrapper around a pthread_mutex_t and a pthread_t. The idea is that in the error handler, the thread can check whether it holds the mutex and can free it if and only if it does. This is important because pthread fast mutexes can be freed by any thread, not just the thread which holds them. Note: it is only ever safe for a thread to check if it holds the mutex itself. It is never safe to check if another thread holds a mutex without first locking that mutex, which makes the whole operation rather pointless. 2012-07-11 09:43:16 +01:00			`#!/usr/bin/env ruby`
			`# encoding: utf-8`

			`# Open a server, accept a client, then we expect a single write`
			`# followed by an entrust. Disconnect after the entrust. We expect a`
			`# reconnection followed by a full mirror.`

			`require 'flexnbd/fake_dest'`
			`include FlexNBD`

			`addr, port, src_pid = *ARGV`
			`server = FakeDest.new( addr, port )`
			`client = server.accept`

			`client.write_hello`
			`write_req = client.read_request`
			`data = client.read_data( write_req[:len] )`
			`client.write_reply( write_req[:handle], 0 )`

			`entrust_req = client.read_request`
			`fail "Not an entrust" unless entrust_req[:type] == 65536`
			`client.close`

			`client2 = server.accept`
			`client2.receive_mirror`

Retry failed rebind attempts When we receive a migration, if rebinding to the new listen address and port fails for a reason which might be fixable, rather than killing the server we retry once a second. Also in this patch: non-overlapping log messages and a fix for the client going away halfway through a sendfile loop. 2012-07-12 14:14:46 +01:00
Free all possibly held mutexes in error handlers Now that we have 3 mutexes lying around, it's important that we check and free these if necessary if error() is called in any thread that can hold them. To do this, we now have flexthread.c, which defines a flexthread_mutex struct. This is a wrapper around a pthread_mutex_t and a pthread_t. The idea is that in the error handler, the thread can check whether it holds the mutex and can free it if and only if it does. This is important because pthread fast mutexes can be freed by any thread, not just the thread which holds them. Note: it is only ever safe for a thread to check if it holds the mutex itself. It is never safe to check if another thread holds a mutex without first locking that mutex, which makes the whole operation rather pointless. 2012-07-11 09:43:16 +01:00			`exit(0)`