def test_sucess_create(self):
env_assist, config = get_env_tools(test_case=self)
(config
.runner.cib.load(
resources="""
<resources>
<primitive id="resourceA" class="service" type="exim"/>
</resources>
"""
)
.env.push_cib(
optional_in_conf="""
<constraints>
<rsc_ticket
id="ticket-ticketA-resourceA-Master"
rsc="resourceA"
rsc-role="Master"
ticket="ticketA"
loss-policy="fence"
/>
</constraints>
"""
)
)
ticket_command.create(
env_assist.get_env(),
"ticketA",
"resourceA",
{
"loss-policy": "fence",
"rsc-role": "master"
}
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.runner.cib.load(resources=self.fixture_multi_resources)
self.multiple_result_reports = (fixture.ReportStore()
.error(
"multiple_result_found",
report_codes.MULTIPLE_RESULTS_FOUND,
result_identifier_list=[
VIRTUAL_MACHINE_ID,
REMOTE_HOST,
"C",
],
result_type="resource",
search_description=REMOTE_HOST,
force_code=report_codes.FORCE_REMOVE_MULTIPLE_NODES
)
.as_warn(
"multiple_result_found",
"multiple_result_found_warn",
)
)
self.dest_list_b = [Destination("B-ADDR", 2224)]
self.config.env.set_known_hosts_dests({
NODE_NAME: NODE_DEST_LIST,
REMOTE_HOST: REMOTE_DEST_LIST,
"B-NAME": self.dest_list_b,
})
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_nodes(["node1", "node2", "node3"])
self.before = dedent("""\
totem {
transport: udp
interface {
broadcast: yes
mcastport: 1234
ttl: 128
}
}
nodelist {
node {
ring0_addr: node1-addr0
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
name: node2
nodeid: 2
}
node {
ring0_addr: node3-addr0
name: node3
nodeid: 3
}
}
"""
)
def setUp(self):
self.env_assistant, self.config = get_env_tools(self)
self.corosync_conf_facade = None
self.node_labels = ["node-1", "node-2"]
self.config.env.set_known_nodes(self.node_labels)
self.corosync_conf_text = "corosync conf"
self.fixture_corosync_conf()
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.runner.cib.load(resources=FIXTURE_RESOURCES)
self.remove_resource = mock.Mock()
self.config.env.set_known_hosts_dests({
NODE_NAME: NODE_DEST_LIST,
})
def setUp(self):
# pylint: disable=invalid-name
self.env_assist, self.config = get_env_tools(test_case=self)
(self.config
.runner.pcmk.can_wait()
.runner.cib.load(resources=self.initial_resources)
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.runner.cib.load(resources=FIXTURE_RESOURCES)
self.remove_resource = mock.Mock()
self.config.env.set_known_hosts_dests({
NODE_NAME: NODE_DEST_LIST,
})
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.runner.cib.load(
resources=fixture_resouces_for_reference_ids(
["e1", "e2", "e3", "a", "b"]),
tags=fixture_tags_xml([("t", ["e1", "e2", "e3"])]),
)
def test_refuse_for_nonexisting_resource(self):
env_assist, config = get_env_tools(test_case=self)
config.runner.cib.load()
env_assist.assert_raise_library_error(
lambda: ticket_command.create(
env_assist.get_env(),
"ticketA",
"resourceA",
str(const.PCMK_ROLE_UNPROMOTED_LEGACY).lower(),
{"loss-policy": "fence"},
),
[
(
severities.ERROR,
report_codes.ID_NOT_FOUND,
{
"context_type": "cib",
"context_id": "",
"id": "resourceA",
"expected_types": [
"bundle",
"clone",
"group",
"master",
"primitive",
],
},
None,
),
],
expected_in_processor=False,
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_nodes(["node1", "node2"])
self.before = dedent("""\
totem {
transport: knet
interface {
linknumber: 2
mcastport: 1234
knet_transport: sctp
}
}
nodelist {
node {
ring0_addr: node1-addr0
ring2_addr: node1-addr2
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
ring2_addr: node2-addr2
name: node2
nodeid: 2
}
}
"""
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.remove_resource = mock.Mock()
(self.config
.runner.cib.load(resources=self.fixture_multi_resources)
)
self.multiple_result_reports = (fixture.ReportStore()
.error(
"multiple_result_found",
report_codes.MULTIPLE_RESULTS_FOUND,
result_identifier_list=[
NODE_NAME,
REMOTE_HOST,
],
result_type="resource",
search_description=REMOTE_HOST,
force_code=report_codes.FORCE_REMOVE_MULTIPLE_NODES
)
.as_warn(
"multiple_result_found",
"multiple_result_found_warn",
)
)
self.config.env.set_known_hosts_dests({
NODE_NAME: NODE_DEST_LIST,
REMOTE_HOST: REMOTE_DEST_LIST,
})
def setUp(self):
# pylint: disable=invalid-name
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.runner.cib.load(
filename=self.initial_cib_filename,
resources=self.initial_resources,
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_nodes(["node1", "node2"])
self.before = dedent("""\
totem {
transport: knet
interface {
linknumber: 2
mcastport: 1234
knet_transport: sctp
}
}
nodelist {
node {
ring0_addr: node1-addr0
ring2_addr: node1-addr2
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
ring2_addr: node2-addr2
name: node2
nodeid: 2
}
}
""")
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_nodes(["node1", "node2", "node3"])
self.before = dedent("""\
totem {
transport: udp
interface {
broadcast: yes
mcastport: 1234
ttl: 128
}
}
nodelist {
node {
ring0_addr: node1-addr0
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
name: node2
nodeid: 2
}
node {
ring0_addr: node3-addr0
name: node3
nodeid: 3
}
}
""")
def setUp(self):
self.env_assistant, self.config = get_env_tools(self)
self.corosync_conf_facade = None
self.node_labels = ["node-1", "node-2"]
self.config.env.set_known_nodes(self.node_labels)
self.corosync_conf_text = "corosync conf"
self.fixture_corosync_conf()
def setUp(self):
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.fs.open(
settings.crm_mon_schema,
mock.mock_open(read_data=crm_mon_rng_with_history)(),
name="fs.open.crm_mon_rng"
)
def setUp(self):
# pylint: disable=invalid-name
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.runner.cib.load(
filename=self.initial_cib_filename,
resources=self.initial_resources,
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_nodes(["node1", "node2"])
self.link_options = {"mcastport": "12345"}
self.node_addr_map = {"node2": "node2-addr2a"}
self.before = dedent("""\
totem {
transport: knet
interface {
linknumber: 2
mcastport: 1234
}
}
nodelist {
node {
ring0_addr: node1-addr0
ring2_addr: node1-addr2
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
ring2_addr: node2-addr2
name: node2
nodeid: 2
}
}
"""
)
self.after = dedent("""\
totem {
transport: knet
interface {
linknumber: 2
mcastport: 12345
}
}
nodelist {
node {
ring0_addr: node1-addr0
ring2_addr: node1-addr2
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
ring2_addr: node2-addr2a
name: node2
nodeid: 2
}
}
"""
)
def test_success_on_valid_cib(self):
cib_tempfile = "/fake/tmp/file"
env_assist, config = get_env_tools(test_case=self)
(config.env.set_cib_data("<cib/>",
cib_tempfile=cib_tempfile).runner.pcmk.verify(
cib_tempfile=cib_tempfile).runner.cib.
load().runner.pcmk.load_state())
verify(env_assist.get_env())
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_hosts_dests(
{
NODE_NAME: NODE_DEST_LIST,
}
)
self.remove_resource = mock.Mock()
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
(self.config.runner.cib.load(
resources=FIXTURE_RESOURCES).local.destroy_pacemaker_remote(
label=NODE_NAME, dest_list=NODE_DEST_LIST))
self.config.env.set_known_hosts_dests({
NODE_NAME: NODE_DEST_LIST,
})
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
(self.config.env.set_known_hosts_dests(
KNOWN_HOSTS_DESTS).local.load_cib().corosync_conf.load(
node_name_list=[NODE_1, NODE_2]).http.host.check_auth(
communication_list=[
dict(label=NODE_NAME, dest_list=NODE_DEST_LIST)
], ).local.get_host_info(NODE_NAME, NODE_DEST_LIST))
def setUp(self):
self.tmp_file = "/fake/tmp_file"
self.cmd_env = dict(CIB_file=self.tmp_file)
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_hosts_dests(KNOWN_HOSTS_DESTS)
with open(rc("cib-empty.xml")) as cib_file:
self.config.env.set_cib_data(cib_file.read(),
cib_tempfile=self.tmp_file)
def setUp(self):
# pylint: disable=invalid-name
self.env_assist, self.config = get_env_tools(self)
self.old_devices = ["device1", "device3"]
self.new_devices = ["device3", "device0", "device2"]
self.added_devices = set(self.new_devices) - set(self.old_devices)
self.check_devices = sorted(
set(self.old_devices) & set(self.new_devices)
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.pcsd_ssl_cert = "pcsd ssl cert"
self.pcsd_ssl_key = "pcsd ssl key"
self.node_names = ["rh7-1", "rh7-2"] # It matches nodes in corosync.conf
(self.config
.corosync_conf.load()
.env.set_known_nodes(self.node_names)
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.pcsd_ssl_cert = "pcsd ssl cert"
self.pcsd_ssl_key = "pcsd ssl key"
self.node_names = [
"rh7-1",
"rh7-2",
] # It matches nodes in corosync.conf
(self.config.corosync_conf.load().env.set_known_nodes(self.node_names))
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_nodes(["node1", "node2"])
self.link_options = {"mcastport": "12345"}
self.node_addr_map = {"node2": "node2-addr2a"}
self.before = dedent("""\
totem {
transport: knet
interface {
linknumber: 2
mcastport: 1234
}
}
nodelist {
node {
ring0_addr: node1-addr0
ring2_addr: node1-addr2
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
ring2_addr: node2-addr2
name: node2
nodeid: 2
}
}
""")
self.after = dedent("""\
totem {
transport: knet
interface {
linknumber: 2
mcastport: 12345
}
}
nodelist {
node {
ring0_addr: node1-addr0
ring2_addr: node1-addr2
name: node1
nodeid: 1
}
node {
ring0_addr: node2-addr0
ring2_addr: node2-addr2a
name: node2
nodeid: 2
}
}
""")
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.runner.cib.load(
tags=fixture_tags_xml([
("tag1", ("i1", "i2")),
("tag2", ("j1", "j2")),
]),
resources=fixture_resources_for_ids(),
)
def setUp(self):
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.runner.cib.load(optional_in_conf="""
<alerts>
<alert id="alert" path="path">
<recipient id="alert-recipient" value="value1"/>
</alert>
</alerts>
""")
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.existing_nodes = ["node1", "node2", "node3"]
self.existing_corosync_nodes = [
node_fixture(node, node_id)
for node_id, node in enumerate(self.existing_nodes, 1)
]
self.config.env.set_known_nodes(self.existing_nodes)
def setUp(self):
self.maxDiff = None
self.env_assist, self.config = get_env_tools(test_case=self)
self.trace_parameters = [
{
"advanced":
True,
"default":
"0",
"deprecated":
False,
"deprecated_by": [],
"deprecated_desc":
None,
"enum_values":
None,
"longdesc":
"Set to 1 to turn on resource agent tracing"
" (expect large output) The trace output will be "
"saved to trace_file, if set, or by default to "
"$HA_VARRUN/ra_trace/<type>/<id>.<action>."
"<timestamp> e.g. $HA_VARRUN/ra_trace/oracle/db."
"start.2012-11-27.08:37:08",
"name":
"trace_ra",
"required":
False,
"shortdesc":
"Set to 1 to turn on resource agent "
"tracing (expect large output)",
"type":
"integer",
"unique_group":
None,
"reloadable":
False,
},
{
"advanced": True,
"default": "",
"deprecated": False,
"deprecated_by": [],
"deprecated_desc": None,
"enum_values": None,
"longdesc":
("Path to a file to store resource agent tracing log"),
"name": "trace_file",
"required": False,
"shortdesc":
("Path to a file to store resource agent tracing log"),
"type": "string",
"unique_group": None,
"reloadable": False,
},
]
def setUp(self):
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.runner.cib.load(optional_in_conf="""
<alerts>
<alert id="alert1" path="path"/>
<alert id="alert2" path="/path"/>
<alert id="alert3" path="/path"/>
<alert id="alert4" path="/path"/>
</alerts>
""")
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.name = "booth"
self.config_path = os.path.join(
settings.booth_config_dir, "{}.conf".format(self.name)
)
self.node_list = ["rh7-1", "rh7-2"]
self.config.env.set_booth({"name": self.name})
self.config.env.set_known_nodes(self.node_list)
self.reason = "fail"
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
local_nodes = generate_nodes(4)
self.remote_nodes = generate_nodes(3, prefix="recovery-")
self.node = self.remote_nodes[0]
self.failed_nodes = local_nodes[-1:]
successful_nodes = local_nodes[:-1]
self.config.env.set_known_nodes(local_nodes + self.remote_nodes)
self.config.raw_file.exists(
file_type_codes.PCS_DR_CONFIG,
settings.pcsd_dr_config_location,
exists=False,
)
self.config.corosync_conf.load_content(
corosync_conf_fixture(local_nodes))
self.config.http.corosync.get_corosync_conf(corosync_conf_fixture(
self.remote_nodes),
node_labels=[self.node])
self.config.http.files.put_files(
node_labels=self.remote_nodes,
pcs_disaster_recovery_conf=dr_cfg_fixture(DrRole.RECOVERY,
DrRole.PRIMARY,
local_nodes),
name="distribute_remote",
)
self.success_communication = [
dict(label=node) for node in successful_nodes
]
self.expected_reports = [
fixture.info(
report_codes.FILES_DISTRIBUTION_STARTED,
file_list=[DR_CFG_DESC],
node_list=self.remote_nodes,
)
] + [
fixture.info(
report_codes.FILE_DISTRIBUTION_SUCCESS,
file_description=DR_CFG_DESC,
node=node,
) for node in self.remote_nodes
] + [
fixture.info(
report_codes.FILES_DISTRIBUTION_STARTED,
file_list=[DR_CFG_DESC],
node_list=local_nodes,
)
] + [
fixture.info(
report_codes.FILE_DISTRIBUTION_SUCCESS,
file_description=DR_CFG_DESC,
node=node,
) for node in successful_nodes
]
def setUp(self):
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.runner.cib.load(
optional_in_conf="""
<alerts>
<alert id="alert" path="path">
<recipient id="alert-recipient" value="value1"/>
</alert>
</alerts>
"""
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
(self.config.env.set_known_hosts_dests(
KNOWN_HOSTS_DESTS).local.load_cluster_configs(
cluster_node_list=[NODE_1, NODE_2]).http.host.check_auth(
communication_list=[
dict(label=NODE_NAME, dest_list=NODE_DEST_LIST)
], ).local.get_host_info(
NODE_NAME,
NODE_DEST_LIST).local.push_existing_authkey_to_remote(
NODE_NAME, NODE_DEST_LIST))
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_hosts_dests(KNOWN_HOSTS_DESTS)
cib_xml_man = XmlManipulation.from_file(rc("cib-empty.xml"))
cib_xml_man.append_to_first_tag_name(
"resources", """
<primitive class="ocf" id="{0}"
provider="heartbeat" type="VirtualDomain"
/>
""".format(VIRTUAL_MACHINE_ID))
self.config.env.set_cib_data(str(cib_xml_man))
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_hosts_dests({
NODE_NAME: NODE_DEST_LIST,
})
(self.config
.runner.cib.load(resources=FIXTURE_RESOURCES)
.local.destroy_pacemaker_remote(
label=NODE_NAME, dest_list=NODE_DEST_LIST
)
)
self.remove_resource = mock.Mock()
def setUp(self):
tmpfile_patcher = mock.patch("pcs.lib.pacemaker.live.write_tmpfile")
self.addCleanup(tmpfile_patcher.stop)
self.mock_write_tmpfile = tmpfile_patcher.start()
self.tmpfile_old = mock_tmpfile("old.cib")
self.tmpfile_new = mock_tmpfile("new.cib")
self.mock_write_tmpfile.side_effect = [
self.tmpfile_old, self.tmpfile_new
]
self.cib_can_diff = "cib-empty-2.0.xml"
self.cib_cannot_diff = "cib-empty-1.2.xml"
self.env_assist, self.config = get_env_tools(test_case=self)
def setUp(self):
tmpfile_patcher = mock.patch("pcs.lib.pacemaker.live.write_tmpfile")
self.addCleanup(tmpfile_patcher.stop)
self.mock_write_tmpfile = tmpfile_patcher.start()
self.tmpfile_old = mock_tmpfile("old.cib")
self.tmpfile_new = mock_tmpfile("new.cib")
self.mock_write_tmpfile.side_effect = [
self.tmpfile_old, self.tmpfile_new
]
self.cib_can_diff = "cib-empty-2.0.xml"
self.cib_cannot_diff = "cib-empty-1.2.xml"
self.env_assist, self.config = get_env_tools(test_case=self)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.existing_nodes = ["node1", "node2", "node3"]
self.existing_corosync_nodes = [
node_fixture(node, node_id)
for node_id, node in enumerate(self.existing_nodes, 1)
]
self.config.corosync_conf.load_content(
corosync_conf_fixture(
self.existing_corosync_nodes,
get_two_node(len(self.existing_corosync_nodes)),
))
def setUp(self):
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.runner.cib.load(
optional_in_conf="""
<alerts>
<alert id="alert1" path="path"/>
<alert id="alert2" path="/path"/>
<alert id="alert3" path="/path"/>
<alert id="alert4" path="/path"/>
</alerts>
"""
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
(self.config
.env.set_known_hosts_dests(KNOWN_HOSTS_DESTS)
.local.load_cluster_configs(cluster_node_list=[NODE_1, NODE_2])
.http.host.check_auth(
communication_list=[
dict(label=NODE_NAME, dest_list=NODE_DEST_LIST)
],
)
.local.get_host_info(NODE_NAME, NODE_DEST_LIST)
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_hosts_dests(KNOWN_HOSTS_DESTS)
cib_xml_man = XmlManipulation.from_file(rc("cib-empty.xml"))
cib_xml_man.append_to_first_tag_name(
"resources",
"""
<primitive class="ocf" id="{0}"
provider="heartbeat" type="VirtualDomain"
/>
""".format(VIRTUAL_MACHINE_ID)
)
self.config.env.set_cib_data(str(cib_xml_man))
def setUp(self):
self.tmpfile_old = "old.cib"
self.tmpfile_new = "new.cib"
self.load_cib_name = "load_cib"
self.tmp_file_mock_obj = TmpFileMock(
file_content_checker=assert_xml_equal, )
self.addCleanup(self.tmp_file_mock_obj.assert_all_done)
tmp_file_patcher = mock.patch("pcs.lib.tools.get_tmp_file")
self.addCleanup(tmp_file_patcher.stop)
tmp_file_mock = tmp_file_patcher.start()
tmp_file_mock.side_effect = (
self.tmp_file_mock_obj.get_mock_side_effect())
self.env_assist, self.config = get_env_tools(test_case=self)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
(self.config
.env.set_known_hosts_dests(KNOWN_HOSTS_DESTS)
.local.load_cib()
.corosync_conf.load(node_name_list=[NODE_1, NODE_2])
.http.host.check_auth(
communication_list=[
dict(label=NODE_NAME, dest_list=NODE_DEST_LIST)
],
)
.local.get_host_info(NODE_NAME, NODE_DEST_LIST)
.local.push_existing_authkey_to_remote(NODE_NAME, NODE_DEST_LIST)
)
def setUp(self):
self. wait = 1
self.env_assist, self.config = get_env_tools(self)
(self.config
.env.set_known_hosts_dests(KNOWN_HOSTS_DESTS)
.runner.pcmk.can_wait()
.local.load_cluster_configs(cluster_node_list=[NODE_1, NODE_2])
.http.host.check_auth(
communication_list=[
dict(label=NODE_NAME, dest_list=NODE_DEST_LIST)
],
)
.local.get_host_info(NODE_NAME, NODE_DEST_LIST)
.local.push_existing_authkey_to_remote(NODE_NAME, NODE_DEST_LIST)
.local.run_pacemaker_remote(NODE_NAME, NODE_DEST_LIST)
.env.push_cib(resources=FIXTURE_RESOURCES, wait=self.wait)
)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.name = "booth"
self.node_name = "node"
self.config_data = "config"
self.config_path = _get_booth_file_path("{}.conf".format(self.name))
self.report_list = [
fixture.info(
report_codes.BOOTH_FETCHING_CONFIG_FROM_NODE,
node=self.node_name,
config=self.name
),
fixture.info(
report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE,
node=None,
name_list=[self.name],
)
]
self.config.env.set_booth({"name": self.name})
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
resources_before = """
<resources>
<primitive id="R1" />
<primitive id="R2" />
</resources>
"""
resources_after = """
<resources>
<group id="G">
<primitive id="R1" />
<primitive id="R2" />
</group>
</resources>
"""
self.timeout = 10
(self.config
.runner.pcmk.can_wait()
.runner.cib.load(resources=resources_before)
.env.push_cib(resources=resources_after, wait=self.timeout)
)
def setUp(self):
self.env_assist, self.config = get_env_tools(test_case=self)
self.config.runner.cib.load(
optional_in_conf="""
<alerts>
<alert id="alert" path="path">
<recipient id="alert-recipient" value="value1"/>
<recipient id="alert-recipient-1" value="value"
description="d"
>
<meta_attributes
id="alert-recipient-1-meta_attributes"
>
<nvpair
id="alert-recipient-1-meta_attributes-attr1"
name="attr1"
value="val1"
/>
<nvpair
id="alert-recipient-1-meta_attributes-attr2"
name="attr2"
value="val2"
/>
</meta_attributes>
<instance_attributes
id="alert-recipient-1-instance_attributes"
>
<nvpair
id="alert-recipient-1-instance_attributes-attr1"
name="attr1"
value="val1"
/>
</instance_attributes>
</recipient>
</alert>
</alerts>
"""
)
def setUp(self):
self.env_assistant, self.config = get_env_tools(self)
def test_is_live_when_no_cib_data_specified(self):
env_assist, _ = get_env_tools(test_case=self)
self.assertTrue(env_assist.get_env().is_cib_live)
def test_is_not_live_when_cib_data_specified(self):
env_assist, config = get_env_tools(test_case=self)
config.env.set_cib_data("<cib/>")
self.assertFalse(env_assist.get_env().is_cib_live)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.config.env.set_known_hosts_dests(KNOWN_HOSTS_DESTS)
def setUp(self):
self.corosync_conf_data = "totem {\n version: 2\n}\n"
self.env_assistant, self.config = get_env_tools(test_case=self)
self.config.env.set_corosync_conf_data(self.corosync_conf_data)
def setUp(self):
self.env_assist, self.config = get_env_tools(self)
self.corosync_conf_name = "corosync-3nodes.conf"
self.node_list = ["rh7-1", "rh7-2", "rh7-3"]
self.config.env.set_known_nodes(self.node_list)
def setUp(self):
self.env_assist, self.config = get_env_tools(test_case=self)
