private void DoCreateService(ServiceControlManager serviceControlManager, ServiceDefinition serviceDefinition, bool startImmediately)
{
using (var svc = serviceControlManager.CreateService(serviceDefinition.ServiceName, serviceDefinition.DisplayName, serviceDefinition.BinaryPath, ServiceType.Win32OwnProcess,
serviceDefinition.AutoStart ? ServiceStartType.AutoStart : ServiceStartType.StartOnDemand, serviceDefinition.ErrorSeverity, serviceDefinition.Credentials))
{
var description = serviceDefinition.Description;
if (!string.IsNullOrEmpty(description))
{
svc.SetDescription(description);
}
var serviceFailureActions = serviceDefinition.FailureActions;
if (serviceFailureActions != null)
{
svc.SetFailureActions(serviceFailureActions);
svc.SetFailureActionFlag(serviceDefinition.FailureActionsOnNonCrashFailures);
}
if (serviceDefinition.AutoStart && serviceDefinition.DelayedAutoStart)
{
svc.SetDelayedAutoStartFlag(true);
}
if (startImmediately)
{
svc.Start();
}
}
}
/// <summary>
/// Creates or updates a Windows service.
/// This does not cause the service to restart.
/// </summary>
/// <param name="serviceDefinition">The service definition.</param>
/// <param name="startImmediately">If set to <see langword="true"/>, the service will be started immediately after updating. Has no effect if the service is already running.</param>
/// <exception cref="ArgumentException">
/// Thrown when <see cref="ServiceDefinition.BinaryPath"/> is null or empty or <see cref="ServiceDefinition.ServiceName"/> is null or empty.
/// </exception>
/// <exception cref="PlatformNotSupportedException">Thrown when run on a non-Windows platform.</exception>
public void CreateOrUpdateService(ServiceDefinition serviceDefinition, bool startImmediately = false)
{
if (string.IsNullOrEmpty(serviceDefinition.BinaryPath))
{
throw new ArgumentException($"Invalid service definition. {nameof(ServiceDefinition.BinaryPath)} must not be null or empty.", nameof(serviceDefinition));
}
if (string.IsNullOrEmpty(serviceDefinition.ServiceName))
{
throw new ArgumentException($"Invalid service definition. {nameof(ServiceDefinition.ServiceName)} must not be null or empty.", nameof(serviceDefinition));
}
try
{
using (var mgr = ServiceControlManager.Connect(nativeInterop, machineName, databaseName, ServiceControlManagerAccessRights.All))
{
if (mgr.TryOpenService(serviceDefinition.ServiceName, ServiceControlAccessRights.All, out var existingService, out var errorException))
{
using (existingService)
{
DoUpdateService(existingService, serviceDefinition, startImmediately);
}
}
else
{
if (errorException.NativeErrorCode == KnownWin32ErrorCoes.ERROR_SERVICE_DOES_NOT_EXIST)
{
DoCreateService(mgr, serviceDefinition, startImmediately);
}
else
{
throw errorException;
}
}
}
/// <summary>
/// Creates or update a service in windows
/// </summary>
/// <param name="serviceName">Service name</param>
/// <param name="displayName">Display name</param>
/// <param name="description">Descriptions</param>
/// <param name="binaryPath">Binary path</param>
/// <param name="credentials">Credentials</param>
/// <param name="serviceFailureActions">Service failure actions</param>
/// <param name="failureActionsOnNonCrashFailures">Failure actions on non crash failures</param>
/// <param name="autoStart">Sets the service to autostart</param>
/// <param name="startImmediately">Starts inmediately after creation</param>
/// <param name="errorSeverity">Error severity</param>
public void CreateOrUpdateService(string serviceName, string displayName, string description, string binaryPath, Win32ServiceCredentials credentials, ServiceFailureActions serviceFailureActions, bool failureActionsOnNonCrashFailures, bool autoStart = false, bool startImmediately = false, ErrorSeverity errorSeverity = ErrorSeverity.Normal)
{
if (string.IsNullOrEmpty(binaryPath))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(binaryPath));
}
if (string.IsNullOrEmpty(serviceName))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(serviceName));
}
try
{
using (var mgr = ServiceControlManager.Connect(_nativeInterop, _machineName, _databaseName, ServiceControlManagerAccessRights.All))
{
if (mgr.TryOpenService(serviceName, ServiceControlAccessRights.All, out var existingService, out var errorException))
{
using (existingService)
{
DoUpdateService(displayName, description, binaryPath, credentials, autoStart, errorSeverity, existingService, serviceFailureActions, failureActionsOnNonCrashFailures);
}
}
else
{
if (errorException.NativeErrorCode == KnownWin32ErrorCoes.ERROR_SERVICE_DOES_NOT_EXIST)
{
DoCreateService(mgr, serviceName, displayName, description, binaryPath, credentials, autoStart, startImmediately, errorSeverity, serviceFailureActions, failureActionsOnNonCrashFailures);
}
else
{
throw errorException;
}
}
}
ServiceHandle INativeInterop.CreateServiceW(ServiceControlManager serviceControlManager, string serviceName, string displayName,
ServiceControlAccessRights desiredControlAccess, ServiceType serviceType, ServiceStartType startType, ErrorSeverity errorSeverity,
string binaryPath,
string loadOrderGroup, IntPtr outUIntTagId, string dependencies, string serviceUserName, string servicePassword)
{
return(CreateServiceW(serviceControlManager, serviceName, displayName, desiredControlAccess, serviceType, startType, errorSeverity,
binaryPath, loadOrderGroup, outUIntTagId, dependencies, serviceUserName, servicePassword));
}
internal static ServiceControlManager Connect(INativeInterop nativeInterop, string machineName, string databaseName, ServiceControlManagerAccessRights desiredAccessRights)
{
ServiceControlManager mgr = nativeInterop.OpenSCManagerW(machineName, databaseName, desiredAccessRights);
mgr.NativeInterop = nativeInterop;
if (mgr.IsInvalid)
{
throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
}
return(mgr);
}
private static extern ServiceHandle CreateServiceW(
ServiceControlManager serviceControlManager,
string serviceName,
string displayName,
ServiceControlAccessRights desiredControlAccess,
ServiceType serviceType,
ServiceStartType startType,
ErrorSeverity errorSeverity,
string binaryPath,
string loadOrderGroup,
IntPtr outUIntTagId,
string dependencies,
string serviceUserName,
string servicePassword);
public void CreateOrUpdateService(string serviceName, string displayName, string description, string binaryPath, Win32ServiceCredentials credentials, ServiceFailureActions serviceFailureActions, bool failureActionsOnNonCrashFailures, bool autoStart = false, bool startImmediately = false, ErrorSeverity errorSeverity = ErrorSeverity.Normal)
{
if (string.IsNullOrEmpty(binaryPath))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(binaryPath));
}
if (string.IsNullOrEmpty(serviceName))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(serviceName));
}
try
{
using (var mgr = ServiceControlManager.Connect(nativeInterop, machineName, databaseName, ServiceControlManagerAccessRights.All))
{
ServiceHandle existingService;
Win32Exception errorException;
if (mgr.TryOpenService(serviceName, ServiceControlAccessRights.All, out existingService, out errorException))
{
using (existingService)
{
DoUpdateService(displayName, description, binaryPath, credentials, autoStart, errorSeverity, existingService, serviceFailureActions, failureActionsOnNonCrashFailures);
}
}
else
{
if (errorException.NativeErrorCode == KnownWin32ErrorCoes.ERROR_SERVICE_DOES_NOT_EXIST)
{
DoCreateService(mgr, serviceName, displayName, description, binaryPath, credentials, autoStart, startImmediately, errorSeverity, serviceFailureActions, failureActionsOnNonCrashFailures);
}
else
{
throw errorException;
}
}
}
}
catch (DllNotFoundException dllException)
{
throw new PlatformNotSupportedException(nameof(Win32ServiceHost) + " is only supported on Windows with service management API set.", dllException);
}
}
private void DoCreateService(ServiceControlManager serviceControlManager, string serviceName, string displayName, string description, string binaryPath, Win32ServiceCredentials credentials, bool autoStart, bool startImmediately, ErrorSeverity errorSeverity, ServiceFailureActions serviceFailureActions, bool failureActionsOnNonCrashFailures)
{
using (var svc = serviceControlManager.CreateService(serviceName, displayName, binaryPath, ServiceType.Win32OwnProcess,
autoStart ? ServiceStartType.AutoStart : ServiceStartType.StartOnDemand, errorSeverity, credentials))
{
if (!string.IsNullOrEmpty(description))
{
svc.SetDescription(description);
}
if (serviceFailureActions != null)
{
svc.SetFailureActions(serviceFailureActions);
svc.SetFailureActionFlag(failureActionsOnNonCrashFailures);
}
if (startImmediately)
{
svc.Start();
}
}
}
public void DeleteService(string serviceName)
{
if (string.IsNullOrEmpty(serviceName))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(serviceName));
}
try
{
using (var mgr = ServiceControlManager.Connect(nativeInterop, machineName, databaseName, ServiceControlManagerAccessRights.All))
{
using (var svc = mgr.OpenService(serviceName, ServiceControlAccessRights.All))
{
svc.Delete();
}
}
}
catch (DllNotFoundException dllException)
{
throw new PlatformNotSupportedException(nameof(Win32ServiceHost) + " is only supported on Windows with service management API set.", dllException);
}
}
public void CreateService(string serviceName, string displayName, string description, string binaryPath, Win32ServiceCredentials credentials, bool autoStart = false, bool startImmediately = false, ErrorSeverity errorSeverity = ErrorSeverity.Normal)
{
if (string.IsNullOrEmpty(binaryPath))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(binaryPath));
}
if (string.IsNullOrEmpty(serviceName))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(serviceName));
}
if (string.IsNullOrEmpty(binaryPath))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(binaryPath));
}
try
{
using (var mgr = ServiceControlManager.Connect(nativeInterop, machineName, databaseName, ServiceControlManagerAccessRights.All))
{
using (
var svc = mgr.CreateService(serviceName, displayName, binaryPath, ServiceType.Win32OwnProcess,
autoStart ? ServiceStartType.AutoStart : ServiceStartType.StartOnDemand, errorSeverity, credentials))
{
if (!string.IsNullOrEmpty(description))
{
svc.SetDescription(description);
}
if (startImmediately)
{
svc.Start();
}
}
}
}
catch (DllNotFoundException dllException)
{
throw new PlatformNotSupportedException(nameof(Win32ServiceHost) + " is only supported on Windows with service management API set.", dllException);
}
}
/// <summary>
/// Creates a new Windows service.
/// </summary>
/// <param name="serviceDefinition">The service definition.</param>
/// <param name="startImmediately">If set to <see langword="true"/>, the service will be started immediately after registering.</param>
/// <exception cref="ArgumentException">
/// Thrown when <see cref="ServiceDefinition.BinaryPath"/> is null or empty or <see cref="ServiceDefinition.ServiceName"/> is null or empty.
/// <exception cref="PlatformNotSupportedException">Thrown when run on a non-Windows platform.</exception>
public void CreateService(ServiceDefinition serviceDefinition, bool startImmediately = false)
{
if (string.IsNullOrEmpty(serviceDefinition.BinaryPath))
{
throw new ArgumentException($"Invalid service definition. {nameof(ServiceDefinition.BinaryPath)} must not be null or empty.", nameof(serviceDefinition));
}
if (string.IsNullOrEmpty(serviceDefinition.ServiceName))
{
throw new ArgumentException($"Invalid service definition. {nameof(ServiceDefinition.ServiceName)} must not be null or empty.", nameof(serviceDefinition));
}
try
{
using (var mgr = ServiceControlManager.Connect(nativeInterop, machineName, databaseName, ServiceControlManagerAccessRights.All))
{
DoCreateService(mgr, serviceDefinition, startImmediately);
}
}
catch (DllNotFoundException dllException)
{
throw new PlatformNotSupportedException(nameof(Win32ServiceHost) + " is only supported on Windows with service management API set.", dllException);
}
}
public void CreateService(string serviceName, string displayName, string description, string binaryPath, Win32ServiceCredentials credentials, ServiceFailureActions serviceFailureActions, bool failureActionsOnNonCrashFailures, bool autoStart = false, bool startImmediately = false, ErrorSeverity errorSeverity = ErrorSeverity.Normal)
{
if (string.IsNullOrEmpty(binaryPath))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(binaryPath));
}
if (string.IsNullOrEmpty(serviceName))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(serviceName));
}
try
{
using (var mgr = ServiceControlManager.Connect(nativeInterop, machineName, databaseName, ServiceControlManagerAccessRights.All))
{
DoCreateService(mgr, serviceName, displayName, description, binaryPath, credentials, autoStart, startImmediately, errorSeverity, serviceFailureActions, failureActionsOnNonCrashFailures);
}
}
catch (DllNotFoundException dllException)
{
throw new PlatformNotSupportedException(nameof(Win32ServiceHost) + " is only supported on Windows with service management API set.", dllException);
}
}
private static extern ServiceHandle OpenServiceW(ServiceControlManager serviceControlManager, string serviceName,
ServiceControlAccessRights desiredControlAccess);
ServiceHandle INativeInterop.OpenServiceW(ServiceControlManager serviceControlManager, string serviceName, ServiceControlAccessRights desiredControlAccess)
{
return(OpenServiceW(serviceControlManager, serviceName, desiredControlAccess));
}
