private static void CreateWindowInstance(ControlTestRequest request, ManualResetEventSlim evt) {
try {
Window = new Window();
if (Screen.AllScreens.Length == 1) {
Window.Left = 0;
Window.Top = 50;
} else {
Screen secondary = Screen.AllScreens.FirstOrDefault(x => !x.Primary);
Window.Left = secondary.WorkingArea.Left;
Window.Top = secondary.WorkingArea.Top + 50;
}
Window.Width = 800;
Window.Height = 600;
Component = Activator.CreateInstance(request.ControlType);
if (Component is Control) {
Control = Component as Control;
} else {
Control = Component.GetType().GetProperty("Control").GetValue(Component) as Control;
}
Window.Title = "Control - " + request.ControlType;
Window.Content = Control;
} finally {
evt.Set();
}
Window.Topmost = true;
Window.ShowDialog();
}
public void If_execution_takes_longer_than_period_it_triggers_next_execution_immediately_after_previous()
{
var counter = 0;
var failure = false;
var lastEndTime = DateTime.MinValue;
var @event = new ManualResetEventSlim(false);
var delay = TimeSpan.Zero;
var executor = new PeriodicExecutor(() =>
{
delay = DateTime.Now - lastEndTime;
if (lastEndTime != DateTime.MinValue && delay > TimeSpan.FromMilliseconds(100))
{
@event.Set();
failure = true;
return;
}
counter++;
Thread.Sleep(2000);
lastEndTime = DateTime.Now;
if (counter == 2)
{
@event.Set();
}
}, TimeSpan.FromSeconds(1));
executor.Start(true);
@event.Wait();
executor.Stop(CancellationToken.None);
Assert.IsFalse(failure, string.Format("Time between finishing previous execution and starting this longer than {0} ms",delay));
}
public void TestLeapPlayerLoop()
{
for (int i = 0; i < 3; i++)
{
var testOver = new ManualResetEventSlim();
var timeoutTimer = new Timer(10000);
var player = new LeapPlayer(@"frames\rotate_1.frames");
player.LoopOutput = true;
var bytesExpected = player.FileSizeInBytes * 3;
Action<Frame> frameListener = frame =>
{
timeoutTimer.Stop();
timeoutTimer.Start();
if (player.TotalBytesRead >= bytesExpected)
{
testOver.Set();
}
};
player.FrameReady += frameListener;
timeoutTimer.Elapsed += (sender, args) => testOver.Set();
player.StartConnection();
timeoutTimer.Start();
testOver.Wait();
player.StopConnection();
Assert.IsTrue(player.TotalBytesRead >= bytesExpected);
}
}
public void MemberRemovedEvent()
{
var reset = new ManualResetEventSlim();
_client.GetCluster().AddMembershipListener(new MembershipListener
{
OnMemberAdded = memberAddedEvent => { reset.Set(); }
});
var member = StartMember(_remoteController, _cluster);
Assert.IsTrue(reset.Wait(30 * 1000));
reset.Reset();
MembershipEvent memberRemovedEvent = null;
_client.GetCluster().AddMembershipListener(new MembershipListener
{
OnMemberRemoved = memberRemoved =>
{
memberRemovedEvent = memberRemoved;
reset.Set();
}
});
StopMember(_remoteController, _cluster, member);
Assert.IsTrue(reset.Wait(30*1000));
Assert.IsInstanceOf<ICluster>(memberRemovedEvent.Source);
Assert.IsInstanceOf<ICluster>(memberRemovedEvent.GetCluster());
Assert.AreEqual(MembershipEvent.MemberRemoved, memberRemovedEvent.GetEventType());
Assert.IsNotNull(memberRemovedEvent.GetMember());
Assert.AreEqual(1, memberRemovedEvent.GetMembers().Count);
}
public void UseSqlNotificationsIfAvailable(bool supportSqlNotifications)
{
// Arrange
var sqlDependencyAdded = false;
var retryLoopCount = 0;
var mre = new ManualResetEventSlim();
var dbProviderFactory = new MockDbProviderFactory();
var dbBehavior = new Mock<IDbBehavior>();
dbBehavior.Setup(db => db.UpdateLoopRetryDelays).Returns(_defaultRetryDelays);
dbBehavior.Setup(db => db.StartSqlDependencyListener()).Returns(supportSqlNotifications);
dbBehavior.Setup(db => db.AddSqlDependency(It.IsAny<IDbCommand>(), It.IsAny<Action<SqlNotificationEventArgs>>()))
.Callback(() =>
{
sqlDependencyAdded = true;
mre.Set();
});
var operation = new ObservableDbOperation("test", "test", new TraceSource("test"), dbProviderFactory, dbBehavior.Object);
operation.Faulted += _ => mre.Set();
operation.Queried += () =>
{
retryLoopCount++;
if (retryLoopCount > 1)
{
mre.Set();
}
};
// Act
ThreadPool.QueueUserWorkItem(_ => operation.ExecuteReaderWithUpdates((record, o) => { }));
mre.Wait();
operation.Dispose();
// Assert
Assert.Equal(supportSqlNotifications, sqlDependencyAdded);
}
/// <summary>
/// Does all the magic of spinning up the bot.
/// </summary>
private static void Main()
{
_logger.Trace("Starting console runner");
try
{
// We may actually not log to the console past this point, so let's go ahead and spam something
// here just in case.
Console.WriteLine("We've spun up the bot and are currently logging to our appenders. Hit CTL+C to quit.");
// We want to know when it's ok to shutdown the bot.
using (var shutdownManualResetEvent = new ManualResetEventSlim(false))
{
// Get our application context from Spring.NET.
var applicationContext = ContextRegistry.GetContext();
// Grab our bean and spin it up.
var bot = applicationContext.GetObject("SpikeLite") as SpikeLite;
// Listen for status changes so we know when to exit
bot.BotStatusChanged += (sender, eventArgs) =>
{
if (eventArgs.NewStatus == BotStatus.Stopped)
// Signal that we're ready to shutdown the bot.
shutdownManualResetEvent.Set();
};
// This won't actually work while we're debugging:
// http://connect.microsoft.com/VisualStudio/feedback/details/524889/debugging-c-console-application-that-handles-console-cancelkeypress-is-broken-in-net-4-0
// Handle SIGTERM gracefully.
Console.CancelKeyPress += ((sender, args) =>
{
// Let us handle the shutdown of the bot
args.Cancel = true;
// Clean up.
bot.Shutdown("Caught SIGTERM, quitting");
// Signal that we're ready to shutdown the bot.
shutdownManualResetEvent.Set();
_logger.Trace("Cancel key pressed. Shutting down bot.");
});
bot.Start();
// Wait untill we're ready to shutdown the bot.
shutdownManualResetEvent.Wait();
_logger.Trace("Application shutting down.");
applicationContext.Dispose();
}
}
catch (Exception ex)
{
_logger.ErrorFormat("Fatal error attempting to start the bot: {0} - {1}", ex.Message, ex.StackTrace);
}
}
protected override void OperateImpl(OperatingContext Context, CancellationToken CancellationToken)
{
using (IProgressController pc = Context.ProgressControllerFactory.CreateController(Progress))
{
pc.SetToIntermediate();
pc.SetDescription(Name);
var re = new ManualResetEventSlim(false);
var t = new Task(() =>
{
while (!re.IsSet)
{
Context.Terminal.WriteLine();
Thread.Sleep(100);
}
});
Stopwatch sw = Stopwatch.StartNew();
while (true)
{
try
{
Context.Surfer.SeekForMatches(Context.Terminal, CancellationToken,
new DelegateExpectation(@"U-Boot", true, Match => t.Start()));
break;
}
catch (TimeoutTerminalException e)
{
if (sw.Elapsed >= _timeout)
throw new CanNotConnectToUBoot(e);
}
}
sw.Stop();
Context.Surfer.SeekForMatches(Context.Terminal, CancellationToken,
new DelegateExpectation(@"NAND:\s+(?<size>\d+) MB", false,
m => Context.NandSize = ulong.Parse(m.Groups["size"].Value) * 1024 * 1024),
new DelegateExpectation(@"NAND read", true,
Match => { throw new UBootInterruptionWasSkippedDnwBurningException(); }),
new DelegateExpectation(@"SMDKC100 #", true, Match =>
{
re.Set();
Context.Terminal.WriteLine();
}));
re.Set();
Context.Surfer.SeekForMatches(Context.Terminal, CancellationToken,
new CommandExpectation(@"SMDKC100 #", Context.Terminal, "version"));
Context.Surfer.SeekForMatches(Context.Terminal, CancellationToken,
new DelegateExpectation(@"U-Boot (?<version>[\d\.]+).*\n", true,
m => CheckUBootVersion(Version.Parse(m.Groups["version"].Value))));
Context.State = ProgrammingContextState.UBoot;
}
}
///<summary>Blocks the current thread until the transaction completes or the timeout expires.</summary>
public static bool WaitForTransactionToComplete(this Transaction me, TimeSpan timeout)
{
Contract.Requires(me != null);
var done = new ManualResetEventSlim();
me.TransactionCompleted += (_, __) => done.Set();
if(me.TransactionInformation.Status != TransactionStatus.Active)
{
done.Set();
}
return done.Wait(timeout);
}
// Demonstrates:
// ManualResetEventSlim construction w/ SpinCount
// ManualResetEventSlim.WaitHandle
static void MRES_SpinCountWaitHandle()
{
// Construct a ManualResetEventSlim with a SpinCount of 1000
// Higher spincount => longer time the MRES will spin-wait before taking lock
System.Threading.ManualResetEventSlim mres1 = new System.Threading.ManualResetEventSlim(false, 1000);
System.Threading.ManualResetEventSlim mres2 = new System.Threading.ManualResetEventSlim(false, 1000);
Task bgTask = Task.Factory.StartNew(() =>
{
// Just wait a little
Thread.Sleep(100);
// Now signal both MRESes
Console.WriteLine("Task signalling both MRESes");
mres1.Set();
mres2.Set();
});
// A common use of MRES.WaitHandle is to use MRES as a participant in
// WaitHandle.WaitAll/WaitAny. Note that accessing MRES.WaitHandle will
// result in the unconditional inflation of the underlying ManualResetEvent.
WaitHandle.WaitAll(new WaitHandle[] { mres1.WaitHandle, mres2.WaitHandle });
Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.");
// Clean up
bgTask.Wait();
mres1.Dispose();
mres2.Dispose();
}
// Demonstrates:
// ManualResetEventSlim construction
// ManualResetEventSlim.Wait()
// ManualResetEventSlim.Set()
// ManualResetEventSlim.Reset()
// ManualResetEventSlim.IsSet
static void MRES_SetWaitReset()
{
System.Threading.ManualResetEventSlim mres1 = new System.Threading.ManualResetEventSlim(false); // initialize as unsignaled
System.Threading.ManualResetEventSlim mres2 = new System.Threading.ManualResetEventSlim(false); // initialize as unsignaled
System.Threading.ManualResetEventSlim mres3 = new System.Threading.ManualResetEventSlim(true); // initialize as signaled
// Start an asynchronous Task that manipulates mres3 and mres2
var observer = Task.Factory.StartNew(() =>
{
mres1.Wait();
Console.WriteLine("observer sees signaled mres1!");
Console.WriteLine("observer resetting mres3...");
mres3.Reset(); // should switch to unsignaled
Console.WriteLine("observer signalling mres2");
mres2.Set();
});
Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet);
Console.WriteLine("main thread signalling mres1");
mres1.Set(); // This will "kick off" the observer Task
mres2.Wait(); // This won't return until observer Task has finished resetting mres3
Console.WriteLine("main thread sees signaled mres2!");
Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet);
// It's good form to Dispose() a ManualResetEventSlim when you're done with it
observer.Wait(); // make sure that this has fully completed
mres1.Dispose();
mres2.Dispose();
mres3.Dispose();
}
static void PrintFooBar(int p)
{
System.Threading.ManualResetEventSlim mres = new System.Threading.ManualResetEventSlim(false); // initialize as unsignaled
System.Threading.ManualResetEventSlim mres2 = new System.Threading.ManualResetEventSlim(true); // initialize as unsignaled
Thread t1 = new Thread(() =>
{
for (int i = 0; i < 20; i++)
{
mres2.Wait();
Console.WriteLine("foo");
mres2.Reset();
mres.Set();
}
}
);
t1.Start();
Thread t2 = new Thread(() =>
{
for (int i = 0; i < 20; i++)
{
mres.Wait();//true
Console.WriteLine("bar");
mres.Reset();
mres2.Set();
}
});
t2.Start();
}
private static void Main(string[] args)
{
var taskOne = Task.Factory.StartNew(() =>
{
Console.WriteLine("Task 1 is starting...");
Thread.Sleep(5000);
ManualResetEventSlim.Set();
Console.WriteLine("Task 1 is completed.");
});
var taskTwo = Task.Factory.StartNew(() =>
{
Console.WriteLine("Task 2 waiting for Task 1 to complete...");
ManualResetEventSlim.Wait();
Console.WriteLine("Task 2 is started...");
Console.WriteLine("All tasks are completed");
});
taskTwo.Wait();
Console.ReadLine();
}
public async void ConnectRetriesOnError()
{
int invokationCount = 0;
var wh = new ManualResetEventSlim();
var redisConnection = GetMockRedisConnection();
var tcs = new TaskCompletionSource<object>();
tcs.TrySetCanceled();
redisConnection.Setup(m => m.ConnectAsync(It.IsAny<string>(), It.IsAny<TraceSource>())).Returns<string, TraceSource>((connectionString, trace) =>
{
if (++invokationCount == 2)
{
wh.Set();
return Task.FromResult(0);
}
else
{
return tcs.Task;
}
});
var redisMessageBus = new RedisMessageBus(GetDependencyResolver(), new RedisScaleoutConfiguration(String.Empty, String.Empty),
redisConnection.Object, false);
await redisMessageBus.ConnectWithRetry();
Assert.True(wh.Wait(TimeSpan.FromSeconds(5)));
Assert.Equal(RedisMessageBus.State.Connected, redisMessageBus.ConnectionState);
}
public void when_sending_message_with_session_then_session_receiver_gets_it()
{
var sender = this.Settings.CreateTopicClient(this.Topic);
var signal = new ManualResetEventSlim();
var body = Guid.NewGuid().ToString();
var receiver = new SessionSubscriptionReceiver(this.Settings, this.Topic, this.Subscription);
sender.Send(new BrokeredMessage(Guid.NewGuid().ToString()));
sender.Send(new BrokeredMessage(body) { SessionId = "foo" });
var received = "";
receiver.Start(
m =>
{
received = m.GetBody<string>();
signal.Set();
return MessageReleaseAction.CompleteMessage;
});
signal.Wait();
receiver.Stop();
Assert.Equal(body, received);
}
public void TriggerBatchTest ()
{
int[] array = null;
var evt = new ManualResetEventSlim (false);
var buffer = new BatchBlock<int> (10);
var block = new ActionBlock<int[]> (i =>
{
array = i;
evt.Set ();
});
buffer.LinkTo (block);
for (int i = 0; i < 9; i++)
Assert.IsTrue (buffer.Post (i));
buffer.TriggerBatch ();
evt.Wait ();
Assert.IsNotNull (array);
Assert.IsTrue (buffer.Post (42));
evt.Wait (1600);
CollectionAssert.AreEquivalent (new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 },
array);
}
public void BasicUsageTest ()
{
int[] array = null;
var evt = new ManualResetEventSlim (false);
var buffer = new BatchBlock<int> (10);
var block = new ActionBlock<int[]> (i =>
{
array = i;
evt.Set ();
});
buffer.LinkTo<int[]> (block);
for (int i = 0; i < 9; i++)
Assert.IsTrue (buffer.Post (i));
Assert.IsFalse (evt.Wait (100));
Assert.IsNull (array);
Assert.IsTrue (buffer.Post (42));
Assert.IsTrue (evt.Wait (1000));
Assert.IsNotNull (array);
CollectionAssert.AreEqual (new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 42 }, array);
}
public void TestAllow()
{
var configSource = StartBootstrap("ConnectionFilter.config");
var serverConfig = configSource.Servers.FirstOrDefault();
var appServer = BootStrap.AppServers.FirstOrDefault() as TestServer;
appServer.NewSessionConnected += m_Server_NewSessionConnected;
EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
{
TestConnectionFilter.Allow = true;
int oldCount = TestConnectionFilter.ConnectedCount;
var signal = new ManualResetEventSlim(false);
ThreadPool.QueueUserWorkItem((o) =>
{
var s = o as Socket;
s.Connect(serverAddress);
signal.Set();
}, socket);
Assert.IsTrue(signal.Wait(2000));
Thread.Sleep(100);
Assert.AreEqual(oldCount + 1, TestConnectionFilter.ConnectedCount);
if (!m_NewSessionConnectedEvent.WaitOne(1000))
Assert.Fail("New session hasnot been accept on time!");
}
}
public void ConnectionErrorCapturesExceptionsThrownInClientHubMethod(HostType hostType, TransportType transportType)
{
using (var host = CreateHost(hostType, transportType))
{
var wh = new ManualResetEventSlim();
Exception thrown = new Exception(),
caught = null;
host.Initialize();
var connection = CreateHubConnection(host);
var proxy = connection.CreateHubProxy("ChatHub");
proxy.On("addMessage", () =>
{
throw thrown;
});
connection.Error += e =>
{
caught = e;
wh.Set();
};
connection.Start(host.Transport).Wait();
proxy.Invoke("Send", "");
Assert.True(wh.Wait(TimeSpan.FromSeconds(5)));
Assert.Equal(thrown, caught);
}
}
public void continuation_error_handling_then_completion()
{
ManualResetEventSlim first = new ManualResetEventSlim(false),
second = new ManualResetEventSlim(false),
third = new ManualResetEventSlim(false);
Exception ex = null;
// each ContinueWith creates a new task
var t = Task.Factory.StartNew(() =>
{
first.Set();
throw new ApplicationException();
//return -5;
})
.ContinueWith(tStart =>
{
second.Set();
ex = tStart.Exception.InnerExceptions.First();
}, TaskContinuationOptions.NotOnRanToCompletion)
.ContinueWith(tStart => third.Set(), TaskContinuationOptions.OnlyOnRanToCompletion);
t.Wait();
Assert.IsTrue(first.IsSet);
Assert.IsTrue(second.IsSet);
Assert.IsTrue(third.IsSet);
Assert.That(ex, Is.InstanceOf<ApplicationException>());
}
/// <summary>
/// Blocking wait for a task, equivalent to calling Task.Wait(),
/// but works around a race in Mono that causes Wait() to hang
/// </summary>
/// <param name="task">The task to wait for</param>
/// <returns>The task</returns>
public static Task WaitForTask(this Task task)
{
// Mono has a race when waiting for a
// task to complete, this workaround
// ensures that the wait call does not hang
if (IsRunningMono)
{
if (!task.IsCompleted)
{
using (var lck = new System.Threading.ManualResetEventSlim(false))
{
task.ContinueWith(x => lck.Set());
// This ensures we never return with
// an incomplete task, but may casue
// some spin waiting
while (!task.IsCompleted)
{
lck.Wait();
}
}
}
}
else
{
try { task.Wait(); }
catch
{
// Don't throw the exception here
// let the caller access the task
}
}
return(task);
}
public void ClientStopsReconnectingAfterDisconnectTimeout(HostType hostType, TransportType transportType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize(keepAlive: 1, disconnectTimeout: 2);
var connection = new Client.Hubs.HubConnection(host.Url);
var reconnectWh = new ManualResetEventSlim();
var disconnectWh = new ManualResetEventSlim();
connection.Reconnecting += () =>
{
reconnectWh.Set();
Assert.Equal(ConnectionState.Reconnecting, connection.State);
};
connection.Closed += () =>
{
disconnectWh.Set();
Assert.Equal(ConnectionState.Disconnected, connection.State);
};
connection.Start(host.Transport).Wait();
host.Shutdown();
Assert.True(reconnectWh.Wait(TimeSpan.FromSeconds(5)));
Assert.True(disconnectWh.Wait(TimeSpan.FromSeconds(5)));
}
}
public void When_command_committed_CompletionTaskSource_is_notified()
{
const int CommandCount = 5;
var leader = CreateNetworkAndGetLeader(3);
var commands = Builder<DictionaryCommand.Set>.CreateListOfSize(CommandCount)
.All()
.With(x => x.Completion = new TaskCompletionSource<object>())
.With(x => x.AssignedIndex = -1)
.Build()
.ToList();
var nonLeaderNode = Nodes.First(x => x.State != RaftEngineState.Leader);
var commitsAppliedEvent = new ManualResetEventSlim();
nonLeaderNode.CommitIndexChanged += (oldIndex, newIndex) =>
{
//CommandCount + 1 --> take into account NOP command that leader sends after election
if (newIndex == CommandCount + 1)
commitsAppliedEvent.Set();
};
commands.ForEach(leader.AppendCommand);
Assert.True(commitsAppliedEvent.Wait(nonLeaderNode.Options.ElectionTimeout * 2));
commands.Should().OnlyContain(cmd => cmd.Completion.Task.Status == TaskStatus.RanToCompletion);
}
public void SubscriptionWithCancelledTaskCanBeDisposed()
{
var dr = new DefaultDependencyResolver();
using (var bus = new MessageBus(dr))
{
var subscriber = new TestSubscriber(new[] { "key" });
var wh = new ManualResetEventSlim();
IDisposable subscription = bus.Subscribe(subscriber, null, async (result, state) =>
{
if (result.Terminal)
{
return false;
}
await Task.Delay(50);
var tcs = new TaskCompletionSource<bool>();
tcs.SetCanceled();
wh.Set();
return await tcs.Task;
}, 10, null);
bus.Publish("me", "key", "hello");
wh.Wait();
subscription.Dispose();
}
}
public static IDisposable RunConnectDisconnect(int connections)
{
var host = new MemoryHost();
host.MapHubs();
for (int i = 0; i < connections; i++)
{
var connection = new Client.Hubs.HubConnection("http://foo");
var proxy = connection.CreateHubProxy("EchoHub");
var wh = new ManualResetEventSlim(false);
proxy.On("echo", _ => wh.Set());
try
{
connection.Start(host).Wait();
proxy.Invoke("Echo", "foo").Wait();
if (!wh.Wait(TimeSpan.FromSeconds(10)))
{
Debugger.Break();
}
}
finally
{
connection.Stop();
}
}
return host;
}
public void events_raised_whilst_consuming_events_should_be_recorded()
{
var waitForConsumption = new ManualResetEventSlim(false);
Transaction consumerTransaction = null;
var eventStore = Substitute.For<EventStore>();
//Because consumers run in background threads, we need to block until complete before we assert.
eventStore.When(_ => _.LogConsumption(Arg.Any<RaisedEvent>(), Arg.Any<ConsumptionLog>())).Do(info =>
{
consumerTransaction =
Transaction.Current;
waitForConsumption.Set();
});
var domain = new TestableDomain(null, null, eventStore);
var key = "test";
domain.Consume(
new RaisedEvent(
new DogRegistered(key, null),
DateTimeOffset.UtcNow));
waitForConsumption.Wait();
var aggregateInfo = domain.AggregateTracker[typeof (Dog), key];
((string) aggregateInfo.Instance.AsDynamic().earbrand).ShouldEqual(key);
aggregateInfo.Lifestate.ShouldEqual(AggregateLifestate.Live);
var recorded = domain.TransactionTracker[consumerTransaction].RecordedEvents;
recorded.Count().ShouldEqual(1);
recorded.First().Event.ShouldBeType<DogIsNotVaccinated>();
}
public void BackgroundHttpRequester_StopAsync_Stops_Current_Active_Request()
{
var cancelled = false;
var mre = new ManualResetEventSlim();
Func<Uri, CancellationToken, bool> processor = (u, c) =>
{
try
{
mre.Wait(c);
}
catch (AggregateException)
{
}
catch (OperationCanceledException)
{
}
mre.Set();
cancelled = c.IsCancellationRequested;
return true;
};
var requester = new BackgroundHttpFuncRequester(processor);
requester.Add(TestHelpers.CreateRequestList(1)[0]);
requester.Start(TimeSpan.FromMilliseconds(10));
Assert.IsFalse(cancelled);
requester.StopAsync().Wait(3000);
Assert.IsTrue(mre.Wait(3000));
Assert.IsTrue(cancelled);
}
public void be_able_to_subscribe_to_empty_db()
{
using (var store = TestConnection.Create(_node.TcpEndPoint))
{
store.ConnectAsync().Wait();
var appeared = new ManualResetEventSlim(false);
var dropped = new CountdownEvent(1);
var subscription = store.SubscribeToAllFrom(null,
false,
(_, x) =>
{
if (!SystemStreams.IsSystemStream(x.OriginalEvent.EventStreamId))
appeared.Set();
},
_ => Log.Info("Live processing started."),
(_, __, ___) => dropped.Signal());
Thread.Sleep(100); // give time for first pull phase
store.SubscribeToAllAsync(false, (s, x) => { }, (s, r, e) => { }).Wait();
Thread.Sleep(100);
Assert.IsFalse(appeared.Wait(0), "Some event appeared.");
Assert.IsFalse(dropped.Wait(0), "Subscription was dropped prematurely.");
subscription.Stop(Timeout);
Assert.IsTrue(dropped.Wait(Timeout));
}
}
public void PushTryPop(int producerThreads, int consumerThreads)
{
var stack = new ConcurrentStack<int>();
var startEvent = new ManualResetEventSlim(false);
var finished = 0;
var stop = false;
var producerTasks = Enumerable.Range(0, producerThreads).Select(i => Task.Factory.StartNew(() =>
{
var count = iterations/producerThreads;
startEvent.Wait();
for (var j = 0; j < count; j++)
stack.Push(0);
Interlocked.Increment(ref finished);
if (finished >= producerThreads) stop = true;
}, TaskCreationOptions.LongRunning)).ToArray();
var consumerTasks = Enumerable.Range(0, consumerThreads).Select(i => Task.Factory.StartNew(() =>
{
int num;
startEvent.Wait();
while (!stop) stack.TryPop(out num);
}, TaskCreationOptions.LongRunning)).ToArray();
var stopwatch = Stopwatch.StartNew();
startEvent.Set();
stop = true;
Task.WaitAll(producerTasks);
Task.WaitAll(consumerTasks);
stopwatch.StopAndLog(iterations);
}
private static void FunWithMRE()
{
ManualResetEventSlim mre = new ManualResetEventSlim();
//MRE mre = new MRE();
mre.WaitAsync().ContinueWith(t => CW("Wait 1 complete"));
mre.WaitAsync().ContinueWith(t => CW("Wait 2 complete"));
mre.WaitAsync().ContinueWith(t => CW("Wait 3 complete"));
WaitUntilKey("set");
mre.Set();
mre.WaitAsync().ContinueWith(t => CW("Wait 4 complete"));
mre.WaitAsync().ContinueWith(t => CW("Wait 5 complete"));
mre.WaitAsync().ContinueWith(t => CW("Wait 6 complete"));
//WaitUntilKey("reset");
mre.Reset();
mre.WaitAsync().ContinueWith(t => CW("Wait 7 complete"));
mre.WaitAsync().ContinueWith(t => CW("Wait 8 complete"));
mre.WaitAsync().ContinueWith(t => CW("Wait 9 complete"));
WaitUntilKey("set again");
mre.Set();
}
public ETradeDispatcher(Action<Exception> errorHandler)
: base(errorHandler)
{
const int num = 2; //num of Add() calls below
var count = 0;
var done = new ManualResetEventSlim(false);
Action report = delegate
{
if (Interlocked.Increment(ref count) == num)
done.Set();
};
int idmain, iddom;
idmain = iddom = 0;
Add(() =>
{
idmain = Thread.CurrentThread.ManagedThreadId;
report();
}, _eventThreadRequestName);
Add(() =>
{
iddom = Thread.CurrentThread.ManagedThreadId;
report();
}, _eventThreadResponseName);
done.Wait();
_eventThreadRequestId = idmain;
_eventThreadResponseId = iddom;
}
public void MarkActiveStopsConnectionIfCalledAfterExtendedPeriod(HostType hostType, TransportType transportType, MessageBusType messageBusType)
{
using (var host = CreateHost(hostType, transportType))
{
host.Initialize(messageBusType: messageBusType);
var connection = CreateHubConnection(host);
using (connection)
{
var disconnectWh = new ManualResetEventSlim();
connection.Closed += () =>
{
disconnectWh.Set();
};
connection.Start(host.Transport).Wait();
// The MarkActive interval should check the reconnect window. Since this is short it should force the connection to disconnect.
((Client.IConnection)connection).ReconnectWindow = TimeSpan.FromSeconds(1);
Assert.True(disconnectWh.Wait(TimeSpan.FromSeconds(15)), "Closed never fired");
}
}
}
[Test] // bug https://bugzilla.novell.com/show_bug.cgi?id=325368
public void EnabledInElapsed()
{
var elapsedCount = 0;
var mre = new ST.ManualResetEventSlim();
timer = new Timer(50);
timer.AutoReset = false;
timer.Elapsed += (s, e) =>
{
elapsedCount++;
if (elapsedCount == 1)
{
timer.Enabled = true;
}
else if (elapsedCount == 2)
{
mre.Set();
}
};
timer.Start();
Assert.IsTrue(mre.Wait(1000), "#1 re-enabling timer in Elapsed didn't work");
Assert.AreEqual(2, elapsedCount, "#2 wrong elapsedCount");
timer.Stop();
}
public void Client_should_connect_to_server_and_signal_appropriate_callbacks()
{
var connected1 = new ManualResetEventSlim(false);
var connected2 = new ManualResetEventSlim(false);
var ex = ServerHelpers.CreateExecutor();
var server = ServerHelpers.CreateServer();
server.Connected.Subscribe(client =>
{
connected1.Set();
});
server.Started.Subscribe(u =>
{
var client = new SocketClient(ex);
client.Connected.Subscribe( _ =>
{
connected2.Set();
});
client.Disconnected.Subscribe(exn =>
{
throw exn;
});
client.Connect(new IPEndPoint(IPAddress.Loopback, server.BindEndPoint.Port));
});
server.Start();
connected1.AssertWaitFor(5000);
connected2.AssertWaitFor(5000);
server.StopAndAssertStopped();
}
public void OpenCalledOnConnectionRestored()
{
int openInvoked = 0;
var wh = new ManualResetEventSlim();
var redisConnection = GetMockRedisConnection();
var redisMessageBus = new Mock<RedisMessageBus>(GetDependencyResolver(), new RedisScaleoutConfiguration(String.Empty, String.Empty),
redisConnection.Object) { CallBase = true };
redisMessageBus.Setup(m => m.OpenStream(It.IsAny<int>())).Callback(() =>
{
// Open would be called twice - once when connection starts and once when it is restored
if (++openInvoked == 2)
{
wh.Set();
}
});
// Creating an instance to invoke the constructor which starts the connection
var instance = redisMessageBus.Object;
redisConnection.Raise(mock => mock.ConnectionRestored += null, new Exception());
Assert.True(wh.Wait(TimeSpan.FromSeconds(5)));
}
public void Ctor_ThrowsAnException_IfLockCanNotBeGranted()
{
var releaseLock = new ManualResetEventSlim(false);
var lockAcquired = new ManualResetEventSlim(false);
var thread = new Thread(
() => UseConnection(connection1 =>
{
var storage = CreateStorage(connection1);
using (new SqlServerDistributedLock(storage, "exclusive", _timeout))
{
lockAcquired.Set();
releaseLock.Wait();
}
}));
thread.Start();
lockAcquired.Wait();
UseConnection(connection2 =>
{
var storage = CreateStorage(connection2);
Assert.Throws<DistributedLockTimeoutException>(
() =>
{
using (new SqlServerDistributedLock(storage, "exclusive", _timeout))
{
}
});
});
releaseLock.Set();
thread.Join();
}
public async Task WebSocketSendReceiveTest()
{
const int MessageCount = 3;
var sentMessages = new List<string>();
var receivedMessages = new List<string>();
using (var hubConnection = new HubConnection(HubUrl))
{
var wh = new ManualResetEventSlim();
var proxy = hubConnection.CreateHubProxy("StoreWebSocketTestHub");
proxy.On<string>("echo", m =>
{
receivedMessages.Add(m);
if (receivedMessages.Count == MessageCount)
{
wh.Set();
}
});
await hubConnection.Start(new WebSocketTransport());
for (var i = 0; i < MessageCount; i++)
{
var message = "MyMessage" + i;
await proxy.Invoke("Echo", message);
sentMessages.Add(message);
}
await Task.Run(() => wh.Wait(5000));
}
Assert.Equal(sentMessages, receivedMessages);
}
public void Start()
{
try
{
slim.Wait();
slim.Reset();
}
finally
{
slim.Set();
}
}
public void AutoResetEventFalseStopsFiringElapsed ()
{
var elapsedCount = 0;
var mre = new ST.ManualResetEventSlim ();
timer = new Timer (50);
timer.AutoReset = false;
timer.Elapsed += (s, e) =>
{
elapsedCount++;
if (elapsedCount > 1)
mre.Set ();
};
timer.Start ();
Assert.IsFalse (mre.Wait (1000), "#1 AutoReset=false didn't stop firing Elapsed, elapsedCount=" + elapsedCount);
Assert.AreEqual (1, elapsedCount, "#2 wrong elapsedCount");
timer.Stop ();
}
public virtual bool TryGetResponse(out string response, int millisecondsTimeout)
{
var mre = new System.Threading.ManualResetEventSlim(false);
string resp = response = null;
ThreadPool.QueueUserWorkItem(_ => {
resp = GetResponse();
mre.Set();
});
if (mre.Wait(millisecondsTimeout))
{
response = resp;
return(true);
}
else
{
return(false);
}
}
private static void ClientConnect()
{
using (var client = new AsyncSocketConnector())
using (var ready = new System.Threading.ManualResetEventSlim(false))
{
client.FilterChain.AddLast("ssl", new SslFilter("TempCert", null));
client.FilterChain.AddLast("text", new ProtocolCodecFilter(new TextLineCodecFactory()));
client.MessageReceived += (s, e) =>
{
Debug.WriteLine("Client got: " + e.Message);
ready.Set();
};
var session = client.Connect(new IPEndPoint(IPAddress.Loopback, port)).Await().Session;
Debug.WriteLine("Client sending: hello");
session.Write("hello ");
Debug.WriteLine("Client sending: send");
session.Write("send");
ready.Wait(3000);
Assert.IsTrue(ready.IsSet);
ready.Reset();
Assert.IsFalse(ready.IsSet);
Debug.WriteLine("Client sending: hello");
session.Write(IoBuffer.Wrap(Encoding.UTF8.GetBytes("hello \n")));
Debug.WriteLine("Client sending: send");
session.Write(IoBuffer.Wrap(Encoding.UTF8.GetBytes("send\n")));
ready.Wait(3000);
Assert.IsTrue(ready.IsSet);
session.Close(true);
}
}
static async Task Main(string[] args)
{
var cts = new CancellationTokenSource();
// Pass the same token source to the delegate and to the task instance.
Task.Run(() => DoWork(cts.Token), cts.Token);
Console.WriteLine("Press c to cancel, p to pause, or s to start/restart,");
Console.WriteLine("or any other key to exit.");
// New-style UI thread.
bool goAgain = true;
while (goAgain)
{
char ch = Console.ReadKey(true).KeyChar;
switch (ch)
{
case 'c':
// Token can only be canceled once.
cts.Cancel();
break;
case 'p':
mres.Reset();
break;
case 's':
mres.Set();
break;
default:
goAgain = false;
break;
}
Thread.Sleep(100);
}
cts.Dispose();
}
public override void Send(SendOrPostCallback d, object state)
{
if (Thread.CurrentThread != m_thread)
{
using (var signal = new System.Threading.ManualResetEventSlim())
{
Post(
(s) =>
{
d(s);
signal.Set();
},
state
);
signal.Wait();
}
}
else
{
d(state);
}
}
// Thread Pump for IRC messages
private void _MessagePump()
{
ServerNumericReply snr = new ServerNumericReply();
ChatMessage msg = new ChatMessage();
msg.Nick = Nick;
snr.Nick = Nick;
while (_ircTcpClient.Connected && _incomingStream.EndOfStream == false)
{
if (_ct.IsCancellationRequested)
{
break;
}
string _incoming = null;
try
{
_incoming = _incomingStream.ReadLine();
}
catch (Exception e)
{
badimebot.Program.ConsoleError("Error Reading from server", e);
System.Threading.Thread.Sleep(50);
if (_ircTcpClient.Connected == false)
{
lock (_lockobject)
{
_state = ConnectionState.Disconnected;
}
Reconnect();
}
else
{
break; // Connected but got a weird error, bail out
}
}
if (_incoming == null)
{
badimebot.Program.ConsoleError("Read blank line from irc server");
break; // end?
}
irclog.WriteLine(_incoming);
// Parse and fire events
if (_incoming.StartsWith("PING"))
{
WriteToServerStream($"PONG {_incoming.Substring(5)}");
}
else
if (snr.TryParse(_incoming))
{
if (snr.ReplyCode == 266)
{
_server_message_connected = true; // Set volatile flag that indicates connection complete and join established
}
if (_LookingforServerResponse && snr.ReplyCode == _LookingforServerResponseCode)
{
_LookingforServerResponse = false;
_LookingforServerResponseEvent.Set();
}
}
else
if (_incoming.Contains("PRIVMSG") && msg.TryParse(_incoming))
{
if (msg.Channel == null)
{
this.PrivateMessageReceived?.Invoke(this, new MessageArgs()
{
From = msg.From, Message = msg.Message
});
}
else
{
this.ChannelMessageReceived?.Invoke(this, new MessageArgs()
{
From = msg.From, Message = msg.Message, Channel = msg.Channel
});
}
}
else
{
// ??
badimebot.Program.ConsoleError($"Unknown server message: {_incoming}");
}
//System.Threading.Thread.Sleep(20);
System.Threading.Thread.Yield();
}
Console.WriteLine("Message pump finished");
}
//
// Taking the Upgradable read lock is like taking a read lock
// but we limit it to a single upgradable at a time.
//
public bool TryEnterUpgradeableReadLock(int millisecondsTimeout)
{
var ctstate = CurrentThreadState;
if (CheckState(ctstate, millisecondsTimeout, LockState.Upgradable))
{
++ctstate.UpgradeableRecursiveCount;
return(true);
}
if (ctstate.LockState.Has(LockState.Read))
{
throw new LockRecursionException("The current thread has already entered read mode");
}
++_numUpgradeWaiters;
var start = millisecondsTimeout == -1 ? 0 : _stopwatch.ElapsedMilliseconds;
var taken = false;
var success = false;
// We first try to obtain the upgradeable right
try
{
while (!_upgradableEvent.IsSet() || !taken)
{
try
{
}
finally
{
taken = _upgradableTaken.TryRelaxedSet();
}
if (taken)
{
break;
}
if (millisecondsTimeout != -1 && (_stopwatch.ElapsedMilliseconds - start) > millisecondsTimeout)
{
--_numUpgradeWaiters;
return(false);
}
_upgradableEvent.Wait(ComputeTimeout(millisecondsTimeout, start));
}
_upgradableEvent.Reset();
RuntimeHelpers.PrepareConstrainedRegions();
try
{
// Then it's a simple reader lock acquiring
TryEnterReadLock(ComputeTimeout(millisecondsTimeout, start), ref success);
}
finally
{
if (success)
{
ctstate.LockState |= LockState.Upgradable;
ctstate.LockState &= ~LockState.Read;
--ctstate.ReaderRecursiveCount;
++ctstate.UpgradeableRecursiveCount;
}
else
{
_upgradableTaken.Value = false;
_upgradableEvent.Set();
}
}
--_numUpgradeWaiters;
}
catch (Exception ex)
{
GC.KeepAlive(ex);
// An async exception occured, if we had taken the upgradable mode, release it
_upgradableTaken.Value &= (!taken || success);
}
return(success);
}
void GatherNewEvents()
{
var log = Log.ScopeStart($"gathering new events");
long eventIdStart;
using (var data = db.NewContext) eventIdStart = data.Events.OrderByDescending(e => e.TawId).Take(1).Select(e => e.TawId).FirstOrDefault();
// if (eventIdStart == default(long)) eventIdStart = 0; // 65000 is theoretically enough, it is about 1 year back, but sometimes we want more
var doBreak = new System.Threading.ManualResetEventSlim();
var tasks = new List <Task>();
var pauseEachXEvents = 1;
for (long i = 1; i < 100000; i++)
{
long eventId = eventIdStart + i;
if (ShouldSkipEvent(eventId))
{
continue;
}
// TODO:
// a clever algorithm that works on ranges, e.g: try eventId+2 eventId+4 .. eventId+1024,
// then eventId+1024-2 eventId+1024-4 eventId+1024-128
// find the next event that works by checking suitable ranges
if (doBreak.IsSet)
{
break;
}
var task = Task.Run(async() =>
{
if (doBreak.IsSet)
{
return;
}
var result = await dataParser.ParseEventData(log, eventId);
if (result == WebDataParser.ParseEventResult.InvalidUriShouldRetry)
{
await Task.Delay(500);
if (doBreak.IsSet)
{
return;
}
result = await dataParser.ParseEventData(log, eventId);
if (result == WebDataParser.ParseEventResult.InvalidUriShouldRetry)
{
await Task.Delay(500);
if (doBreak.IsSet)
{
return;
}
result = await dataParser.ParseEventData(log, eventId);
if (result == WebDataParser.ParseEventResult.InvalidUriShouldRetry)
{
log.Warn("retried to parse event taw id:" + eventId + " already 3 times, failed all of them, probably last event, stopping event parsing");
doBreak.Set();
}
}
}
else
{
if (pauseEachXEvents <= 100)
{
Interlocked.Increment(ref pauseEachXEvents); // successfull, lets parse more at the same time
}
}
});
tasks.Add(task);
if (i % pauseEachXEvents == 0)
{
tasks.WaitAll(Log);
tasks.Clear();
}
}
tasks.WaitAll(Log);
log.End();
}
public void Dispose()
{
_Disposed = true;
Thread.MemoryBarrier();
_WaiterSignal.Set();
}
