public void HashedWheelTimer_Should_Schedule_In_Order()
{
var results = new List<int>();
var actions = new Action[100];
var timer = new HashedWheelTimer(20, 8);
Stopwatch watch = new Stopwatch();
watch.Start();
for (var i = 0; i < actions.Length; i++)
{
var index = i;
actions[i] = () =>
{
// ReSharper disable once AccessToDisposedClosure
timer.NewTimeout(() =>
{
results.Add(index);
}, 20 * (actions.Length - index));
};
}
TestHelper.ParallelInvoke(actions);
var counter = 0;
while (results.Count < actions.Length && ++counter < 10)
{
Thread.Sleep(500);
Trace.WriteLine("Slept " + counter);
}
Assert.AreEqual(actions.Length, results.Count);
counter = 100;
CollectionAssert.AreEqual(Enumerable.Repeat(0, actions.Length).Select(_ => --counter), results);
timer.Dispose();
}
public HostConnectionPool(Host host, HostDistance distance, Configuration config)
{
_host = host;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_distance = distance;
_config = config;
_timer = config.Timer;
}
public HostConnectionPool(Host host, HostDistance distance, Configuration config, Serializer serializer)
{
_host = host;
_host.CheckedAsDown += OnHostCheckedAsDown;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_host.Remove += OnHostRemoved;
_distance = distance;
_config = config;
_serializer = serializer;
_timer = config.Timer;
}
public HostConnectionPool(Host host, HostDistance distance, Configuration config, Serializer serializer)
{
_host = host;
_host.CheckedAsDown += OnHostCheckedAsDown;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_host.Remove += OnHostRemoved;
_distance = distance;
_config = config;
_serializer = serializer;
_timer = config.Timer;
}
public void TestCancelledTaskShouldNotBeExecuted(int interval, int timeout, int cancelDelayTime)
{
var timer = new HashedWheelTimer(TimeSpan.FromMilliseconds(interval));
var barrier = new CountdownEvent(1);
var timedCallback = timer.ScheduleTimeout(() => {
barrier.Signal();
}, timeout);
Task.Delay(TimeSpan.FromMilliseconds(cancelDelayTime)).Wait();
Assert.True(timedCallback.TryCancel());
Assert.False(barrier.Wait(timeout));
}
public void TestScheduleTimeoutShouldRunAfterDelay()
{
ITimer timer = new HashedWheelTimer();
var barrier = new CountdownEvent(1);
ITimeout timeout = timer.NewTimeout(
new ActionTimerTask(
t => { barrier.Signal(); }),
TimeSpan.FromSeconds(2));
Assert.True(barrier.Wait(TimeSpan.FromSeconds(3)));
Assert.True(timeout.Expired, "timer should expire");
timer.StopAsync().Wait();
}
public HostConnectionPool(Host host, Configuration config, Serializer serializer)
{
_host = host;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_host.Remove += OnHostRemoved;
_host.DistanceChanged += OnDistanceChanged;
_config = config;
_serializer = serializer;
_timer = config.Timer;
_reconnectionSchedule = config.Policies.ReconnectionPolicy.NewSchedule();
_expectedConnectionLength = 1;
}
public void TestScheduleTimeoutShouldRunAfterDelay()
{
var timer = new HashedWheelTimer();
var barrier = new CountdownEvent(1);
Action cb = () => {
Console.WriteLine("Test");
barrier.Signal();;
};
TimedCallback timeout = timer.ScheduleTimeout(cb, TimeSpan.FromSeconds(4));
Assert.False(timeout.IsExpired, "TimedTask should not expire");
Assert.True(barrier.Wait(TimeSpan.FromSeconds(5)), "TimedTask should expire");
timer.Stop();
}
public void ShouldCancelTheTimer()
{
var expired = false;
var wheelTimer = new HashedWheelTimer(16, 100);
var cancellation = wheelTimer.SetTimeout(200, () => expired = true);
wheelTimer.Start();
cancellation.Cancel();
Thread.Sleep(300);
Assert.IsFalse(expired);
}
public void TestOverflow()
{
CountdownEvent barrier = new CountdownEvent(1);
const int intervalMs = 50;
var timer = new HashedWheelTimer(interval: TimeSpan.FromMilliseconds(intervalMs));
TimeSpan superDureTimeSpan = TimeSpan.FromMilliseconds(intervalMs) * 0xffffffff;
var timeout = timer.ScheduleTimeout(() =>
{
barrier.Signal();
}, superDureTimeSpan);
Assert.False(barrier.Wait(TimeSpan.FromSeconds(1)));
Assert.True(timeout.TryCancel());
timer.Stop();
}
public HostConnectionPool(Host host, Configuration config, ISerializer serializer, IObserverFactory observerFactory)
{
_host = host;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_host.DistanceChanged += OnDistanceChanged;
_config = config ?? throw new ArgumentNullException(nameof(config));
_poolingOptions = config.GetOrCreatePoolingOptions(serializer.ProtocolVersion);
_maxRequestsPerConnection = _poolingOptions.GetMaxRequestsPerConnection();
_serializer = serializer;
_observerFactory = observerFactory;
_timer = config.Timer;
_reconnectionSchedule = config.Policies.ReconnectionPolicy.NewSchedule();
_expectedConnectionLength = 1;
}
public HostConnectionPool(Host host, Configuration config, Serializer serializer)
{
_host = host;
_host.Down += OnHostDown;
_host.Up += OnHostUp;
_host.Remove += OnHostRemoved;
_host.DistanceChanged += OnDistanceChanged;
_config = config ?? throw new ArgumentNullException(nameof(config));
_maxRequestsPerConnection = config.GetPoolingOptions(serializer.ProtocolVersion)
.GetMaxRequestsPerConnection();
_serializer = serializer;
_timer = config.Timer;
_reconnectionSchedule = config.Policies.ReconnectionPolicy.NewSchedule();
_expectedConnectionLength = 1;
}
public void TestDelayTimeoutShouldNotLargerThanSingleTickDuration(int tickInterval, int timeout)
{
var watch = new ConcurrentStopwatch();
var barrier = new CountdownEvent(1);
var timer = new HashedWheelTimer(interval: TimeSpan.FromMilliseconds(tickInterval));
long elapsed = 0;
watch.Start();
timer.ScheduleTimeout(() =>
{
Interlocked.Exchange(ref elapsed, watch.Elapsed);
barrier.Signal();
}, TimeSpan.FromMilliseconds(timeout));
Assert.True(barrier.Wait(tickInterval * 2 + timeout), $"Elapsed: {NanoTime.ToMilliseconds(elapsed)}, ticks interval: {tickInterval}, timeout: {timeout}.");
}
public void TestScheduleTimeoutShouldNotRunBeforeDelay(double expiryTime, double waitTime)
{
var timer = new HashedWheelTimer();
var barrier = new CountdownEvent(1);
bool flag = false;
Action cb = () => {
flag = true;
barrier.Signal();
};
TimedCallback timeout = timer.ScheduleTimeout(cb, TimeSpan.FromMilliseconds(expiryTime));
Assert.False(barrier.Wait(TimeSpan.FromMilliseconds(waitTime)));
Assert.False(timeout.IsExpired, "TimedTask should not be expired");
Assert.False(flag);
timer.Stop();
}
public void PendingTimeouts()
{
var latch = new ManualResetEvent(false);
var timer = new HashedWheelTimer();
var t1 = timer.NewTimeout(new TimerTask(() => { }), TimeSpan.FromMinutes(100));
var t2 = timer.NewTimeout(new TimerTask(() => { }), TimeSpan.FromMinutes(100));
timer.NewTimeout(new ManualResetEventTask(latch), TimeSpan.FromMilliseconds(90));
Assert.Equal(3, timer.PendingTimeouts);
t1.Cancel();
t2.Cancel();
latch.WaitOne();
Assert.Equal(0, timer.PendingTimeouts);
timer.Stop();
}
public void NewTimeoutShouldStopThrowingRejectedExecutionExceptionWhenExistingTimeoutIsCancelled()
{
var latch = new ManualResetEvent(false);
var timer = new HashedWheelTimer(TimeSpan.FromMilliseconds(25), 4, 2);
timer.NewTimeout(new TimerTask(() => { }), TimeSpan.FromSeconds(5));
timer.NewTimeout(new ManualResetEventTask(latch), TimeSpan.FromMilliseconds(90));
latch.WaitOne();
var secondLatch = new ManualResetEvent(false);
timer.NewTimeout(new ManualResetEventTask(secondLatch), TimeSpan.FromMilliseconds(90));
secondLatch.WaitOne();
timer.Stop();
}
public void ShouldOnlyCancelThisTimer()
{
var expired = new List <string>(3);
var wheelTimer = new HashedWheelTimer(16, 100);
var cancellation1 = wheelTimer.SetTimeout(200, () => expired.Add("1"));
var cancellation2 = wheelTimer.SetTimeout(200, () => expired.Add("2"));
var cancellation3 = wheelTimer.SetTimeout(200, () => expired.Add("3"));
wheelTimer.Start();
cancellation2.Cancel();
Thread.Sleep(300);
Assert.AreEqual(2, expired.Count);
CollectionAssert.DoesNotContain(expired, "2");
}
public void ReportPendingTimeouts()
{
var latch = new CountdownEvent(1);
var timer = new HashedWheelTimer();
var t1 = timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromMinutes(100));
var t2 = timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromMinutes(100));
timer.NewTimeout(CreateCountdownEventTimerTask(latch), TimeSpan.FromMilliseconds(90));
Assert.Equal(3, timer.PendingTimeouts);
t1.Cancel();
t2.Cancel();
latch.Wait();
Assert.Equal(0, timer.PendingTimeouts);
timer.StopAsync().GetAwaiter().GetResult();
}
public void TestScheduleTimeoutShouldNotRunBeforeDelay()
{
ITimer timer = new HashedWheelTimer(TimeSpan.FromMilliseconds(100), 512, -1);
var barrier = new CountdownEvent(1);
ITimeout timeout = timer.NewTimeout(
new ActionTimerTask(
t =>
{
Assert.True(false, "This should not have run");
barrier.Signal();
}),
TimeSpan.FromSeconds(10));
Assert.False(barrier.Wait(TimeSpan.FromSeconds(3)));
Assert.False(timeout.Expired, "timer should not expire");
timer.StopAsync().Wait();
}
public void HashedWheelTimer_Cancelled_Should_Be_Removed_From_Bucket()
{
using (var timer = new HashedWheelTimer(200, 8))
{
var flag = 0;
timer.NewTimeout(_ => flag += 1, null, 500);
//this callback should never be executed
var timeout2 = (TimeoutItem)timer.NewTimeout(_ => flag += 2, null, 500);
timer.NewTimeout(_ => flag += 4, null, 500);
Thread.Sleep(300);
Assert.NotNull(timeout2.Bucket);
timeout2.Cancel();
Thread.Sleep(800);
Assert.AreEqual(5, flag);
timer.Dispose();
}
}
[Fact] // (timeout = 3000)
public void TestNewTimeoutShouldStopThrowingRejectedExecutionExceptionWhenExistingTimeoutIsExecuted()
{
var latch = new CountdownEvent(1);
var timer = new HashedWheelTimer(TimeSpan.FromMilliseconds(25), 4, 2);
timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromSeconds(5));
timer.NewTimeout(CreateCountdownEventTimerTask(latch), TimeSpan.FromMilliseconds(90));
latch.Wait(3000);
var secondLatch = new CountdownEvent(1);
timer.NewTimeout(CreateCountdownEventTimerTask(secondLatch), TimeSpan.FromMilliseconds(90));
secondLatch.Wait(3000);
timer.StopAsync().Wait();
}
[Fact] // (timeout = 3000)
public void TestTimerShouldThrowExceptionAfterShutdownForNewTimeouts()
{
var latch = new CountdownEvent(3);
ITimer timer = new HashedWheelTimer();
for (int i = 0; i < 3; i++)
{
timer.NewTimeout(
new ActionTimerTask(
t => { latch.Signal(); }),
TimeSpan.FromMilliseconds(1));
}
latch.Wait(3000);
timer.StopAsync().Wait();
Assert.Throws <RejectedExecutionException>(() => timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromMilliseconds(1)));
}
[Fact] // (timeout = 5000)
public void TestTimerOverflowWheelLength()
{
var timer = new HashedWheelTimer(TimeSpan.FromMilliseconds(100), 32, -1);
var latch = new CountdownEvent(3);
ActionTimerTask task = null;
task = new ActionTimerTask(
t =>
{
timer.NewTimeout(task, TimeSpan.FromMilliseconds(100));
latch.Signal();
});
timer.NewTimeout(task, TimeSpan.FromMilliseconds(100));
Assert.True(latch.Wait(5000));
Assert.NotEqual(0, timer.StopAsync().Result.Count);
}
public void WheelTimer_Bucket_Should_Remove_Head_Items_Correctly()
{
using (var timer = new HashedWheelTimer(500, 10))
{
var bucket = new Bucket();
var t1 = new TimeoutItem(timer, EmptyAction, null);
var t2 = new TimeoutItem(timer, EmptyAction, null);
var t3 = new TimeoutItem(timer, EmptyAction, null);
var t4 = new TimeoutItem(timer, EmptyAction, null);
bucket.Add(t1);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1 });
Assert.AreEqual(bucket.Tail, t1);
bucket.Add(t2);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1, t2 });
Assert.AreEqual(bucket.Tail, t2);
bucket.Add(t3);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1, t2, t3 });
Assert.AreEqual(bucket.Tail, t3);
bucket.Add(t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1, t2, t3, t4 });
Assert.AreEqual(bucket.Tail, t4);
bucket.Remove(t1);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t3, t4 });
Assert.AreEqual(bucket.Tail, t4);
bucket.Remove(t3);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t4 });
Assert.AreEqual(bucket.Tail, t4);
bucket.Remove(t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2 });
Assert.AreEqual(bucket.Tail, t2);
bucket.Remove(t2);
Assert.AreEqual(bucket.ToArray(), new TimeoutItem[0]);
}
}
public void SchemaParser_GetQueryTrace_When_First_QueryAsync_Fails_Exception_Should_Propagate()
{
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny <bool>()))
.Returns(() => TaskHelper.FromException <IEnumerable <Row> >(new Exception("Test exception")));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask(Enumerable.Empty <Row>()));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
var ex = Assert.Throws <Exception>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer)));
Assert.AreEqual("Test exception", ex.Message);
timer.Dispose();
}
public void WheelTimer_Bucket_Should_Remove_Head_Items_Correctly()
{
using (var timer = new HashedWheelTimer(500, 10))
{
var bucket = new Bucket();
var t1 = new TimeoutItem(timer, EmptyAction, null);
var t2 = new TimeoutItem(timer, EmptyAction, null);
var t3 = new TimeoutItem(timer, EmptyAction, null);
var t4 = new TimeoutItem(timer, EmptyAction, null);
bucket.Add(t1);
CollectionAssert.AreEqual(bucket.ToArray(), new[] {t1});
Assert.AreEqual(bucket.Tail, t1);
bucket.Add(t2);
CollectionAssert.AreEqual(bucket.ToArray(), new[] {t1, t2});
Assert.AreEqual(bucket.Tail, t2);
bucket.Add(t3);
CollectionAssert.AreEqual(bucket.ToArray(), new[] {t1, t2, t3});
Assert.AreEqual(bucket.Tail, t3);
bucket.Add(t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] {t1, t2, t3, t4});
Assert.AreEqual(bucket.Tail, t4);
bucket.Remove(t1);
CollectionAssert.AreEqual(bucket.ToArray(), new[] {t2, t3, t4});
Assert.AreEqual(bucket.Tail, t4);
bucket.Remove(t3);
CollectionAssert.AreEqual(bucket.ToArray(), new[] {t2, t4});
Assert.AreEqual(bucket.Tail, t4);
bucket.Remove(t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] {t2});
Assert.AreEqual(bucket.Tail, t2);
bucket.Remove(t2);
Assert.AreEqual(bucket.ToArray(), new TimeoutItem[0]);
}
}
public void TestNewTimeoutShouldStopThrowingRejectedExecutionExceptionWhenExistingTimeoutIsCancelled()
{
var tickDurationMs = 100;
var timer = new HashedWheelTimer(TimeSpan.FromMilliseconds(tickDurationMs), 32, 2);
timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromSeconds(5));
var timeoutToCancel = timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromSeconds(5));
Assert.True(timeoutToCancel.Cancel());
Thread.Sleep(tickDurationMs * 5);
var secondLatch = new CountdownEvent(1);
timer.NewTimeout(CreateCountdownEventTimerTask(secondLatch), TimeSpan.FromMilliseconds(90));
secondLatch.Wait();
timer.StopAsync().Wait();
}
public void HashedWheelTimer_Should_Not_Execute_Cancelled()
{
//Schedule 3 actions
//sleep a couple of ms
//Cancel one of them
//Check that it has not been executed
using (var timer = new HashedWheelTimer(200, 8))
{
var flag = 0;
timer.NewTimeout(_ => flag += 1, null, 500);
var timeout2 = timer.NewTimeout(_ => flag += 2, null, 500);
timer.NewTimeout(_ => flag += 4, null, 500);
Thread.Sleep(300);
timeout2.Cancel();
Thread.Sleep(800);
Assert.AreEqual(5, flag);
timer.Dispose();
}
}
public void TestActivePendingTimeoutsShouldBeZero()
{
CountdownEvent barrier = new CountdownEvent(1);
var timer = new HashedWheelTimer();
var t1 = timer.ScheduleTimeout(EmptyCallback(), TimeSpan.FromMinutes(100));
var t2 = timer.ScheduleTimeout(EmptyCallback(), TimeSpan.FromMinutes(100));
timer.ScheduleTimeout(() =>
{
barrier.Signal();
}, TimeSpan.FromMilliseconds(90));
Assert.Equal(3, timer.ActiveTimeoutsCount);
Assert.True(t1.TryCancel());
Assert.True(t2.TryCancel());
barrier.Wait();
Assert.Equal(0, timer.ActiveTimeoutsCount);
timer.Stop();
}
public void TestRejectedExecutionExceptionWhenTooManyTimeoutsAreAddedBackToBack()
{
var timer = new HashedWheelTimer(TimeSpan.FromMilliseconds(100), 32, 2);
timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromSeconds(5));
timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromSeconds(5));
try
{
timer.NewTimeout(CreateNoOpTimerTask(), TimeSpan.FromMilliseconds(1));
Assert.True(false, "Timer allowed adding 3 timeouts when maxPendingTimeouts was 2");
}
catch (RejectedExecutionException)
{
// Expected
}
finally
{
timer.StopAsync().Wait();
}
}
/// <summary>
/// Creates a new instance. This class is also used to shareable a context across all instance that are created below one Cluster instance.
/// One configuration instance per Cluster instance.
/// </summary>
internal Configuration(Policies policies,
ProtocolOptions protocolOptions,
PoolingOptions poolingOptions,
SocketOptions socketOptions,
ClientOptions clientOptions,
IAuthProvider authProvider,
IAuthInfoProvider authInfoProvider,
QueryOptions queryOptions,
IAddressTranslator addressTranslator,
IStartupOptionsFactory startupOptionsFactory,
ISessionFactoryBuilder <IInternalCluster, IInternalSession> sessionFactoryBuilder,
IRequestHandlerFactory requestHandlerFactory = null,
IHostConnectionPoolFactory hostConnectionPoolFactory = null,
IRequestExecutionFactory requestExecutionFactory = null,
IConnectionFactory connectionFactory = null,
IControlConnectionFactory controlConnectionFactory = null)
{
AddressTranslator = addressTranslator ?? throw new ArgumentNullException(nameof(addressTranslator));
QueryOptions = queryOptions ?? throw new ArgumentNullException(nameof(queryOptions));
Policies = policies;
ProtocolOptions = protocolOptions;
PoolingOptions = poolingOptions;
SocketOptions = socketOptions;
ClientOptions = clientOptions;
AuthProvider = authProvider;
AuthInfoProvider = authInfoProvider;
StartupOptionsFactory = startupOptionsFactory;
SessionFactoryBuilder = sessionFactoryBuilder;
RequestHandlerFactory = requestHandlerFactory ?? new RequestHandlerFactory();
HostConnectionPoolFactory = hostConnectionPoolFactory ?? new HostConnectionPoolFactory();
RequestExecutionFactory = requestExecutionFactory ?? new RequestExecutionFactory();
ConnectionFactory = connectionFactory ?? new ConnectionFactory();
ControlConnectionFactory = controlConnectionFactory ?? new ControlConnectionFactory();
// Create the buffer pool with 16KB for small buffers and 256Kb for large buffers.
// The pool does not eagerly reserve the buffers, so it doesn't take unnecessary memory
// to create the instance.
BufferPool = new RecyclableMemoryStreamManager(16 * 1024, 256 * 1024, ProtocolOptions.MaximumFrameLength);
Timer = new HashedWheelTimer();
}
public void WheelTimer_Bucket_Should_Support_Add_And_Remove()
{
using (var timer = new HashedWheelTimer(500, 10))
{
var bucket = new Bucket();
Assert.Null(bucket.Head);
var t1 = new TimeoutItem(timer, EmptyAction, null);
var t2 = new TimeoutItem(timer, EmptyAction, null);
var t3 = new TimeoutItem(timer, EmptyAction, null);
var t4 = new TimeoutItem(timer, EmptyAction, null);
var t5 = new TimeoutItem(timer, EmptyAction, null);
var t6 = new TimeoutItem(timer, EmptyAction, null);
bucket.Add(t1);
bucket.Add(t2);
bucket.Add(t3);
bucket.Add(t4);
Assert.AreEqual(bucket.Head, t1);
Assert.AreEqual(bucket.Tail, t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1, t2, t3, t4 });
bucket.Remove(t3);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1, t2, t4 });
Assert.AreEqual(t2.Next, t4);
Assert.AreEqual(t4.Previous, t2);
bucket.Remove(t1);
Assert.AreEqual(bucket.Head, t2);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t4 });
bucket.Add(t5);
Assert.AreEqual(bucket.Tail, t5);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t4, t5 });
bucket.Add(t6);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t4, t5, t6 });
bucket.Remove(t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t5, t6 });
bucket.Remove(t2);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t5, t6 });
bucket.Remove(t6);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t5 });
bucket.Remove(t5);
CollectionAssert.AreEqual(bucket.ToArray(), new TimeoutItem[0]);
}
}
public void WheelTimer_Bucket_Should_Support_Add_And_Remove()
{
using (var timer = new HashedWheelTimer(500, 10))
{
var bucket = new Bucket();
Assert.Null(bucket.Head);
var t1 = new TimeoutItem(timer, EmptyAction, null);
var t2 = new TimeoutItem(timer, EmptyAction, null);
var t3 = new TimeoutItem(timer, EmptyAction, null);
var t4 = new TimeoutItem(timer, EmptyAction, null);
var t5 = new TimeoutItem(timer, EmptyAction, null);
var t6 = new TimeoutItem(timer, EmptyAction, null);
bucket.Add(t1);
bucket.Add(t2);
bucket.Add(t3);
bucket.Add(t4);
Assert.AreEqual(bucket.Head, t1);
Assert.AreEqual(bucket.Tail, t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1, t2, t3, t4 });
bucket.Remove(t3);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t1, t2, t4 });
Assert.AreEqual(t2.Next, t4);
Assert.AreEqual(t4.Previous, t2);
bucket.Remove(t1);
Assert.AreEqual(bucket.Head, t2);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t4 });
bucket.Add(t5);
Assert.AreEqual(bucket.Tail, t5);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t4, t5 });
bucket.Add(t6);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t4, t5, t6 });
bucket.Remove(t4);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t2, t5, t6 });
bucket.Remove(t2);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t5, t6 });
bucket.Remove(t6);
CollectionAssert.AreEqual(bucket.ToArray(), new[] { t5 });
bucket.Remove(t5);
CollectionAssert.AreEqual(bucket.ToArray(), new TimeoutItem[0]);
}
}
public void SchemaParser_GetQueryTrace_Should_Query_Traces_Tables()
{
var sessionRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "duration", 10 },
{ "request", "test query" },
{ "coordinator", IPAddress.Parse("192.168.12.13") },
{ "parameters", null },
{ "started_at", DateTimeOffset.Now }
});
var eventRow = TestHelper.CreateRow(new Dictionary <string, object>
{
{ "activity", "whatever" },
{ "event_id", TimeUuid.NewId() },
{ "source_elapsed", 100 },
{ "source", IPAddress.Parse("192.168.1.100") },
{ "thread", "thread name" }
});
var queryProviderMock = new Mock <IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { sessionRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny <bool>()))
.Returns(() => TestHelper.DelayedTask <IEnumerable <Row> >(new[] { eventRow }));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
var resultTrace = TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer));
Assert.AreSame(queryTrace, resultTrace);
Assert.Greater(queryTrace.DurationMicros, 0);
Assert.AreEqual("test query", queryTrace.RequestType);
Assert.AreEqual(1, queryTrace.Events.Count);
Assert.AreEqual("whatever", queryTrace.Events.First().Description);
timer.Dispose();
}
public void TimerShouldThrowExceptionAfterShutdownForNewTimeouts()
{
var timer = new HashedWheelTimer();
int count1 = 3;
for (int i = 0; i < 3; i++)
{
timer.NewTimeout(new TimerTask(() => { count1--; }), TimeSpan.FromMilliseconds(1));
}
while (count1 > 0)
{
Thread.Sleep(100);
}
timer.Stop();
Assert.Throws <InvalidOperationException>(() =>
{
timer.NewTimeout(new TimerTask(() => { }), TimeSpan.FromMilliseconds(1));
});
}
public void SchemaParser_GetQueryTrace_When_First_QueryAsync_Fails_Exception_Should_Propagate()
{
var queryProviderMock = new Mock<IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny<bool>()))
.Returns(() => TaskHelper.FromException<IEnumerable<Row>>(new Exception("Test exception")));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny<bool>()))
.Returns(() => TestHelper.DelayedTask(Enumerable.Empty<Row>()));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
var ex = Assert.Throws<Exception>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer)));
Assert.AreEqual("Test exception", ex.Message);
timer.Dispose();
}
public void HashedWheelTimer_Should_Not_Execute_Cancelled()
{
//Schedule 3 actions
//sleep a couple of ms
//Cancel one of them
//Check that it has not been executed
var timer = new HashedWheelTimer(200, 8);
var flag = 0;
timer.NewTimeout(() => flag += 1, 500);
var timeout2 = timer.NewTimeout(() => flag += 2, 500);
timer.NewTimeout(() => flag += 4, 500);
Thread.Sleep(300);
timeout2.Cancel();
Thread.Sleep(800);
Assert.AreEqual(5, flag);
timer.Dispose();
}
public void SchemaParser_GetQueryTrace_When_Second_QueryAsync_Fails_Exception_Should_Propagate()
{
var sessionRow = TestHelper.CreateRow(new Dictionary<string, object>
{
{"duration", 10},
{"request", "test query"},
{"coordinator", IPAddress.Parse("192.168.12.13")},
{"parameters", null},
{"started_at", DateTimeOffset.Now}
});
var queryProviderMock = new Mock<IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny<bool>()))
.Returns(() => TestHelper.DelayedTask<IEnumerable<Row>>(new[] { sessionRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny<bool>()))
.Returns(() => TaskHelper.FromException<IEnumerable<Row>>(new Exception("Test exception 2")));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
var ex = Assert.Throws<Exception>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer)));
Assert.AreEqual("Test exception 2", ex.Message);
timer.Dispose();
}
public void SpeculativeExecution_With_Multiple_Nodes_Pausing()
{
_testCluster = TestClusterManager.GetNonShareableTestCluster(3, 1, true, false);
var session = GetSession(new ConstantSpeculativeExecutionPolicy(50L, 1));
var timer = new HashedWheelTimer(1000, 64);
timer.NewTimeout(_ => Task.Factory.StartNew(() => _testCluster.PauseNode(2)), null, 2000);
//2 secs after resume node2
timer.NewTimeout(_ => Task.Factory.StartNew(() => _testCluster.ResumeNode(2)), null, 4000);
timer.NewTimeout(_ => Task.Factory.StartNew(() => _testCluster.PauseNode(1)), null, 6000);
//4 secs after resume node1
timer.NewTimeout(_ => Task.Factory.StartNew(() => _testCluster.ResumeNode(1)), null, 10000);
var finished = false;
timer.NewTimeout(_ => Task.Factory.StartNew(() => finished = true), null, 12000);
//64 constant concurrent requests
var semaphore = new SemaphoreSlim(64);
while (!finished)
{
TestHelper.ParallelInvoke(() =>
{
semaphore.Wait();
session.Execute(new SimpleStatement(QueryLocal).SetIdempotence(true));
semaphore.Release();
}, 512);
}
Thread.Sleep(1000);
timer.Dispose();
}
public void SchemaParser_GetQueryTrace_Should_Not_Try_More_Than_Max_Attempts()
{
var counter = 0;
var queryProviderMock = new Mock<IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny<bool>()))
.Returns(() =>
{
counter++;
var sessionRow = TestHelper.CreateRow(new Dictionary<string, object>
{
{"duration", null },
{"request", "test query "},
{"coordinator", IPAddress.Parse("192.168.12.13")},
{"parameters", null},
{"started_at", DateTimeOffset.Now}
});
return TestHelper.DelayedTask<IEnumerable<Row>>(new[] { sessionRow });
});
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny<bool>()))
.Returns(() => TaskHelper.ToTask(Enumerable.Empty<Row>()));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
Assert.Throws<TraceRetrievalException>(() => TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer)));
Assert.AreEqual(counter, 5);
timer.Dispose();
}
/// <summary>
/// Cancels the previous and set the next reconnection timeout, as an atomic operation.
/// </summary>
private void SetReconnectionTimeout(HashedWheelTimer.ITimeout nextTimeout)
{
var timeout = Interlocked.Exchange(ref _timeout, nextTimeout);
if (timeout != null)
{
timeout.Cancel();
}
}
public void SchemaParser_GetQueryTrace_Should_Query_Traces_Tables()
{
var sessionRow = TestHelper.CreateRow(new Dictionary<string, object>
{
{"duration", 10},
{"request", "test query"},
{"coordinator", IPAddress.Parse("192.168.12.13")},
{"parameters", null},
{"started_at", DateTimeOffset.Now}
});
var eventRow = TestHelper.CreateRow(new Dictionary<string, object>
{
{"activity", "whatever"},
{"event_id", TimeUuid.NewId()},
{"source_elapsed", 100 },
{"source", IPAddress.Parse("192.168.1.100")},
{"thread", "thread name"}
});
var queryProviderMock = new Mock<IMetadataQueryProvider>(MockBehavior.Strict);
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.sessions"), It.IsAny<bool>()))
.Returns(() => TestHelper.DelayedTask<IEnumerable<Row>>(new[] { sessionRow }));
queryProviderMock
.Setup(cc => cc.QueryAsync(It.IsRegex("system_traces\\.events"), It.IsAny<bool>()))
.Returns(() => TestHelper.DelayedTask<IEnumerable<Row>>(new[] { eventRow }));
var queryTrace = GetQueryTrace();
var parser = GetV1Instance(queryProviderMock.Object);
var timer = new HashedWheelTimer();
var resultTrace = TaskHelper.WaitToComplete(parser.GetQueryTrace(queryTrace, timer));
Assert.AreSame(queryTrace, resultTrace);
Assert.Greater(queryTrace.DurationMicros, 0);
Assert.AreEqual("test query", queryTrace.RequestType);
Assert.AreEqual(1, queryTrace.Events.Count);
Assert.AreEqual("whatever", queryTrace.Events.First().Description);
timer.Dispose();
}
public void HashedWheelTimer_Cancelled_Should_Be_Removed_From_Bucket()
{
using (var timer = new HashedWheelTimer(200, 8))
{
var flag = 0;
timer.NewTimeout(_ => flag += 1, null, 500);
//this callback should never be executed
var timeout2 = (TimeoutItem)timer.NewTimeout(_ => flag += 2, null, 500);
timer.NewTimeout(_ => flag += 4, null, 500);
Thread.Sleep(300);
Assert.NotNull(timeout2.Bucket);
timeout2.Cancel();
Thread.Sleep(800);
Assert.Null(timeout2.Bucket);
Assert.AreEqual(5, flag);
timer.Dispose();
}
}