WindowsService.cs

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Threading;
using NewLife.Log;
using static NewLife.Agent.Advapi32;

namespace NewLife.Agent
{
    /// <summary>Windows服务</summary>
    public class WindowsService : Host
    {
        private IHostedService _service;
        private SERVICE_STATUS _status;
        private Int32 _acceptedCommands;

        /// <summary>开始执行服务</summary>
        /// <param name="service"></param>
        public override void Run(IHostedService service)
        {
            if (service == null) throw new ArgumentNullException(nameof(service));

            _service = service;

            var num = Marshal.SizeOf(typeof(SERVICE_TABLE_ENTRY));
            var intPtr = Marshal.AllocHGlobal(checked((1 + 1) * num));
            try
            {
                // Win32OwnProcess/StartPending
                _status.serviceType = 16;
                _status.currentState = ServiceControllerStatus.StartPending;
                _status.controlsAccepted = 0;
                _status.win32ExitCode = 0;
                _status.serviceSpecificExitCode = 0;
                _status.checkPoint = 0;
                _status.waitHint = 0;

                // CanStop | CanShutdown | CanPauseAndContinue | CanHandlePowerEvent | CanHandleSessionChangeEvent
                //_acceptedCommands = 1 | 4 | 2 | 64 | 128;
                // CanStop | CanShutdown
                _acceptedCommands = 1 | 4;

                SERVICE_TABLE_ENTRY result = default;
                result.callback = ServiceMainCallback;
                result.name = Marshal.StringToHGlobalUni(service.ServiceName);
                Marshal.StructureToPtr(result, intPtr, false);

                SERVICE_TABLE_ENTRY result2 = default;
                result2.callback = null;
                result2.name = (IntPtr)0;
                Marshal.StructureToPtr(result2, intPtr + num, false);

                /*
                 * 如果StartServiceCtrlDispatcher函数执行成功，调用线程（也就是服务进程的主线程）不会返回，直到所有的服务进入到SERVICE_STOPPED状态。
                 * 调用线程扮演着控制分发的角色，干这样的事情：
                 * 1、在新的服务启动时启动新线程去调用服务主函数（主意：服务的任务是在新线程中做的）；
                 * 2、当服务有请求时（注意：请求是由SCM发给它的），调用它对应的处理函数（主意：这相当于主线程“陷入”了，它在等待控制消息并对消息做处理）。
                 */

                XTrace.WriteLine("启动服务 {0}", service.ServiceName);

                var flag = StartServiceCtrlDispatcher(intPtr);
                if (!flag) XTrace.WriteLine("服务启动失败！");
            }
            finally
            {
                Marshal.FreeHGlobal(intPtr);
            }
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        private unsafe void ServiceMainCallback(Int32 argCount, IntPtr argPointer)
        {
            XTrace.WriteLine("ServiceMainCallback");

            fixed (SERVICE_STATUS* status = &_status)
            {
                // 我们直接忽略传入参数 argCount/argPointer

                _statusHandle = RegisterServiceCtrlHandlerEx(_service.ServiceName, ServiceCommandCallbackEx, IntPtr.Zero);

                _status.controlsAccepted = _acceptedCommands;
                if ((_status.controlsAccepted & 1) != 0)
                {
                    _status.controlsAccepted |= 4;
                }
                _status.currentState = ServiceControllerStatus.StartPending;
                if (SetServiceStatus(_statusHandle, status))
                {
                    // 使用线程池启动服务Start函数，并等待信号量
                    _startCompletedSignal = new ManualResetEvent(initialState: false);
                    ThreadPool.QueueUserWorkItem(ServiceQueuedMainCallback, null);
                    _startCompletedSignal.WaitOne();

                    // 设置服务状态
                    if (!SetServiceStatus(_statusHandle, status))
                    {
                        XTrace.WriteLine("启动服务{0}失败，{1}", _service.ServiceName, new Win32Exception().Message);

                        _status.currentState = ServiceControllerStatus.Stopped;
                        SetServiceStatus(_statusHandle, status);
                    }
                }
            }
        }

        private ManualResetEvent _startCompletedSignal;
        private void ServiceQueuedMainCallback(Object state)
        {
            //var args = (String[])state;
            try
            {
                //OnStart(args);
                var source = new CancellationTokenSource();
                _service.StartAsync(source.Token);
                //WriteLogEntry(SR.StartSuccessful);
                _status.checkPoint = 0;
                _status.waitHint = 0;
                _status.currentState = ServiceControllerStatus.Running;
            }
            catch (Exception ex)
            {
                XTrace.WriteException(ex);

                _status.currentState = ServiceControllerStatus.Stopped;
            }
            _startCompletedSignal.Set();
        }

        private IntPtr _statusHandle;
        private unsafe Int32 ServiceCommandCallbackEx(Int32 command, Int32 eventType, IntPtr eventData, IntPtr eventContext)
        {
            XTrace.WriteLine("ServiceCommandCallbackEx(command={0}, eventType={1}, eventData={2}, eventContext={3}", command, eventType, eventData, eventContext);

            // Power | SessionChange
            if (command == ControlOptions.CONTROL_POWEREVENT || command == ControlOptions.CONTROL_SESSIONCHANGE) return 0;

            fixed (SERVICE_STATUS* status = &_status)
            {
                if (command == ControlOptions.CONTROL_INTERROGATE)
                {
                    SetServiceStatus(_statusHandle, status);
                }
                else if (_status.currentState != ServiceControllerStatus.ContinuePending &&
                    _status.currentState != ServiceControllerStatus.StartPending &&
                    _status.currentState != ServiceControllerStatus.StopPending &&
                    _status.currentState != ServiceControllerStatus.PausePending)
                {
                    switch (command)
                    {
                        //case ControlOptions.CONTROL_CONTINUE:
                        //    if (_status.currentState == ServiceControllerStatus.Paused)
                        //    {
                        //        _status.currentState = ServiceControllerStatus.ContinuePending;
                        //        SetServiceStatus(_statusHandle, status);
                        //        //ThreadPool.QueueUserWorkItem(delegate
                        //        //{
                        //        //    DeferredContinue();
                        //        //});
                        //    }
                        //    break;
                        //case ControlOptions.CONTROL_PAUSE:
                        //    if (_status.currentState == ServiceControllerStatus.Running)
                        //    {
                        //        _status.currentState = ServiceControllerStatus.PausePending;
                        //        SetServiceStatus(_statusHandle, status);
                        //        //ThreadPool.QueueUserWorkItem(delegate
                        //        //{
                        //        //    DeferredPause();
                        //        //});
                        //    }
                        //    break;
                        case ControlOptions.CONTROL_STOP:
                            var currentState = _status.currentState;
                            if (_status.currentState == ServiceControllerStatus.Paused ||
                                _status.currentState == ServiceControllerStatus.Running)
                            {
                                // 设置为StopPending，然后线程池去执行停止
                                _status.currentState = ServiceControllerStatus.StopPending;
                                SetServiceStatus(_statusHandle, status);
                                _status.currentState = currentState;

                                ThreadPool.QueueUserWorkItem(s => DeferredStop());
                            }
                            break;
                        case ControlOptions.CONTROL_SHUTDOWN:
                            if (_status.currentState == ServiceControllerStatus.Paused ||
                                _status.currentState == ServiceControllerStatus.Running)
                            {
                                _status.checkPoint = 0;
                                _status.waitHint = 0;
                                _status.currentState = ServiceControllerStatus.Stopped;
                                SetServiceStatus(_statusHandle, status);

                                ThreadPool.QueueUserWorkItem(s => DeferredStop());
                            }
                            break;
                        default:
                            //ThreadPool.QueueUserWorkItem(delegate
                            //{
                            //    DeferredCustomCommand(command);
                            //});
                            break;
                    }
                }
            }

            return 0;
        }

        private unsafe void DeferredStop()
        {
            fixed (SERVICE_STATUS* status = &_status)
            {
                var currentState = _status.currentState;
                _status.checkPoint = 0;
                _status.waitHint = 0;
                _status.currentState = ServiceControllerStatus.StopPending;
                SetServiceStatus(_statusHandle, status);
                try
                {
                    var source = new CancellationTokenSource();
                    _service.StopAsync(source.Token);

                    _status.currentState = ServiceControllerStatus.Stopped;
                    SetServiceStatus(_statusHandle, status);
                }
                catch (Exception ex)
                {
                    XTrace.WriteException(ex);

                    _status.currentState = currentState;
                    SetServiceStatus(_statusHandle, status);
                }
            }
        }

        #region 服务状态和控制
        /// <summary>服务是否已安装</summary>
        /// <param name="serviceName">服务名</param>
        /// <returns></returns>
        public override Boolean IsInstalled(String serviceName)
        {
            using var manager = new SafeServiceHandle(OpenSCManager(null, null, ServiceControllerOptions.SC_MANAGER_CONNECT));
            if (manager == null || manager.IsInvalid) return false;

            using var service = new SafeServiceHandle(OpenService(manager, serviceName, ServiceOptions.SERVICE_QUERY_CONFIG));
            if (service == null || service.IsInvalid) return false;

            return true;
        }

        /// <summary>服务是否已启动</summary>
        /// <param name="serviceName">服务名</param>
        /// <returns></returns>
        public override unsafe Boolean IsRunning(String serviceName)
        {
            using var manager = new SafeServiceHandle(OpenSCManager(null, null, ServiceControllerOptions.SC_MANAGER_CONNECT));
            if (manager == null || manager.IsInvalid) return false;

            using var service = new SafeServiceHandle(OpenService(manager, serviceName, ServiceOptions.SERVICE_QUERY_STATUS));
            if (service == null || service.IsInvalid) return false;

            SERVICE_STATUS status = default;
            if (!QueryServiceStatus(service, &status))
                throw new Win32Exception(Marshal.GetLastWin32Error());

            return status.currentState == ServiceControllerStatus.Running;
        }

        /// <summary>安装服务</summary>
        /// <param name="serviceName">服务名</param>
        /// <param name="displayName"></param>
        /// <param name="binPath"></param>
        /// <param name="description"></param>
        /// <returns></returns>
        public override Boolean Install(String serviceName, String displayName, String binPath, String description)
        {
            XTrace.WriteLine("{0}.Install {1}, {2}, {3}, {4}", GetType().Name, serviceName, displayName, binPath, description);

            using var manager = new SafeServiceHandle(OpenSCManager(null, null, ServiceControllerOptions.SC_MANAGER_CREATE_SERVICE));
            if (manager.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            using var service = new SafeServiceHandle(CreateService(manager, serviceName, displayName, ServiceOptions.SERVICE_ALL_ACCESS, 0x10, 2, 1, binPath, null, 0, null, null, null));
            if (service.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            // 设置描述信息
            if (!description.IsNullOrEmpty())
            {
                SERVICE_DESCRIPTION sd;
                sd.Description = description;
                var lpInfo = Marshal.AllocHGlobal(Marshal.SizeOf(sd));

                try
                {
                    Marshal.StructureToPtr(sd, lpInfo, false);

                    const Int32 SERVICE_CONFIG_DESCRIPTION = 1;
                    ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, lpInfo);
                }
                finally
                {
                    Marshal.FreeHGlobal(lpInfo);
                }
            }

            return true;
        }

        /// <summary>卸载服务</summary>
        /// <param name="serviceName">服务名</param>
        /// <returns></returns>
        public override unsafe Boolean Remove(String serviceName)
        {
            XTrace.WriteLine("{0}.Remove {1}", GetType().Name, serviceName);

            using var manager = new SafeServiceHandle(OpenSCManager(null, null, ServiceControllerOptions.SC_MANAGER_ALL));
            if (manager.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            using var service = new SafeServiceHandle(OpenService(manager, serviceName, ServiceOptions.SERVICE_STOP | ServiceOptions.STANDARD_RIGHTS_DELETE));
            if (service.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            SERVICE_STATUS status = default;
            ControlService(service, ControlOptions.CONTROL_STOP, &status);

            if (DeleteService(service) == 0) throw new Win32Exception(Marshal.GetLastWin32Error());

            return true;
        }

        /// <summary>启动服务</summary>
        /// <param name="serviceName">服务名</param>
        /// <returns></returns>
        public override Boolean Start(String serviceName)
        {
            XTrace.WriteLine("{0}.Start {1}", GetType().Name, serviceName);

            using var manager = new SafeServiceHandle(OpenSCManager(null, null, ServiceControllerOptions.SC_MANAGER_CONNECT));
            if (manager.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            using var service = new SafeServiceHandle(OpenService(manager, serviceName, ServiceOptions.SERVICE_START));
            if (service.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            if (!StartService(service, 0, IntPtr.Zero))
                throw new Win32Exception(Marshal.GetLastWin32Error());

            return true;
        }

        /// <summary>停止服务</summary>
        /// <param name="serviceName">服务名</param>
        /// <returns></returns>
        public override unsafe Boolean Stop(String serviceName)
        {
            XTrace.WriteLine("{0}.Stop {1}", GetType().Name, serviceName);

            using var manager = new SafeServiceHandle(OpenSCManager(null, null, ServiceControllerOptions.SC_MANAGER_ALL));
            if (manager.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            using var service = new SafeServiceHandle(OpenService(manager, serviceName, ServiceOptions.SERVICE_STOP));
            if (service.IsInvalid) throw new Win32Exception(Marshal.GetLastWin32Error());

            SERVICE_STATUS status = default;
            if (!ControlService(service, ControlOptions.CONTROL_STOP, &status))
                throw new Win32Exception(Marshal.GetLastWin32Error());

            return true;
        }
        #endregion
    }
}