ServiceInstaller.cs

using System;
using System.ComponentModel;
using System.Reflection;
using Waher.IoTGateway.Svc.ServiceManagement.Classes;
using Waher.IoTGateway.Svc.ServiceManagement.Enumerations;
using Waher.IoTGateway.Svc.ServiceManagement.Structures;
 
namespace Waher.IoTGateway.Svc.ServiceManagement
{
    internal delegate void ServiceMainFunction(int numArs, IntPtr argPtrPtr);
 
    public class ServiceInstaller
    {
        private readonly string serviceName;
        private readonly string instanceName;
 
        internal ServiceInstaller(string ServiceName, string InstanceName)
        {
            this.serviceName = ServiceName;
            this.instanceName = InstanceName;
 
            if (!string.IsNullOrEmpty(InstanceName))
                this.serviceName += " " + InstanceName;
        }
 
        public int Install(string DisplayName, string Description, ServiceStartType StartType, bool StartImmediately,
            ServiceFailureActions FailureActions, Win32ServiceCredentials Credentials)
        {
            string Path = Assembly.GetExecutingAssembly().Location.Replace(".dll", ".exe");
 
            if (!string.IsNullOrEmpty(this.instanceName))
                Path += " -instance \"" + this.instanceName + "\"";
 
            try
            {
                using ServiceControlManager mgr = ServiceControlManager.Connect(null, null, ServiceControlManagerAccessRights.All);
 
                if (mgr.TryOpenService(this.serviceName, ServiceControlAccessRights.All, out ServiceHandle existingService,
                    out Win32Exception errorException))
                {
                    using (existingService)
                    {
                        existingService.ChangeConfig(DisplayName, Path, ServiceType.Win32OwnProcess, StartType,
                            ErrorSeverity.Normal, Credentials);
 
                        if (!string.IsNullOrEmpty(Description))
                            existingService.SetDescription(Description);
 
                        if (FailureActions is not null)
                        {
                            existingService.SetFailureActions(FailureActions);
                            existingService.SetFailureActionFlag(true);
                        }
                        else
                            existingService.SetFailureActionFlag(false);
 
                        if (StartImmediately)
                        {
                            existingService.Start(throwIfAlreadyRunning: false);
                            return 3;
                        }
                        else
                            return 2;
                    }
                }
                else
                {
                    if (errorException.NativeErrorCode == Win32.ERROR_SERVICE_DOES_NOT_EXIST)
                    {
                        using ServiceHandle svc = mgr.CreateService(this.serviceName, DisplayName, Path, ServiceType.Win32OwnProcess,
                            StartType, ErrorSeverity.Normal, Credentials);
 
                        if (!string.IsNullOrEmpty(Description))
                            svc.SetDescription(Description);
 
                        if (FailureActions is not null)
                        {
                            svc.SetFailureActions(FailureActions);
                            svc.SetFailureActionFlag(true);
                        }
                        else
                            svc.SetFailureActionFlag(false);
 
                        if (StartImmediately)
                        {
                            svc.Start();
                            return 1;
                        }
                        else
                            return 0;
                    }
                    else
                        throw errorException;
                }
            }
            catch (DllNotFoundException dllException)
            {
                throw new PlatformNotSupportedException("Unable to call windows service management API.", dllException);
            }
        }
 
        public bool Uninstall()
        {
            try
            {
                using ServiceControlManager mgr = ServiceControlManager.Connect(null, null, ServiceControlManagerAccessRights.All);
 
                if (mgr.TryOpenService(this.serviceName, ServiceControlAccessRights.All, out ServiceHandle existingService,
                    out Win32Exception errorException))
                {
                    using (existingService)
                    {
                        existingService.Delete();
                        return true;
                    }
                }
                else
                {
                    if (errorException.NativeErrorCode == Win32.ERROR_SERVICE_DOES_NOT_EXIST)
                        return false;
                    else
                        throw errorException;
                }
            }
            catch (DllNotFoundException dllException)
            {
                throw new PlatformNotSupportedException("Unable to call windows service management API.", dllException);
            }
        }
 
    }
}