SocketMonitor::Cancel() does not actually unregister the socket; it
only disables the event.

When mounting had not yet finished, SocketMonitor::IsDefined() was
always false, due to the workaround at the beginning of the function
that calls SocketMonitor::Steal().  This commit drops the IsDefined()
check because it was never necessary and breaks reconnect.

nfs_destroy_context() will invoke all pending callbacks with
err==-EINTR.  In CancellableCallback::Callback(), this will invoke
NfsConnection::DeferClose(), which however is only designed to be
called from nfs_service().  In non-debug mode, this will leak memory
because nfs_close_async() is never called.

Workaround: before nfs_destroy_context(), invoke nfs_close_async() on
all pending file handles.

The method NfsConnection::CancellableCallback::Callback() will always
invoke NfsConnection::Close() on the file handle, even if the void
pointer is not a nfsfh.  This can happen if the Open() was not
successful, e.g. when the file does not exist.

Avoids crash because Close() invokes a call on a destructed
NfsConnection.

Avoid calling NfsConnection::RemoveLease(), because the lease has been
removed already.

Clean up the "state" to indicate that there is no longer any
asynchronous operation.  Fixes another NFS-related crash due to
cleanup of a non-existing asynchronous operation.

Avoids a crash that occurs when NfsConnection::OnSocketReady()
dereferences itself before returning.

During the NfsLease::OnNfsConnectionFailed() call, the old (defunct)
nfs_context may be used to close file handles.  Such code does not yet
exist, but will be added soon to fix other bugs.

Fixes potential second mount attempt after the old connection to the
NFS server was shut down.

Share the NFS connection with the NFS input plugin.

Creating a NfsStorage sets its own export_name as the "base".  Now
NfsFileReader can use this information to derive the export_name to be
mounted, instead of guessing.  This solves the "too many connection"
problem on the NFS server while updating the database.

If an async opertion is in progress, nfs_close_async() will make
libnfs crash because the RPC callback will dereference an object that
was freed by nfs_close_async().

Close the newly allocated file handle passed to the callback.

All locks are currenly held from only a single thread (the IOThread)
and thus we don't need the Mutex.

Not used anymore because NfsManager now uses boost::intrusive::set
instead of std::map.

Reduce overhead for storing the key twice, and more overhead while
looking up the connection to remove it after a failure.

This allows eliminating the indirection code from the NfsConnection
destructor.

It's just a useless wrapper for class NfsManager.