/*
* SendTime Handler
* */
public void Handle(SendTime message)
{
Data.RequestId = message.RequestId;
TimeoutMessage tmMessage = new TimeoutMessage();
tmMessage.RequestId = message.RequestId;
DateTime toSet = (DateTime)setDateTime(message);
/**
* Save Email Info
* */
Data.emailServer = message.emailServer;
Data.toAddress = message.toAddress;
Data.fromAddress = message.fromAddress;
/**
* Save Timer Info
* */
Data.HrTxt = message.HrTxt;
Data.MinTxt = message.MinTxt;
Data.SecTxt = message.SecTxt;
Data.AmPmTxt = message.AmPmTxt;
RequestTimeout(toSet, tmMessage);
Bus.Send(message);
}
/*
* Timeout
* */
public void Timeout(TimeoutMessage message)
{
/**
* Retrieve SFTP Info
* */
SFTPMessage sftpMessage = new SFTPMessage();
sftpMessage.sftpServer = Data.sftpServer;
sftpMessage.fileName = Data.fileName;
sftpMessage.username = Data.username;
sftpMessage.password = Data.password;
/**
* Get Timer Info
* */
SendTime timeMessage = new SendTime();
timeMessage.AmPmTxt = Data.AmPmTxt;
timeMessage.HrTxt = Data.HrTxt;
timeMessage.MinTxt = Data.MinTxt;
timeMessage.SecTxt = Data.SecTxt;
/**
*
* Reset the Timer
*
**/
TimeoutMessage tmMessage = new TimeoutMessage();
DateTime toSet = (DateTime)setDateTime(timeMessage);
RequestTimeout(toSet, tmMessage);
Bus.Send(sftpMessage);
}
/*
* SendTime Handler
* */
public void Handle(SendTime message)
{
Data.RequestId = message.RequestId;
TimeoutMessage tmMessage = new TimeoutMessage();
tmMessage.RequestId = message.RequestId;
DateTime toSet = (DateTime)setDateTime(message);
/**
* Save SFTP Info
* */
Data.sftpServer = message.sftpServer;
Data.fileName = message.fileName;
Data.username = message.username;
Data.password = message.password;
/**
* Save Timer Info
* */
Data.HrTxt = message.HrTxt;
Data.MinTxt = message.MinTxt;
Data.SecTxt = message.SecTxt;
Data.AmPmTxt = message.AmPmTxt;
RequestTimeout(toSet, tmMessage);
Bus.Send(message);
}
/*****
*
* Return the DateTime of today or tomorrow
* based on rather it has passed or not
*
* ******/
public DateTime setDateTime(SendTime message)
{
DateTime at = DateTime.Now;
TimeoutMessage tmMessage = new TimeoutMessage();
/*****
* Calculate AM or PM
* ***/
int hours = Convert.ToInt32(message.HrTxt);
if ((message.AmPmTxt == "AM") && (hours == 12))
{
hours = 0;
}
else if (((message.AmPmTxt == "PM") && (hours < 12)))
{
hours += 12;
}
int mins = Convert.ToInt32(message.MinTxt);
int secs = Convert.ToInt32(message.SecTxt);
var date = DateTime.Now.Date.Add(new TimeSpan(hours, mins, secs));
// If date has passed
if (at > date)
{
DateTime tomorrow = DateTime.Now.AddDays(1).Add(new TimeSpan(hours, mins, secs));
return(tomorrow);
}
else
{
return(date);
}
}
/*
* Timeout
* */
public void Timeout(TimeoutMessage message)
{
/**
* Retrieve Email Info
* */
EmailMessage emailMessage = new EmailMessage();
emailMessage.emailServer = Data.emailServer;
emailMessage.fromAddress = Data.fromAddress;
emailMessage.toAddress = Data.toAddress;
/**
* Get Timer Info
* */
SendTime timeMessage = new SendTime();
timeMessage.AmPmTxt = Data.AmPmTxt;
timeMessage.HrTxt = Data.HrTxt;
timeMessage.MinTxt = Data.MinTxt;
timeMessage.SecTxt = Data.SecTxt;
/**
*
* Reset the Timer
*
**/
TimeoutMessage tmMessage = new TimeoutMessage();
DateTime toSet = (DateTime)setDateTime(timeMessage);
RequestTimeout(toSet, tmMessage);
Bus.Send(emailMessage);
}
private void OnMessage(TimeoutMessage message, IDeliveryContext context)
{
Console.WriteLine("[Consumer] Received message: {0}", message.JobId);
Thread.Sleep(8000);
Console.WriteLine("[Consumer] Processed message: {0}", message.JobId);
context.Reply(new TimeoutResponse());
}
public override bool Equals(object obj)
{
if (obj.GetType() != this.GetType())
{
return(false);
}
ProverTimeout that = ( ProverTimeout )obj;
return(TimeoutMessage.ToString().Equals(that.TimeoutMessage.ToString()));
}
public void Start()
{
isRunning = true;
// create a subscription to timeout messages
// with a custom timeout subscription topology
var subscription = bus.Subscribe <TimeoutMessage>(
OnMessageTimeout,
s => s.SetTopology <TimeoutSubscriptionTopology>());
// get the name of our subscription queue
var timeoutSubscriptionQueueName = subscription.Queues[0].Name;
// this subscription should never be fired
// create a subscription to timeout messages
// with a custom timeout subscription topology
bus.Subscribe <TimeoutMessage>(
OnMessageTimeoutAlt,
s => s.SetTopology <TimeoutSubscriptionTopology>());
// create a standard requester
using (var requester = bus.CreateRequester <TimeoutMessage, TimeoutResponse>())
{
while (isRunning)
{
Console.WriteLine("[Publisher] Publishing new timeout message");
// set the routing key on each message to the subscription
// queue name, this will route our timeout message to our
// timeout subscription
var message = new TimeoutMessage
{
JobId = Guid.NewGuid().ToString(),
RoutingKey = timeoutSubscriptionQueueName
};
requester.Request(message, OnResponse);
Thread.Sleep(3000);
}
}
}
public void InnerPoll(CancellationToken cancellationToken)
{
var utcNow = DateTime.UtcNow;
if (NextQueryUtc > utcNow || cancellationToken.IsCancellationRequested)
{
return;
}
// connect to the data store and get all the expired timeouts
TimeoutsBatch timeoutsBatch = _processManagerFinder.GetTimeoutsBatch();
foreach (var timeoutData in timeoutsBatch.DueTimeouts)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
// dispatch the timeout message
var timeoutMsg = new TimeoutMessage(timeoutData.ProcessManagerId);
_bus.Send(timeoutData.Destination, timeoutMsg);
// remove dispatch timeout
_processManagerFinder.RemoveDispatchedTimeout(timeoutData.Id);
}
lock (_locker)
{
var nextQueryTime = timeoutsBatch.NextQueryTime;
// ensure to poll at least every minute
var maxNextQuery = utcNow.AddMinutes(1);
NextQueryUtc = (nextQueryTime > maxNextQuery) ? maxNextQuery : nextQueryTime;
Logger.DebugFormat("Polling next query is at {0}.", NextQueryUtc.ToLocalTime());
}
}
public Task Timeout(TimeoutMessage state, IMessageHandlerContext context)
{
// Can receive timeouts when saga is actually complete
if (!Data.Aborting && Data.CurrentIndex == Data.Commands.Length)
{
MarkAsComplete();
return(Task.CompletedTask);
}
if (Data.Aborting && Data.CurrentIndex == Data.AbortCommands.Length)
{
MarkAsComplete();
return(Task.CompletedTask);
}
if (!Data.Aborting)
{
return(Handle(new AbortCommandSaga {
SagaId = Data.SagaId
}, context));
}
// a timeout while aborting........
throw new SagaAbortionFailureException(Data.Originating);
}
public void OnNetworkTimeoutMessage(TimeoutMessage m)
{
this.timeout = m.gameRunning;
}
public Task Timeout(TimeoutMessage stat, IMessageHandlerContext context)
{
Context.ReceivedTimeoutMessage = true;
return(Task.FromResult(0));
}
public void Timeout(TimeoutMessage state)
{
logger.Info("--------MySaga Timeout-------");
Bus.Publish <IRequestExpiredEvent>(x => x.RequestId = Data.RequestId);
MarkAsComplete();
}
public void Timeout(TimeoutMessage state)
{
Bus.Publish <IRequestExpiredEvent>(x => x.RequestId = Data.RequestId);
MarkAsComplete();
}
private static Task <StepResult <EmailRouteState> > timeoutLogic(StateAccess <EmailRouteState> access, TimeoutMessage tm)
{
return(Task.Run(() => StepResult.Cancel <EmailRouteState>()));
}
private void OnMessageTimeout(TimeoutMessage message)
{
Console.WriteLine("[Publisher] MESSAGE TIMEDOUT: {0}", message.JobId);
}
public void Timeout(TimeoutMessage state)
{
Context.ReceivedTimeoutMessage = true;
}
public override int GetHashCode()
{
return(TimeoutMessage.GetHashCode());
}
private void OnMessageTimeoutAlt(TimeoutMessage message)
{
throw new Exception("Other timeout subscriber, should never be called");
}
public Task Timeout(TimeoutMessage state, IMessageHandlerContext context)
{
MarkAsComplete();
ManualResetEvent.Set();
return(Task.FromResult(0));
}
public Task Timeout(TimeoutMessage state, IMessageHandlerContext context)
{
testContext.WasCalled = true;
return(Task.FromResult(0));
}
