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(); } } }