private bool IsServerRunning()
{
if (Mutex.TryOpenExisting(MutexName.GetServerMutexName(Pipe.Value()), out var mutex))
{
mutex.Dispose();
return(true);
}
return(false);
}
protected override Task <int> ExecuteCoreAsync()
{
// Make sure there's only one server with the same identity at a time.
var serverMutexName = MutexName.GetServerMutexName(Pipe.Value());
Mutex serverMutex = null;
var holdsMutex = false;
try
{
serverMutex = new Mutex(initiallyOwned: true, name: serverMutexName, createdNew: out holdsMutex);
}
catch (Exception ex)
{
// The Mutex constructor can throw in certain cases. One specific example is docker containers
// where the /tmp directory is restricted. In those cases there is no reliable way to execute
// the server and we need to fall back to the command line.
// Example: https://github.com/dotnet/roslyn/issues/24124
Error.Write($"Server mutex creation failed. {ex.Message}");
return(Task.FromResult(-1));
}
if (!holdsMutex)
{
// Another server is running, just exit.
Error.Write("Another server already running...");
return(Task.FromResult(1));
}
FileStream pidFileStream = null;
try
{
try
{
// Write the process and pipe information to a file in a well-known location.
pidFileStream = WritePidFile();
}
catch (Exception ex)
{
// Something happened when trying to write to the pid file. Log and move on.
ServerLogger.LogException(ex, "Failed to create PID file.");
}
TimeSpan?keepAlive = null;
if (KeepAlive.HasValue() && int.TryParse(KeepAlive.Value(), out var result))
{
// Keep alive times are specified in seconds
keepAlive = TimeSpan.FromSeconds(result);
}
var host = ConnectionHost.Create(Pipe.Value());
var compilerHost = CompilerHost.Create();
ExecuteServerCore(host, compilerHost, Cancelled, eventBus: null, keepAlive: keepAlive);
}
finally
{
serverMutex.ReleaseMutex();
serverMutex.Dispose();
pidFileStream?.Close();
}
return(Task.FromResult(0));
}
private static async Task <ServerResponse> RunOnServerCore(
IList <string> arguments,
ServerPaths serverPaths,
string pipeName,
string keepAlive,
int?timeoutOverride,
TryCreateServerCoreDelegate <string, string, int?, bool, bool> tryCreateServerFunc,
CancellationToken cancellationToken,
bool debug)
{
if (pipeName == null)
{
return(new RejectedServerResponse());
}
if (serverPaths.TempDirectory == null)
{
return(new RejectedServerResponse());
}
var clientDir = serverPaths.ClientDirectory;
var timeoutNewProcess = timeoutOverride ?? TimeOutMsNewProcess;
var timeoutExistingProcess = timeoutOverride ?? TimeOutMsExistingProcess;
var clientMutexName = MutexName.GetClientMutexName(pipeName);
Task <Client> pipeTask = null;
Mutex clientMutex = null;
var holdsMutex = false;
try
{
try
{
clientMutex = new Mutex(initiallyOwned: true, name: clientMutexName, createdNew: out holdsMutex);
}
catch (Exception ex)
{
// The Mutex constructor can throw in certain cases. One specific example is docker containers
// where the /tmp directory is restricted. In those cases there is no reliable way to execute
// the server and we need to fall back to the command line.
// Example: https://github.com/dotnet/roslyn/issues/24124
ServerLogger.LogException(ex, "Client mutex creation failed.");
return(new RejectedServerResponse());
}
if (!holdsMutex)
{
try
{
holdsMutex = clientMutex.WaitOne(timeoutNewProcess);
if (!holdsMutex)
{
return(new RejectedServerResponse());
}
}
catch (AbandonedMutexException)
{
holdsMutex = true;
}
}
// Check for an already running server
var serverMutexName = MutexName.GetServerMutexName(pipeName);
var wasServerRunning = WasServerMutexOpen(serverMutexName);
var timeout = wasServerRunning ? timeoutExistingProcess : timeoutNewProcess;
if (wasServerRunning || tryCreateServerFunc(clientDir, pipeName, out var _, debug))
{
pipeTask = Client.ConnectAsync(pipeName, TimeSpan.FromMilliseconds(timeout), cancellationToken);
}
}
finally
{
if (holdsMutex)
{
clientMutex?.ReleaseMutex();
}
clientMutex?.Dispose();
}
if (pipeTask != null)
{
var client = await pipeTask.ConfigureAwait(false);
if (client != null)
{
var request = ServerRequest.Create(
serverPaths.WorkingDirectory,
serverPaths.TempDirectory,
arguments,
keepAlive);
return(await TryProcessRequest(client, request, cancellationToken).ConfigureAwait(false));
}
}
return(new RejectedServerResponse());
}
