void ITransport.ClearTimeout(string timeoutCorrelationID) { var transaction = openTransaction; // check for "ambient" transaction on current thread var commitAndDisposeTransaction = false; if (transaction == null) { transaction = BeginTransaction(); commitAndDisposeTransaction = true; } try { var conversationHandle = Guid.Parse(timeoutCorrelationID); if (PopTimeoutMessage(transaction, conversationHandle) != null) { ServiceBrokerWrapper.EndConversation(transaction, conversationHandle); } if (commitAndDisposeTransaction) { transaction.Commit(); } } finally { if (commitAndDisposeTransaction) { TryDisposeTransactionAndConnection(transaction); } } }
public int PeekCount() { var transaction = openTransaction; // check for "ambient" transaction on current thread var commitAndDisposeTransaction = false; if (transaction == null) { transaction = BeginTransaction(); commitAndDisposeTransaction = true; } try { var count = ServiceBrokerWrapper.QueryMessageCount(transaction, ServiceBrokerQueue, ServiceBrokerMessageType); if (commitAndDisposeTransaction) { transaction.Commit(); } return(count); } finally { if (commitAndDisposeTransaction) { TryDisposeTransactionAndConnection(transaction); } } }
private void InitServiceBroker() { using (var connection = OpenConnection()) using (var transaction = connection.BeginTransaction()) { // Ensure the service and queue exist ServiceBrokerWrapper.CreateServiceAndQueue(transaction, ServiceBrokerService, ServiceBrokerQueue, ServiceBrokerMessageType, ServiceBrokerContract); transaction.Commit(); } }
private void TryReceiveMessage() { // NOTE this method _should not_ throw an exception! ServiceBrokerMessage message = null; SqlTransaction transaction = null; try { transaction = BeginTransaction(); logger.Debug("RECEIVE FROM {0}", ServiceBrokerQueue); message = ServiceBrokerWrapper.WaitAndReceive(transaction, ServiceBrokerQueue, waitTimeout); } catch (Exception e) { logger.Error(e, "Exception caught trying to receive from queue {0}. Rolling back and backing off before reconnecting.", ServiceBrokerQueue); TryRollbackTransaction(transaction); TryDisposeTransactionAndConnection(transaction); workerThreadPool.Release(1); Thread.Sleep(1000); // back-off because we will return and loop immediately return; } // No message? That's okay if (message == null) { try { transaction.Commit(); } finally { TryDisposeTransactionAndConnection(transaction); workerThreadPool.Release(1); } return; } // start a Task.Run(() => { // TryHandleHessage _should not_ throw an exception. It will also commit and cleanup the transactions try { TryHandleMessage(transaction, message); } finally { workerThreadPool.Release(1); // release this semaphore back to the pool regardless of what happened } }); }
void ITransport.Send(OutgoingTransportMessage transportMessage, IEnumerable <string> destinations) { var transaction = openTransaction; // check for "ambient" transaction on current thread var commitAndDisposeTransaction = false; if (transaction == null) { transaction = BeginTransaction(); commitAndDisposeTransaction = true; } try { transportMessage.Headers[StandardHeaders.TimeSent] = DateTime.UtcNow.ToString("o"); transportMessage.Headers[StandardHeaders.ReplyToAddress] = this.ServiceBrokerService; transportMessage.Headers[StandardHeaders.OriginatingAddress] = this.ServiceBrokerService; using (var stream = new MemoryStream()) { FastXmlTransportMessageSerializer.Serialize(transportMessage, stream); var messageBuffer = stream.ToArray(); foreach (var destination in destinations) { var conversationHandle = ServiceBrokerWrapper.SendOne(transaction, ServiceBrokerService, destination, ServiceBrokerContract, ServiceBrokerMessageType, messageBuffer); #if DEBUG logger.Debug(string.Format("Sending message {0} with Handle {1} to Service Named {2}.", transportMessage.Message.GetType().AssemblyQualifiedName, conversationHandle, destination)); logger.Debug(string.Format("ToString() of the message yields: {0}\n" + "Message headers:\n{1}", transportMessage.Message.ToString(), string.Join(", ", transportMessage.Headers.Select(h => h.Key + ":" + h.Value).ToArray()))); #endif } } if (commitAndDisposeTransaction) { transaction.Commit(); } } finally { if (commitAndDisposeTransaction) { TryDisposeTransactionAndConnection(transaction); } } }
private void TryHandleMessageInner(SqlTransaction transaction, ServiceBrokerMessage message) { // Only handle transport messages if (message.MessageTypeName != ServiceBrokerMessageType && !message.IsDialogTimerMessage()) { logger.Debug("Ignoring message of type {0} from queue {1}", message.MessageTypeName, ServiceBrokerQueue); return; // ignore } IncomingTransportMessage transportMessage = null; try { if (message.IsDialogTimerMessage()) { transportMessage = TryLoadDialogTimerTimeoutMessage(transaction, message); } else { transportMessage = TryDeserializeTransportMessage(message); } if (!transportMessage.Headers.ContainsKey(StandardHeaders.OriginatingAddress)) { transportMessage.Headers[StandardHeaders.OriginatingAddress] = ServiceBrokerWrapper.TryGetConversationFarService(transaction, message.ConversationHandle); } Exception lastException = null; if (faultManager.MaxRetriesExceeded(transportMessage, out lastException)) { logger.Debug("MaxRetriesExceeded: Moving message {0} from queue {1} to poison message table.", message.ConversationHandle.ToString(), ServiceBrokerQueue); MoveToPoisonMessage(transaction, message, transportMessage, lastException, "MaxRetriesExceeded", MaxRetries); return; // return without error to commit transaction } logger.Debug("Notifying observers of new TransportMessage for message {0} from queue {1}.", message.ConversationHandle, ServiceBrokerQueue); if (this.MessageAvailable != null) { this.MessageAvailable(this, new MessageAvailable(transportMessage)); } } catch (CannotDeserializeMessageException e) { // If we can't deserialize the transport message or inner message, there is no reason to retry. // note: error is already logged so we don't need to log here logger.Debug("DeserializeError: Moving message {0} from queue {1} to poison message table.", message.ConversationHandle.ToString(), ServiceBrokerQueue); MoveToPoisonMessage(transaction, message, transportMessage, e, "DeserializeError", 0); return; // return without error to commit transaction } }
string ITransport.RequestTimeoutMessage(int secondsToWait, OutgoingTransportMessage transportMessage) { var transaction = openTransaction; // check for "ambient" transaction on current thread var commitAndDisposeTransaction = false; if (transaction == null) { transaction = BeginTransaction(); commitAndDisposeTransaction = true; } try { transportMessage.Headers[StandardHeaders.TimeSent] = DateTime.UtcNow.ToString("o"); transportMessage.Headers[StandardHeaders.ReplyToAddress] = this.ServiceBrokerService; transportMessage.Headers[StandardHeaders.OriginatingAddress] = this.ServiceBrokerService; var conversationHandle = ServiceBrokerWrapper.BeginConversation(transaction, ServiceBrokerService, ServiceBrokerService); ServiceBrokerWrapper.BeginTimer(transaction, conversationHandle, secondsToWait); using (var stream = new MemoryStream()) { FastXmlTransportMessageSerializer.Serialize(transportMessage, stream); var messageBuffer = stream.ToArray(); PushTimeoutMessage(transaction, conversationHandle, messageBuffer, secondsToWait); } if (commitAndDisposeTransaction) { transaction.Commit(); } return(conversationHandle.ToString()); } finally { if (commitAndDisposeTransaction) { TryDisposeTransactionAndConnection(transaction); } } }
private void TryHandleMessage(SqlTransaction transaction, ServiceBrokerMessage message) { logger.Debug("Received message {0} from queue {1}", message.ConversationHandle, ServiceBrokerQueue); // NOTE this method _should not_ throw an exception! // It is responsible for committing or rolling back the SqlTransaction // that was passed in. // We can keep track of the openTransaction on the current thread in case we need it. openTransaction = transaction; try { // this may throw an exception if we need to rollback TryHandleMessageInner(transaction, message); // End the conversation and commit ServiceBrokerWrapper.EndConversation(transaction, message.ConversationHandle); transaction.Commit(); faultManager.ClearFailuresForMessage(message.ConversationHandle.ToString()); logger.Debug("Committed message {0} from queue {1}", message.ConversationHandle, ServiceBrokerQueue); } catch (Exception e) { TryRollbackTransaction(transaction); faultManager.IncrementFailuresForMessage(message.ConversationHandle.ToString(), e); logger.Error(e, "Exception caught handling message {0} from queue {1}. Rolling back transaction to retry.", message.ConversationHandle, ServiceBrokerQueue); #if DEBUG if (System.Diagnostics.Debugger.IsAttached) { System.Diagnostics.Debugger.Break(); } #endif } finally { openTransaction = null; TryDisposeTransactionAndConnection(transaction); // shoud not throw exception } }
private void MoveToPoisonMessage(SqlTransaction transaction, ServiceBrokerMessage serviceBrokerMessage, IncomingTransportMessage transportMessage, Exception exception, string errorCode, int retries) { var origin_service_name = ""; if (transportMessage != null && transportMessage.Headers.ContainsKey(StandardHeaders.OriginatingAddress)) { origin_service_name = transportMessage.Headers[StandardHeaders.OriginatingAddress]; } else if (transportMessage != null && transportMessage.Headers.ContainsKey(StandardHeaders.ReplyToAddress)) { origin_service_name = transportMessage.Headers[StandardHeaders.ReplyToAddress]; } else { origin_service_name = ServiceBrokerWrapper.TryGetConversationFarService(transaction, serviceBrokerMessage.ConversationHandle); } try { // write to the message to the PosionMessage table using (var command = transaction.Connection.CreateCommand()) { command.CommandText = "spInsertPoisonMessage"; command.CommandType = CommandType.StoredProcedure; command.Parameters.AddWithValue("@conversation_handle", serviceBrokerMessage.ConversationHandle); command.Parameters.AddWithValue("@origin_service_name", origin_service_name); command.Parameters.AddWithValue("@service_name", this.ServiceBrokerService); command.Parameters.AddWithValue("@queue_name", this.ServiceBrokerQueue); command.Parameters.AddWithValue("@message_body", serviceBrokerMessage.Body); command.Parameters.AddWithValue("@retries", retries); command.Parameters.AddWithValue("@errorCode", errorCode); if (exception != null) { command.Parameters.AddWithValue("@errorMessage", FormatErrorMessage(exception)); } else { command.Parameters.AddWithValue("@errorMessage", DBNull.Value); } command.Transaction = transaction; command.ExecuteNonQuery(); } } catch (Exception e) { logger.Fatal(e, "Failed to write PoisonMessage for message {0} from queue {1}", serviceBrokerMessage.ConversationHandle, ServiceBrokerQueue); // suppress -- don't let this exception take down the process } if (PoisonMessageDetected != null) { PoisonMessageDetected(this, new PoisonMessageDetectedEventArgs() { MessageId = serviceBrokerMessage.ConversationHandle.ToString(), OriginServiceName = origin_service_name, ServiceName = this.ServiceBrokerService, QueueName = this.ServiceBrokerQueue, MessageBody = serviceBrokerMessage.Body, Retries = retries, ErrorCode = errorCode, Exception = exception, }); } }