public async Task NoServerMutex() { var pipeName = Guid.NewGuid().ToString(); var exitCode = await VBCSCompiler.RunShutdownAsync(pipeName, waitForProcess : false).ConfigureAwait(false); Assert.Equal(CommonCompiler.Succeeded, exitCode); }
public void MutexAcquiredWhenRunningServer() { var mutexName = Guid.NewGuid().ToString("N"); var host = new Mock <IClientConnectionHost>(MockBehavior.Strict); host .Setup(x => x.CreateListenTask(It.IsAny <CancellationToken>())) .Returns(() => { // Use a thread instead of Task to guarantee this code runs on a different // thread and we can validate the mutex state. var source = new TaskCompletionSource <bool>(); var thread = new Thread(_ => { Mutex mutex; Assert.True(Mutex.TryOpenExisting(mutexName, out mutex)); Assert.False(mutex.WaitOne(millisecondsTimeout: 0)); source.SetResult(true); }); // Synchronously wait here. Don't returned a Task value because we need to // ensure the above check completes before the server hits a timeout and // releases the mutex. thread.Start(); source.Task.Wait(); return(new TaskCompletionSource <IClientConnection>().Task); }); var result = VBCSCompiler.Run(mutexName, host.Object, keepAlive: TimeSpan.FromSeconds(1)); Assert.Equal(CommonCompiler.Succeeded, result); }
internal static ServerData CreateServer( string pipeName = null, TimeSpan?timeout = null, ICompilerServerHost compilerServerHost = null) { pipeName = pipeName ?? Guid.NewGuid().ToString(); compilerServerHost = compilerServerHost ?? new DesktopCompilerServerHost(DefaultClientDirectory, DefaultSdkDirectory); var taskSource = new TaskCompletionSource <ServerStats>(); var cts = new CancellationTokenSource(); var thread = new Thread(_ => { var listener = new TestableDiagnosticListener(); try { var clientConnectionHost = new NamedPipeClientConnectionHost(compilerServerHost, pipeName); var mutexName = BuildProtocolConstants.GetServerMutexName(pipeName); VBCSCompiler.Run( mutexName, clientConnectionHost, listener, timeout ?? TimeSpan.FromMilliseconds(-1), cts.Token); } finally { var serverStats = new ServerStats(connections: listener.ConnectionCount, completedConnections: listener.CompletedCount); taskSource.SetResult(serverStats); } }); thread.Start(); return(new ServerData(cts, taskSource.Task, pipeName)); }
public async Task Standard() { using (var serverData = ServerUtil.CreateServer()) { // Make sure the server is listening for this particular test. await serverData.ListenTask; var exitCode = await VBCSCompiler.RunShutdownAsync(serverData.PipeName, waitForProcess : false).ConfigureAwait(false); Assert.Equal(CommonCompiler.Succeeded, exitCode); await serverData.Verify(connections : 1, completed : 1); } }
private Task CreateServerCore(string pipeName) { Action action = () => { var compilerServerHost = new DesktopCompilerServerHost(ClientDirectory, SdkDirectory); var clientConnectionHost = new NamedPipeClientConnectionHost(compilerServerHost, pipeName); var mutexName = $"{pipeName}.server"; VBCSCompiler.Run(mutexName, clientConnectionHost, TimeSpan.FromSeconds(3)); }; var task = new Task(action, TaskCreationOptions.LongRunning); task.Start(TaskScheduler.Default); return(task); }
public async Task ServerShutdownsDuringProcessing() { using (var readyMre = new ManualResetEvent(initialState: false)) using (var doneMre = new ManualResetEvent(initialState: false)) { var pipeName = Guid.NewGuid().ToString(); var mutexName = BuildProtocolConstants.GetServerMutexName(pipeName); bool created = false; bool connected = false; var thread = new Thread(() => { using (var stream = new NamedPipeServerStream(pipeName)) { var mutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out created); readyMre.Set(); stream.WaitForConnection(); connected = true; // Client is waiting for a response. Close the mutex now. Then close the connection // so the client gets an error. mutex.ReleaseMutex(); mutex.Dispose(); stream.Close(); doneMre.WaitOne(); } }); // Block until the mutex and named pipe is setup. thread.Start(); readyMre.WaitOne(); var exitCode = await VBCSCompiler.RunShutdownAsync(pipeName, waitForProcess : false); // Let the fake server exit. doneMre.Set(); thread.Join(); Assert.Equal(CommonCompiler.Succeeded, exitCode); Assert.True(connected); Assert.True(created); } }
public async Task NoServerConnection() { using (var readyMre = new ManualResetEvent(initialState: false)) using (var doneMre = new ManualResetEvent(initialState: false)) { var pipeName = Guid.NewGuid().ToString(); var mutexName = BuildProtocolConstants.GetServerMutexName(pipeName); bool created = false; bool connected = false; var thread = new Thread(() => { using (var mutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out created)) using (var stream = new NamedPipeServerStream(pipeName)) { readyMre.Set(); // Get a client connection and then immediately close it. Don't give any response. stream.WaitForConnection(); connected = true; stream.Close(); doneMre.WaitOne(); mutex.ReleaseMutex(); } }); // Block until the mutex and named pipe is setup. thread.Start(); readyMre.WaitOne(); var exitCode = await VBCSCompiler.RunShutdownAsync(pipeName, waitForProcess : false); // Let the fake server exit. doneMre.Set(); thread.Join(); Assert.Equal(CommonCompiler.Failed, exitCode); Assert.True(connected); Assert.True(created); } }
public void MutexStopsServerStarting() { var mutexName = Guid.NewGuid().ToString("N"); bool holdsMutex; using (var mutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out holdsMutex)) { Assert.True(holdsMutex); try { var host = new Mock <IClientConnectionHost>(MockBehavior.Strict); var result = VBCSCompiler.Run(mutexName, host.Object, keepAlive: null); Assert.Equal(CommonCompiler.Failed, result); } finally { mutex.ReleaseMutex(); } } }
private bool Parse(params string[] args) { return(VBCSCompiler.ParseCommandLine(args, out _pipeName, out _shutdown)); }