def test_threshold_exceeded(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (
self.fixture_status_xml(1000, 1000),
"",
0
)
assert_raise_library_error(
lambda: lib.resource_cleanup(mock_runner),
(
Severity.ERROR,
report_codes.RESOURCE_CLEANUP_TOO_TIME_CONSUMING,
{"threshold": 100},
report_codes.FORCE_LOAD_THRESHOLD
)
)
mock_runner.run.assert_called_once_with(self.crm_mon_cmd())
def test_user(self, mock_runner):
expected_runner = mock.MagicMock()
mock_runner.return_value = expected_runner
user = "******"
env = LibraryEnvironment(
self.mock_logger,
self.mock_reporter,
user_login=user
)
runner = env.cmd_runner()
self.assertEqual(expected_runner, runner)
mock_runner.assert_called_once_with(
self.mock_logger,
self.mock_reporter,
{
"CIB_user": user,
"LC_ALL": "C",
}
)
def test_raises_when_duplicate_element_found(self, export_with_set):
export_with_set.return_value = "exported_duplicate_element"
element = mock.MagicMock()
element.tag = "constraint_type"
report_processor = MockLibraryReportProcessor()
assert_raise_library_error(
lambda: constraint.check_is_without_duplication(
report_processor,
fixture_constraint_section(["duplicate_element"]),
element,
are_duplicate=lambda e1, e2: True,
export_element=constraint.export_with_set,
),
(severities.ERROR, report_codes.DUPLICATE_CONSTRAINTS_EXIST, {
'constraint_info_list': ['exported_duplicate_element'],
'constraint_type': 'constraint_type'
}, report_codes.FORCE_CONSTRAINT_DUPLICATE),
)
def test_unstandby_all(self):
nodes = ("node1", "node2", "node3")
for i, n in enumerate(nodes, 1):
self.fixture_add_node_status(self.fixture_get_node_status(n, i))
mock_runner = mock.MagicMock(spec_set=CommandRunner)
call_list = [mock.call(self.crm_mon_cmd())]
call_list += [
mock.call([self.path("crm_standby"), "-D", "-N", n]) for n in nodes
]
return_value_list = [(str(self.status), "", 0)]
return_value_list += [("dummy", "", 0) for n in nodes]
mock_runner.run.side_effect = return_value_list
output = lib.nodes_unstandby(mock_runner, all_nodes=True)
self.assertEqual(len(return_value_list), len(call_list))
self.assertEqual(len(return_value_list), mock_runner.run.call_count)
mock_runner.run.assert_has_calls(call_list)
self.assertEqual(None, output)
def test_success(self, mock_func):
mock_com = mock.MagicMock(spec_set=NodeCommunicator)
mock_rep = MockLibraryReportProcessor()
node_list = [NodeAddresses("node" + str(i)) for i in range(2)]
data = {
node_list[0]: {
"watchdog": "/dev/watchdog1",
"device_list": ["/dev/sdb", "/dev/vda1"],
},
node_list[1]: {
"watchdog": "/dev/watchdog2",
"device_list": ["/dev/sda2"],
}
}
lib_sbd.check_sbd_on_all_nodes(mock_rep, mock_com, data)
items = sorted(data.items())
mock_func.assert_called_once_with(lib_sbd.check_sbd_on_node, [([
mock_rep, mock_com, node, data["watchdog"], data["device_list"]
], {}) for node, data in items])
def test_success(self, mock_named_file):
mock_file = mock.MagicMock()
mock_file.name = "mock_file_name"
mock_file.read.return_value = "<cib/>"
mock_named_file.return_value = mock_file
self.mock_runner.run.return_value = ("", "", 0)
self.assertEqual(
"<cib/>",
lib.upgrade_cib_file(etree.XML("<old_cib/>"), self.mock_runner))
mock_named_file.assert_called_once_with("w+", suffix=".pcs")
mock_file.write.assert_called_once_with("<old_cib/>")
mock_file.flush.assert_called_once_with()
self.mock_runner.run.assert_called_once_with(
[
join(settings.pacemaker_binaries, "cibadmin"), "--upgrade",
"--force"
],
env_extend={"CIB_file": "mock_file_name"})
mock_file.seek.assert_called_once_with(0)
mock_file.read.assert_called_once_with()
def test_invalid_status(self):
expected_stdout = "invalid xml"
expected_stderr = ""
expected_retval = 0
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (
expected_stdout,
expected_stderr,
expected_retval
)
assert_raise_library_error(
lambda: lib.get_local_node_status(mock_runner),
(
Severity.ERROR,
report_codes.BAD_CLUSTER_STATE_FORMAT,
{}
)
)
mock_runner.run.assert_called_once_with(self.crm_mon_cmd())
def test_success(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = ("\n".join([
"heartbeat",
"openstack",
"pacemaker",
"booth",
"",
]), "", 0)
self.assertEqual(
lib_ra.list_resource_agents_ocf_providers(mock_runner), [
"booth",
"heartbeat",
"openstack",
"pacemaker",
])
mock_runner.run.assert_called_once_with(
["/usr/sbin/crm_resource", "--list-ocf-providers"])
def setUp(self):
self.agent = lib_ra.AgentMetadata(
mock.MagicMock(spec_set=CommandRunner))
self.metadata = etree.XML("""
<resource-agent>
<parameters>
<parameter name="test_param" required="0">
<longdesc>Long description</longdesc>
<shortdesc>short description</shortdesc>
<content type="string" default="default_value" />
</parameter>
<parameter name="required_param" required="1">
<content type="boolean" />
</parameter>
<parameter name="another_required_param" required="1">
<content type="string" />
</parameter>
</parameters>
</resource-agent>
""")
def test_upgrade_failed(self, mock_named_file):
mock_file = mock.MagicMock()
mock_file.name = "mock_file_name"
mock_named_file.return_value = mock_file
self.mock_runner.run.return_value = ("some info", "some error", 1)
assert_raise_library_error(
lambda: lib.upgrade_cib_file(etree.XML("<old_cib/>"), self.
mock_runner),
(severities.ERROR, report_codes.CIB_UPGRADE_FAILED, {
"reason": "some error\nsome info",
}))
mock_named_file.assert_called_once_with("w+", suffix=".pcs")
mock_file.write.assert_called_once_with("<old_cib/>")
mock_file.flush.assert_called_once_with()
self.mock_runner.run.assert_called_once_with(
[
join(settings.pacemaker_binaries, "cibadmin"), "--upgrade",
"--force"
],
env_extend={"CIB_file": "mock_file_name"})
def test_scope_error(self):
expected_stdout = "some info"
expected_stderr = "some error"
expected_retval = 6
scope = "test_scope"
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (expected_stdout, expected_stderr,
expected_retval)
assert_raise_library_error(
lambda: lib.get_cib_xml(mock_runner, scope=scope),
(Severity.ERROR, report_codes.CIB_LOAD_ERROR_SCOPE_MISSING, {
"scope": scope,
"reason": expected_stderr + "\n" + expected_stdout,
}))
mock_runner.run.assert_called_once_with([
self.path("cibadmin"), "--local", "--query",
"--scope={0}".format(scope)
])
def test_basic(self):
expected_stdout = "expected output"
expected_stderr = "expected stderr"
mock_runner = mock.MagicMock(spec_set=CommandRunner)
call_list = [
mock.call(self.crm_mon_cmd()),
mock.call([self.path("crm_resource"), "--cleanup"]),
]
return_value_list = [
(self.fixture_status_xml(1, 1), "", 0),
(expected_stdout, expected_stderr, 0),
]
mock_runner.run.side_effect = return_value_list
real_output = lib.resource_cleanup(mock_runner)
self.assertEqual(len(return_value_list), len(call_list))
self.assertEqual(len(return_value_list), mock_runner.run.call_count)
mock_runner.run.assert_has_calls(call_list)
self.assertEqual(expected_stdout + "\n" + expected_stderr, real_output)
def test_wait_timeout_success(self):
expected_stdout = "expected output"
expected_stderr = "expected stderr"
expected_retval = 0
timeout = 10
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (
expected_stdout,
expected_stderr,
expected_retval
)
self.assertEqual(None, lib.wait_for_idle(mock_runner, timeout))
mock_runner.run.assert_called_once_with(
[
self.path("crm_resource"),
"--wait", "--timeout={0}".format(timeout)
]
)
def test_skip_agent_name_when_InvalidResourceAgentName_raised(self):
invalid_agent_name = "systemd:lvm2-pvscan@252:2" #suppose it is invalid
class Agent(object):
def __init__(self, runner, name):
if name == invalid_agent_name:
raise lib_ra.InvalidResourceAgentName(name)
self.name = name
def get_name_info(self):
return self.name
self.assertEqual(["ocf:heartbeat:Dummy"],
lib._complete_agent_list(
mock.MagicMock(),
["ocf:heartbeat:Dummy", invalid_agent_name],
describe=False,
search=False,
metadata_class=Agent,
))
def test_catch_exactly_his_exception(self, mock_is_file,
mock_console_report):
next_in_line = mock.Mock(side_effect=LibraryEnvError(
ReportItem.error(report_codes.FILE_DOES_NOT_EXIST,
info={
"file_role": env_file_role_codes.BOOTH_CONFIG,
}),
ReportItem.error(report_codes.FILE_DOES_NOT_EXIST,
info={
"file_role": env_file_role_codes.BOOTH_KEY,
}),
ReportItem.error("OTHER ERROR", info={}),
))
mock_is_file.return_value = False
mock_env = mock.MagicMock()
#run tested code
booth_conf_middleware = middleware_config(
"booth-name",
"/local/file/path.conf",
"/local/file/path.key",
)
raised_exception = []
def run_middleware():
try:
booth_conf_middleware(next_in_line, mock_env)
except Exception as e:
raised_exception.append(e)
raise e
self.assertRaises(LibraryEnvError, run_middleware)
self.assertEqual(1, len(raised_exception[0].unprocessed))
self.assertEqual("OTHER ERROR",
raised_exception[0].unprocessed[0].code)
self.assertEqual(mock_console_report.error.mock_calls, [
mock.call(
"Booth config file '/local/file/path.conf' does not exist"),
mock.call("Booth key file '/local/file/path.key' does not exist"),
])
def test_filter_hidden_agents(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (
"\n".join([
"fence_na",
"fence_wti",
"fence_scsi",
"fence_vmware_helper",
"fence_nss_wrapper",
"fence_node",
"fence_vmware_soap",
"fence_virt",
"fence_pcmk",
"fence_sanlockd",
"fence_xvm",
"fence_ack_manual",
"fence_legacy",
"fence_check",
"fence_tool",
"fence_kdump_send",
"fence_virtd",
"",
]),
"",
0
)
self.assertEqual(
lib_ra.list_stonith_agents(mock_runner),
[
"fence_scsi",
"fence_virt",
"fence_vmware_soap",
"fence_wti",
"fence_xvm",
]
)
mock_runner.run.assert_called_once_with([
"/usr/sbin/crm_resource", "--list-agents", "stonith"
])
def setUp(self):
self.mock_logger = mock.MagicMock(logging.Logger)
self.mock_reporter = MockLibraryReportProcessor()
self.lib_env = LibraryEnvironment(self.mock_logger, self.mock_reporter)
self.metadata = """
<resource-agent>
<shortdesc>short desc</shortdesc>
<longdesc>long desc</longdesc>
<parameters>
</parameters>
<actions>
</actions>
</resource-agent>
"""
self.description = {
"name": "ocf:test:Dummy",
"shortdesc": "short desc",
"longdesc": "long desc",
"parameters": [],
"actions": [],
}
def test_success(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = ("\n".join([
"fence_xvm",
"fence_wti",
"fence_vmware_soap",
"fence_virt",
"fence_scsi",
"",
]), "", 0)
self.assertEqual(lib_ra.list_stonith_agents(mock_runner), [
"fence_scsi",
"fence_virt",
"fence_vmware_soap",
"fence_wti",
"fence_xvm",
])
mock_runner.run.assert_called_once_with(
["/usr/sbin/crm_resource", "--list-agents", "stonith"])
def test_success_standard(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = ("\n".join([
"docker",
"Dummy",
"dhcpd",
"Dummy",
"ethmonitor",
"",
]), "", 0)
self.assertEqual(lib_ra.list_resource_agents(mock_runner, "ocf"), [
"dhcpd",
"docker",
"Dummy",
"Dummy",
"ethmonitor",
])
mock_runner.run.assert_called_once_with(
["/usr/sbin/crm_resource", "--list-agents", "ocf"])
def test_success_scope(self):
expected_stdout = "<xml />"
expected_stderr = ""
expected_retval = 0
scope = "test_scope"
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (
expected_stdout,
expected_stderr,
expected_retval
)
real_xml = lib.get_cib_xml(mock_runner, scope)
mock_runner.run.assert_called_once_with(
[
self.path("cibadmin"),
"--local", "--query", "--scope={0}".format(scope)
]
)
self.assertEqual(expected_stdout, real_xml)
def test_report_when_duplication_allowed(self, export_with_set):
export_with_set.return_value = "exported_duplicate_element"
element = mock.MagicMock()
element.tag = "constraint_type"
report_processor = MockLibraryReportProcessor()
constraint.check_is_without_duplication(
report_processor,
fixture_constraint_section(["duplicate_element"]),
element,
are_duplicate=lambda e1, e2: True,
export_element=constraint.export_with_set,
duplication_alowed=True,
)
assert_report_item_list_equal(report_processor.report_item_list, [(
severities.WARNING,
report_codes.DUPLICATE_CONSTRAINTS_EXIST,
{
'constraint_info_list': ['exported_duplicate_element'],
'constraint_type': 'constraint_type'
},
)])
def test_node_and_resource(self):
node = "test_node"
resource = "test_resource"
expected_stdout = "expected output"
expected_stderr = "expected stderr"
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (expected_stdout, expected_stderr, 0)
real_output = lib.resource_cleanup(
mock_runner, resource=resource, node=node
)
mock_runner.run.assert_called_once_with(
[
self.path("crm_resource"),
"--cleanup", "--resource", resource, "--node", node
]
)
self.assertEqual(
expected_stdout + "\n" + expected_stderr,
real_output
)
def get_env(self):
self.__call_queue = CallQueue(self.__config.calls)
#pylint: disable=attribute-defined-outside-init
self._env = LibraryEnvironment(
mock.MagicMock(logging.Logger),
MockLibraryReportProcessor(),
cib_data=self.__config.env.cib_data,
corosync_conf_data=self.__config.env.corosync_conf_data,
token_file_data_getter=((lambda: {
"tokens": self.__config.spy.auth_tokens,
"ports": self.__config.spy.ports or {},
}) if self.__config.spy else None),
booth=self.__config.env.booth,
)
self.__unpatch = patch_env(self.__call_queue, self.__config, self._env)
# If pushing corosync.conf has not been patched in the
# LibraryEnvironment, store any corosync.conf passed to the
# LibraryEnvironment for check for changes in cleanup.
if not is_push_corosync_conf_call_in(self.__call_queue):
self.__original_mocked_corosync_conf = (
self.__config.env.corosync_conf_data)
return self._env
def test_successfuly_build_and_write_to_std_path(
self, mock_validate_peers, mock_build, mock_generate_key
):
env = mock.MagicMock()
commands.config_setup(
env,
booth_configuration=[
{"key": "site", "value": "1.1.1.1", "details": []},
{"key": "arbitrator", "value": "2.2.2.2", "details": []},
],
)
env.booth.create_config.assert_called_once_with(
"config content",
False
)
env.booth.create_key.assert_called_once_with(
"key value",
False
)
mock_validate_peers.assert_called_once_with(
["1.1.1.1"], ["2.2.2.2"]
)
def test_success_standard_provider(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = ("\n".join([
"ping",
"SystemHealth",
"SysInfo",
"HealthCPU",
"Dummy",
"",
]), "", 0)
self.assertEqual(
lib_ra.list_resource_agents(mock_runner, "ocf:pacemaker"), [
"Dummy",
"HealthCPU",
"ping",
"SysInfo",
"SystemHealth",
])
mock_runner.run.assert_called_once_with(
["/usr/sbin/crm_resource", "--list-agents", "ocf:pacemaker"])
def test_success_and_filter_stonith_out(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = ("\n".join([
"ocf",
"lsb",
"service",
"systemd",
"nagios",
"stonith",
"",
]), "", 0)
self.assertEqual(lib_ra.list_resource_agents_standards(mock_runner), [
"lsb",
"nagios",
"ocf",
"service",
"systemd",
])
mock_runner.run.assert_called_once_with(
["/usr/sbin/crm_resource", "--list-standards"])
def test_catch_exactly_his_exception(self):
report_missing = self.setup_patch("env_file.report_missing")
next_in_line = mock.Mock(side_effect=LibraryEnvError(
ReportItem.error(report_codes.FILE_DOES_NOT_EXIST,
info={
"file_role": env_file_role_codes.BOOTH_CONFIG,
}),
ReportItem.error(report_codes.FILE_DOES_NOT_EXIST,
info={
"file_role": env_file_role_codes.BOOTH_KEY,
}),
ReportItem.error("OTHER ERROR", info={}),
))
mock_env = mock.MagicMock()
self.read.return_value = {"content": None}
booth_conf_middleware = env.middleware_config(
"booth-name",
"/local/file/path.conf",
"/local/file/path.key",
)
raised_exception = []
def run_middleware():
try:
booth_conf_middleware(next_in_line, mock_env)
except Exception as e:
raised_exception.append(e)
raise e
self.assertRaises(LibraryEnvError, run_middleware)
self.assertEqual(1, len(raised_exception[0].unprocessed))
self.assertEqual("OTHER ERROR",
raised_exception[0].unprocessed[0].code)
self.assertEqual(report_missing.mock_calls, [
mock.call('Booth config file', '/local/file/path.conf'),
mock.call('Booth key file', '/local/file/path.key'),
])
def test_success(self):
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.side_effect = [
("\n".join([
"ocf",
"lsb",
"service",
"systemd",
"nagios",
"stonith",
"",
]), "", 0),
("\n".join([
"heartbeat",
"openstack",
"pacemaker",
"booth",
"",
]), "", 0),
]
self.assertEqual(
lib_ra.list_resource_agents_standards_and_providers(mock_runner), [
"lsb",
"nagios",
"ocf:booth",
"ocf:heartbeat",
"ocf:openstack",
"ocf:pacemaker",
"service",
"systemd",
])
self.assertEqual(2, len(mock_runner.run.mock_calls))
mock_runner.run.assert_has_calls([
mock.call(["/usr/sbin/crm_resource", "--list-standards"]),
mock.call(["/usr/sbin/crm_resource", "--list-ocf-providers"]),
])
def setUp(self):
self.agent = lib_ra.StonithAgent(
mock.MagicMock(spec_set=CommandRunner),
"fence_dummy"
)
self.metadata = etree.XML("""
<resource-agent>
<parameters>
<parameter name="test_param" required="0">
<longdesc>Long description</longdesc>
<shortdesc>short description</shortdesc>
<content type="string" default="default_value" />
</parameter>
<parameter name="required_param" required="1">
<content type="boolean" />
</parameter>
<parameter name="action">
<content type="string" default="reboot" />
<shortdesc>Fencing action</shortdesc>
</parameter>
</parameters>
</resource-agent>
""")
patcher = mock.patch.object(lib_ra.StonithAgent, "_get_metadata")
self.addCleanup(patcher.stop)
self.get_metadata = patcher.start()
self.get_metadata.return_value = self.metadata
patcher_stonithd = mock.patch.object(
lib_ra.StonithdMetadata, "_get_metadata"
)
self.addCleanup(patcher_stonithd.stop)
self.get_stonithd_metadata = patcher_stonithd.start()
self.get_stonithd_metadata.return_value = etree.XML("""
<resource-agent>
<parameters />
</resource-agent>
""")
def test_error(self):
xml = "<xml/>"
expected_stdout = "expected output"
expected_stderr = "expected stderr"
expected_retval = 1
mock_runner = mock.MagicMock(spec_set=CommandRunner)
mock_runner.run.return_value = (expected_stdout, expected_stderr,
expected_retval)
assert_raise_library_error(
lambda: lib.replace_cib_configuration(
mock_runner,
XmlManipulation.from_str(xml).tree),
(Severity.ERROR, report_codes.CIB_PUSH_ERROR, {
"reason": expected_stderr,
"pushed_cib": expected_stdout,
}))
mock_runner.run.assert_called_once_with([
self.path("cibadmin"), "--replace", "--verbose", "--xml-pipe",
"--scope", "configuration"
],
stdin_string=xml)
