def Run(self, unused_arg):
"""This kills us with no cleanups."""
logging.debug("Disabling service")
win32serviceutil.ChangeServiceConfig(
None, config_lib.CONFIG["Nanny.service_name"],
startType=win32service.SERVICE_DISABLED)
svc_config = QueryService(config_lib.CONFIG["Nanny.service_name"])
if svc_config[1] == win32service.SERVICE_DISABLED:
logging.info("Disabled service successfully")
self.SendReply(string="Service disabled.")
else:
self.SendReply(string="Service failed to disable.")
def is_installed(self):
"""Determines whether this service is installed on this system.
Returns:
True when this service is installed on this system and false
when it was not installed on this system.
"""
try:
win32serviceutil.ChangeServiceConfig(self.class_name, self.name)
except:
return False
return True
def setup(cls, cmd, user=None, password=None, startup='manual', cwd=None, wait=0):
from gramex.config import app_log
name, service_name = cls._svc_display_name_, cls._svc_name_
port = getattr(cls, '_svc_port_', None)
if cwd is None:
cwd = os.getcwd()
info = (name, cwd, 'port %s' % port if port is not None else '')
service_class = win32serviceutil.GetServiceClassString(cls)
startup = cls.startup_map[startup]
running = win32service.SERVICE_RUNNING
if cmd[0] == 'install':
win32serviceutil.InstallService(
service_class, service_name, displayName=name, description=cls._svc_description_,
startType=startup, userName=user, password=password)
win32serviceutil.SetServiceCustomOption(cls._svc_name_, 'cwd', cwd)
app_log.info('Installed service. %s will run from %s %s' % info)
elif cmd[0] in {'update', 'change'}:
win32serviceutil.ChangeServiceConfig(
service_class, service_name, displayName=name, description=cls._svc_description_,
startType=startup, userName=user, password=password)
win32serviceutil.SetServiceCustomOption(cls._svc_name_, 'cwd', cwd)
app_log.info('Updated service. %s will run from %s %s' % info)
elif cmd[0] in {'remove', 'uninstall'}:
try:
win32serviceutil.StopService(service_name)
except pywintypes.error as e:
if e.args[0] != winerror.ERROR_SERVICE_NOT_ACTIVE:
raise
win32serviceutil.RemoveService(service_name)
app_log.info('Removed service. %s ran from %s %s' % info)
elif cmd[0] == 'start':
win32serviceutil.StartService(service_name, cmd[1:])
if wait:
win32serviceutil.WaitForServiceStatus(service_name, running, wait)
app_log.info('Started service %s at %s %s' % info)
elif cmd[0] == 'stop':
if wait:
win32serviceutil.StopServiceWithDeps(service_name, waitSecs=wait)
else:
win32serviceutil.StopService(service_name)
app_log.info('Stopped service %s at %s %s' % info)
elif cmd[0]:
app_log.error('Unknown command: %s' % cmd[0])
def stop_services(services: list, disable_startup: bool = True) -> None:
import win32serviceutil
print('Number of services: %i' % len(services))
print('Stopping services...')
for service in services:
print()
try:
if win32serviceutil.QueryServiceStatus(service[0])[1] == 4:
win32serviceutil.StopService(service[0])
print('%s stopped.' % service[1])
else:
print('%s was already stopped.' % service[1])
except:
print('\tCould not stop service %s!' % service[1])
if disable_startup:
try:
win32serviceutil.ChangeServiceConfig(None, serviceName=service[0], startType='disabled', delayedstart=None)
print('%s startup settings changed.' % service[1])
except:
print('\tCould not change settings of service %s!' % service[1])
if service[1] == 'Update Orchestrator Service':
print('\tThis is an expected behaviour.')
print('\nFinished stopping services.')
def config(self, svc_disp=None, svc_desp=None, svc_deps=None, username=None, password=None, exe_name=None, exe_args=None, startup=None, interactive=None):
starttype = None
delayedstart = None
if startup is not None:
mapping = {"manual": win32service.SERVICE_DEMAND_START,
"auto": win32service.SERVICE_AUTO_START,
"delayed": win32service.SERVICE_AUTO_START,
"disabled": win32service.SERVICE_DISABLED}
try:
starttype = mapping[startup.lower()]
except KeyError:
logger.info("'%s' is not a valid startup option", startup)
if startup.lower() == "delayed":
delayedstart = True
elif startup.lower() == "auto":
delayedstart = False
try:
win32serviceutil.ChangeServiceConfig(self.svc_clss,
self.svc_name,
serviceDeps=svc_deps,
startType=starttype,
bRunInteractive=interactive,
userName=username,
password=password,
exeName=exe_name,
displayName=svc_disp,
perfMonIni=None,
perfMonDll=None,
exeArgs=exe_args,
description=svc_desp,
delayedstart=delayedstart)
logger.info("service '%s' updated", self.svc_name)
except win32service.error as exc:
logger.info("error changing service '%s' configuration: %s (%d)", self.svc_name, exc.strerror, exc.winerror)
def HandleCommandLine(cls,
command,
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
serviceName = cls._svc_name_
serviceDisplayName = cls._svc_display_name_
serviceClassString = "aservice"
# Pull apart the command line
import getopt
opts = []
args = []
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
}
try:
startup = map[val.lower()]
except KeyError:
print("'%s' is not a valid startup option" % val)
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.")
arg = command
knownArg = 0
# First we process all arguments which pass additional args on
if arg == "start":
knownArg = 1
print("Starting service %s" % (serviceName))
try:
win32serviceutil.StartService(serviceName, args[1:])
if waitSecs:
WaitForServiceStatus(serviceName, win32service.SERVICE_RUNNING,
waitSecs)
except Exception as ex:
print("Error starting service:", ex)
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 Exception as ex:
print("The service does not appear to be installed.")
print("Please install the service before debugging it.")
sys.exit(1)
try:
os.system("%s -debug %s %s" % (exeName, 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("Installing service %s" % (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 doesnt!
try:
win32serviceutil.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 ex: # Can be raised by custom option handler.
print("Error installing service: ", ex.message)
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:
win32serviceutil.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
