# General purpose service utilities, both for standard Python scripts, # and for for Python programs which run as services... # # Note that most utility functions here will raise win32api.error's # (which is win32service.error, pywintypes.error, etc) # when things go wrong - eg, not enough permissions to hit the # registry etc. import importlib.machinery import os import sys import warnings import pywintypes import win32api import win32con import win32service import winerror error = RuntimeError # Re-exported alias # Returns the full path to an executable for hosting a Python service - typically # 'pythonservice.exe' # * If you pass a param and it exists as a file, you'll get the abs path back # * Otherwise we'll use the param instead of 'pythonservice.exe', and we will # look for it. def LocatePythonServiceExe(exe=None): if not exe and hasattr(sys, "frozen"): # If py2exe etc calls this with no exe, default is current exe, # and all setup is their problem :) return sys.executable if exe and os.path.isfile(exe): return win32api.GetFullPathName(exe) suffix = "_d" if "_d.pyd" in importlib.machinery.EXTENSION_SUFFIXES else "" # We are confused if we aren't now looking for our default. But if that # exists as specified we assume it's good. exe = f"pythonservice{suffix}.exe" if os.path.isfile(exe): return win32api.GetFullPathName(exe) # Now we are searching for the .exe # We are going to want it here. correct = os.path.join(sys.exec_prefix, exe) # Even if that file already exists, we copy the one installed by pywin32 # in-case it was upgraded. # pywin32 installed it next to win32service.pyd (but we can't run it from there) maybe = os.path.join(os.path.dirname(win32service.__file__), exe) if os.path.exists(maybe): print(f"moving host exe '{maybe}' -> '{correct}'") # Handle case where MoveFile() fails. Particularly if destination file # has a resource lock and can't be replaced by src file try: win32api.MoveFileEx(maybe, correct, win32con.MOVEFILE_REPLACE_EXISTING) except win32api.error as exc: print(f"Failed to move host exe '{exc}'") if not os.path.exists(correct): raise error(f"Can't find '{correct}'") # If pywintypes.dll isn't next to us, or at least next to pythonXX.dll, # there's a good chance the service will not run. That's usually copied by # `pywin32_postinstall`, but putting it next to the python DLL seems reasonable. # (Unlike the .exe above, we don't unconditionally copy this, and possibly # copy it to a different place. Doesn't seem a good reason for that!?) python_dll = win32api.GetModuleFileName(sys.dllhandle) pyw = f"pywintypes{sys.version_info.major}{sys.version_info.minor}{suffix}.dll" correct_pyw = os.path.join(os.path.dirname(python_dll), pyw) if not os.path.exists(correct_pyw): print(f"copying helper dll '{pywintypes.__file__}' -> '{correct_pyw}'") win32api.CopyFile(pywintypes.__file__, correct_pyw) return correct def _GetServiceShortName(longName): # looks up a services name # from the display name # Thanks to Andy McKay for this code. access = ( win32con.KEY_READ | win32con.KEY_ENUMERATE_SUB_KEYS | win32con.KEY_QUERY_VALUE ) hkey = win32api.RegOpenKey( win32con.HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services", 0, access ) num = win32api.RegQueryInfoKey(hkey)[0] longName = longName.lower() # loop through number of subkeys for x in range(0, num): # find service name, open subkey svc = win32api.RegEnumKey(hkey, x) skey = win32api.RegOpenKey(hkey, svc, 0, access) try: # find display name thisName = str(win32api.RegQueryValueEx(skey, "DisplayName")[0]) if thisName.lower() == longName: return svc except win32api.error: # in case there is no key called DisplayName pass return None # Open a service given either it's long or short name. def SmartOpenService(hscm, name, access): try: return win32service.OpenService(hscm, name, access) except win32api.error as details: if details.winerror not in [ winerror.ERROR_SERVICE_DOES_NOT_EXIST, winerror.ERROR_INVALID_NAME, ]: raise name = win32service.GetServiceKeyName(hscm, name) return win32service.OpenService(hscm, name, access) def LocateSpecificServiceExe(serviceName): # Return the .exe name of any service. hkey = win32api.RegOpenKey( win32con.HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\%s" % (serviceName), 0, win32con.KEY_QUERY_VALUE, ) try: return win32api.RegQueryValueEx(hkey, "ImagePath")[0] finally: hkey.Close() def InstallPerfmonForService(serviceName, iniName, dllName=None): # If no DLL name, look it up in the INI file name if not dllName: # May be empty string! dllName = win32api.GetProfileVal("Python", "dll", "", iniName) # Still not found - look for the standard one in the same dir as win32service.pyd if not dllName: try: tryName = os.path.join( os.path.split(win32service.__file__)[0], "perfmondata.dll" ) if os.path.isfile(tryName): dllName = tryName except AttributeError: # Frozen app? - anyway, can't find it! pass if not dllName: raise ValueError("The name of the performance DLL must be available") dllName = win32api.GetFullPathName(dllName) # Now setup all the required "Performance" entries. hkey = win32api.RegOpenKey( win32con.HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\%s" % (serviceName), 0, win32con.KEY_ALL_ACCESS, ) try: subKey = win32api.RegCreateKey(hkey, "Performance") try: win32api.RegSetValueEx(subKey, "Library", 0, win32con.REG_SZ, dllName) win32api.RegSetValueEx( subKey, "Open", 0, win32con.REG_SZ, "OpenPerformanceData" ) win32api.RegSetValueEx( subKey, "Close", 0, win32con.REG_SZ, "ClosePerformanceData" ) win32api.RegSetValueEx( subKey, "Collect", 0, win32con.REG_SZ, "CollectPerformanceData" ) finally: win32api.RegCloseKey(subKey) finally: win32api.RegCloseKey(hkey) # Now do the "Lodctr" thang... try: import perfmon path, fname = os.path.split(iniName) oldPath = os.getcwd() if path: os.chdir(path) try: perfmon.LoadPerfCounterTextStrings("python.exe " + fname) finally: os.chdir(oldPath) except win32api.error as details: print("The service was installed OK, but the performance monitor") print("data could not be loaded.", details) def _GetCommandLine(exeName, exeArgs): if exeArgs is not None: return exeName + " " + exeArgs else: return exeName def InstallService( pythonClassString, serviceName, displayName, startType=None, errorControl=None, bRunInteractive=0, serviceDeps=None, userName=None, password=None, exeName=None, perfMonIni=None, perfMonDll=None, exeArgs=None, description=None, delayedstart=None, ): # Handle the default arguments. if startType is None: startType = win32service.SERVICE_DEMAND_START serviceType = win32service.SERVICE_WIN32_OWN_PROCESS if bRunInteractive: serviceType |= win32service.SERVICE_INTERACTIVE_PROCESS if errorControl is None: errorControl = win32service.SERVICE_ERROR_NORMAL exeName = '"%s"' % LocatePythonServiceExe(exeName) commandLine = _GetCommandLine(exeName, exeArgs) hscm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_ALL_ACCESS) try: hs = win32service.CreateService( hscm, serviceName, displayName, win32service.SERVICE_ALL_ACCESS, # desired access serviceType, # service type startType, errorControl, # error control type commandLine, None, 0, serviceDeps, userName, password, ) if description is not None: try: win32service.ChangeServiceConfig2( hs, win32service.SERVICE_CONFIG_DESCRIPTION, description ) except NotImplementedError: pass ## ChangeServiceConfig2 and description do not exist on NT if delayedstart is not None: try: win32service.ChangeServiceConfig2( hs, win32service.SERVICE_CONFIG_DELAYED_AUTO_START_INFO, delayedstart, ) except (win32service.error, NotImplementedError): ## delayed start only exists on Vista and later - warn only when trying to set delayed to True warnings.warn( "Delayed Start not available on this system", stacklevel=2 ) win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) InstallPythonClassString(pythonClassString, serviceName) # If I have performance monitor info to install, do that. if perfMonIni is not None: InstallPerfmonForService(serviceName, perfMonIni, perfMonDll) def ChangeServiceConfig( pythonClassString, serviceName, startType=None, errorControl=None, bRunInteractive=0, serviceDeps=None, userName=None, password=None, exeName=None, displayName=None, perfMonIni=None, perfMonDll=None, exeArgs=None, description=None, delayedstart=None, ): # Before doing anything, remove any perfmon counters. try: import perfmon perfmon.UnloadPerfCounterTextStrings("python.exe " + serviceName) except (ImportError, win32api.error): pass # The EXE location may have changed exeName = '"%s"' % LocatePythonServiceExe(exeName) # Handle the default arguments. if startType is None: startType = win32service.SERVICE_NO_CHANGE if errorControl is None: errorControl = win32service.SERVICE_NO_CHANGE hscm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_ALL_ACCESS) serviceType = win32service.SERVICE_WIN32_OWN_PROCESS if bRunInteractive: serviceType |= win32service.SERVICE_INTERACTIVE_PROCESS commandLine = _GetCommandLine(exeName, exeArgs) try: hs = SmartOpenService(hscm, serviceName, win32service.SERVICE_ALL_ACCESS) try: win32service.ChangeServiceConfig( hs, serviceType, # service type startType, errorControl, # error control type commandLine, None, 0, serviceDeps, userName, password, displayName, ) if description is not None: try: win32service.ChangeServiceConfig2( hs, win32service.SERVICE_CONFIG_DESCRIPTION, description ) except NotImplementedError: pass ## ChangeServiceConfig2 and description do not exist on NT if delayedstart is not None: try: win32service.ChangeServiceConfig2( hs, win32service.SERVICE_CONFIG_DELAYED_AUTO_START_INFO, delayedstart, ) except (win32service.error, NotImplementedError): ## Delayed start only exists on Vista and later. On Nt, will raise NotImplementedError since ChangeServiceConfig2 ## doensn't exist. On Win2k and XP, will fail with ERROR_INVALID_LEVEL ## Warn only if trying to set delayed to True if delayedstart: warnings.warn( "Delayed Start not available on this system", stacklevel=2 ) finally: win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) InstallPythonClassString(pythonClassString, serviceName) # If I have performance monitor info to install, do that. if perfMonIni is not None: InstallPerfmonForService(serviceName, perfMonIni, perfMonDll) def InstallPythonClassString(pythonClassString, serviceName): # Now setup our Python specific entries. if pythonClassString: key = win32api.RegCreateKey( win32con.HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\%s\\PythonClass" % serviceName, ) try: win32api.RegSetValue(key, None, win32con.REG_SZ, pythonClassString) finally: win32api.RegCloseKey(key) # Utility functions for Services, to allow persistant properties. def SetServiceCustomOption(serviceName, option, value): try: serviceName = serviceName._svc_name_ except AttributeError: pass key = win32api.RegCreateKey( win32con.HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\%s\\Parameters" % serviceName, ) try: if isinstance(value, int): win32api.RegSetValueEx(key, option, 0, win32con.REG_DWORD, value) else: win32api.RegSetValueEx(key, option, 0, win32con.REG_SZ, value) finally: win32api.RegCloseKey(key) def GetServiceCustomOption(serviceName, option, defaultValue=None): # First param may also be a service class/instance. # This allows services to pass "self" try: serviceName = serviceName._svc_name_ except AttributeError: pass key = win32api.RegCreateKey( win32con.HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\%s\\Parameters" % serviceName, ) try: try: return win32api.RegQueryValueEx(key, option)[0] except win32api.error: # No value. return defaultValue finally: win32api.RegCloseKey(key) def RemoveService(serviceName): try: import perfmon perfmon.UnloadPerfCounterTextStrings("python.exe " + serviceName) except (ImportError, win32api.error): pass hscm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_ALL_ACCESS) try: hs = SmartOpenService(hscm, serviceName, win32service.SERVICE_ALL_ACCESS) win32service.DeleteService(hs) win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) import win32evtlogutil try: win32evtlogutil.RemoveSourceFromRegistry(serviceName) except win32api.error: pass def ControlService(serviceName, code, machine=None): hscm = win32service.OpenSCManager(machine, None, win32service.SC_MANAGER_ALL_ACCESS) try: hs = SmartOpenService(hscm, serviceName, win32service.SERVICE_ALL_ACCESS) try: status = win32service.ControlService(hs, code) finally: win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) return status def __FindSvcDeps(findName): dict = {} k = win32api.RegOpenKey( win32con.HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services" ) num = 0 while 1: try: svc = win32api.RegEnumKey(k, num) except win32api.error: break num += 1 sk = win32api.RegOpenKey(k, svc) try: deps, typ = win32api.RegQueryValueEx(sk, "DependOnService") except win32api.error: deps = () for dep in deps: dep = dep.lower() dep_on = dict.get(dep, []) dep_on.append(svc) dict[dep] = dep_on return __ResolveDeps(findName, dict) def __ResolveDeps(findName, dict): items = dict.get(findName.lower(), []) retList = [] for svc in items: retList.insert(0, svc) retList = __ResolveDeps(svc, dict) + retList return retList def WaitForServiceStatus(serviceName, status, waitSecs, machine=None): """Waits for the service to return the specified status. You should have already requested the service to enter that state""" for i in range(waitSecs * 4): now_status = QueryServiceStatus(serviceName, machine)[1] if now_status == status: break win32api.Sleep(250) else: raise pywintypes.error( winerror.ERROR_SERVICE_REQUEST_TIMEOUT, "QueryServiceStatus", win32api.FormatMessage(winerror.ERROR_SERVICE_REQUEST_TIMEOUT)[:-2], ) def __StopServiceWithTimeout(hs, waitSecs=30): try: status = win32service.ControlService(hs, win32service.SERVICE_CONTROL_STOP) except pywintypes.error as exc: if exc.winerror != winerror.ERROR_SERVICE_NOT_ACTIVE: raise for i in range(waitSecs): status = win32service.QueryServiceStatus(hs) if status[1] == win32service.SERVICE_STOPPED: break win32api.Sleep(1000) else: raise pywintypes.error( winerror.ERROR_SERVICE_REQUEST_TIMEOUT, "ControlService", win32api.FormatMessage(winerror.ERROR_SERVICE_REQUEST_TIMEOUT)[:-2], ) def StopServiceWithDeps(serviceName, machine=None, waitSecs=30): # Stop a service recursively looking for dependant services hscm = win32service.OpenSCManager(machine, None, win32service.SC_MANAGER_ALL_ACCESS) try: deps = __FindSvcDeps(serviceName) for dep in deps: hs = win32service.OpenService(hscm, dep, win32service.SERVICE_ALL_ACCESS) try: __StopServiceWithTimeout(hs, waitSecs) finally: win32service.CloseServiceHandle(hs) # Now my service! hs = win32service.OpenService( hscm, serviceName, win32service.SERVICE_ALL_ACCESS ) try: __StopServiceWithTimeout(hs, waitSecs) finally: win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) def StopService(serviceName, machine=None): return ControlService(serviceName, win32service.SERVICE_CONTROL_STOP, machine) def StartService(serviceName, args=None, machine=None): hscm = win32service.OpenSCManager(machine, None, win32service.SC_MANAGER_ALL_ACCESS) try: hs = SmartOpenService(hscm, serviceName, win32service.SERVICE_ALL_ACCESS) try: win32service.StartService(hs, args) finally: win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) def RestartService(serviceName, args=None, waitSeconds=30, machine=None): "Stop the service, and then start it again (with some tolerance for allowing it to stop.)" try: StopService(serviceName, machine) except pywintypes.error as exc: # Allow only "service not running" error if exc.winerror != winerror.ERROR_SERVICE_NOT_ACTIVE: raise # Give it a few goes, as the service may take time to stop for i in range(waitSeconds): try: StartService(serviceName, args, machine) break except pywintypes.error as exc: if exc.winerror != winerror.ERROR_SERVICE_ALREADY_RUNNING: raise win32api.Sleep(1000) else: print("Gave up waiting for the old service to stop!") def _DebugCtrlHandler(evt): if evt in (win32con.CTRL_C_EVENT, win32con.CTRL_BREAK_EVENT): assert g_debugService print("Stopping debug service.") g_debugService.SvcStop() return True return False def DebugService(cls, argv=[]): # Run a service in "debug" mode. Re-implements what pythonservice.exe # does when it sees a "-debug" param. # Currently only used by "frozen" (ie, py2exe) programs (but later may # end up being used for all services should we ever remove # pythonservice.exe) import servicemanager global g_debugService print(f"Debugging service {cls._svc_name_} - press Ctrl+C to stop.") servicemanager.Debugging(True) servicemanager.PrepareToHostSingle(cls) g_debugService = cls(argv) # Setup a ctrl+c handler to simulate a "stop" win32api.SetConsoleCtrlHandler(_DebugCtrlHandler, True) try: g_debugService.SvcRun() finally: win32api.SetConsoleCtrlHandler(_DebugCtrlHandler, False) servicemanager.Debugging(False) g_debugService = None def GetServiceClassString(cls, argv=None): if argv is None: argv = sys.argv import pickle modName = pickle.whichmodule(cls, cls.__name__) if modName == "__main__": try: fname = win32api.GetFullPathName(argv[0]) path = os.path.split(fname)[0] # Eaaaahhhh - sometimes this will be a short filename, which causes # problems with 1.5.1 and the silly filename case rule. filelist = win32api.FindFiles(fname) # win32api.FindFiles will not detect files in a zip or exe. If list is empty, # skip the test and hope the file really exists. if len(filelist) != 0: # Get the long name fname = os.path.join(path, filelist[0][8]) except win32api.error: raise error( "Could not resolve the path name '%s' to a full path" % (argv[0]) ) modName = os.path.splitext(fname)[0] return modName + "." + cls.__name__ def QueryServiceStatus(serviceName, machine=None): hscm = win32service.OpenSCManager(machine, None, win32service.SC_MANAGER_CONNECT) try: hs = SmartOpenService(hscm, serviceName, win32service.SERVICE_QUERY_STATUS) try: status = win32service.QueryServiceStatus(hs) finally: win32service.CloseServiceHandle(hs) finally: win32service.CloseServiceHandle(hscm) return status def usage(): try: fname = os.path.split(sys.argv[0])[1] except: fname = sys.argv[0] print( "Usage: '%s [options] install|update|remove|start [...]|stop|restart [...]|debug [...]'" % fname ) print("Options for 'install' and 'update' commands only:") print(" --username domain\\username : The Username the service is to run under") print(" --password password : The password for the username") print( " --startup [manual|auto|disabled|delayed] : How the service starts, default = manual" ) print(" --interactive : Allow the service to interact with the desktop.") print( " --perfmonini file: .ini file to use for registering performance monitor data" ) print(" --perfmondll file: .dll file to use when querying the service for") print(" performance data, default = perfmondata.dll") print("Options for 'start' and 'stop' commands only:") print(" --wait seconds: Wait for the service to actually start or stop.") print(" If you specify --wait with the 'stop' option, the service") print(" and all dependent services will be stopped, each waiting") print(" the specified period.") sys.exit(1) def HandleCommandLine( cls, serviceClassString=None, argv=None, customInstallOptions="", customOptionHandler=None, ): """Utility function allowing services to process the command line. Allows standard commands such as 'start', 'stop', 'debug', 'install' etc. Install supports 'standard' command line options prefixed with '--', such as --username, --password, etc. In addition, the function allows custom command line options to be handled by the calling function. """ err = 0 if argv is None: argv = sys.argv if len(argv) <= 1: usage() serviceName = cls._svc_name_ serviceDisplayName = cls._svc_display_name_ if serviceClassString is None: serviceClassString = GetServiceClassString(cls) # Pull apart the command line import getopt try: opts, args = getopt.getopt( argv[1:], customInstallOptions, [ "password=", "username=", "startup=", "perfmonini=", "perfmondll=", "interactive", "wait=", ], ) except getopt.error as details: print(details) usage() userName = None password = None perfMonIni = perfMonDll = None startup = None delayedstart = None interactive = None waitSecs = 0 for opt, val in opts: if opt == "--username": userName = val elif opt == "--password": password = val elif opt == "--perfmonini": perfMonIni = val elif opt == "--perfmondll": perfMonDll = val elif opt == "--interactive": interactive = 1 elif opt == "--startup": map = { "manual": win32service.SERVICE_DEMAND_START, "auto": win32service.SERVICE_AUTO_START, "delayed": win32service.SERVICE_AUTO_START, ## ChangeServiceConfig2 called later "disabled": win32service.SERVICE_DISABLED, } startup = map.get(val.lower()) if not startup: print(f"{val!r} is not a valid startup option") if val.lower() == "delayed": delayedstart = True elif val.lower() == "auto": delayedstart = False ## else no change elif opt == "--wait": try: waitSecs = int(val) except ValueError: print("--wait must specify an integer number of seconds.") usage() arg = args[0] knownArg = 0 # First we process all arguments which pass additional args on if arg == "start": knownArg = 1 print("Starting service %s" % (serviceName)) try: StartService(serviceName, args[1:]) if waitSecs: WaitForServiceStatus( serviceName, win32service.SERVICE_RUNNING, waitSecs ) except win32service.error as exc: print("Error starting service: %s" % exc.strerror) err = exc.winerror elif arg == "restart": knownArg = 1 print("Restarting service %s" % (serviceName)) RestartService(serviceName, args[1:]) if waitSecs: WaitForServiceStatus(serviceName, win32service.SERVICE_RUNNING, waitSecs) elif arg == "debug": knownArg = 1 if not hasattr(sys, "frozen"): # non-frozen services use pythonservice.exe which handles a # -debug option svcArgs = " ".join(args[1:]) try: exeName = LocateSpecificServiceExe(serviceName) except win32api.error as exc: if exc.winerror == winerror.ERROR_FILE_NOT_FOUND: print("The service does not appear to be installed.") print("Please install the service before debugging it.") sys.exit(1) raise try: os.system(f"{exeName} -debug {serviceName} {svcArgs}") # ^C is used to kill the debug service. Sometimes Python also gets # interrupted - ignore it... except KeyboardInterrupt: pass else: # py2exe services don't use pythonservice - so we simulate # debugging here. DebugService(cls, args) if not knownArg and len(args) != 1: usage() # the rest of the cmds don't take addn args if arg == "install": knownArg = 1 try: serviceDeps = cls._svc_deps_ except AttributeError: serviceDeps = None try: exeName = cls._exe_name_ except AttributeError: exeName = None # Default to PythonService.exe try: exeArgs = cls._exe_args_ except AttributeError: exeArgs = None try: description = cls._svc_description_ except AttributeError: description = None print(f"Installing service {serviceName}") # Note that we install the service before calling the custom option # handler, so if the custom handler fails, we have an installed service (from NT's POV) # but is unlikely to work, as the Python code controlling it failed. Therefore # we remove the service if the first bit works, but the second doesn't! try: InstallService( serviceClassString, serviceName, serviceDisplayName, serviceDeps=serviceDeps, startType=startup, bRunInteractive=interactive, userName=userName, password=password, exeName=exeName, perfMonIni=perfMonIni, perfMonDll=perfMonDll, exeArgs=exeArgs, description=description, delayedstart=delayedstart, ) if customOptionHandler: customOptionHandler(*(opts,)) print("Service installed") except win32service.error as exc: if exc.winerror == winerror.ERROR_SERVICE_EXISTS: arg = "update" # Fall through to the "update" param! else: print( "Error installing service: %s (%d)" % (exc.strerror, exc.winerror) ) err = exc.winerror except ValueError as msg: # Can be raised by custom option handler. print("Error installing service: %s" % str(msg)) err = -1 # xxx - maybe I should remove after _any_ failed install - however, # xxx - it may be useful to help debug to leave the service as it failed. # xxx - We really _must_ remove as per the comments above... # As we failed here, remove the service, so the next installation # attempt works. try: RemoveService(serviceName) except win32api.error: print("Warning - could not remove the partially installed service.") if arg == "update": knownArg = 1 try: serviceDeps = cls._svc_deps_ except AttributeError: serviceDeps = None try: exeName = cls._exe_name_ except AttributeError: exeName = None # Default to PythonService.exe try: exeArgs = cls._exe_args_ except AttributeError: exeArgs = None try: description = cls._svc_description_ except AttributeError: description = None print("Changing service configuration") try: ChangeServiceConfig( serviceClassString, serviceName, serviceDeps=serviceDeps, startType=startup, bRunInteractive=interactive, userName=userName, password=password, exeName=exeName, displayName=serviceDisplayName, perfMonIni=perfMonIni, perfMonDll=perfMonDll, exeArgs=exeArgs, description=description, delayedstart=delayedstart, ) if customOptionHandler: customOptionHandler(*(opts,)) print("Service updated") except win32service.error as exc: print( "Error changing service configuration: %s (%d)" % (exc.strerror, exc.winerror) ) err = exc.winerror elif arg == "remove": knownArg = 1 print("Removing service %s" % (serviceName)) try: RemoveService(serviceName) print("Service removed") except win32service.error as exc: print("Error removing service: %s (%d)" % (exc.strerror, exc.winerror)) err = exc.winerror elif arg == "stop": knownArg = 1 print("Stopping service %s" % (serviceName)) try: if waitSecs: StopServiceWithDeps(serviceName, waitSecs=waitSecs) else: StopService(serviceName) except win32service.error as exc: print("Error stopping service: %s (%d)" % (exc.strerror, exc.winerror)) err = exc.winerror if not knownArg: err = -1 print("Unknown command - '%s'" % arg) usage() return err # # Useful base class to build services from. # class ServiceFramework: # Required Attributes: # _svc_name_ = The service name # _svc_display_name_ = The service display name # Optional Attributes: _svc_deps_ = None # sequence of service names on which this depends _exe_name_ = None # Default to PythonService.exe _exe_args_ = None # Default to no arguments _svc_description_ = ( None # Only exists on Windows 2000 or later, ignored on windows NT ) def __init__(self, args): import servicemanager self.ssh = servicemanager.RegisterServiceCtrlHandler( args[0], self.ServiceCtrlHandlerEx, True ) servicemanager.SetEventSourceName(self._svc_name_) self.checkPoint = 0 def GetAcceptedControls(self): # Setup the service controls we accept based on our attributes. Note # that if you need to handle controls via SvcOther[Ex](), you must # override this. accepted = 0 if hasattr(self, "SvcStop"): accepted |= win32service.SERVICE_ACCEPT_STOP if hasattr(self, "SvcPause") and hasattr(self, "SvcContinue"): accepted |= win32service.SERVICE_ACCEPT_PAUSE_CONTINUE if hasattr(self, "SvcShutdown"): accepted |= win32service.SERVICE_ACCEPT_SHUTDOWN return accepted def ReportServiceStatus( self, serviceStatus, waitHint=5000, win32ExitCode=0, svcExitCode=0 ): if self.ssh is None: # Debugging! return if serviceStatus == win32service.SERVICE_START_PENDING: accepted = 0 else: accepted = self.GetAcceptedControls() if serviceStatus in [ win32service.SERVICE_RUNNING, win32service.SERVICE_STOPPED, ]: checkPoint = 0 else: self.checkPoint += 1 checkPoint = self.checkPoint # Now report the status to the control manager status = ( win32service.SERVICE_WIN32_OWN_PROCESS, serviceStatus, accepted, # dwControlsAccepted, win32ExitCode, # dwWin32ExitCode; svcExitCode, # dwServiceSpecificExitCode; checkPoint, # dwCheckPoint; waitHint, ) win32service.SetServiceStatus(self.ssh, status) def SvcInterrogate(self): # Assume we are running, and everyone is happy. self.ReportServiceStatus(win32service.SERVICE_RUNNING) def SvcOther(self, control): try: print("Unknown control status - %d" % control) except OSError: # services may not have a valid stdout! pass def ServiceCtrlHandler(self, control): return self.ServiceCtrlHandlerEx(control, 0, None) # The 'Ex' functions, which take additional params def SvcOtherEx(self, control, event_type, data): # The default here is to call self.SvcOther as that is the old behaviour. # If you want to take advantage of the extra data, override this method return self.SvcOther(control) def ServiceCtrlHandlerEx(self, control, event_type, data): if control == win32service.SERVICE_CONTROL_STOP: return self.SvcStop() elif control == win32service.SERVICE_CONTROL_PAUSE: return self.SvcPause() elif control == win32service.SERVICE_CONTROL_CONTINUE: return self.SvcContinue() elif control == win32service.SERVICE_CONTROL_INTERROGATE: return self.SvcInterrogate() elif control == win32service.SERVICE_CONTROL_SHUTDOWN: return self.SvcShutdown() else: return self.SvcOtherEx(control, event_type, data) def SvcRun(self): # This is the entry point the C framework calls when the Service is # started. Your Service class should implement SvcDoRun(). # Or you can override this method for more control over the Service # statuses reported to the SCM. # If this method raises an exception, the C framework will detect this # and report a SERVICE_STOPPED status with a non-zero error code. self.ReportServiceStatus(win32service.SERVICE_RUNNING) self.SvcDoRun() # Once SvcDoRun terminates, the service has stopped. # We tell the SCM the service is still stopping - the C framework # will automatically tell the SCM it has stopped when this returns. self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)