mirror of
https://github.com/valitydev/salt.git
synced 2024-11-08 09:23:56 +00:00
363 lines
12 KiB
Python
363 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
'''
|
|
:codeauthor: :email:`Pedro Algarvio (pedro@algarvio.me)`
|
|
|
|
|
|
tests.integration.shell.minion
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
'''
|
|
|
|
# Import python libs
|
|
from __future__ import absolute_import
|
|
import os
|
|
import sys
|
|
import getpass
|
|
import platform
|
|
import yaml
|
|
import signal
|
|
import shutil
|
|
import tempfile
|
|
import logging
|
|
|
|
# Import Salt Testing libs
|
|
from salttesting.helpers import ensure_in_syspath
|
|
ensure_in_syspath('../../')
|
|
|
|
# Import salt libs
|
|
import integration
|
|
from integration.utils import testprogram
|
|
import salt.utils
|
|
import salt.defaults.exitcodes
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
DEBUG = True
|
|
|
|
|
|
class MinionTest(integration.ShellCase, integration.ShellCaseCommonTestsMixIn):
|
|
'''
|
|
Various integration tests for the salt-minion executable.
|
|
'''
|
|
_call_binary_ = 'salt-minion'
|
|
_test_dir = None
|
|
|
|
_test_minions = (
|
|
'minion',
|
|
'subminion',
|
|
)
|
|
|
|
def setUp(self):
|
|
# Setup for scripts
|
|
self._test_dir = tempfile.mkdtemp(prefix='salt-testdaemon-')
|
|
|
|
def tearDown(self):
|
|
# shutdown for scripts
|
|
if self._test_dir and os.path.sep == self._test_dir[0]:
|
|
shutil.rmtree(self._test_dir)
|
|
self._test_dir = None
|
|
|
|
def test_issue_7754(self):
|
|
old_cwd = os.getcwd()
|
|
config_dir = os.path.join(integration.TMP, 'issue-7754')
|
|
if not os.path.isdir(config_dir):
|
|
os.makedirs(config_dir)
|
|
|
|
os.chdir(config_dir)
|
|
|
|
config_file_name = 'minion'
|
|
pid_path = os.path.join(config_dir, '{0}.pid'.format(config_file_name))
|
|
with salt.utils.fopen(self.get_config_file_path(config_file_name), 'r') as fhr:
|
|
config = yaml.load(fhr.read())
|
|
config['log_file'] = 'file:///tmp/log/LOG_LOCAL3'
|
|
|
|
with salt.utils.fopen(os.path.join(config_dir, config_file_name), 'w') as fhw:
|
|
fhw.write(
|
|
yaml.dump(config, default_flow_style=False)
|
|
)
|
|
|
|
ret = self.run_script(
|
|
self._call_binary_,
|
|
'--disable-keepalive --config-dir {0} --pid-file {1} -l debug'.format(
|
|
config_dir,
|
|
pid_path
|
|
),
|
|
timeout=5,
|
|
catch_stderr=True,
|
|
with_retcode=True
|
|
)
|
|
|
|
# Now kill it if still running
|
|
if os.path.exists(pid_path):
|
|
with salt.utils.fopen(pid_path) as fhr:
|
|
try:
|
|
os.kill(int(fhr.read()), signal.SIGKILL)
|
|
except OSError:
|
|
pass
|
|
try:
|
|
self.assertFalse(os.path.isdir(os.path.join(config_dir, 'file:')))
|
|
self.assertIn(
|
|
'Failed to setup the Syslog logging handler', '\n'.join(ret[1])
|
|
)
|
|
self.assertEqual(ret[2], 2)
|
|
finally:
|
|
self.chdir(old_cwd)
|
|
if os.path.isdir(config_dir):
|
|
shutil.rmtree(config_dir)
|
|
|
|
def _run_initscript(
|
|
self,
|
|
init_script,
|
|
minions,
|
|
minion_running,
|
|
action,
|
|
exitstatus=None,
|
|
message=''
|
|
):
|
|
'''
|
|
Wrapper that runs the initscript for the configured minions and
|
|
verifies the results.
|
|
'''
|
|
ret = init_script.run(
|
|
[action],
|
|
catch_stderr=True,
|
|
with_retcode=True,
|
|
timeout=90,
|
|
)
|
|
|
|
# Check minion state
|
|
for minion in minions:
|
|
self.assertEqual(
|
|
minion.is_running(),
|
|
minion_running,
|
|
'Minion "{0}" must be {1} and is not.\nSTDOUT:{2}\nSTDERR:{3}'.format(
|
|
minion.name,
|
|
["stopped", "running"][minion_running],
|
|
'\nSTDOUT:'.join(ret[0]),
|
|
'\nSTDERR:'.join(ret[1]),
|
|
)
|
|
)
|
|
|
|
for line in ret[0]:
|
|
log.debug('script: salt-minion: stdout: {0}'.format(line))
|
|
for line in ret[1]:
|
|
log.debug('script: salt-minion: stderr: {0}'.format(line))
|
|
|
|
if exitstatus is not None:
|
|
self.assertEqual(
|
|
ret[2],
|
|
exitstatus,
|
|
'script action "{0}" {1} exited {2}, must be {3}\nSTDOUT:{4}\nSTDERR:{5}'.format(
|
|
action,
|
|
message,
|
|
ret[2],
|
|
exitstatus,
|
|
'\nSTDOUT:'.join(ret[0]),
|
|
'\nSTDERR:'.join(ret[1]),
|
|
)
|
|
)
|
|
return ret
|
|
|
|
def _initscript_setup(self, minions):
|
|
'''Re-usable setup for running salt-minion tests'''
|
|
user = getpass.getuser()
|
|
|
|
_minions = []
|
|
for mname in minions:
|
|
minion = testprogram.TestDaemonSaltMinion(
|
|
name=mname,
|
|
config={'user': user},
|
|
parent_dir=self._test_dir,
|
|
)
|
|
# Call setup here to ensure config and script exist
|
|
minion.setup()
|
|
_minions.append(minion)
|
|
|
|
# Need salt-call, salt-minion for wrapper script
|
|
salt_call = testprogram.TestProgramSaltCall(parent_dir=self._test_dir)
|
|
# Ensure that run-time files are generated
|
|
salt_call.setup()
|
|
sysconf_dir = os.path.dirname(_minions[0].config_dir)
|
|
cmd_env = {
|
|
'PATH': ':'.join([salt_call.script_dir, os.getenv('PATH')]),
|
|
'PYTHONPATH': ':'.join(sys.path),
|
|
'SALTMINION_DEBUG': '1' if DEBUG else '',
|
|
'SALTMINION_PYTHON': sys.executable,
|
|
'SALTMINION_SYSCONFDIR': sysconf_dir,
|
|
'SALTMINION_BINDIR': _minions[0].script_dir,
|
|
'SALTMINION_CONFIGS': '\n'.join([
|
|
'{0} {1}'.format(user, minion.config_dir) for minion in _minions
|
|
]),
|
|
}
|
|
|
|
default_dir = os.path.join(sysconf_dir, 'default')
|
|
if not os.path.exists(default_dir):
|
|
os.makedirs(default_dir)
|
|
with open(os.path.join(default_dir, 'salt'), 'w') as defaults:
|
|
# Test suites is quite slow - extend the timeout
|
|
defaults.write(
|
|
'TIMEOUT=60\n'
|
|
'TICK=1\n'
|
|
)
|
|
|
|
init_script = testprogram.TestProgram(
|
|
name='init:salt-minion',
|
|
program=os.path.join(integration.CODE_DIR, 'pkg', 'rpm', 'salt-minion'),
|
|
env=cmd_env,
|
|
)
|
|
|
|
return _minions, salt_call, init_script
|
|
|
|
def test_linux_initscript(self):
|
|
'''
|
|
Various tests of the init script to verify that it properly controls a salt minion.
|
|
'''
|
|
|
|
pform = platform.uname()[0].lower()
|
|
if pform not in ('linux',):
|
|
self.skipTest('salt-minion init script is unavailable on {1}'.format(platform))
|
|
|
|
minions, _, init_script = self._initscript_setup(self._test_minions[:1])
|
|
|
|
try:
|
|
# I take visual readability with aligned columns over strict PEP8
|
|
# (bad-whitespace) Exactly one space required after comma
|
|
# pylint: disable=C0326
|
|
ret = self._run_initscript(init_script, minions, False, 'bogusaction', 2)
|
|
ret = self._run_initscript(init_script, minions, False, 'reload', 3) # Not implemented
|
|
ret = self._run_initscript(init_script, minions, False, 'stop', 0, 'when not running')
|
|
ret = self._run_initscript(init_script, minions, False, 'status', 3, 'when not running')
|
|
ret = self._run_initscript(init_script, minions, False, 'condrestart', 7, 'when not running')
|
|
ret = self._run_initscript(init_script, minions, False, 'try-restart', 7, 'when not running')
|
|
ret = self._run_initscript(init_script, minions, True, 'start', 0, 'when not running')
|
|
|
|
ret = self._run_initscript(init_script, minions, True, 'status', 0, 'when running')
|
|
# Verify that PIDs match
|
|
for (minion, stdout) in zip(minions, ret[0]):
|
|
status_pid = int(stdout.rsplit(' ', 1)[-1])
|
|
self.assertEqual(
|
|
status_pid,
|
|
minion.daemon_pid,
|
|
'PID in "{0}" is {1} and does not match status PID {2}'.format(
|
|
minion.pid_path,
|
|
minion.daemon_pid,
|
|
status_pid
|
|
)
|
|
)
|
|
|
|
ret = self._run_initscript(init_script, minions, True, 'start', 0, 'when running')
|
|
ret = self._run_initscript(init_script, minions, True, 'condrestart', 0, 'when running')
|
|
ret = self._run_initscript(init_script, minions, True, 'try-restart', 0, 'when running')
|
|
ret = self._run_initscript(init_script, minions, False, 'stop', 0, 'when running')
|
|
|
|
finally:
|
|
# Ensure that minions are shutdown
|
|
for minion in minions:
|
|
minion.shutdown()
|
|
|
|
def _assert_exit_status(self, status, ex_status, message=None, stdout=None, stderr=None):
|
|
'''
|
|
Helper function to verify exit status and emit failure information.
|
|
'''
|
|
|
|
ex_val = getattr(salt.defaults.exitcodes, ex_status)
|
|
_message = '' if not message else ' ({0})'.format(message)
|
|
_stdout = '' if not stdout else '\nstdout: {0}'.format('\nstdout: '.join(stdout))
|
|
_stderr = '' if not stderr else '\nstderr: {0}'.format('\nstderr: '.join(stderr))
|
|
self.assertEqual(
|
|
status,
|
|
ex_val,
|
|
'Exit status was {0}, must be {1} (salt.default.exitcodes.{2}){3}{4}{5}'.format(
|
|
status,
|
|
ex_val,
|
|
ex_status,
|
|
_message,
|
|
_stderr,
|
|
_stderr,
|
|
)
|
|
)
|
|
|
|
def test_exit_status_unknown_user(self):
|
|
'''
|
|
Ensure correct exit status when the minion is configured to run as an unknown user.
|
|
'''
|
|
|
|
minion = testprogram.TestDaemonSaltMinion(
|
|
name='unknown_user',
|
|
program=os.path.join(integration.CODE_DIR, 'scripts', 'salt-minion'),
|
|
config={'user': 'unknown'},
|
|
parent_dir=self._test_dir,
|
|
env={
|
|
'PYTHONPATH': ':'.join(sys.path),
|
|
},
|
|
)
|
|
# Call setup here to ensure config and script exist
|
|
minion.setup()
|
|
stdout, stderr, status = minion.run(
|
|
args=['-d'],
|
|
catch_stderr=True,
|
|
with_retcode=True,
|
|
)
|
|
self._assert_exit_status(
|
|
status,
|
|
'EX_NOUSER',
|
|
message='unknown user not on system',
|
|
stdout=stdout,
|
|
stderr=stderr
|
|
)
|
|
|
|
# pylint: disable=invalid-name
|
|
def test_exit_status_unknown_argument(self):
|
|
'''
|
|
Ensure correct exit status when an unknown argument is passed to salt-minion.
|
|
'''
|
|
|
|
user = getpass.getuser()
|
|
|
|
minion = testprogram.TestDaemonSaltMinion(
|
|
name='unknown_argument',
|
|
program=os.path.join(integration.CODE_DIR, 'scripts', 'salt-minion'),
|
|
config={'user': user},
|
|
parent_dir=self._test_dir,
|
|
env={
|
|
'PYTHONPATH': ':'.join(sys.path),
|
|
},
|
|
)
|
|
# Call setup here to ensure config and script exist
|
|
minion.setup()
|
|
stdout, stderr, status = minion.run(
|
|
args=['-d', '--unknown-argument'],
|
|
catch_stderr=True,
|
|
with_retcode=True,
|
|
)
|
|
self._assert_exit_status(status, 'EX_USAGE', message='unknown argument', stdout=stdout, stderr=stderr)
|
|
|
|
def test_exit_status_correct_usage(self):
|
|
'''
|
|
Ensure correct exit status when salt-minion starts correctly.
|
|
'''
|
|
|
|
user = getpass.getuser()
|
|
|
|
minion = testprogram.TestDaemonSaltMinion(
|
|
name='correct_usage',
|
|
program=os.path.join(integration.CODE_DIR, 'scripts', 'salt-minion'),
|
|
config={'user': user},
|
|
parent_dir=self._test_dir,
|
|
env={
|
|
'PYTHONPATH': ':'.join(sys.path),
|
|
},
|
|
)
|
|
# Call setup here to ensure config and script exist
|
|
minion.setup()
|
|
stdout, stderr, status = minion.run(
|
|
args=['-d'],
|
|
catch_stderr=True,
|
|
with_retcode=True,
|
|
)
|
|
self._assert_exit_status(status, 'EX_OK', message='correct usage', stdout=stdout, stderr=stderr)
|
|
minion.shutdown()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
integration.run_tests(MinionTest)
|