Exemplo n.º 1
0
    def test_authfile_not_in_booth_dir(self):
        config_file_content = "authfile=/etc/my_booth.conf"

        (self.config
            .fs.open(
                self.config_path,
                mock.mock_open(read_data=config_file_content)(),
                name="open.conf"
            )
            .corosync_conf.load()
            .http.booth.send_config(
                self.name, config_file_content, node_labels=self.node_list,
            )
        )

        commands.config_sync(self.env_assist.get_env(), self.name)
        self.env_assist.assert_reports(
            [
                fixture.warn(report_codes.BOOTH_UNSUPORTED_FILE_LOCATION),
                fixture.info(report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED)
            ]
            +
            [
                fixture.info(
                    report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE,
                    node=node,
                    name_list=[self.name]
                ) for node in self.node_list
            ]
        )
Exemplo n.º 2
0
    def test_authfile_not_accessible(self):
        auth_file = "auth.file"
        auth_file_path = os.path.join(settings.booth_config_dir, auth_file)
        config_content = "authfile={}".format(auth_file_path)

        (self.config.fs.open(self.config_path,
                             mock.mock_open(read_data=config_content)(),
                             name="open.conf").fs.open(
                                 auth_file_path,
                                 mode="rb",
                                 name="open.authfile",
                                 side_effect=EnvironmentError(
                                     0, self.reason, auth_file_path),
                             ).corosync_conf.load().http.booth.send_config(
                                 self.name,
                                 config_content,
                                 node_labels=self.node_list,
                             ))

        commands.config_sync(self.env_assist.get_env(), self.name)
        self.env_assist.assert_reports([
            fixture.warn(
                report_codes.FILE_IO_ERROR,
                reason="{}: '{}'".format(self.reason, auth_file_path),
                file_role=file_roles.BOOTH_KEY,
                file_path=auth_file_path,
                operation="read",
            ),
            fixture.info(report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED)
        ] + [
            fixture.info(report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE,
                         node=node,
                         name_list=[self.name]) for node in self.node_list
        ])
Exemplo n.º 3
0
    def test_no_authfile(self):
        (self.config
            .fs.open(
                self.config_path,
                mock.mock_open(read_data="")(),
                name="open.conf"
            )
            .corosync_conf.load()
            .http.booth.send_config(
                self.name, "", node_labels=self.node_list,
            )
        )

        commands.config_sync(self.env_assist.get_env(), self.name)
        self.env_assist.assert_reports(
            [fixture.info(report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED)]
            +
            [
                fixture.info(
                    report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE,
                    node=node,
                    name_list=[self.name]
                ) for node in self.node_list
            ]
        )
Exemplo n.º 4
0
 def test_need_stopped_cluster_not_stopped_skip_offline(self):
     # If we know for sure that corosync is running, skip_offline doesn't
     # matter.
     self.corosync_conf_facade.need_stopped_cluster = True
     (self.config
         .http.corosync.check_corosync_offline(
             communication_list=[
                 dict(
                     label="node-1",
                     output='{"corosync":true}',
                 ),
                 dict(
                     label="node-2",
                 ),
             ]
         )
     )
     env = self.env_assistant.get_env()
     self.env_assistant.assert_raise_library_error(
         lambda: env.push_corosync_conf(
             self.corosync_conf_facade, skip_offline_nodes=True
         ),
         []
     )
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
         fixture.error(
             report_codes.COROSYNC_RUNNING_ON_NODE,
             node="node-1",
         ),
         fixture.info(
             report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
             node="node-2",
         )
     ])
Exemplo n.º 5
0
 def test_success_node_offline_skip_offline(self):
     err_msg = "Failed connect to rh7-3:2224; No route to host"
     online_nodes_list = ["rh7-2", "rh7-3"]
     self.config.runner.corosync.version()
     self.config.corosync_conf.load(filename=self.corosync_conf_name)
     self.config.http.host.check_auth(
         communication_list=[{
             "label": "rh7-1",
             "was_connected": False,
             "errno": 7,
             "error_msg": err_msg,
         }, {
             "label": "rh7-2"
         }, {
             "label": "rh7-3"
         }])
     self.config.http.pcmk.set_stonith_watchdog_timeout_to_zero(
         node_labels=online_nodes_list[:1])
     self.config.http.sbd.disable_sbd(node_labels=online_nodes_list)
     disable_sbd(self.env_assist.get_env(), ignore_offline_nodes=True)
     self.env_assist.assert_reports(
         [fixture.warn(report_codes.OMITTING_NODE, node="rh7-1")] +
         [fixture.info(report_codes.SBD_DISABLING_STARTED)] + [
             fixture.info(report_codes.SERVICE_DISABLE_SUCCESS,
                          service="sbd",
                          node=node,
                          instance=None) for node in online_nodes_list
         ] + [
             fixture.warn(
                 report_codes.CLUSTER_RESTART_REQUIRED_TO_APPLY_CHANGES)
         ])
Exemplo n.º 6
0
    def test_node_offline_skip_offline(self):
        (self.config.fs.open(
            self.config_path, mock.mock_open(read_data="")(),
            name="open.conf").corosync_conf.load().http.booth.send_config(
                self.name,
                "",
                communication_list=[
                    dict(
                        label=self.node_list[0],
                        errno=1,
                        error_msg=self.reason,
                        was_connected=False,
                    ),
                    dict(label=self.node_list[1], )
                ],
            ))

        commands.config_sync(self.env_assist.get_env(),
                             skip_offline_nodes=True)
        self.env_assist.assert_reports([
            fixture.info(report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED),
            fixture.info(report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE,
                         node=self.node_list[1],
                         name_list=[self.name]),
            fixture.warn(
                report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
                node=self.node_list[0],
                reason=self.reason,
                command="remote/booth_set_config",
            ),
        ])
Exemplo n.º 7
0
    def test_node_failure_skip_offline(self):
        (self.config.fs.open(
            self.config_path, mock.mock_open(read_data="")(),
            name="open.conf").corosync_conf.load().http.booth.send_config(
                self.name,
                "",
                communication_list=[
                    dict(
                        label=self.node_list[0],
                        response_code=400,
                        output=self.reason,
                    ),
                    dict(label=self.node_list[1], )
                ]))

        commands.config_sync(self.env_assist.get_env(),
                             skip_offline_nodes=True)
        self.env_assist.assert_reports([
            fixture.info(report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED),
            fixture.info(report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE,
                         node=self.node_list[1],
                         name_list=[self.name]),
            fixture.warn(
                report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL,
                node=self.node_list[0],
                reason=self.reason,
                command="remote/booth_set_config",
            ),
        ])
Exemplo n.º 8
0
def fixture_reports_new_node_unreachable(node_name, omitting=False):
    if omitting:
        report = [
            fixture.warn(
                report_codes.OMITTING_NODE,
                node=node_name,
            ),
        ]
    else:
        report = [
            fixture.warn(
                report_codes.HOST_NOT_FOUND,
                host_list=[node_name],
            ),
        ]
    return report + [
        fixture.info(
            report_codes.FILES_DISTRIBUTION_SKIPPED,
            reason_type="unreachable",
            file_list=["pacemaker authkey"],
            node_list=[node_name],
        ),
        fixture.info(
            report_codes.SERVICE_COMMANDS_ON_NODES_SKIPPED,
            reason_type="unreachable",
            action_list=["pacemaker_remote start", "pacemaker_remote enable"],
            node_list=[node_name],
        ),
    ]
Exemplo n.º 9
0
 def test_disable_failed(self):
     err_msg = "Error"
     self.config.runner.corosync.version()
     self.config.corosync_conf.load(filename=self.corosync_conf_name)
     self.config.http.host.check_auth(node_labels=self.node_list)
     self.config.http.pcmk.set_stonith_watchdog_timeout_to_zero(
         node_labels=self.node_list[:1])
     self.config.http.sbd.disable_sbd(communication_list=[{
         "label": "rh7-1"
     }, {
         "label": "rh7-2"
     }, {
         "label": "rh7-3",
         "response_code": 400,
         "output": err_msg
     }])
     self.env_assist.assert_raise_library_error(
         lambda: disable_sbd(self.env_assist.get_env()),
         [],
     )
     self.env_assist.assert_reports(
         [fixture.info(report_codes.SBD_DISABLING_STARTED)] + [
             fixture.info(report_codes.SERVICE_DISABLE_SUCCESS,
                          service="sbd",
                          node=node,
                          instance=None) for node in self.node_list[:2]
         ] + [
             fixture.error(
                 report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL,
                 node="rh7-3",
                 reason=err_msg,
                 command="remote/sbd_disable")
         ])
Exemplo n.º 10
0
 def test_need_stopped_cluster_comunnication_failure(self):
     self.corosync_conf_facade.need_stopped_cluster = True
     (self.config.http.corosync.check_corosync_offline(communication_list=[
         dict(label="node-1", ),
         dict(label="node-2",
              response_code=401,
              output="""{"notauthorized":"true"}"""),
     ]))
     env = self.env_assistant.get_env()
     self.env_assistant.assert_raise_library_error(
         lambda: env.push_corosync_conf(self.corosync_conf_facade), [])
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
         fixture.info(
             report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
             node="node-1",
         ),
         fixture.error(
             report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
             force_code=report_codes.SKIP_OFFLINE_NODES,
             node="node-2",
         ),
         fixture.error(
             report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
             force_code=report_codes.SKIP_OFFLINE_NODES,
             node="node-2",
         ),
     ])
Exemplo n.º 11
0
    def test_success(self):
        auth_file = "auth.file"
        auth_file_path = os.path.join(settings.booth_config_dir, auth_file)
        config_content = "authfile={}".format(auth_file_path)
        auth_file_content = b"auth"
        (self.config.fs.open(self.config_path,
                             mock.mock_open(read_data=config_content)(),
                             name="open.conf").fs.open(
                                 auth_file_path,
                                 mock.mock_open(read_data=auth_file_content)(),
                                 mode="rb",
                                 name="open.authfile",
                             ).corosync_conf.load().http.booth.send_config(
                                 self.name,
                                 config_content,
                                 authfile=auth_file,
                                 authfile_data=auth_file_content,
                                 node_labels=self.node_list,
                             ))

        commands.config_sync(self.env_assist.get_env(), self.name)
        self.env_assist.assert_reports(
            [fixture.info(report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED)] + [
                fixture.info(report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE,
                             node=node,
                             name_list=[self.name]) for node in self.node_list
            ])
Exemplo n.º 12
0
 def test_dont_need_stopped_cluster_error_skip_offline(self):
     (self.config.http.corosync.set_corosync_conf(
         self.corosync_conf_text,
         communication_list=[
             {
                 "label": "node-1",
             },
             {
                 "label": "node-2",
                 "response_code": 400,
                 "output": "Failed"
             },
         ]).runner.systemctl.is_active("corosync").runner.corosync.reload())
     self.env_assistant.get_env().push_corosync_conf(
         self.corosync_conf_facade, skip_offline_nodes=True)
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED),
         fixture.info(
             report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
             node="node-1",
         ),
         fixture.warn(
             report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL,
             node="node-2",
             command="remote/set_corosync_conf",
             reason="Failed",
         ),
         fixture.warn(
             report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR,
             node="node-2",
         ),
         fixture.info(report_codes.COROSYNC_CONFIG_RELOADED)
     ])
Exemplo n.º 13
0
 def test_dont_need_stopped_cluster_error(self):
     (self.config.http.corosync.set_corosync_conf(self.corosync_conf_text,
                                                  communication_list=[
                                                      {
                                                          "label": "node-1",
                                                      },
                                                      {
                                                          "label": "node-2",
                                                          "response_code":
                                                          400,
                                                          "output": "Failed"
                                                      },
                                                  ]))
     env = self.env_assistant.get_env()
     self.env_assistant.assert_raise_library_error(
         lambda: env.push_corosync_conf(self.corosync_conf_facade), [])
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED),
         fixture.info(
             report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
             node="node-1",
         ),
         fixture.error(
             report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL,
             force_code=report_codes.SKIP_OFFLINE_NODES,
             node="node-2",
             command="remote/set_corosync_conf",
             reason="Failed",
         ),
         fixture.error(
             report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR,
             force_code=report_codes.SKIP_OFFLINE_NODES,
             node="node-2",
         ),
     ])
Exemplo n.º 14
0
    def test_need_stopped_cluster_not_stopped_skip_offline(
            self, mock_is_systemctl):
        mock_is_systemctl.return_value = True
        self.corosync_conf_facade.need_stopped_cluster = True
        (self.config.http.add_communication(
            "status",
            [
                dict(
                    label="node-1",
                    output="""\
{"uptime":"0 days, 06:36:00","corosync":true,"pacemaker":true,"cman":false,\
"corosync_enabled":false,"pacemaker_enabled":false,"pacemaker_remote":false,\
"pacemaker_remote_enabled":false,"pcsd_enabled":true,"corosync_online":\
["node-1"],"corosync_offline":["node-2"],"pacemaker_online":["node-1"],\
"pacemaker_offline":["node-2"],"pacemaker_standby":[],"cluster_name":\
"cluster_name","resources":[],"groups":[],"constraints":{},"cluster_settings":\
{"have-watchdog":"false","dc-version":"1.1.16-11.el7-94ff4df",\
"cluster-infrastructure":"corosync","cluster-name":"cluster_name"},\
"node_id":"1","node_attr":{},"fence_levels":{},"need_ring1_address":false,\
"is_cman_with_udpu_transport":false,"acls":{"role":{},"group":{},"user":{},\
"target":{}},"username":"******"}
                        """,
                ),
                dict(
                    label="node-2",
                    output="""\
{"uptime":"0 days, 06:35:58","corosync":false,"pacemaker":false,"cman":false,\
"corosync_enabled":false,"pacemaker_enabled":false,"pacemaker_remote":false,\
"pacemaker_remote_enabled":false,"pcsd_enabled":true,"corosync_online":[],\
"corosync_offline":["node-1","node-2"],"pacemaker_online":[],\
"pacemaker_offline":[],"pacemaker_standby":[],"cluster_name":"cluster_name",\
"resources":[],"groups":[],"constraints":{},"cluster_settings":\
{"error":"Unable to get configuration settings"},"node_id":"","node_attr":{},\
"fence_levels":{},"need_ring1_address":false,"is_cman_with_udpu_transport":\
false,"acls":{},"username":"******"}
                        """,
                ),
            ],
            action="remote/status",
            response_code=200,
        ))
        env = self.env_assistant.get_env()
        self.env_assistant.assert_raise_library_error(
            lambda: env.push_corosync_conf(self.corosync_conf_facade,
                                           skip_offline_nodes=True), [])
        self.env_assistant.assert_reports([
            fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
            fixture.error(
                report_codes.COROSYNC_RUNNING_ON_NODE,
                node="node-1",
            ),
            fixture.info(
                report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
                node="node-2",
            )
        ])
Exemplo n.º 15
0
 def test_need_stopped_cluster_comunnication_failures_skip_offline(self):
     # If we don't know if corosync is running, skip_offline matters.
     self.corosync_conf_facade.need_stopped_cluster = True
     (self.config.http.corosync.check_corosync_offline(communication_list=[
         dict(
             label="node-1",
             output="{"  # not valid json
         ),
         dict(label="node-2",
              response_code=401,
              output="""{"notauthorized":"true"}"""),
     ]).http.corosync.set_corosync_conf(
         self.corosync_conf_text,
         communication_list=[
             dict(label="node-1", ),
             dict(
                 label="node-2",
                 response_code=401,
                 output="""{"notauthorized":"true"}""",
             )
         ]).runner.systemctl.is_active("corosync", is_active=False))
     self.env_assistant.get_env().push_corosync_conf(
         self.corosync_conf_facade, skip_offline_nodes=True)
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
         fixture.warn(
             report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
             node="node-1",
         ),
         fixture.warn(
             report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
             node="node-2",
             reason="HTTP error: 401",
             command="remote/status",
         ),
         fixture.warn(
             report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
             node="node-2",
         ),
         fixture.info(report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED),
         fixture.info(
             report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
             node="node-1",
         ),
         fixture.warn(
             report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
             node="node-2",
             reason="HTTP error: 401",
             command="remote/set_corosync_conf",
         ),
         fixture.warn(
             report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR,
             node="node-2",
         ),
     ])
Exemplo n.º 16
0
    def test_need_stopped_cluster_comunnication_failure(
            self, mock_is_systemctl):
        mock_is_systemctl.return_value = True
        self.corosync_conf_facade.need_stopped_cluster = True
        (self.config.http.add_communication(
            "status",
            [
                dict(
                    label="node-1",
                    response_code=200,
                    output="""\
{"uptime":"0 days, 00:11:52","corosync":false,"pacemaker":false,"cman":false,\
"corosync_enabled":false,"pacemaker_enabled":false,"pacemaker_remote":false,\
"pacemaker_remote_enabled":false,"pcsd_enabled":true,"corosync_online":[],\
"corosync_offline":["node-1","node-2"],"pacemaker_online":[],\
"pacemaker_offline":[],"pacemaker_standby":[],"cluster_name":"cluster_name",\
"resources":[],"groups":[],"constraints":{},"cluster_settings":\
{"error":"Unable to get configuration settings"},"node_id":"","node_attr":{},\
"fence_levels":{},"need_ring1_address":false,"is_cman_with_udpu_transport":\
false,"acls":{},"username":"******"}
                        """,
                ),
                dict(label="node-2",
                     response_code=401,
                     output="""{"notauthorized":"true"}"""),
            ],
            action="remote/status",
        ))
        env = self.env_assistant.get_env()
        self.env_assistant.assert_raise_library_error(
            lambda: env.push_corosync_conf(self.corosync_conf_facade), [])
        self.env_assistant.assert_reports([
            fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
            fixture.info(
                report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
                node="node-1",
            ),
            fixture.error(
                report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
                force_code=report_codes.SKIP_OFFLINE_NODES,
                node="node-2",
            ),
            fixture.error(
                report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
                force_code=report_codes.SKIP_OFFLINE_NODES,
                node="node-2",
            ),
        ])
Exemplo n.º 17
0
 def test_need_stopped_cluster_json_error(self):
     self.corosync_conf_facade.need_stopped_cluster = True
     (self.config.http.corosync.check_corosync_offline(communication_list=[
         dict(
             label="node-1",
             output="{"  # not valid json
         ),
         dict(
             label="node-2",
             # The expected key (/corosync) is missing, we don't
             # care about version 2 status key
             # (/services/corosync/running)
             output='{"services":{"corosync":{"running":true}}}'),
     ]))
     env = self.env_assistant.get_env()
     self.env_assistant.assert_raise_library_error(
         lambda: env.push_corosync_conf(self.corosync_conf_facade), [])
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
         fixture.error(
             report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
             force_code=report_codes.SKIP_OFFLINE_NODES,
             node="node-1",
         ),
         fixture.error(
             report_codes.COROSYNC_NOT_RUNNING_CHECK_NODE_ERROR,
             force_code=report_codes.SKIP_OFFLINE_NODES,
             node="node-2",
         ),
     ])
Exemplo n.º 18
0
 def test_unknown_host_addr_not_specified(self):
     meta_attributes = """
         <meta_attributes id="virtual_machine_id-meta_attributes">
             <nvpair id="virtual_machine_id-meta_attributes-remote-addr"
                 name="remote-addr" value="node-name"
             />
             <nvpair
                 id="virtual_machine_id-meta_attributes-remote-node"
                 name="remote-node" value="node-name"
             />
             <nvpair
                 id="virtual_machine_id-meta_attributes-remote-port"
                 name="remote-port" value="99"
             />
         </meta_attributes>
     """
     self.config.env.set_known_hosts_dests(dict())
     (self.config.local.load_cib().local.push_cib(
         meta_attributes=meta_attributes))
     node_add_guest(self.env_assist.get_env(),
                    options={"remote-port": "99"})
     self.env_assist.assert_reports([
         fixture.info(
             report_codes.USING_KNOWN_HOST_ADDRESS_FOR_HOST,
             host_name=NODE_NAME,
             address=NODE_NAME,
         ),
     ] + fixture_reports_not_live_cib(NODE_NAME))
Exemplo n.º 19
0
 def test_need_stopped_cluster_not_stopped(self):
     self.corosync_conf_facade.need_stopped_cluster = True
     (self.config
         .http.corosync.check_corosync_offline(
             communication_list=[
                 {
                     "label": node,
                     "output": '{"corosync":true}'
                 }
                 for node in self.node_labels
             ]
         )
     )
     env = self.env_assistant.get_env()
     self.env_assistant.assert_raise_library_error(
         lambda: env.push_corosync_conf(self.corosync_conf_facade),
         []
     )
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
         fixture.error(
             report_codes.COROSYNC_RUNNING_ON_NODE,
             node="node-1",
         ),
         fixture.error(
             report_codes.COROSYNC_RUNNING_ON_NODE,
             node="node-2",
         ),
     ])
Exemplo n.º 20
0
 def test_success(self):
     self.config.corosync_conf.load(filename=self.corosync_conf_name)
     self.config.http.host.check_auth(node_labels=self.node_list)
     self.config.http.pcmk.set_stonith_watchdog_timeout_to_zero(
         node_labels=self.node_list[:1])
     self.config.http.sbd.disable_sbd(node_labels=self.node_list)
     disable_sbd(self.env_assist.get_env())
     self.env_assist.assert_reports(
         [fixture.info(report_codes.SBD_DISABLING_STARTED)] + [
             fixture.info(report_codes.SERVICE_DISABLE_SUCCESS,
                          service="sbd",
                          node=node,
                          instance=None) for node in self.node_list
         ] + [
             fixture.warn(
                 report_codes.CLUSTER_RESTART_REQUIRED_TO_APPLY_CHANGES)
         ])
Exemplo n.º 21
0
    def test_qdevice_reload(self):
        self.corosync_conf_facade.need_qdevice_reload = True
        (self.config
            .http.corosync.set_corosync_conf(
                self.corosync_conf_text,
                node_labels=self.node_labels
            )
            .runner.systemctl.is_active("corosync", is_active=False)
            .http.corosync.qdevice_client_stop(
                node_labels=self.node_labels
            )
            .http.corosync.qdevice_client_start(
                node_labels=self.node_labels
            )
        )

        self.env_assistant.get_env().push_corosync_conf(
            self.corosync_conf_facade
        )

        self.env_assistant.assert_reports([
            fixture.info(report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED),
            fixture.info(
                report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
                node="node-1",
            ),
            fixture.info(
                report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
                node="node-2",
            ),
            fixture.info(report_codes.QDEVICE_CLIENT_RELOAD_STARTED),
            fixture.info(
                report_codes.SERVICE_STOP_SUCCESS,
                node="node-1",
                service="corosync-qdevice",
                instance=None,
            ),
            fixture.info(
                report_codes.SERVICE_STOP_SUCCESS,
                node="node-2",
                service="corosync-qdevice",
                instance=None,
            ),
            fixture.info(
                report_codes.SERVICE_START_SUCCESS,
                node="node-1",
                service="corosync-qdevice",
                instance=None,
            ),
            fixture.info(
                report_codes.SERVICE_START_SUCCESS,
                node="node-2",
                service="corosync-qdevice",
                instance=None,
            ),
        ])
Exemplo n.º 22
0
 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})
Exemplo n.º 23
0
    def test_get_and_push_cib_version_upgrade_needed(self):
        (self.config.runner.cib.load(
            name="load_cib_old").runner.cib.upgrade().runner.cib.load(
                filename="cib-empty-2.8.xml"))
        env = self.env_assist.get_env()
        env.get_cib((2, 8, 0))

        self.env_assist.assert_reports(
            [fixture.info(report_codes.CIB_UPGRADE_SUCCESSFUL)])
Exemplo n.º 24
0
    def test_qdevice_reload_corosync_stopped(self):
        self.corosync_conf_facade.need_qdevice_reload = True
        (self.config.http.corosync.set_corosync_conf(
            self.corosync_conf_text,
            node_labels=self.node_labels).runner.systemctl.is_active(
                "corosync", is_active=False).http.corosync.qdevice_client_stop(
                    node_labels=self.node_labels).http.corosync.
         qdevice_client_start(
             communication_list=[{
                 "label": label,
                 "output": "corosync is not running, skipping",
             } for label in self.node_labels]))

        self.env_assistant.get_env().push_corosync_conf(
            self.corosync_conf_facade)

        self.env_assistant.assert_reports([
            fixture.info(report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED),
            fixture.info(
                report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
                node="node-1",
            ),
            fixture.info(
                report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
                node="node-2",
            ),
            fixture.info(report_codes.QDEVICE_CLIENT_RELOAD_STARTED),
            fixture.info(
                report_codes.SERVICE_STOP_SUCCESS,
                node="node-1",
                service="corosync-qdevice",
                instance=None,
            ),
            fixture.info(
                report_codes.SERVICE_STOP_SUCCESS,
                node="node-2",
                service="corosync-qdevice",
                instance=None,
            ),
            fixture.info(
                report_codes.SERVICE_START_SKIPPED,
                node="node-1",
                service="corosync-qdevice",
                instance=None,
                reason="corosync is not running",
            ),
            fixture.info(
                report_codes.SERVICE_START_SKIPPED,
                node="node-2",
                service="corosync-qdevice",
                instance=None,
                reason="corosync is not running",
            ),
        ])
Exemplo n.º 25
0
 def test_dont_need_stopped_cluster(self):
     (self.config.http.corosync.set_corosync_conf(
         self.corosync_conf_text,
         node_labels=self.node_labels).runner.systemctl.is_active(
             "corosync").runner.corosync.reload())
     self.env_assistant.get_env().push_corosync_conf(
         self.corosync_conf_facade)
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED),
         fixture.info(
             report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
             node="node-1",
         ),
         fixture.info(
             report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
             node="node-2",
         ),
         fixture.info(report_codes.COROSYNC_CONFIG_RELOADED)
     ])
Exemplo n.º 26
0
    def test_cib_upgrade(self):
        (self.config.runner.cib.load(
            name="load_cib_old_version",
            filename=self.upgraded_cib_filename,
            before="runner.cib.load").runner.cib.upgrade(
                before="runner.cib.load").env.push_cib(
                    resources=self.fixture_resources_bundle_simple))

        self.run_bundle_cmd()

        self.env_assist.assert_reports(
            [fixture.info(report_codes.CIB_UPGRADE_SUCCESSFUL)])
Exemplo n.º 27
0
 def test_need_stopped_cluster(self):
     self.corosync_conf_facade.need_stopped_cluster = True
     (self.config
         .http.corosync.check_corosync_offline(
             node_labels=self.node_labels
         )
         .http.corosync.set_corosync_conf(
             self.corosync_conf_text,
             node_labels=self.node_labels
         )
         .runner.systemctl.is_active("corosync", is_active=False)
     )
     self.env_assistant.get_env().push_corosync_conf(
         self.corosync_conf_facade
     )
     self.env_assistant.assert_reports([
         fixture.info(report_codes.COROSYNC_NOT_RUNNING_CHECK_STARTED),
         fixture.info(
             report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
             node="node-1",
         ),
         fixture.info(
             report_codes.COROSYNC_NOT_RUNNING_ON_NODE,
             node="node-2",
         ),
         fixture.info(report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED),
         fixture.info(
             report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
             node="node-1",
         ),
         fixture.info(
             report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE,
             node="node-2",
         ),
     ])
Exemplo n.º 28
0
def fixture_reports_not_live_cib(node_name):
    return [
        fixture.info(
            report_codes.COROSYNC_NODE_CONFLICT_CHECK_SKIPPED,
            reason_type="not_live_cib",
        ),
        fixture.info(
            report_codes.FILES_DISTRIBUTION_SKIPPED,
            reason_type="not_live_cib",
            file_list=["pacemaker authkey"],
            node_list=[node_name],
        ),
        fixture.info(
            report_codes.SERVICE_COMMANDS_ON_NODES_SKIPPED,
            reason_type="not_live_cib",
            action_list=[
                "pacemaker_remote start",
                "pacemaker_remote enable",
            ],
            node_list=[node_name],
        ),
    ]
Exemplo n.º 29
0
 def test_set_stonith_watchdog_timeout_fails_on_some_nodes(self):
     err_msg = "Error"
     self.config.runner.corosync.version()
     self.config.corosync_conf.load(filename=self.corosync_conf_name)
     self.config.http.host.check_auth(node_labels=self.node_list)
     self.config.http.pcmk.set_stonith_watchdog_timeout_to_zero(
         communication_list=[[{
             "label": "rh7-1",
             "was_connected": False,
             "errno": 7,
             "error_msg": err_msg,
         }], [{
             "label": "rh7-2",
             "response_code": 400,
             "output": "FAILED",
         }], [{
             "label": "rh7-3"
         }]])
     self.config.http.sbd.disable_sbd(node_labels=self.node_list)
     disable_sbd(self.env_assist.get_env())
     self.env_assist.assert_reports([
         fixture.warn(
             report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT,
             node="rh7-1",
             reason=err_msg,
             command="remote/set_stonith_watchdog_timeout_to_zero"),
         fixture.warn(report_codes.NODE_COMMUNICATION_COMMAND_UNSUCCESSFUL,
                      node="rh7-2",
                      reason="FAILED",
                      command="remote/set_stonith_watchdog_timeout_to_zero")
     ] + [fixture.info(report_codes.SBD_DISABLING_STARTED)] + [
         fixture.info(report_codes.SERVICE_DISABLE_SUCCESS,
                      service="sbd",
                      node=node,
                      instance=None) for node in self.node_list
     ] + [
         fixture.warn(
             report_codes.CLUSTER_RESTART_REQUIRED_TO_APPLY_CHANGES)
     ])
Exemplo n.º 30
0
 def test_unknown_host_addr_not_specified(self):
     self.config.env.set_known_hosts_dests(dict())
     (self.config.runner.cib.load().runner.pcmk.load_agent(
         agent_name="ocf:pacemaker:remote").env.push_cib(
             resources=FIXTURE_RESOURCES_TEMPLATE.format(server=NODE_NAME)))
     node_add_remote(self.env_assist.get_env(), no_node_addr=True)
     self.env_assist.assert_reports([
         fixture.info(
             report_codes.USING_KNOWN_HOST_ADDRESS_FOR_HOST,
             host_name=NODE_NAME,
             address=NODE_NAME,
         ),
     ] + fixture_reports_not_live_cib(NODE_NAME))