public bool TakeMessage(CancellationToken token, out MessageTransportContext context) { while (!token.IsCancellationRequested) { for (var i = 0; i < _readers.Length; i++) { var queue = _readers[i]; var message = queue.TryGetMessage(); switch (message.State) { case GetEnvelopeResultState.Success: _emptyCycles = 0; context = message.Message; return true; case GetEnvelopeResultState.Empty: _emptyCycles += 1; break; case GetEnvelopeResultState.Exception: // access problem, fall back a bit break; case GetEnvelopeResultState.Retry: // this could be the poison break; default: throw new ArgumentOutOfRangeException(); } var waiting = _waiter(_emptyCycles); token.WaitHandle.WaitOne(waiting); } } context = null; return false; }
/// <summary> /// ACKs the message by deleting it from the queue. /// </summary> /// <param name="message">The message context to ACK.</param> public void AckMessage(MessageTransportContext message) { if (message == null) { throw new ArgumentNullException("message"); } _queue.DeleteMessage((CloudQueueMessage)message.TransportMessage); }
/// <summary> /// ACKs the message by deleting it from the queue. /// </summary> /// <param name="message">The message context to ACK.</param> public void AckMessage(MessageTransportContext message) { if (message == null) { throw new ArgumentNullException("message"); } ((FileInfo)message.TransportMessage).Delete(); }
public void AckMessage(MessageTransportContext message) { foreach (var queue in _readers) { if (queue.Name == message.QueueName) { queue.AckMessage(message); } } }
public void AckMessage(MessageTransportContext message) { if (message == null) throw new ArgumentNullException("message"); foreach (var queue in _readers) { if (queue.Name == message.QueueName) { queue.AckMessage(message); } } }
public void AckMessage(MessageTransportContext message) { if (message == null) { throw new ArgumentNullException("message"); } foreach (var queue in _readers) { if (queue.Name == message.QueueName) { queue.AckMessage(message); } } }
public bool TakeMessage(CancellationToken token, out MessageTransportContext context) { while (!token.IsCancellationRequested) { // if incoming message is delayed and in future -> push it to the timer queue. // timer will be responsible for publishing back. byte[] envelope; var result = BlockingCollection<byte[]>.TakeFromAny(_queues, out envelope); if (result >= 0) { context = new MessageTransportContext(result, envelope, _names[result]); return true; } } context = null; return false; }
public GetEnvelopeResult TryGetMessage() { FileInfo message; try { message = _queue.EnumerateFiles().FirstOrDefault(); } catch (Exception ex) { SystemObserver.Notify(new FailedToReadMessage(ex, _queueName)); return(GetEnvelopeResult.Error()); } if (null == message) { return(GetEnvelopeResult.Empty); } try { var buffer = File.ReadAllBytes(message.FullName); var unpacked = new MessageTransportContext(message, buffer, _queueName); return(GetEnvelopeResult.Success(unpacked)); } catch (IOException ex) { // this is probably sharing violation, no need to // scare people. if (!IsSharingViolation(ex)) { SystemObserver.Notify(new FailedToAccessStorage(ex, _queue.Name, message.Name)); } return(GetEnvelopeResult.Retry); } catch (Exception ex) { SystemObserver.Notify(new MessageInboxFailed(ex, _queue.Name, message.FullName)); // new poison details return(GetEnvelopeResult.Retry); } }
public bool TakeMessage(CancellationToken token, out MessageTransportContext context) { while (!token.IsCancellationRequested) { // if incoming message is delayed and in future -> push it to the timer queue. // timer will be responsible for publishing back. byte[] envelope; var result = BlockingCollection <byte[]> .TakeFromAny(_queues, out envelope); if (result >= 0) { context = new MessageTransportContext(result, envelope, _names[result]); return(true); } } context = null; return(false); }
public GetEnvelopeResult TryGetMessage() { FileInfo message; try { message = _queue.EnumerateFiles().FirstOrDefault(); } catch (Exception ex) { SystemObserver.Notify(new FailedToReadMessage(ex, _queueName)); return GetEnvelopeResult.Error(); } if (null == message) { return GetEnvelopeResult.Empty; } try { var buffer = File.ReadAllBytes(message.FullName); var unpacked = new MessageTransportContext(message, buffer, _queueName); return GetEnvelopeResult.Success(unpacked); } catch (IOException ex) { // this is probably sharing violation, no need to // scare people. if (!IsSharingViolation(ex)) { SystemObserver.Notify(new FailedToAccessStorage(ex, _queue.Name, message.Name)); } return GetEnvelopeResult.Retry; } catch (Exception ex) { SystemObserver.Notify(new MessageInboxFailed(ex, _queue.Name, message.FullName)); // new poison details return GetEnvelopeResult.Retry; } }
void ProcessMessage(MessageTransportContext context) { var dispatched = false; try { _dispatcher(context.Unpacked); dispatched = true; } catch (ThreadAbortException) { // we are shutting down. Stop immediately return; } catch (Exception dispatchEx) { // if the code below fails, it will just cause everything to be reprocessed later, // which is OK (duplication manager will handle this) SystemObserver.Notify(new MessageDispatchFailed(context, context.QueueName, dispatchEx)); // quarantine is atomic with the processing _inbox.TryNotifyNack(context); } if (!dispatched) return; try { _inbox.AckMessage(context); // 3rd - notify. SystemObserver.Notify(new MessageAcked(context)); } catch (ThreadAbortException) { // nothing. We are going to sleep } catch (Exception ex) { // not a big deal. Message will be processed again. SystemObserver.Notify(new MessageAckFailed(ex, context)); } }
public bool TakeMessage(CancellationToken token, out MessageTransportContext context) { while (!token.IsCancellationRequested) { for (var i = 0; i < _readers.Length; i++) { var queue = _readers[i]; var message = queue.TryGetMessage(); switch (message.State) { case GetEnvelopeResultState.Success: _emptyCycles = 0; context = message.Message; return(true); case GetEnvelopeResultState.Empty: _emptyCycles += 1; break; case GetEnvelopeResultState.Exception: // access problem, fall back a bit break; case GetEnvelopeResultState.Retry: // this could be the poison break; default: throw new ArgumentOutOfRangeException(); } var waiting = _waiter(_emptyCycles); token.WaitHandle.WaitOne(waiting); } } context = null; return(false); }
public void AckMessage(MessageTransportContext message) { }
public void TryNotifyNack(MessageTransportContext context) { }
/// <summary> /// ACKs the message by deleting it from the queue. /// </summary> /// <param name="message">The message context to ACK.</param> public void AckMessage(MessageTransportContext message) { if (message == null) throw new ArgumentNullException("message"); _queue.DeleteMessage((CloudQueueMessage) message.TransportMessage); }
public DispatchRecoveryFailed(Exception exception, MessageTransportContext message, string queueName) { DispatchException = exception; Message = message; QueueName = queueName; }
/// <summary> /// ACKs the message by deleting it from the queue. /// </summary> /// <param name="message">The message context to ACK.</param> public void AckMessage(MessageTransportContext message) { if (message == null) throw new ArgumentNullException("message"); ((FileInfo) message.TransportMessage).Delete(); }
public void when_reader_ack_messages() { _queueWriter.PutMessage(Encoding.UTF8.GetBytes("message")); var msg = _statelessReader.TryGetMessage(); var transportContext = new MessageTransportContext( msg.Message.TransportMessage , msg.Message.Unpacked , msg.Message.QueueName); _queueReader.AckMessage(transportContext); var msg2 = _statelessReader.TryGetMessage(); Assert.AreEqual(GetEnvelopeResultState.Empty, msg2.State); }
public MessageAckFailed(Exception exception, MessageTransportContext context) { Exception = exception; Context = context; }
public static GetEnvelopeResult Success(MessageTransportContext message) { return new GetEnvelopeResult(message, GetEnvelopeResultState.Success); }
public static GetEnvelopeResult Success(MessageTransportContext message) { return(new GetEnvelopeResult(message, GetEnvelopeResultState.Success)); }
GetEnvelopeResult(MessageTransportContext message, GetEnvelopeResultState state) { _message = message; State = state; }
public bool TakeMessage(CancellationToken token, out MessageTransportContext context) { context = new MessageTransportContext(null, new byte[0], "Name"); return false; }
public void TryNotifyNack(MessageTransportContext context) { var id = (int)context.TransportMessage; _queues[id].Add(context.Unpacked); }
public MessageDispatchFailed(MessageTransportContext message, string queueName, Exception exception) { Exception = exception; Message = message; QueueName = queueName; }
public MessageAcked(MessageTransportContext attributes) { Context = attributes; }
public void TryNotifyNack(MessageTransportContext context) { var id = (int) context.TransportMessage; _queues[id].Add(context.Unpacked); }