public void start(StartCallback callback)
{
try
{
lock(this)
{
//
// The connection might already be closed if the communicator was destroyed.
//
if(_state >= StateClosed)
{
Debug.Assert(_exception != null);
throw _exception;
}
if(!initialize(IceInternal.SocketOperation.None) || !validate(IceInternal.SocketOperation.None))
{
_startCallback = callback;
return;
}
//
// We start out in holding state.
//
setState(StateHolding);
}
}
catch(LocalException ex)
{
exception(ex);
callback.connectionStartFailed(this, _exception);
return;
}
callback.connectionStartCompleted(this);
}
public void start(StartCallback callback)
{
try
{
_m.Lock();
try
{
//
// The connection might already be closed if the communicator was destroyed.
//
if(_state >= StateClosed)
{
Debug.Assert(_exception != null);
throw _exception;
}
if(!initialize(IceInternal.SocketOperation.None) || !validate(IceInternal.SocketOperation.None))
{
if(callback != null)
{
_startCallback = callback;
return;
}
//
// Wait for the connection to be validated.
//
while(_state <= StateNotValidated)
{
_m.Wait();
}
if(_state >= StateClosing)
{
Debug.Assert(_exception != null);
throw _exception;
}
}
//
// We start out in holding state.
//
setState(StateHolding);
}
finally
{
_m.Unlock();
}
}
catch(LocalException ex)
{
exception(ex);
if(callback != null)
{
callback.connectionStartFailed(this, _exception);
return;
}
else
{
waitUntilFinished();
throw;
}
}
if(callback != null)
{
callback.connectionStartCompleted(this);
}
}
private void dispatch(StartCallback startCB, Queue<OutgoingMessage> sentCBs, MessageInfo info)
{
int dispatchedCount = 0;
//
// Notify the factory that the connection establishment and
// validation has completed.
//
if(startCB != null)
{
startCB.connectionStartCompleted(this);
++dispatchedCount;
}
//
// Notify AMI calls that the message was sent.
//
if(sentCBs != null)
{
foreach(OutgoingMessage m in sentCBs)
{
if(m.sentCallback != null)
{
m.outAsync.invokeSent(m.sentCallback);
}
if(m.receivedReply)
{
IceInternal.OutgoingAsync outAsync = (IceInternal.OutgoingAsync)m.outAsync;
Ice.AsyncCallback cb = outAsync.completed();
if(cb != null)
{
outAsync.invokeCompleted(cb);
}
}
}
++dispatchedCount;
}
//
// Asynchronous replies must be handled outside the thread
// synchronization, so that nested calls are possible.
//
if(info.outAsync != null)
{
info.outAsync.invokeCompleted(info.completedCallback);
++dispatchedCount;
}
if(info.heartbeatCallback != null)
{
try
{
info.heartbeatCallback.heartbeat(this);
}
catch(System.Exception ex)
{
_logger.error("connection callback exception:\n" + ex + '\n' + _desc);
}
++dispatchedCount;
}
//
// Method invocation (or multiple invocations for batch messages)
// must be done outside the thread synchronization, so that nested
// calls are possible.
//
if(info.invokeNum > 0)
{
invokeAll(info.stream, info.invokeNum, info.requestId, info.compress, info.servantManager,
info.adapter);
//
// Don't increase dispatchedCount, the dispatch count is
// decreased when the incoming reply is sent.
//
}
//
// Decrease dispatch count.
//
if(dispatchedCount > 0)
{
lock(this)
{
_dispatchCount -= dispatchedCount;
if(_dispatchCount == 0)
{
//
// Only initiate shutdown if not already done. It
// might have already been done if the sent callback
// or AMI callback was dispatched when the connection
// was already in the closing state.
//
if(_state == StateClosing)
{
try
{
initiateShutdown();
}
catch(Ice.LocalException ex)
{
setState(StateClosed, ex);
}
}
else if(_state == StateFinished)
{
reap();
}
System.Threading.Monitor.PulseAll(this);
}
}
}
}
private void dispatch(StartCallback startCB, Queue<OutgoingMessage> sentCBs, MessageInfo info)
{
//
// Notify the factory that the connection establishment and
// validation has completed.
//
if(startCB != null)
{
startCB.connectionStartCompleted(this);
}
//
// Notify AMI calls that the message was sent.
//
if(sentCBs != null)
{
foreach(OutgoingMessage m in sentCBs)
{
if(m.sentCallback != null)
{
m.outAsync.sent__(m.sentCallback);
}
if(m.replyOutAsync != null)
{
m.replyOutAsync.finished__();
}
}
}
//
// Asynchronous replies must be handled outside the thread
// synchronization, so that nested calls are possible.
//
if(info.outAsync != null)
{
info.outAsync.finished__();
}
if(info.invokeNum > 0)
{
//
// Method invocation (or multiple invocations for batch messages)
// must be done outside the thread synchronization, so that nested
// calls are possible.
//
invokeAll(info.stream, info.invokeNum, info.requestId, info.compress, info.servantManager,
info.adapter);
}
//
// Decrease dispatch count.
//
if(sentCBs != null || info.outAsync != null)
{
_m.Lock();
try
{
if(--_dispatchCount == 0)
{
//
// Only initiate shutdown if not already done. It
// might have already been done if the sent callback
// or AMI callback was dispatched when the connection
// was already in the closing state.
//
if(_state == StateClosing && !_shutdownInitiated)
{
try
{
initiateShutdown();
}
catch(Ice.LocalException ex)
{
setState(StateClosed, ex);
}
}
else if(_state == StateFinished)
{
_reaper.add(this, _observer);
}
_m.NotifyAll();
}
}
finally
{
_m.Unlock();
}
}
}
