internal int RunServer(string pipeName, IClientConnectionHost clientConnectionHost = null, IDiagnosticListener listener = null, TimeSpan? keepAlive = null, CancellationToken cancellationToken = default(CancellationToken)) { keepAlive = keepAlive ?? GetKeepAliveTimeout(); listener = listener ?? new EmptyDiagnosticListener(); clientConnectionHost = clientConnectionHost ?? CreateClientConnectionHost(pipeName); return RunServerCore(pipeName, clientConnectionHost, listener, keepAlive, cancellationToken); }
internal static int Run(string mutexName, IClientConnectionHost connectionHost, TimeSpan? keepAlive) { // Grab the server mutex to prevent multiple servers from starting with the same // pipename and consuming excess resources. If someone else holds the mutex // exit immediately with a non-zero exit code bool holdsMutex; using (var serverMutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out holdsMutex)) { if (!holdsMutex) { return CommonCompiler.Failed; } try { return RunCore(connectionHost, keepAlive); } finally { serverMutex.ReleaseMutex(); } } }
protected override int RunServerCore(string pipeName, IClientConnectionHost connectionHost, IDiagnosticListener listener, TimeSpan? keepAlive, CancellationToken cancellationToken) { // Grab the server mutex to prevent multiple servers from starting with the same // pipename and consuming excess resources. If someone else holds the mutex // exit immediately with a non-zero exit code var mutexName = DesktopBuildClient.GetServerMutexName(pipeName); bool holdsMutex; using (var serverMutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out holdsMutex)) { if (!holdsMutex) { return CommonCompiler.Failed; } try { return base.RunServerCore(pipeName, connectionHost, listener, keepAlive, cancellationToken); } finally { serverMutex.ReleaseMutex(); } } }
protected virtual int RunServerCore(string pipeName, IClientConnectionHost connectionHost, IDiagnosticListener listener, TimeSpan? keepAlive, CancellationToken cancellationToken) { CompilerServerLogger.Log("Keep alive timeout is: {0} milliseconds.", keepAlive?.TotalMilliseconds ?? 0); FatalError.Handler = FailFast.OnFatalException; var dispatcher = new ServerDispatcher(connectionHost, listener); dispatcher.ListenAndDispatchConnections(keepAlive, cancellationToken); return CommonCompiler.Succeeded; }
internal static ServerData CreateServer( string pipeName = null, TimeSpan?timeout = null, ICompilerServerHost compilerServerHost = null, IClientConnectionHost clientConnectionHost = null) { pipeName = pipeName ?? Guid.NewGuid().ToString(); compilerServerHost = compilerServerHost ?? new DesktopCompilerServerHost(DefaultClientDirectory, DefaultSdkDirectory); var serverStatsSource = new TaskCompletionSource <ServerStats>(); var serverListenSource = new TaskCompletionSource <bool>(); var cts = new CancellationTokenSource(); var mutexName = BuildServerConnection.GetServerMutexName(pipeName); var thread = new Thread(_ => { var listener = new TestableDiagnosticListener(); listener.Listening += (sender, e) => { serverListenSource.TrySetResult(true); }; try { clientConnectionHost = clientConnectionHost ?? new NamedPipeClientConnectionHost(compilerServerHost, pipeName); DesktopBuildServerController.RunServer( pipeName, clientConnectionHost, listener, timeout ?? TimeSpan.FromMilliseconds(-1), cts.Token); } finally { var serverStats = new ServerStats(connections: listener.ConnectionCount, completedConnections: listener.CompletedCount); serverStatsSource.SetResult(serverStats); } }); thread.Start(); // The contract of this function is that it will return once the server has started. Spin here until // we can verify the server has started or simply failed to start. while (BuildServerConnection.WasServerMutexOpen(mutexName) != true && thread.IsAlive) { Thread.Yield(); } return(new ServerData(cts, pipeName, serverStatsSource.Task, serverListenSource.Task)); }
internal static async Task <ServerData> CreateServer( ICompilerServerLogger logger, string pipeName = null, ICompilerServerHost compilerServerHost = null, IClientConnectionHost clientConnectionHost = null, TimeSpan?keepAlive = null ) { // The total pipe path must be < 92 characters on Unix, so trim this down to 10 chars pipeName ??= GetPipeName(); compilerServerHost ??= BuildServerController.CreateCompilerServerHost(logger); clientConnectionHost ??= BuildServerController.CreateClientConnectionHost( pipeName, logger ); keepAlive ??= TimeSpan.FromMilliseconds(-1); var listener = new TestableDiagnosticListener(); var serverListenSource = new TaskCompletionSource <bool>(); var cts = new CancellationTokenSource(); var mutexName = BuildServerConnection.GetServerMutexName(pipeName); var task = Task.Run( () => { BuildServerController.CreateAndRunServer( pipeName, compilerServerHost, clientConnectionHost, listener, keepAlive: keepAlive, cancellationToken: cts.Token ); return(listener); } ); // The contract of this function is that it will return once the server has started. Spin here until // we can verify the server has started or simply failed to start. while (BuildServerConnection.WasServerMutexOpen(mutexName) != true && !task.IsCompleted) { await Task.Yield(); } return(new ServerData(cts, pipeName, logger, task)); }
internal int RunServer( string pipeName, string tempPath, IClientConnectionHost clientConnectionHost = null, IDiagnosticListener listener = null, TimeSpan?keepAlive = null, CancellationToken cancellationToken = default(CancellationToken)) { if (GenerationServerConnection.IsPipePathTooLong(pipeName, tempPath)) { return(CommonGenerator.Failed); } keepAlive = keepAlive ?? GetKeepAliveTimeout(); listener = listener ?? new EmptyDiagnosticListener(); clientConnectionHost = clientConnectionHost ?? CreateClientConnectionHost(pipeName); return(RunServerCore(pipeName, clientConnectionHost, listener, keepAlive, cancellationToken)); }
protected override int RunServerCore(string pipeName, IClientConnectionHost connectionHost, IDiagnosticListener listener, TimeSpan?keepAlive, CancellationToken cancellationToken) { // Grab the server mutex to prevent multiple servers from starting with the same // pipename and consuming excess resources. If someone else holds the mutex // exit immediately with a non-zero exit code var mutexName = BuildServerConnection.GetServerMutexName(pipeName); bool createdNew; using (var serverMutex = BuildServerConnection.OpenOrCreateMutex(name: mutexName, createdNew: out createdNew)) { if (!createdNew) { return(CommonCompiler.Failed); } return(base.RunServerCore(pipeName, connectionHost, listener, keepAlive, cancellationToken)); } }
internal static ServerData CreateServer( string pipeName = null, TimeSpan?timeout = null, ICompilerServerHost compilerServerHost = null, IClientConnectionHost clientConnectionHost = null) { pipeName = pipeName ?? Guid.NewGuid().ToString(); compilerServerHost = compilerServerHost ?? new DesktopCompilerServerHost(DefaultClientDirectory, DefaultSdkDirectory); var serverStatsSource = new TaskCompletionSource <ServerStats>(); var serverListenSource = new TaskCompletionSource <bool>(); var cts = new CancellationTokenSource(); var thread = new Thread(_ => { var listener = new TestableDiagnosticListener(); listener.Listening += (sender, e) => { serverListenSource.TrySetResult(true); }; try { clientConnectionHost = 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); serverStatsSource.SetResult(serverStats); } }); thread.Start(); return(new ServerData(cts, pipeName, serverStatsSource.Task, serverListenSource.Task)); }
internal static ServerData CreateServer( string pipeName = null, TimeSpan? timeout = null, ICompilerServerHost compilerServerHost = null, IClientConnectionHost clientConnectionHost = null) { pipeName = pipeName ?? Guid.NewGuid().ToString(); compilerServerHost = compilerServerHost ?? new DesktopCompilerServerHost(DefaultClientDirectory, DefaultSdkDirectory); var serverStatsSource = new TaskCompletionSource<ServerStats>(); var serverListenSource = new TaskCompletionSource<bool>(); var cts = new CancellationTokenSource(); var thread = new Thread(_ => { var listener = new TestableDiagnosticListener(); listener.Listening += (sender, e) => { serverListenSource.TrySetResult(true); }; try { clientConnectionHost = 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); serverStatsSource.SetResult(serverStats); } }); thread.Start(); return new ServerData(cts, pipeName, serverStatsSource.Task, serverListenSource.Task); }
protected override int RunServerCore(string pipeName, IClientConnectionHost connectionHost, IDiagnosticListener listener, TimeSpan?keepAlive, CancellationToken cancellationToken) { // Grab the server mutex to prevent multiple servers from starting with the same // pipename and consuming excess resources. If someone else holds the mutex // exit immediately with a non-zero exit code var mutexName = BuildServerConnection.GetServerMutexName(pipeName); bool holdsMutex; using (var serverMutex = new Mutex(initiallyOwned: true, name: mutexName, createdNew: out holdsMutex)) { if (!holdsMutex) { return(CommonCompiler.Failed); } try { #if XSHARP if (pipeName != null && pipeName.EndsWith("::CS")) { XSharpString.CaseSensitive = true; } else { XSharpString.CaseSensitive = false; } #endif return(base.RunServerCore(pipeName, connectionHost, listener, keepAlive, cancellationToken)); } finally { serverMutex.ReleaseMutex(); } } }
internal ServerDispatcher(ICompilerServerHost compilerServerHost, IClientConnectionHost clientConnectionHost, IDiagnosticListener?diagnosticListener = null) { _compilerServerHost = compilerServerHost; _clientConnectionHost = clientConnectionHost; _diagnosticListener = diagnosticListener ?? new EmptyDiagnosticListener(); }
private static int RunCore(IClientConnectionHost connectionHost, TimeSpan? keepAliveTimeout) { CompilerServerLogger.Log("Keep alive timeout is: {0} milliseconds.", keepAliveTimeout?.TotalMilliseconds ?? 0); FatalError.Handler = FailFast.OnFatalException; var dispatcher = new ServerDispatcher(connectionHost, new EmptyDiagnosticListener()); dispatcher.ListenAndDispatchConnections(keepAliveTimeout); return CommonCompiler.Succeeded; }
public FailingClientConnectionHost(IClientConnectionHost underlyingHost) { _underlyingHost = underlyingHost; }
internal static int Run(string mutexName, IClientConnectionHost connectionHost, TimeSpan?keepAlive, CancellationToken cancellationToken = default(CancellationToken)) { return(Run(mutexName, connectionHost, new EmptyDiagnosticListener(), keepAlive, cancellationToken)); }
internal ServerDispatcher(IClientConnectionHost clientConnectionHost, IDiagnosticListener diagnosticListener = null) { _clientConnectionHost = clientConnectionHost; _diagnosticListener = diagnosticListener ?? new EmptyDiagnosticListener(); }
internal static new int RunServer(string pipeName, IClientConnectionHost clientConnectionHost = null, IDiagnosticListener listener = null, TimeSpan?keepAlive = null, CancellationToken cancellationToken = default(CancellationToken)) { BuildServerController controller = new DesktopBuildServerController(new NameValueCollection()); return(controller.RunServer(pipeName, clientConnectionHost, listener, keepAlive, cancellationToken)); }
internal static new int RunServer(string pipeName, IClientConnectionHost clientConnectionHost = null, IDiagnosticListener listener = null, TimeSpan? keepAlive = null, CancellationToken cancellationToken = default(CancellationToken)) { BuildServerController controller = new DesktopBuildServerController(); return controller.RunServer(pipeName, clientConnectionHost, listener, keepAlive, cancellationToken); }
internal static ServerData CreateServer( string pipeName = null, TimeSpan? timeout = null, ICompilerServerHost compilerServerHost = null, IClientConnectionHost clientConnectionHost = null) { pipeName = pipeName ?? Guid.NewGuid().ToString(); compilerServerHost = compilerServerHost ?? new DesktopCompilerServerHost(DefaultClientDirectory, DefaultSdkDirectory); var serverStatsSource = new TaskCompletionSource<ServerStats>(); var serverListenSource = new TaskCompletionSource<bool>(); var cts = new CancellationTokenSource(); var mutexName = DesktopBuildClient.GetServerMutexName(pipeName); var thread = new Thread(_ => { var listener = new TestableDiagnosticListener(); listener.Listening += (sender, e) => { serverListenSource.TrySetResult(true); }; try { clientConnectionHost = clientConnectionHost ?? new NamedPipeClientConnectionHost(compilerServerHost, pipeName); DesktopBuildServerController.RunServer( pipeName, clientConnectionHost, listener, timeout ?? TimeSpan.FromMilliseconds(-1), cts.Token); } finally { var serverStats = new ServerStats(connections: listener.ConnectionCount, completedConnections: listener.CompletedCount); serverStatsSource.SetResult(serverStats); } }); thread.Start(); // The contract of this function is that it will return once the server has started. Spin here until // we can verify the server has started or simply failed to start. while (DesktopBuildClient.WasServerMutexOpen(mutexName) != true && thread.IsAlive) { Thread.Yield(); } return new ServerData(cts, pipeName, serverStatsSource.Task, serverListenSource.Task); }
internal static int Run(string mutexName, IClientConnectionHost connectionHost, TimeSpan? keepAlive, CancellationToken cancellationToken = default(CancellationToken)) { return Run(mutexName, connectionHost, new EmptyDiagnosticListener(), keepAlive, cancellationToken); }