def action_configure(self):
hSCM = safe_open_scmanager()
try:
hSvc = safe_open_service(hSCM, self.resource.service_name)
self._fix_start_type()
try:
win32service.ChangeServiceConfig(
hSvc, win32service.SERVICE_NO_CHANGE,
self.resource.start_type, win32service.SERVICE_NO_CHANGE,
None, None, 0, None, None, None,
self.resource.display_name)
if self.resource.description:
try:
win32service.ChangeServiceConfig2(
hSvc, win32service.SERVICE_CONFIG_DESCRIPTION,
self.resource.description)
except NotImplementedError:
pass ## ChangeServiceConfig2 and description do not exist on NT
except win32api.error, details:
raise Fail("Error configuring service {0}: {1}".format(
self.resource.service_name, details.winerror))
finally:
win32service.CloseServiceHandle(hSvc)
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 = 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')
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 Update(cls, startupMode="auto", username=None, password=None):
# Handle the default arguments.
if startupMode is None:
startType = win32service.SERVICE_NO_CHANGE
else:
startType = cls._get_start_type(startupMode)
hscm = win32service.OpenSCManager(None, None,
win32service.SC_MANAGER_ALL_ACCESS)
serviceType = win32service.SERVICE_WIN32_OWN_PROCESS
commandLine = os.path.abspath(cls._exe_name_)
try:
hs = SmartOpenService(hscm, cls._svc_name_,
win32service.SERVICE_ALL_ACCESS)
try:
win32service.ChangeServiceConfig(
hs,
serviceType, # service type
startType,
win32service.SERVICE_NO_CHANGE, # error control type
commandLine,
None,
0,
None,
username,
password,
cls._svc_display_name_)
print "Service updated"
finally:
win32service.CloseServiceHandle(hs)
finally:
win32service.CloseServiceHandle(hscm)
def on_host_init_response(self, message):
global_variables = message.body.get('global_variables') or []
for kv in global_variables:
self._global_variables[kv['name']] = kv['value'].encode(
'utf-8') if kv['value'] else ''
if 'chef' in message.body and message.body['chef']:
if linux.os.windows_family:
self._chef_client_bin = r'C:\opscode\chef\bin\chef-client.bat'
self._chef_solo_bin = r'C:\opscode\chef\bin\chef-solo.bat'
else:
# Workaround for 'chef' behavior enabled, but chef not installed
self._chef_client_bin = which('chef-client')
self._chef_solo_bin = which('chef-solo')
self._chef_data = message.chef.copy()
if not self._chef_data.get('node_name'):
self._chef_data['node_name'] = self.get_node_name()
self._with_json_attributes = self._chef_data.get(
'json_attributes', {}) or {}
if self._with_json_attributes:
self._with_json_attributes = json.loads(
self._with_json_attributes)
self._run_list = self._chef_data.get('run_list')
if self._run_list:
self._with_json_attributes['run_list'] = json.loads(
self._run_list)
elif self._chef_data.get('role'):
self._with_json_attributes['run_list'] = [
"role[%s]" % self._chef_data['role']
]
if linux.os.windows_family:
# TODO: why not doing the same on linux?
try:
# Set startup type to 'manual' for chef-client service
hscm = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_ALL_ACCESS)
try:
hs = win32serviceutil.SmartOpenService(
hscm, WIN_SERVICE_NAME,
win32service.SERVICE_ALL_ACCESS)
try:
snc = win32service.SERVICE_NO_CHANGE
# change only startup type
win32service.ChangeServiceConfig(
hs, snc, win32service.SERVICE_DEMAND_START,
snc, None, None, 0, None, None, None, None)
finally:
win32service.CloseServiceHandle(hs)
finally:
win32service.CloseServiceHandle(hscm)
win32serviceutil.StopService(WIN_SERVICE_NAME)
except:
e = sys.exc_info()[1]
self._logger.warning('Could not stop chef service: %s' % e)
def enable(self):
if win32service.QueryServiceConfig(
self._service_handle)[1] == win32service.SERVICE_DISABLED:
win32service.ChangeServiceConfig(self._service_handle,
win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_DEMAND_START,
win32service.SERVICE_NO_CHANGE,
None, None, 0, None, None, None,
None)
def set_service_credentials(self, service_name, username, password):
LOG.debug('Setting service credentials: %s', service_name)
with self._get_service_handle(
service_name, win32service.SERVICE_CHANGE_CONFIG) as hs:
win32service.ChangeServiceConfig(hs,
win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_NO_CHANGE,
None, None, False, None, username,
password, None)
def set_start_type(self, start_type):
""" Change the startup type of the service. """
hService = winsvc.OpenService(self.scm_handle, self.ServiceName,
winsvc.SERVICE_CHANGE_CONFIG)
try:
winsvc.ChangeServiceConfig(hService, winsvc.SERVICE_NO_CHANGE,
start_type, winsvc.SERVICE_NO_CHANGE,
None, None, False, None, None, None,
None)
except pywintypes.error, e:
self.last_error = e.strerror
def OnOK(self):
self.BeginWaitCursor()
starttype = self.GetCheckedRadioButton(self.IDC_BOOT, self.IDC_DISABLED) - self.IDC_BOOT
try:
win32service.ChangeServiceConfig(self.service, win32service.SERVICE_NO_CHANGE, starttype,
win32service.SERVICE_NO_CHANGE, None, None, 0, None, None, None, None)
except:
self.MessageBox('Unable to change startup configuration', None,
win32con.MB_ICONEXCLAMATION)
self.EndWaitCursor()
return dialog.Dialog.OnOK(self)
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):
# 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 = 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
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 setstartup(self, startuptype):
self.startuptype = startuptype.lower()
if self.startuptype == "boot":
self.suptype = 0
elif self.startuptype == "system":
self.suptype = 1
elif self.startuptype == "automatic":
self.suptype = 2
elif self.startuptype == "manual":
self.suptype = 3
elif self.startuptype == "disabled":
self.suptype = 4
self.snc = ws.SERVICE_NO_CHANGE
ws.ChangeServiceConfig(self.handle, self.snc, self.suptype, \
self.snc, None, None, 0, None, None, None, self.lserv)
def enable(self):
hSCM = safe_open_scmanager()
try:
hSvc = safe_open_service(hSCM, self.resource.service_name)
if win32service.QueryServiceConfig(
hSvc)[1] == win32service.SERVICE_DISABLED:
win32service.ChangeServiceConfig(
hSvc, win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_DEMAND_START,
win32service.SERVICE_NO_CHANGE, None, None, 0, None, None,
None, None)
win32service.CloseServiceHandle(hSvc)
except win32api.error, details:
raise Fail("Error enabling service {0}: {1}".format(
self.resource.service_name, details.winerror))
def action_change_user(self):
hSCM = safe_open_scmanager()
try:
hSvc = safe_open_service(hSCM, self.resource.service_name)
self._fix_user_name()
try:
win32service.ChangeServiceConfig(
hSvc, win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_NO_CHANGE,
win32service.SERVICE_NO_CHANGE, None, None, 0, None,
self.resource.username, self.resource.password, None)
except win32api.error, details:
raise Fail("Error changing user for service {0}: {1}".format(
self.resource.service_name, details.winerror))
finally:
win32service.CloseServiceHandle(hSvc)
def _SaveExistingService(self, serviceConfigManagerHandle, serviceStartNamePassword=None):
serviceHandle = None
try:
serviceHandle = win32service.OpenService(serviceConfigManagerHandle,
self.configurations['ServiceName'].StringValue(),
win32service.SERVICE_CHANGE_CONFIG | win32service.SERVICE_START)
win32service.ChangeServiceConfig(serviceHandle,
self.configurations['ServiceType'].Win32Value(),
self.configurations['StartType'].Win32Value(),
self.configurations['ErrorControl'].Win32Value(),
self.configurations['BinaryPathName'].Win32Value(),
self.configurations['LoadOrderGroup'].Win32Value(),
0,
self.configurations['Dependencies'].Win32Value(),
self.configurations['ServiceStartName'].Win32Value(),
serviceStartNamePassword,
self.configurations['DisplayName'].Win32Value())
finally:
if serviceHandle:
win32service.CloseServiceHandle(serviceHandle)
def setstartup(self, startuptype):
sut = startuptype.lower()
if sut == "boot":
suptype_id = 0
elif sut == "system":
suptype_id = 1
elif sut == "automatic":
suptype_id = 2
elif sut == "manual":
suptype_id = 3
elif sut == "disabled":
suptype_id = 4
if self.handle is None:
self._log.info('The %s service does not exist.' % self.userv)
else:
ws.ChangeServiceConfig(self.handle, ws.SERVICE_NO_CHANGE,
suptype_id, ws.SERVICE_NO_CHANGE, None,
None, 0, None, None, None, self.lserv)
def on_host_init_response(self, message):
self._global_variables = message.body.get('global_variables') or []
# global_variables = message.body.get('global_variables') or []
# for kv in global_variables:
# self._global_variables[kv['name']] = kv['value'].encode('utf-8') if kv['value'] else ''
if 'chef' in message.body and message.body['chef']:
self._hir_data = message.body.copy()
self._chef_data = message.chef.copy()
if not self._chef_data.get('node_name'):
self._chef_data['node_name'] = self.get_node_name()
self._chef_data['first_bootstrap'] = True
self._with_json_attributes = extract_json_attributes(
self._chef_data)
if linux.os.windows_family:
# TODO: why not doing the same on linux?
try:
# Set startup type to 'manual' for chef-client service
hscm = win32service.OpenSCManager(
None, None, win32service.SC_MANAGER_ALL_ACCESS)
try:
hs = win32serviceutil.SmartOpenService(
hscm, WIN_SERVICE_NAME,
win32service.SERVICE_ALL_ACCESS)
try:
snc = win32service.SERVICE_NO_CHANGE
# change only startup type
win32service.ChangeServiceConfig(
hs, snc, win32service.SERVICE_DEMAND_START,
snc, None, None, 0, None, None, None, None)
finally:
win32service.CloseServiceHandle(hs)
finally:
win32service.CloseServiceHandle(hscm)
win32serviceutil.StopService(WIN_SERVICE_NAME)
except:
e = sys.exc_info()[1]
self._logger.warning('Could not stop chef service: %s' % e)
def setstartup(self, startuptype):
self.startuptype = startuptype.lower()
self.snc = win32service.SERVICE_NO_CHANGE
win32service.ChangeServiceConfig(self.handle, self.snc, self.suptype,
self.snc, None, None, 0, None, None,
None, self.lserv)
def modify(
name,
bin_path=None,
exe_args=None,
display_name=None,
description=None,
service_type=None,
start_type=None,
start_delayed=None,
error_control=None,
load_order_group=None,
dependencies=None,
account_name=None,
account_password=None,
run_interactive=None,
):
# pylint: disable=anomalous-backslash-in-string
"""
Modify a service's parameters. Changes will not be made for parameters that
are not passed.
.. versionadded:: 2016.11.0
Args:
name (str):
The name of the service. Can be found using the
``service.get_service_name`` function
bin_path (str):
The path to the service executable. Backslashes must be escaped, eg:
``C:\\path\\to\\binary.exe``
exe_args (str):
Any arguments required by the service executable
display_name (str):
The name to display in the service manager
description (str):
The description to display for the service
service_type (str):
Specifies the service type. Default is ``own``. Valid options are as
follows:
- kernel: Driver service
- filesystem: File system driver service
- adapter: Adapter driver service (reserved)
- recognizer: Recognizer driver service (reserved)
- own (default): Service runs in its own process
- share: Service shares a process with one or more other services
start_type (str):
Specifies the service start type. Valid options are as follows:
- boot: Device driver that is loaded by the boot loader
- system: Device driver that is started during kernel initialization
- auto: Service that automatically starts
- manual: Service must be started manually
- disabled: Service cannot be started
start_delayed (bool):
Set the service to Auto(Delayed Start). Only valid if the start_type
is set to ``Auto``. If service_type is not passed, but the service
is already set to ``Auto``, then the flag will be set.
error_control (str):
The severity of the error, and action taken, if this service fails
to start. Valid options are as follows:
- normal: Error is logged and a message box is displayed
- severe: Error is logged and computer attempts a restart with the
last known good configuration
- critical: Error is logged, computer attempts to restart with the
last known good configuration, system halts on failure
- ignore: Error is logged and startup continues, no notification is
given to the user
load_order_group (str):
The name of the load order group to which this service belongs
dependencies (list):
A list of services or load ordering groups that must start before
this service
account_name (str):
The name of the account under which the service should run. For
``own`` type services this should be in the ``domain\\username``
format. The following are examples of valid built-in service
accounts:
- NT Authority\\LocalService
- NT Authority\\NetworkService
- NT Authority\\LocalSystem
- .\\LocalSystem
account_password (str):
The password for the account name specified in ``account_name``. For
the above built-in accounts, this can be None. Otherwise a password
must be specified.
run_interactive (bool):
If this setting is True, the service will be allowed to interact
with the user. Not recommended for services that run with elevated
privileges.
Returns:
dict: a dictionary of changes made
CLI Example:
.. code-block:: bash
salt '*' service.modify spooler start_type=disabled
"""
# pylint: enable=anomalous-backslash-in-string
# https://msdn.microsoft.com/en-us/library/windows/desktop/ms681987(v=vs.85).aspx
# https://msdn.microsoft.com/en-us/library/windows/desktop/ms681988(v-vs.85).aspx
handle_scm = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_CONNECT)
try:
handle_svc = win32service.OpenService(
handle_scm,
name,
win32service.SERVICE_CHANGE_CONFIG | win32service.SERVICE_QUERY_CONFIG,
)
except pywintypes.error as exc:
raise CommandExecutionError("Failed To Open {}: {}".format(name, exc.strerror))
config_info = win32service.QueryServiceConfig(handle_svc)
changes = dict()
# Input Validation
if bin_path is not None:
# shlex.quote the path to the binary
bin_path = _cmd_quote(bin_path)
if exe_args is not None:
bin_path = "{} {}".format(bin_path, exe_args)
changes["BinaryPath"] = bin_path
if service_type is not None:
if service_type.lower() in SERVICE_TYPE:
service_type = SERVICE_TYPE[service_type.lower()]
if run_interactive:
service_type = service_type | win32service.SERVICE_INTERACTIVE_PROCESS
else:
raise CommandExecutionError("Invalid Service Type: {}".format(service_type))
else:
if run_interactive is True:
service_type = config_info[0] | win32service.SERVICE_INTERACTIVE_PROCESS
elif run_interactive is False:
service_type = config_info[0] ^ win32service.SERVICE_INTERACTIVE_PROCESS
else:
service_type = win32service.SERVICE_NO_CHANGE
if service_type is not win32service.SERVICE_NO_CHANGE:
flags = list()
for bit in SERVICE_TYPE:
if isinstance(bit, int) and service_type & bit:
flags.append(SERVICE_TYPE[bit])
changes["ServiceType"] = flags if flags else service_type
if start_type is not None:
if start_type.lower() in SERVICE_START_TYPE:
start_type = SERVICE_START_TYPE[start_type.lower()]
else:
raise CommandExecutionError("Invalid Start Type: {}".format(start_type))
changes["StartType"] = SERVICE_START_TYPE[start_type]
else:
start_type = win32service.SERVICE_NO_CHANGE
if error_control is not None:
if error_control.lower() in SERVICE_ERROR_CONTROL:
error_control = SERVICE_ERROR_CONTROL[error_control.lower()]
else:
raise CommandExecutionError(
"Invalid Error Control: {}".format(error_control)
)
changes["ErrorControl"] = SERVICE_ERROR_CONTROL[error_control]
else:
error_control = win32service.SERVICE_NO_CHANGE
if account_name is not None:
changes["ServiceAccount"] = account_name
if account_name in ["LocalSystem", "LocalService", "NetworkService"]:
account_password = ""
if account_password is not None:
changes["ServiceAccountPassword"] = "******"
if load_order_group is not None:
changes["LoadOrderGroup"] = load_order_group
if dependencies is not None:
changes["Dependencies"] = dependencies
if display_name is not None:
changes["DisplayName"] = display_name
win32service.ChangeServiceConfig(
handle_svc,
service_type,
start_type,
error_control,
bin_path,
load_order_group,
0,
dependencies,
account_name,
account_password,
display_name,
)
if description is not None:
win32service.ChangeServiceConfig2(
handle_svc, win32service.SERVICE_CONFIG_DESCRIPTION, description
)
changes["Description"] = description
if start_delayed is not None:
# You can only set delayed start for services that are set to auto start
# Start type 2 is Auto
# Start type -1 is no change
if (start_type == -1 and config_info[1] == 2) or start_type == 2:
win32service.ChangeServiceConfig2(
handle_svc,
win32service.SERVICE_CONFIG_DELAYED_AUTO_START_INFO,
start_delayed,
)
changes["StartTypeDelayed"] = start_delayed
else:
changes["Warning"] = 'start_delayed: Requires start_type "auto"'
win32service.CloseServiceHandle(handle_scm)
win32service.CloseServiceHandle(handle_svc)
return changes
def _set_service_startup_type(self, service, start_type):
win32service.ChangeServiceConfig(service,
win32service.SERVICE_NO_CHANGE,
start_type,
win32service.SERVICE_NO_CHANGE, None,
None, 0, None, None, None, None)
