/// <summary> /// Pull responses for Java clients /// </summary> /// <param name="action">indicating the action</param> /// <param name="position">indicating the position</param> /// <param name="count">indicating the count</param> /// <returns>returns the responses messages</returns> /// <param name="version">indicating the message version</param> public BrokerResponseMessages PullResponses(string action, GetResponsePosition position, int count, MessageVersion version) { this.CheckDisconnected(); this.timeoutManager.ResetTimeout(); if (this.responsesClient is PullResponsesHandler) { PullResponsesHandler handler = this.responsesClient as PullResponsesHandler; if (handler.Match(action)) { return(handler.PullResponses(position, count)); } } if (this.responsesClient != null) { this.responsesClient.Dispose(); } this.responsesClient = new PullResponsesHandler(this.queue, action, this.timeoutManager, this.observer, this.sharedData, version); return((this.responsesClient as PullResponsesHandler).PullResponses(position, count)); }
/// <summary> /// Get responses /// </summary> /// <param name="action">indicating the action</param> /// <param name="clientData">indicating the client data</param> /// <param name="resetToBegin">indicating the position</param> /// <param name="count">indicating the count</param> /// <param name="callbackInstance">indicating the callback instance</param> /// <param name="version">indicating the message version</param> public void GetResponses(string action, string clientData, GetResponsePosition resetToBegin, int count, IResponseServiceCallback callbackInstance, MessageVersion version) { this.CheckDisconnected(); this.timeoutManager.ResetTimeout(); if (this.responsesClient is GetResponsesHandler) { GetResponsesHandler handler = this.responsesClient as GetResponsesHandler; if (handler.Matches(action, clientData)) { handler.GetResponses(resetToBegin, count, callbackInstance); return; } } if (this.responsesClient != null) { this.responsesClient.Dispose(); } this.responsesClient = new GetResponsesHandler(this.queue, action, clientData, this.clientId, this.timeoutManager, this.observer, this.sharedData, version); (this.responsesClient as GetResponsesHandler).GetResponses(resetToBegin, count, callbackInstance); }
/// <summary> /// Dispose the broker client /// </summary> /// <param name="disposing">indicating whether it is disposing</param> private void Dispose(bool disposing) { this.disposing = disposing; try { // Set state this.state = BrokerClientState.Disconnected; // Copy all the connected instances out of lock List <object> connectedList = null; lock (this.connectedInstance) { connectedList = new List <object>(this.connectedInstance.Keys); } foreach (object instance in connectedList) { try { BrokerTracing.TraceInfo("[BrokerClient] Try to close the connected instance: {0} ({1})", instance.ToString(), instance.GetHashCode()); if (instance is IDisposable) { // BrokerController ((IDisposable)instance).Dispose(); } else if (instance is IChannel) { Utility.AsyncCloseICommunicationObject((ICommunicationObject)instance); } else { Debug.Fail("[BrokerClient] Connected instance must be IDisposable or IChannel."); } } catch (Exception e) { BrokerTracing.TraceWarning("[BrokerClient] Failed to close the connected instance: {0}", e); } } if (disposing) { if (this.queue != null) { this.queue.OnEvent -= this.Queue_OnEvent; this.queue.OnPutResponsesSuccessEvent -= this.Queue_OnPutResponsesSuccessEvent; this.queue.OnFatalExceptionEvent -= this.Queue_OnFatalExceptionEvent; //for durable session, the queue is closed unless there were flushed requests, dispose if EOM was called. if (this.sharedData.BrokerInfo.Durable) { if (this.queue.FlushedRequestsCount == 0) { BrokerTracing.TraceInfo("[BrokerClient] durable session broker client {0} close the queue.", this.clientId); //if not ever flushed, reduce the count of all requests in the queue this.observer.ReduceUncommittedCounter(this.queue.AllRequestsCount); this.queue.Close(); } else if (this.endOfMessageCalled) { // Only dispose the broker queue if it is a durable session. Non-durable broker queue for // interactive session should be kept/reused and closed when closing the broker domain. // // Note (related bug #14224): logic in BrokerClient.SyncDisconnect() ensures that BrokerClient // instance will not be disposed if EndRequests is called (this.state = BrokerClientState.EndRequests). // So below code snippet could only be reached on broker entry exiting. this.observer.ReduceUncommittedCounter(this.queue.AllRequestsCount - this.queue.FlushedRequestsCount); this.queue.Dispose(); } } else //for interactive session, close the queue if EOM is not called. { if (!this.endOfMessageCalled) { BrokerTracing.TraceInfo("[BrokerClient] interactive session broker client {0} close the queue.", this.clientId); if (!this.v2ProxyClient) { //reduce the count of all unflushed requests in the queue this.observer.ReduceUncommittedCounter(this.queue.AllRequestsCount - this.queue.FlushedRequestsCount); } this.queue.Close(); } } this.queue = null; this.batchMessageIds.Clear(); } } if (this.responsesClient != null) { this.responsesClient.Dispose(); this.responsesClient = null; } if (this.timeoutManager != null) { this.timeoutManager.Dispose(); this.timeoutManager = null; } // do not dispose this.lockForDiscardRequests for this may block the threads in the write queue, which may lead to the hang when broker entry exits. // do not dispose this.batchIdChangedEvent for any wait for the event would hang } catch (Exception e) { BrokerTracing.TraceWarning("[BrokerClient] Exception thrown while disposing: {0}", e); } }