Single instance dotnetcore cli app on linux

Question

I am interested in how to inforce a single instance policy for dotnetcore console apps. To my surprise it seems like there isn't much out there on the topic. I found this one stacko, How to restrict a program to a single instance, but it doesnt seem to work for me on dotnetcore with ubuntu. Anyone here do this before?

Answer 1

Variation of @MusuNaji's solution at: How to restrict a program to a single instance

    private static bool AlreadyRunning()
    {
        Process[] processes = Process.GetProcesses();
        Process currentProc = Process.GetCurrentProcess();
        logger.LogDebug("Current proccess: {0}", currentProc.ProcessName);
        foreach (Process process in processes)
        {
            if (currentProc.ProcessName == process.ProcessName && currentProc.Id != process.Id)
            {
                logger.LogInformation("Another instance of this process is already running: {pid}", process.Id);
                return true;
            }
        }
        return false;
    }

Answer 2

This is a little more difficult on .NET core than it should be, due to the problem of mutex checking on Linux/MacOS (as reported above). Also Theyouthis's solution isn't helpful as all .NET core apps are run via the CLI which has a process name of 'dotnet' which if you are running multiple .NET core apps on the same machine the duplicate instance check will trigger incorrectly.

A simple way to do this that is also multi-platform robust is to open a file for write when the application starts, and close it at the end. If the file fails to open it is due to another instance running concurrently and you can handle that in the try/catch. Using FileStream to open the file will also create it if it doesn't first exist.

            try
            {
                lockFile = File.OpenWrite("SingleInstance.lck");
            }
            catch (Exception)
            {
                Console.WriteLine("ERROR - Server is already running. End that instance before re-running. Exiting in 5 seconds...");
                System.Threading.Thread.Sleep(5000);
                return;
            }

Answer 3

Here is my implementation using Named pipes. It supports passing arguments from the second instance.

Note: I did not test on Linux or Mac but it should work in theory.

Usage

        public static int Main(string[] args)
        {
            instanceManager = new SingleInstanceManager("8A3B7DE2-6AB4-4983-BBC0-DF985AB56703");
            if (!instanceManager.Start())
            {
                return 0; // exit, if same app is running
            }
            instanceManager.SecondInstanceLaunched += InstanceManager_SecondInstanceLaunched;
            // Initialize app. Below is an example in WPF.
            app = new App();
            app.InitializeComponent();
            return app.Run();
        }
        private static void InstanceManager_SecondInstanceLaunched(object sender, SecondInstanceLaunchedEventArgs e)
        {
            app.Dispatcher.Invoke(() => new MainWindow().Show());
        }

Your Copy-and-paste code

    public class SingleInstanceManager
    {
        private readonly string applicationId;
        public SingleInstanceManager(string applicationId)
        {
            this.applicationId = applicationId;
        }
        /// <summary>
        /// Detect if this is the first instance. If it is, start a named pipe server to listen for subsequent instances. Otherwise, send <see cref="Environment.GetCommandLineArgs()"/> to the first instance.
        /// </summary>
        /// <returns>True if this is tthe first instance. Otherwise, false.</returns>
        public bool Start()
        {
            using var client = new NamedPipeClientStream(applicationId);
            try
            {
                client.Connect(0);
            }
            catch (TimeoutException)
            {
                Task.Run(() => StartListeningServer());
                return true;
            }
            var args = Environment.GetCommandLineArgs();
            using (var writer = new BinaryWriter(client, Encoding.UTF8))
            {
                writer.Write(args.Length);
                for (int i = 0; i < args.Length; i++)
                {
                    writer.Write(args[i]);
                }
            }
            return false;
        }
        private void StartListeningServer()
        {
            var server = new NamedPipeServerStream(applicationId);
            server.WaitForConnection();
            using (var reader = new BinaryReader(server, Encoding.UTF8))
            {
                var argc = reader.ReadInt32();
                var args = new string[argc];
                for (int i = 0; i < argc; i++)
                {
                    args[i] = reader.ReadString();
                }
                SecondInstanceLaunched?.Invoke(this, new SecondInstanceLaunchedEventArgs { Arguments = args });
            }
            StartListeningServer();
        }
        public event EventHandler<SecondInstanceLaunchedEventArgs> SecondInstanceLaunched;
    }
    public class SecondInstanceLaunchedEventArgs
    {
        public string[] Arguments { get; set; }
    }

Unit test

[TestClass]
    public class SingleInstanceManagerTests
    {
        [TestMethod]
        public void SingleInstanceManagerTest()
        {
            var id = Guid.NewGuid().ToString();
            var manager = new SingleInstanceManager(id);
            string[] receivedArguments = null;
            var correctArgCount = Environment.GetCommandLineArgs().Length;
            manager.SecondInstanceLaunched += (sender, e) => receivedArguments = e.Arguments;
            var instance1 = manager.Start();
            Thread.Sleep(200);
            var manager2 = new SingleInstanceManager(id);
            Assert.IsFalse(manager2.Start());
            Thread.Sleep(200);
            Assert.IsTrue(instance1);
            Assert.IsNotNull(receivedArguments);
            Assert.AreEqual(correctArgCount, receivedArguments.Length);
            var receivedArguments2 = receivedArguments;
            var manager3 = new SingleInstanceManager(id);
            Thread.Sleep(200);
            Assert.IsFalse(manager3.Start());
            Assert.AreNotSame(receivedArguments, receivedArguments2);
            Assert.AreEqual(correctArgCount, receivedArguments.Length);
        }
    }

Answer 4

The downside of deandob's solution is that one can launch the application from another path. So you may prefer some static path or a tmp path for all users.

Here is my attempt:

//second instance launch guard
var tempPath = Environment.GetEnvironmentVariable("TEMP", EnvironmentVariableTarget.Machine) 
           ?? 
           Path.GetTempPath();
var lockPath = Path.Combine(tempPath, "SingleInstance.lock");
await using var lockFile = File.OpenWrite(lockPath);

here I'm trying to get TEMP system variable at the scope of machine (not the user TEMP) and if its empty - fallback to the user's temp folder on windows or shared /tmp on some linuxes.