public void Create_Default2()
{
const int id = 19334;
var test = new RollbackMessageCommand(null, id, null);
Assert.Equal(id, test.QueueId);
Assert.Equal(null, test.IncreaseQueueDelay);
Assert.Equal(null, test.LastHeartBeat);
}
public void Create_Default2()
{
const int id = 19334;
var test = new RollbackMessageCommand <long>(null, id, null);
Assert.Equal(id, test.QueueId);
Assert.Null(test.IncreaseQueueDelay);
Assert.Null(test.LastHeartBeat);
}
public void Create_Default()
{
DateTime? lastDateTime = DateTime.Now;
TimeSpan? queue = TimeSpan.FromDays(1);
const int id = 19334;
var test = new RollbackMessageCommand(lastDateTime, id, queue);
Assert.Equal(id, test.QueueId);
Assert.Equal(queue, test.IncreaseQueueDelay);
Assert.Equal(lastDateTime, test.LastHeartBeat);
}
public void Create_Default()
{
DateTime? lastDateTime = DateTime.Now;
TimeSpan? queue = TimeSpan.FromDays(1);
const int id = 19334;
var test = new RollbackMessageCommand <long>(lastDateTime, id, queue);
Assert.Equal(id, test.QueueId);
Assert.Equal(queue, test.IncreaseQueueDelay);
Assert.Equal(lastDateTime, test.LastHeartBeat);
}
/// <inheritdoc />
public void Handle(RollbackMessageCommand <string> command)
{
if (command.IncreaseQueueDelay.HasValue && command.IncreaseQueueDelay.Value != TimeSpan.Zero)
{
var unixTimestamp = _unixTimeFactory.Create().GetAddDifferenceMilliseconds(command.IncreaseQueueDelay.Value);
_rollbackDelayLua.Execute(command.QueueId, unixTimestamp);
}
else
{
_rollbackLua.Execute(command.QueueId);
}
}
/// <inheritdoc />
public void Handle(RollbackMessageCommand <string> command)
{
//lets add a bit more information to the active span if possible
if (Activity.Current != null)
{
if (command.IncreaseQueueDelay.HasValue)
{
Activity.Current.SetTag("MessageDelay",
command.IncreaseQueueDelay.Value.ToString());
}
}
_handler.Handle(command);
}
public void Create_Default(string number)
{
var test = new RollbackMessageCommand <string>(null, number, null);
Assert.Equal(number, test.QueueId);
Assert.Null(test.IncreaseQueueDelay);
TimeSpan?time = TimeSpan.MinValue;
test = new RollbackMessageCommand <string>(null, number, time);
Assert.Equal(number, test.QueueId);
Assert.Equal(time, test.IncreaseQueueDelay);
}
/// <inheritdoc />
public void Handle(RollbackMessageCommand <long> command)
{
//lets add a bit more information to the active span if possible
if (_tracer.ActiveSpan != null)
{
if (command.IncreaseQueueDelay.HasValue)
{
_tracer.ActiveSpan.SetTag("MessageDelay",
command.IncreaseQueueDelay.Value.ToString());
}
if (command.LastHeartBeat.HasValue)
{
_tracer.ActiveSpan.SetTag("LastHeartBeatValue",
command.LastHeartBeat.Value.ToString(System.Globalization.CultureInfo.InvariantCulture));
}
}
_handler.Handle(command);
}
/// <summary>
/// Handles the specified rollback command.
/// </summary>
/// <param name="rollBackCommand">The rollBackCommand.</param>
public void Handle(RollbackMessageCommand <int> rollBackCommand)
{
if (!_databaseExists.Exists())
{
return;
}
using (var db = _connectionInformation.GetDatabase())
{
db.Database.BeginTrans();
try
{
var col = db.Database.GetCollection <Schema.MetaDataTable>(_tableNameHelper.MetaDataName);
var results2 = col.Query()
.Where(x => x.QueueId.Equals(rollBackCommand.QueueId))
.Limit(1)
.ToList();
if (results2 != null && results2.Count == 1)
{
var record = results2[0];
if (record != null)
{
var process = true;
if (rollBackCommand.LastHeartBeat.HasValue)
{
//heartbeat must match
if (TrimMilliseconds(record.HeartBeat) !=
TrimMilliseconds(rollBackCommand.LastHeartBeat))
{
process = false;
}
}
if (process)
{
if (_options.Value.EnableDelayedProcessing &&
rollBackCommand.IncreaseQueueDelay.HasValue)
{
var dtUtcDate = _getUtcDateQuery.Create().GetCurrentUtcDate();
var dtUtcDateIncreased = dtUtcDate.Add(rollBackCommand.IncreaseQueueDelay.Value);
//move to future
record.QueueProcessTime = dtUtcDateIncreased;
}
if (_options.Value.EnableHeartBeat)
{
record.HeartBeat = null;
}
record.Status = QueueStatuses.Waiting;
col.Update(record);
if (_options.Value.EnableStatusTable)
{
var statusCol = db.Database.GetCollection <Schema.StatusTable>(_tableNameHelper.StatusName);
var results = statusCol.Query()
.Where(x => x.QueueId.Equals(record.QueueId))
.Limit(1)
.ToList();
if (results.Count == 1)
{
var statusRecord = results[0];
statusRecord.Status = record.Status;
statusCol.Update(statusRecord);
}
}
}
}
}
db.Database.Commit();
}
catch
{
db.Database.Rollback();
throw;
}
}
}
public void Handle(RollbackMessageCommand <long> rollBackCommand)
{
if (!_databaseExists.Exists(_connectionInformation.ConnectionString))
{
return;
}
SetupSql();
using (var connection = _dbFactory.CreateConnection(_connectionInformation.ConnectionString, false))
{
connection.Open();
using (var trans = _dbFactory.CreateTransaction(connection).BeginTransaction())
{
using (var command = connection.CreateCommand())
{
command.Transaction = trans;
var param = command.CreateParameter();
param.ParameterName = "@QueueID";
param.DbType = DbType.Int64;
param.Value = rollBackCommand.QueueId;
command.Parameters.Add(param);
if (_options.Value.EnableDelayedProcessing && rollBackCommand.IncreaseQueueDelay.HasValue)
{
if (rollBackCommand.LastHeartBeat.HasValue)
{
command.CommandText = GetRollbackSql(false, true);
param = command.CreateParameter();
param.ParameterName = "@HeartBeat";
param.DbType = DbType.DateTime2;
param.Value = rollBackCommand.LastHeartBeat.Value.Ticks;
command.Parameters.Add(param);
}
else
{
command.CommandText = GetRollbackSql(true, false);
}
var dtUtcDate = _getUtcDateQuery.Create().GetCurrentUtcDate();
var dtUtcDateIncreased = dtUtcDate.Add(rollBackCommand.IncreaseQueueDelay.Value);
param = command.CreateParameter();
param.ParameterName = "@QueueProcessTime";
param.DbType = DbType.DateTime2;
param.Value = dtUtcDateIncreased.Ticks;
command.Parameters.Add(param);
}
else
{
if (rollBackCommand.LastHeartBeat.HasValue)
{
command.CommandText = GetRollbackSql(false, true);
param = command.CreateParameter();
param.ParameterName = "@HeartBeat";
param.DbType = DbType.DateTime2;
param.Value = rollBackCommand.LastHeartBeat.Value.Ticks;
command.Parameters.Add(param);
}
else
{
command.CommandText = GetRollbackSql(false, false);
}
}
command.ExecuteNonQuery();
}
if (_options.Value.EnableStatusTable)
{
using (var command = connection.CreateCommand())
{
command.Transaction = trans;
var param = command.CreateParameter();
param.ParameterName = "@QueueID";
param.DbType = DbType.Int64;
param.Value = rollBackCommand.QueueId;
command.Parameters.Add(param);
param = command.CreateParameter();
param.ParameterName = "@Status";
param.DbType = DbType.Int32;
param.Value = Convert.ToInt16(QueueStatuses.Waiting);
command.Parameters.Add(param);
command.CommandText =
_commandCache.GetCommand(CommandStringTypes.UpdateStatusRecord);
command.ExecuteNonQuery();
}
}
trans.Commit();
}
}
}
/// <inheritdoc />
public void Handle(RollbackMessageCommand <long> rollBackCommand)
{
SetupSql();
using (var connection = new NpgsqlConnection(_connectionInformation.ConnectionString))
{
connection.Open();
using (var trans = connection.BeginTransaction())
{
using (var command = connection.CreateCommand())
{
command.Transaction = trans;
command.Parameters.Add("@QueueID", NpgsqlDbType.Bigint);
command.Parameters["@QueueID"].Value = rollBackCommand.QueueId;
if (_options.Value.EnableDelayedProcessing && rollBackCommand.IncreaseQueueDelay.HasValue)
{
if (rollBackCommand.LastHeartBeat.HasValue)
{
command.CommandText = GetRollbackSql(false, true);
command.Parameters.Add("@HeartBeat", NpgsqlDbType.Bigint);
command.Parameters["@HeartBeat"].Value = rollBackCommand.LastHeartBeat.Value.Ticks;
}
else
{
command.CommandText = GetRollbackSql(true, false);
}
var dtUtcDate = _getUtcDateQuery.Create().GetCurrentUtcDate();
dtUtcDate = dtUtcDate.Add(rollBackCommand.IncreaseQueueDelay.Value);
command.Parameters.Add("@QueueProcessTime", NpgsqlDbType.Bigint);
command.Parameters["@QueueProcessTime"].Value = dtUtcDate.Ticks;
}
else
{
if (rollBackCommand.LastHeartBeat.HasValue)
{
command.CommandText = GetRollbackSql(false, true);
command.Parameters.Add("@HeartBeat", NpgsqlDbType.Bigint);
command.Parameters["@HeartBeat"].Value = rollBackCommand.LastHeartBeat.Value.Ticks;
}
else
{
command.CommandText = GetRollbackSql(false, false);
}
}
command.ExecuteNonQuery();
}
if (_options.Value.EnableStatusTable)
{
using (var command = connection.CreateCommand())
{
command.Transaction = trans;
command.Parameters.Add("@QueueID", NpgsqlDbType.Bigint);
command.Parameters["@QueueID"].Value = rollBackCommand.QueueId;
command.Parameters.Add("@status", NpgsqlDbType.Integer);
command.Parameters["@status"].Value = Convert.ToInt16(QueueStatuses.Waiting);
command.CommandText =
_commandCache.GetCommand(CommandStringTypes.UpdateStatusRecord);
command.ExecuteNonQuery();
}
}
trans.Commit();
}
}
}
public void Create_Null_Constructor_Time_Ok(string number)
{
var test = new RollbackMessageCommand(new RedisQueueId(number), null);
Assert.NotNull(test);
}