/// <inheritdoc />
public long Handle(ResetHeartBeatCommand <int> inputCommand)
{
using (var db = _connectionInformation.GetDatabase())
{
db.Database.BeginTrans();
try
{
var col = db.Database.GetCollection <Schema.MetaDataTable>(_tableNameHelper.MetaDataName);
var results = col.Query()
.Where(x => x.Status == QueueStatuses.Processing)
.Where(x => x.HeartBeat != null && x.HeartBeat.Value == inputCommand.MessageReset.HeartBeat)
.Where(x => x.QueueId == inputCommand.MessageReset.QueueId)
.Limit(1)
.ToList();
if (results.Count == 1)
{
results[0].Status = QueueStatuses.Waiting;
results[0].HeartBeat = null;
col.Update(results[0]);
}
db.Database.Commit();
return(results.Count);
}
catch
{
db.Database.Rollback();
throw;
}
}
}
/// <inheritdoc />
public List <ResetHeartBeatOutput> Reset(CancellationToken cancelToken)
{
if (!_configuration.HeartBeat.Enabled)
{
return(new List <ResetHeartBeatOutput>(0));
}
if (string.IsNullOrEmpty(_configuration.TransportConfiguration.ConnectionInfo.ConnectionString))
{
return(new List <ResetHeartBeatOutput>(0));
}
List <ResetHeartBeatOutput> returnData = new List <ResetHeartBeatOutput>();
var query = new FindMessagesToResetByHeartBeatQuery <T>(cancelToken);
DateTime start = _getTime.GetCurrentUtcDate();
var results = _queryHandler.Handle(query);
DateTime end = _getTime.GetCurrentUtcDate();
foreach (var result in results)
{
var id = new MessageQueueId <T>(result.QueueId);
var command = new ResetHeartBeatCommand <T>(result);
var resetResult = _commandHandler.Handle(command);
if (resetResult <= 0)
{
continue;
}
var data = new ResetHeartBeatOutput(id, result.Headers, start, end);
returnData.Add(data);
}
return(returnData);
}
/// <summary>
/// Handles the specified command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="dbCommand">The database command.</param>
/// <param name="commandType">Type of the command.</param>
public void Handle(ResetHeartBeatCommand <long> command, IDbCommand dbCommand, CommandStringTypes commandType)
{
dbCommand.CommandText = _commandCache.GetCommand(CommandStringTypes.ResetHeartbeat);
var param = dbCommand.CreateParameter();
param.ParameterName = "@QueueID";
param.DbType = DbType.Int64;
param.Value = command.MessageReset.QueueId;
dbCommand.Parameters.Add(param);
param = dbCommand.CreateParameter();
param.ParameterName = "@SourceStatus";
param.DbType = DbType.Int32;
param.Value = Convert.ToInt16(QueueStatuses.Processing);
dbCommand.Parameters.Add(param);
param = dbCommand.CreateParameter();
param.ParameterName = "@Status";
param.DbType = DbType.Int32;
param.Value = Convert.ToInt16(QueueStatuses.Waiting);
dbCommand.Parameters.Add(param);
param = dbCommand.CreateParameter();
param.ParameterName = "@HeartBeat";
param.DbType = DbType.Int64;
param.Value = command.MessageReset.HeartBeat.Ticks;
dbCommand.Parameters.Add(param);
}
public void Create_Default()
{
const int id = 293;
var date = DateTime.Now;
var message = new MessageToReset(id, date);
var test = new ResetHeartBeatCommand(message);
Assert.Equal(message, test.MessageReset);
}
public long Handle(ResetHeartBeatCommand <long> inputCommand)
{
using (var connection = _connectionFactory.Create())
{
connection.Open();
using (var trans = _transactionFactory.Create(connection).BeginTransaction())
{
using (var command = connection.CreateCommand())
{
command.Transaction = trans;
_prepareCommand.Handle(inputCommand, command, CommandStringTypes.ResetHeartbeat);
var result = command.ExecuteNonQuery();
if (result > 0)
{
trans.Commit();
}
return(result);
}
}
}
}
public void Create_Default()
{
var test = new ResetHeartBeatCommand <string>(new MessageToReset <string>(string.Empty, DateTime.Now, null));
Assert.NotNull(test);
}
/// <summary>
/// Handles the specified command.
/// </summary>
/// <param name="command">The command.</param>
/// <returns></returns>
public long Handle(ResetHeartBeatCommand <long> command)
{
return(!_databaseExists.Exists(_connectionInformation.ConnectionString) ? 0 : _decorated.Handle(command));
}
/// <inheritdoc />
public List <ResetHeartBeatOutput> Handle(ResetHeartBeatCommand <string> command)
{
return(_resetHeartbeatLua.Execute(_unixTimeFactory.Create().GetSubtractDifferenceMilliseconds(_configuration.Time), _options.ResetHeartBeatBatchLimit));
}
public void Create_Default()
{
var test = new ResetHeartBeatCommand();
Assert.NotNull(test);
}
public void Create_Default()
{
var test = new ResetHeartBeatCommand();
Assert.NotNull(test);
}
