//TODO: Unit test all upstream messages
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
// great. let's remove it
var msg = message as CommandCompleted;
if (msg != null)
{
_storage.Delete(msg.Message.Command);
}
// won't try anymore.
var aborted = message as CommandAborted;
if (aborted != null)
{
_storage.Delete(aborted.Message.Command);
}
var failed = message as CommandFailed;
if (failed != null)
{
_storage.Update(failed.Message);
}
context.SendUpstream(message);
}
/// <summary>
/// Send a message back up the chain, typically an error message
/// </summary>
/// <param name="message">Message to send</param>
public void SendUpstream(IUpstreamMessage message)
{
Message = message;
_upEvent.Set();
if (_up != null)
_up(message);
}
/// <summary>
/// Sends the upstream.
/// </summary>
/// <param name="message">The message.</param>
/// <exception cref="System.ArgumentNullException">message</exception>
public void SendUpstream(IUpstreamMessage message)
{
if (message == null) throw new ArgumentNullException("message");
if (_up == null)
throw new InvalidOperationException("No upstream handler has been set.");
_up.Invoke(message);
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
if (message is CommandFailed)
Console.WriteLine("Failed to deliver, attempt {0}",
((CommandFailed) message).NumberOfAttempts);
else
Console.WriteLine("In error handler: {0}", message);
}
/// <summary>
/// Send a message back up the chain, typically an error message
/// </summary>
/// <param name="message">Message to send</param>
public void SendUpstream(IUpstreamMessage message)
{
Message = message;
_upEvent.Set();
if (_up != null)
{
_up(message);
}
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
if (message is CommandFailed)
{
Console.WriteLine("Failed to deliver, attempt {0}",
((CommandFailed)message).NumberOfAttempts);
}
else
{
Console.WriteLine("In error handler: {0}", message);
}
}
/// <summary>
/// Sends the upstream.
/// </summary>
/// <param name="message">The message.</param>
/// <exception cref="System.ArgumentNullException">message</exception>
public void SendUpstream(IUpstreamMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (_up == null)
{
throw new InvalidOperationException("No upstream handler has been set.");
}
_up.Invoke(message);
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
var msg = message as CommandFailed;
if (msg != null)
{
if (msg.Message.Attempts >= _numberOfAttempts)
{
context.SendUpstream(new CommandAborted(msg.Message, msg.Exception));
return;
}
context.SendDownstream(msg.Message);
}
context.SendUpstream(message);
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
var msg = message as CommandFailed;
if (msg != null)
{
if (msg.Message.Attempts >= _numberOfAttempts)
{
context.SendUpstream(new CommandAborted(msg.Message, msg.Exception));
return;
}
context.SendDownstream(msg.Message);
}
context.SendUpstream(message);
}
//TODO: Unit test all upstream messages
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
// great. let's remove it
var msg = message as CommandCompleted;
if (msg != null)
{
_storage.Delete(msg.Message.Command);
}
// won't try anymore.
var aborted = message as CommandAborted;
if (aborted != null)
{
_storage.Delete(aborted.Message.Command);
}
var failed = message as CommandFailed;
if (failed != null)
{
_storage.Update(failed.Message);
}
context.SendUpstream(message);
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param><param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
var aborted = message as CommandAborted;
if (aborted != null)
MessageBox.Show(aborted.Exception.ToString());
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
void IUpstreamHandler.HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
throw new InvalidOperationException(_upstream[_upstream.Count - 2] +
" invoked SendUpstream when its the last handler. Don't do that..");
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
Invoked = true;
context.SendUpstream(message);
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
Invoked = true;
context.SendUpstream(message);
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="message">Message to send, most commonly <see cref="DispatchCommand" />.</param>
public void SendUpstream(IUpstreamMessage message)
{
_upMessages.Enqueue(message);
}
/// <summary>
/// Invokes the specified message.
/// </summary>
/// <param name="message">The message.</param>
public void Invoke(IUpstreamMessage message)
{
_mine.HandleUpstream(this, message);
InvokeUpstream();
InvokeDownstream();
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
void IUpstreamHandler.HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
throw new InvalidOperationException(_upstream[_upstream.Count - 2] +
" invoked SendUpstream when its the last handler. Don't do that..");
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
Console.WriteLine("In error handler: {0}", message);
}
/// <summary>
/// Invokes the specified message.
/// </summary>
/// <param name="message">The message.</param>
public void Invoke(IUpstreamMessage message)
{
_mine.HandleUpstream(this, message);
InvokeUpstream();
InvokeDownstream();
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="message">Message to send, most commonly <see cref="DispatchCommand" />.</param>
public void SendUpstream(IUpstreamMessage message)
{
_upMessages.Enqueue(message);
}
/// <summary>
/// Send a message to the next handler
/// </summary>
/// <param name="context">My context</param>
/// <param name="message">Message received</param>
public void HandleUpstream(IUpstreamContext context, IUpstreamMessage message)
{
Console.WriteLine("In error handler: {0}", message);
}
