public void GetNextChunk_GetsNextTimeouts()
{
AddTimeouts();
DateTime nextTimeToRun;
var result = _persister.GetNextChunk(DateTime.UtcNow.AddDays(-5), out nextTimeToRun);
result.Count().Should().Be(5);
}
public void Should_return_the_next_time_of_retrieval()
{
new TimeoutsIndex().Execute(store);
var persister = new TimeoutPersister
{
DocumentStore = store,
EndpointName = "MyTestEndpoint",
CleanupGapFromTimeslice = TimeSpan.FromSeconds(1),
TriggerCleanupEvery = TimeSpan.MinValue,
};
var nextTime = DateTime.UtcNow.AddHours(1);
persister.Add(new TimeoutData
{
Time = nextTime,
Destination = new Address("timeouts", RuntimeEnvironment.MachineName),
SagaId = Guid.NewGuid(),
State = new byte[] { 0, 0, 133 },
Headers = new Dictionary<string, string> { { "Bar", "34234" }, { "Foo", "aString1" }, { "Super", "aString2" } },
OwningTimeoutManager = "MyTestEndpoint",
});
WaitForIndexing(store);
DateTime nextTimeToRunQuery;
persister.GetNextChunk(DateTime.UtcNow.AddYears(-3), out nextTimeToRunQuery);
Assert.IsTrue((nextTime - nextTimeToRunQuery).TotalSeconds < 1);
}
public void Should_return_the_complete_list_of_timeouts()
{
new TimeoutsIndex().Execute(store);
var persister = new TimeoutPersister
{
DocumentStore = store,
EndpointName = "MyTestEndpoint",
};
const int numberOfTimeoutsToAdd = 10;
for (var i = 0; i < numberOfTimeoutsToAdd; i++)
{
persister.Add(new TimeoutData
{
Time = DateTime.UtcNow.AddHours(-1),
Destination = new Address("timeouts", RuntimeEnvironment.MachineName),
SagaId = Guid.NewGuid(),
State = new byte[] { 0, 0, 133 },
Headers = new Dictionary<string, string> { { "Bar", "34234" }, { "Foo", "aString1" }, { "Super", "aString2" } },
OwningTimeoutManager = "MyTestEndpoint",
});
}
WaitForIndexing(store);
DateTime nextTimeToRunQuery;
Assert.AreEqual(numberOfTimeoutsToAdd, persister.GetNextChunk(DateTime.UtcNow.AddYears(-3), out nextTimeToRunQuery).Count());
}
public void Should_return_the_next_time_of_retrieval()
{
new TimeoutsIndex().Execute(store);
var persister = new TimeoutPersister
{
DocumentStore = store,
EndpointName = "MyTestEndpoint",
CleanupGapFromTimeslice = TimeSpan.FromSeconds(1),
TriggerCleanupEvery = TimeSpan.MinValue,
};
var nextTime = DateTime.UtcNow.AddHours(1);
persister.Add(new TimeoutData
{
Time = nextTime,
Destination = new Address("timeouts", RuntimeEnvironment.MachineName),
SagaId = Guid.NewGuid(),
State = new byte[] { 0, 0, 133 },
Headers = new Dictionary <string, string> {
{ "Bar", "34234" }, { "Foo", "aString1" }, { "Super", "aString2" }
},
OwningTimeoutManager = "MyTestEndpoint",
});
WaitForIndexing(store);
DateTime nextTimeToRunQuery;
persister.GetNextChunk(DateTime.UtcNow.AddYears(-3), out nextTimeToRunQuery);
Assert.IsTrue((nextTime - nextTimeToRunQuery).TotalSeconds < 1);
}
public void Should_return_the_complete_list_of_timeouts()
{
new TimeoutsIndex().Execute(store);
var persister = new TimeoutPersister
{
DocumentStore = store,
EndpointName = "MyTestEndpoint",
};
const int numberOfTimeoutsToAdd = 10;
for (var i = 0; i < numberOfTimeoutsToAdd; i++)
{
persister.Add(new TimeoutData
{
Time = DateTime.UtcNow.AddHours(-1),
Destination = new Address("timeouts", RuntimeEnvironment.MachineName),
SagaId = Guid.NewGuid(),
State = new byte[] { 0, 0, 133 },
Headers = new Dictionary <string, string> {
{ "Bar", "34234" }, { "Foo", "aString1" }, { "Super", "aString2" }
},
OwningTimeoutManager = "MyTestEndpoint",
});
}
WaitForIndexing(store);
DateTime nextTimeToRunQuery;
Assert.AreEqual(numberOfTimeoutsToAdd, persister.GetNextChunk(DateTime.UtcNow.AddYears(-3), out nextTimeToRunQuery).Count());
}
public void Should_remove_timeouts_by_id()
{
new TimeoutsIndex().Execute(store);
var persister = new TimeoutPersister
{
DocumentStore = store,
EndpointName = "MyTestEndpoint",
};
var t1 = new TimeoutData
{
Time = DateTime.Now.AddYears(-1),
OwningTimeoutManager = "MyTestEndpoint",
Headers = new Dictionary <string, string>
{
{ "Header1", "Value1" }
}
};
var t2 = new TimeoutData
{
Time = DateTime.Now.AddYears(-1),
OwningTimeoutManager = "MyTestEndpoint",
Headers = new Dictionary <string, string>
{
{ "Header1", "Value1" }
}
};
persister.Add(t1);
persister.Add(t2);
WaitForIndexing(store);
DateTime nextTimeToRunQuery;
var timeouts = persister.GetNextChunk(DateTime.UtcNow.AddYears(-3), out nextTimeToRunQuery);
foreach (var timeout in timeouts)
{
TimeoutData timeoutData;
persister.TryRemove(timeout.Item1, out timeoutData);
}
using (var session = store.OpenSession())
{
Assert.Null(session.Load <Timeout>(new Guid(t1.Id)));
Assert.Null(session.Load <Timeout>(new Guid(t2.Id)));
}
}
public void Never_ever()
{
var db = Guid.NewGuid().ToString();
using (var documentStore = new DocumentStore
{
Url = "http://localhost:8081",
DefaultDatabase = db,
}.Initialize())
{
new TimeoutsIndex().Execute(documentStore);
var persister = new TimeoutPersister
{
DocumentStore = documentStore,
EndpointName = "foo",
TriggerCleanupEvery = TimeSpan.FromHours(1), // Make sure cleanup doesn't run automatically
};
var startSlice = DateTime.UtcNow.AddYears(-10);
// avoid cleanup from running during the test by making it register as being run
Assert.AreEqual(0, persister.GetCleanupChunk(startSlice).Count());
var expected = new List <Tuple <string, DateTime> >();
var lastTimeout = DateTime.UtcNow;
var finishedAdding = false;
new Thread(() =>
{
var sagaId = Guid.NewGuid();
for (var i = 0; i < 10000; i++)
{
var td = new TimeoutData
{
SagaId = sagaId,
Destination = new Address("queue", "machine"),
Time = DateTime.UtcNow.AddSeconds(RandomProvider.GetThreadRandom().Next(1, 20)),
OwningTimeoutManager = string.Empty,
};
persister.Add(td);
expected.Add(new Tuple <string, DateTime>(td.Id, td.Time));
lastTimeout = (td.Time > lastTimeout) ? td.Time : lastTimeout;
}
finishedAdding = true;
Trace.WriteLine("*** Finished adding ***");
}).Start();
// Mimic the behavior of the TimeoutPersister coordinator
var found = 0;
TimeoutData tmptd;
while (!finishedAdding || startSlice < lastTimeout)
{
DateTime nextRetrieval;
var timeoutDatas = persister.GetNextChunk(startSlice, out nextRetrieval);
foreach (var timeoutData in timeoutDatas)
{
if (startSlice < timeoutData.Item2)
{
startSlice = timeoutData.Item2;
}
Assert.IsTrue(persister.TryRemove(timeoutData.Item1, out tmptd));
found++;
}
}
WaitForIndexing(documentStore);
// If the persister reports stale results have been seen at one point during its normal operation,
// we need to perform manual cleaup.
while (true)
{
var chunkToCleanup = persister.GetCleanupChunk(DateTime.UtcNow.AddDays(1)).ToArray();
if (chunkToCleanup.Length == 0)
{
break;
}
found += chunkToCleanup.Length;
foreach (var tuple in chunkToCleanup)
{
Assert.IsTrue(persister.TryRemove(tuple.Item1, out tmptd));
}
WaitForIndexing(documentStore);
}
using (var session = documentStore.OpenSession())
{
var results = session.Query <TimeoutData>().ToList();
Assert.AreEqual(0, results.Count);
}
Assert.AreEqual(expected.Count, found);
}
}
