public bool TryAddNewExceptionInfo([NotNull] TaskMetaInformation taskMeta, [NotNull] Exception exception, out List <TimeGuid> newExceptionInfoIds)
{
if (!taskMeta.IsTimeBased())
{
throw new InvalidOperationException(string.Format("TaskMeta is not time-based: {0}", taskMeta));
}
newExceptionInfoIds = null;
var newExceptionInfo = new TaskExceptionInfo(exception);
var lastExceptionInfo = TryGetLastExceptionInfo(taskMeta);
if (lastExceptionInfo != null && lastExceptionInfo.ExceptionMessageInfo == newExceptionInfo.ExceptionMessageInfo)
{
return(false);
}
var newExceptionInfoId = TimeGuid.NowGuid();
var timestamp = newExceptionInfoId.GetTimestamp().Ticks;
TimeGuid oldExceptionInfoId;
newExceptionInfoIds = taskMeta.AddExceptionInfoId(newExceptionInfoId, out oldExceptionInfoId);
var newExceptionInfoBytes = serializer.Serialize(newExceptionInfo);
timeBasedBlobStorage.Write(taskMeta.Id, newExceptionInfoId, newExceptionInfoBytes, timestamp, taskMeta.GetTtl());
if (oldExceptionInfoId != null)
{
timeBasedBlobStorage.Delete(taskMeta.Id, oldExceptionInfoId, timestamp);
}
return(true);
}
public void ToByteArray()
{
var timeGuid = TimeGuid.NowGuid();
var bytes = timeGuid.ToByteArray();
Assert.That(new TimeGuid(bytes), Is.EqualTo(timeGuid));
}
public void NowGuid()
{
var nowDateTime = DateTime.UtcNow;
var nowGuid = TimeGuid.NowGuid();
Assert.That(TimeSpan.FromTicks(nowGuid.GetTimestamp().Ticks - nowDateTime.Ticks), Is.LessThan(TimeSpan.FromTicks(100 * 10_000)));
Assert.That(TimeSpan.FromMilliseconds((nowGuid.GetTimestamp().ToDateTime() - nowDateTime).TotalMilliseconds), Is.LessThan(TimeSpan.FromMilliseconds(100)));
}
public void InvalidV1Guid()
{
Assert.Throws <InvalidOperationException>(() => new TimeGuid(Guid.NewGuid()));
Assert.Throws <InvalidOperationException>(() => new TimeGuid(minGuid));
Assert.Throws <InvalidOperationException>(() => new TimeGuid(maxGuid));
Assert.Throws <InvalidOperationException>(() => new TimeGuid(new byte[0]));
Assert.Throws <InvalidOperationException>(() => new TimeGuid(TimeGuid.NowGuid().ToByteArray().Take(15).ToArray()));
Assert.Throws <InvalidOperationException>(() => new TimeGuid(TimeGuid.NowGuid().ToByteArray().Concat(new byte[] { 0xff }).ToArray()));
}
public void ToGuid()
{
var timeGuid = TimeGuid.NowGuid();
Console.Out.WriteLine(timeGuid);
var guid = timeGuid.ToGuid();
Assert.That(new TimeGuid(guid), Is.EqualTo(timeGuid));
Assert.That(new TimeGuid(guid).ToGuid(), Is.EqualTo(guid));
}
public void StrongOrdering_ByTimestampNow()
{
var lastGuid = TimeGuid.MinValue;
for (var i = 0; i < 5 * 1000 * 1000; i++)
{
var nowGuid = TimeGuid.NowGuid();
Assert.That(nowGuid.GetTimestamp(), Is.GreaterThan(lastGuid.GetTimestamp()));
lastGuid = nowGuid;
}
}
public void IsTimeGuid()
{
Assert.That(TimeGuid.IsTimeGuid(Guid.NewGuid()), Is.False);
Assert.That(TimeGuid.IsTimeGuid(minGuid), Is.False);
Assert.That(TimeGuid.IsTimeGuid(maxGuid), Is.False);
Assert.That(TimeGuid.IsTimeGuid(TimeGuid.NowGuid().ToGuid()), Is.True);
Assert.That(TimeGuid.IsTimeGuid(TimeGuid.MinValue.ToGuid()), Is.True);
Assert.That(TimeGuid.IsTimeGuid(TimeGuid.MaxValue.ToGuid()), Is.True);
Assert.That(TimeGuid.IsTimeGuid(TimeGuid.MinForTimestamp(TimeGuidBitsLayout.GregorianCalendarStart).ToGuid()), Is.True);
Assert.That(TimeGuid.IsTimeGuid(TimeGuid.MaxForTimestamp(TimeGuidBitsLayout.GregorianCalendarEnd).ToGuid()), Is.True);
}
public void TryParse()
{
Assert.That(TimeGuid.TryParse(null, out var actual), Is.False);
Assert.That(actual, Is.Null);
Assert.That(TimeGuid.TryParse("some-string", out actual), Is.False);
Assert.That(actual, Is.Null);
Assert.That(TimeGuid.TryParse(Guid.NewGuid().ToString(), out actual), Is.False);
Assert.That(actual, Is.Null);
var timeGuid = TimeGuid.NowGuid();
Assert.That(TimeGuid.TryParse(timeGuid.ToGuid().ToString(), out actual), Is.True);
Assert.That(actual, Is.EqualTo(timeGuid));
}
public void Read_NoExceptions()
{
var taskMetas = new[]
{
TimeGuidMeta(),
TimeGuidMeta().With(x => x.TaskExceptionInfoIds = new List <TimeGuid>()),
TimeGuidMeta().With(x => x.TaskExceptionInfoIds = new List <TimeGuid> {
TimeGuid.NowGuid()
})
};
Check(new[]
{
new Tuple <TaskMetaInformation, Exception[]>(taskMetas[0], new Exception[0]),
new Tuple <TaskMetaInformation, Exception[]>(taskMetas[1], new Exception[0]),
new Tuple <TaskMetaInformation, Exception[]>(taskMetas[2], new Exception[0])
});
}
public void SearchByTimeGuid()
{
var t0 = Timestamp.Now;
var timeGuid0 = TimeGuid.NowGuid();
var taskId0 = QueueTask(new TimeGuidTaskData {
Value = timeGuid0
});
var timeGuid1 = TimeGuid.NowGuid();
var taskId1 = QueueTask(new TimeGuidTaskData {
Value = timeGuid1
});
WaitForTasks(new[] { taskId0, taskId1 }, TimeSpan.FromSeconds(5));
monitoringServiceClient.ExecuteForcedFeeding();
var t1 = Timestamp.Now;
CheckSearch("*", t0, t1, taskId0, taskId1);
CheckSearch($"Data.\\*.Value:\"{timeGuid0.ToGuid().ToString()}\"", t0, t1, taskId0);
CheckSearch($"Data.\\*.Value:\"{timeGuid1.ToGuid().ToString()}\"", t0, t1, taskId1);
}
public IRemoteTask CreateTask <T>([NotNull] T taskData, [CanBeNull] CreateTaskOptions createTaskOptions = null) where T : IRtqTaskData
{
createTaskOptions ??= new CreateTaskOptions();
var type = taskData.GetType();
var taskId = TimeGuid.NowGuid().ToGuid().ToString();
var taskMeta = new TaskMetaInformation(TaskDataRegistry.GetTaskName(type), taskId)
{
Attempts = 0,
Ticks = Timestamp.Now.Ticks,
ParentTaskId = string.IsNullOrEmpty(createTaskOptions.ParentTaskId) ? GetCurrentExecutingTaskId() : createTaskOptions.ParentTaskId,
TaskGroupLock = createTaskOptions.TaskGroupLock,
State = TaskState.New,
MinimalStartTicks = 0,
};
var taskDataBytes = Serializer.Serialize(type, taskData);
var task = new Task(taskMeta, taskDataBytes);
return(enableContinuationOptimization && localTaskQueue != null
? new RemoteTaskWithContinuationOptimization(task, TaskTtl, HandleTaskCollection, localTaskQueue)
: new RemoteTask(task, TaskTtl, HandleTaskCollection));
}
private static BlobId RegularBlobId(TimeGuid timeGuid = null)
{
return(new BlobId(timeGuid ?? TimeGuid.NowGuid(), BlobType.Regular));
}
private static TimeGuid NewBlobId()
{
return(TimeGuid.NowGuid());
}
private static TaskMetaInformation TimeGuidMeta(TimeSpan?ttl = null)
{
return(TaskMeta(TimeGuid.NowGuid().ToGuid().ToString(), ttl));
}
public static BlobId GenerateNewBlobId(int blobSize)
{
var id = TimeGuid.NowGuid();
return(new BlobId(id, blobSize > TimeBasedBlobStorageSettings.MaxRegularBlobSize ? BlobType.Large : BlobType.Regular));
}
private static string TaskId()
{
return(TimeGuid.NowGuid().ToGuid().ToString());
}
private static BlobId LargeBlobId()
{
return(new BlobId(TimeGuid.NowGuid(), BlobType.Large));
}
public void TestCancel_UnknownTask()
{
var taskId = TimeGuid.NowGuid().ToGuid().ToString();
Assert.That(remoteTaskQueue.TryCancelTask(taskId), Is.EqualTo(TaskManipulationResult.Failure_TaskDoesNotExist));
}
