Esempio n. 1
0
 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(5)]
     lib_sbd.enable_sbd_service_on_all_nodes(mock_rep, mock_com, node_list)
     mock_func.assert_called_once_with(lib_sbd.enable_sbd_service_on_node,
                                       [([mock_rep, mock_com, node], {})
                                        for node in node_list])
Esempio n. 2
0
 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(5)]
     lib_sbd.enable_sbd_service_on_all_nodes(mock_rep, mock_com, node_list)
     mock_func.assert_called_once_with(
         lib_sbd.enable_sbd_service_on_node,
         [([mock_rep, mock_com, node], {}) for node in node_list]
     )
Esempio n. 3
0
def enable_sbd(lib_env,
               default_watchdog,
               watchdog_dict,
               sbd_options,
               allow_unknown_opts=False,
               ignore_offline_nodes=False):
    """
    Enable SBD on all nodes in cluster.

    lib_env -- LibraryEnvironment
    default_watchdog -- watchdog for nodes which are not specified in
        watchdog_dict. Uses default value from settings if None.
    watchdog_dict -- dictionary with NodeAddresses as keys and watchdog path
        as value
    sbd_options -- dictionary in format: <SBD config option>: <value>
    allow_unknown_opts -- if True, accept also unknown options.
    ignore_offline_nodes -- if True, omit offline nodes
    """
    node_list = _get_cluster_nodes(lib_env)

    if not default_watchdog:
        default_watchdog = settings.sbd_watchdog_default

    # input validation begin
    full_watchdog_dict = _get_full_watchdog_list(node_list, default_watchdog,
                                                 watchdog_dict)

    # config validation
    sbd_options = dict([(opt.upper(), val)
                        for opt, val in sbd_options.items()])
    lib_env.report_processor.process_list(
        _validate_sbd_options(sbd_options, allow_unknown_opts))

    # check nodes status
    online_nodes = _get_online_nodes(lib_env, node_list, ignore_offline_nodes)
    for node in list(full_watchdog_dict):
        if node not in online_nodes:
            full_watchdog_dict.pop(node, None)
    # input validation end

    # check if SBD can be enabled
    sbd.check_sbd_on_all_nodes(lib_env.report_processor,
                               lib_env.node_communicator(), full_watchdog_dict)

    # enable ATB if needed
    if not lib_env.is_cman_cluster:
        corosync_conf = lib_env.get_corosync_conf()
        if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
            lib_env.report_processor.process(reports.sbd_requires_atb())
            corosync_conf.set_quorum_options(lib_env.report_processor,
                                             {"auto_tie_breaker": "1"})
            lib_env.push_corosync_conf(corosync_conf, ignore_offline_nodes)

    # distribute SBD configuration
    config = sbd.get_default_sbd_config()
    config.update(sbd_options)
    sbd.set_sbd_config_on_all_nodes(lib_env.report_processor,
                                    lib_env.node_communicator(), online_nodes,
                                    config, full_watchdog_dict)

    # remove cluster prop 'stonith_watchdog_timeout'
    sbd.remove_stonith_watchdog_timeout_on_all_nodes(
        lib_env.node_communicator(), online_nodes)

    # enable SBD service an all nodes
    sbd.enable_sbd_service_on_all_nodes(lib_env.report_processor,
                                        lib_env.node_communicator(),
                                        online_nodes)

    lib_env.report_processor.process(
        reports.cluster_restart_required_to_apply_changes())
Esempio n. 4
0
def enable_sbd(
        lib_env, default_watchdog, watchdog_dict, sbd_options,
        allow_unknown_opts=False, ignore_offline_nodes=False
):
    """
    Enable SBD on all nodes in cluster.

    lib_env -- LibraryEnvironment
    default_watchdog -- watchdog for nodes which are not specified in
        watchdog_dict. Uses default value from settings if None.
    watchdog_dict -- dictionary with NodeAddresses as keys and watchdog path
        as value
    sbd_options -- dictionary in format: <SBD config option>: <value>
    allow_unknown_opts -- if True, accept also unknown options.
    ignore_offline_nodes -- if True, omit offline nodes
    """
    node_list = _get_cluster_nodes(lib_env)

    if not default_watchdog:
        default_watchdog = settings.sbd_watchdog_default

    # input validation begin
    full_watchdog_dict = _get_full_watchdog_list(
        node_list, default_watchdog, watchdog_dict
    )

    # config validation
    sbd_options = dict([(opt.upper(), val) for opt, val in sbd_options.items()])
    lib_env.report_processor.process_list(
        _validate_sbd_options(sbd_options, allow_unknown_opts)
    )

    # check nodes status
    online_nodes = _get_online_nodes(lib_env, node_list, ignore_offline_nodes)
    for node in list(full_watchdog_dict):
        if node not in online_nodes:
            full_watchdog_dict.pop(node, None)
    # input validation end

    # check if SBD can be enabled
    sbd.check_sbd_on_all_nodes(
        lib_env.report_processor,
        lib_env.node_communicator(),
        full_watchdog_dict
    )

    # enable ATB if needed
    if not lib_env.is_cman_cluster:
        corosync_conf = lib_env.get_corosync_conf()
        if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
            lib_env.report_processor.process(reports.sbd_requires_atb())
            corosync_conf.set_quorum_options(
                lib_env.report_processor, {"auto_tie_breaker": "1"}
            )
            lib_env.push_corosync_conf(corosync_conf, ignore_offline_nodes)

    # distribute SBD configuration
    config = sbd.get_default_sbd_config()
    config.update(sbd_options)
    sbd.set_sbd_config_on_all_nodes(
        lib_env.report_processor,
        lib_env.node_communicator(),
        online_nodes,
        config,
        full_watchdog_dict
    )

    # remove cluster prop 'stonith_watchdog_timeout'
    sbd.remove_stonith_watchdog_timeout_on_all_nodes(
        lib_env.node_communicator(), online_nodes
    )

    # enable SBD service an all nodes
    sbd.enable_sbd_service_on_all_nodes(
        lib_env.report_processor, lib_env.node_communicator(), online_nodes
    )

    lib_env.report_processor.process(
        reports.cluster_restart_required_to_apply_changes()
    )
Esempio n. 5
0
File: sbd.py Progetto: cwjenkins/pcs
def enable_sbd(
    lib_env,
    default_watchdog,
    watchdog_dict,
    sbd_options,
    default_device_list=None,
    node_device_dict=None,
    allow_unknown_opts=False,
    ignore_offline_nodes=False,
):
    """
    Enable SBD on all nodes in cluster.

    lib_env -- LibraryEnvironment
    default_watchdog -- watchdog for nodes which are not specified in
        watchdog_dict. Uses default value from settings if None.
    watchdog_dict -- dictionary with node names as keys and watchdog path
        as value
    sbd_options -- dictionary in format: <SBD config option>: <value>
    default_device_list -- list of devices for all nodes
    node_device_dict -- dictionary with node names as keys and list of devices
        as value
    allow_unknown_opts -- if True, accept also unknown options.
    ignore_offline_nodes -- if True, omit offline nodes
    """
    node_list = _get_cluster_nodes(lib_env)
    using_devices = not (default_device_list is None
                         and node_device_dict is None)
    if default_device_list is None:
        default_device_list = []
    if node_device_dict is None:
        node_device_dict = {}
    if not default_watchdog:
        default_watchdog = settings.sbd_watchdog_default
    sbd_options = dict([(opt.upper(), val)
                        for opt, val in sbd_options.items()])

    full_watchdog_dict = _get_full_node_dict(node_list, watchdog_dict,
                                             default_watchdog)
    full_device_dict = _get_full_node_dict(node_list, node_device_dict,
                                           default_device_list)

    lib_env.report_processor.process_list(
        _check_node_names_in_cluster(
            node_list,
            watchdog_dict.keys() + node_device_dict.keys()) +
        _validate_watchdog_dict(full_watchdog_dict) +
        _validate_device_dict(full_device_dict) if using_devices else [] +
        _validate_sbd_options(sbd_options, allow_unknown_opts))

    online_nodes = _get_online_nodes(lib_env, node_list, ignore_offline_nodes)

    node_data_dict = {}
    for node in online_nodes:
        node_data_dict[node] = {
            "watchdog": full_watchdog_dict[node],
            "device_list": full_device_dict[node] if using_devices else [],
        }

    # check if SBD can be enabled
    sbd.check_sbd_on_all_nodes(
        lib_env.report_processor,
        lib_env.node_communicator(),
        node_data_dict,
    )

    # enable ATB if needed
    if not lib_env.is_cman_cluster and not using_devices:
        corosync_conf = lib_env.get_corosync_conf()
        if sbd.atb_has_to_be_enabled_pre_enable_check(corosync_conf):
            lib_env.report_processor.process(reports.sbd_requires_atb())
            corosync_conf.set_quorum_options(lib_env.report_processor,
                                             {"auto_tie_breaker": "1"})
            lib_env.push_corosync_conf(corosync_conf, ignore_offline_nodes)

    # distribute SBD configuration
    config = sbd.get_default_sbd_config()
    config.update(sbd_options)
    sbd.set_sbd_config_on_all_nodes(
        lib_env.report_processor,
        lib_env.node_communicator(),
        online_nodes,
        config,
        full_watchdog_dict,
        full_device_dict,
    )

    # remove cluster prop 'stonith_watchdog_timeout'
    sbd.remove_stonith_watchdog_timeout_on_all_nodes(
        lib_env.node_communicator(), online_nodes)

    # enable SBD service an all nodes
    sbd.enable_sbd_service_on_all_nodes(lib_env.report_processor,
                                        lib_env.node_communicator(),
                                        online_nodes)

    lib_env.report_processor.process(
        reports.cluster_restart_required_to_apply_changes())