def _get_agent_facade(
report_processor: reports.ReportProcessor,
factory: ResourceAgentFacadeFactory,
name: str,
allow_absent_agent: bool,
) -> ResourceAgentFacade:
try:
if ":" in name:
raise InvalidResourceAgentName(name)
full_name = ResourceAgentName("stonith", None, name)
return factory.facade_from_parsed_name(full_name)
except (UnableToGetAgentMetadata, UnsupportedOcfVersion) as e:
if allow_absent_agent:
report_processor.report(
resource_agent_error_to_report_item(
e, reports.ReportItemSeverity.warning(), is_stonith=True))
return factory.void_facade_from_parsed_name(full_name)
report_processor.report(
resource_agent_error_to_report_item(
e,
reports.ReportItemSeverity.error(reports.codes.FORCE),
is_stonith=True,
))
raise LibraryError() from e
except ResourceAgentError as e:
report_processor.report(
resource_agent_error_to_report_item(
e, reports.ReportItemSeverity.error(), is_stonith=True))
raise LibraryError() from e
def _get_agent_facade(
report_processor: reports.ReportProcessor,
factory: ResourceAgentFacadeFactory,
allow_absent_agent: bool,
name: ResourceAgentName,
) -> ResourceAgentFacade:
try:
return factory.facade_from_parsed_name(name)
except UnableToGetAgentMetadata as e:
if allow_absent_agent:
report_processor.report(
resource_agent_error_to_report_item(
e, reports.ReportItemSeverity.warning()
)
)
return factory.void_facade_from_parsed_name(name)
report_processor.report(
resource_agent_error_to_report_item(
e, reports.ReportItemSeverity.error(reports.codes.FORCE)
)
)
raise LibraryError() from e
except ResourceAgentError as e:
report_processor.report(
resource_agent_error_to_report_item(
e, reports.ReportItemSeverity.error()
)
)
raise LibraryError() from e
def get_fence_agent_info(lib, argv, modifiers):
"""
Options: no options
"""
del lib
modifiers.ensure_only_supported()
if len(argv) != 1:
utils.err("One parameter expected")
agent = argv[0]
if not agent.startswith("stonith:"):
utils.err("Invalid fence agent name")
runner = utils.cmd_runner()
try:
metadata = lib_ra.StonithAgent(runner, agent[len("stonith:"):])
info = metadata.get_full_info()
info["name"] = "stonith:{0}".format(info["name"])
print(json.dumps(info))
except lib_ra.ResourceAgentError as e:
process_library_reports(
[lib_ra.resource_agent_error_to_report_item(e)])
except LibraryError as e:
process_library_reports(e.args)
def describe_agent(
lib_env: LibraryEnvironment, agent_name: str
) -> Dict[str, Any]:
"""
Get agent's description (metadata) in a structure
agent_name -- name of the agent
"""
runner = lib_env.cmd_runner()
report_processor = lib_env.report_processor
agent_factory = ResourceAgentFacadeFactory(runner, report_processor)
try:
found_name = (
split_resource_agent_name(agent_name)
if ":" in agent_name
else find_one_resource_agent_by_type(
runner, report_processor, agent_name
)
)
return _agent_metadata_to_dict(
agent_factory.facade_from_parsed_name(found_name).metadata,
describe=True,
)
except ResourceAgentError as e:
lib_env.report_processor.report(resource_agent_error_to_report_item(e))
raise LibraryError() from e
def _complete_agent_list(
runner: CommandRunner,
report_processor: ReportProcessor,
agent_names: Iterable[ResourceAgentName],
describe: bool,
search: Optional[str],
) -> List[Dict[str, Any]]:
agent_factory = ResourceAgentFacadeFactory(runner, report_processor)
search_lower = search.lower() if search else None
agent_list = []
for name in agent_names:
if search_lower and search_lower not in name.full_name.lower():
continue
try:
metadata = (
agent_factory.facade_from_parsed_name(name).metadata
if describe
else name_to_void_metadata(name)
)
agent_list.append(_agent_metadata_to_dict(metadata, describe))
except ResourceAgentError as e:
report_processor.report(
resource_agent_error_to_report_item(
e, ReportItemSeverity.warning()
)
)
return agent_list
def get_fence_agent_info(lib, argv, modifiers):
"""
Options: no options
"""
del lib
modifiers.ensure_only_supported()
if len(argv) != 1:
utils.err("One parameter expected")
agent = argv[0]
if not agent.startswith("stonith:"):
utils.err("Invalid fence agent name")
runner = utils.cmd_runner()
try:
metadata = lib_ra.StonithAgent(runner, agent[len("stonith:"):])
info = metadata.get_full_info()
info["name"] = "stonith:{0}".format(info["name"])
print(json.dumps(info))
except lib_ra.ResourceAgentError as e:
utils.process_library_reports(
[lib_ra.resource_agent_error_to_report_item(e)]
)
except LibraryError as e:
utils.process_library_reports(e.args)
def get_structured_agent_name(lib_env: LibraryEnvironment,
agent_name: str) -> ResourceAgentNameDto:
# This is a temporary solution and should never be available via pcsd REST
# API. The code for splitting an agent name will be eventually moved to cli
# once all old commands that require this will be replaced and removed.
try:
return split_resource_agent_name(agent_name).to_dto()
except ResourceAgentError as e:
lib_env.report_processor.report(resource_agent_error_to_report_item(e))
raise LibraryError() from e
def describe_agent(lib_env, agent_name):
"""
Get agent's description (metadata) in a structure
string agent_name name of the agent (not containing "stonith:" prefix)
"""
try:
metadata = resource_agent.StonithAgent(lib_env.cmd_runner(),
agent_name)
return metadata.get_full_info()
except resource_agent.ResourceAgentError as e:
raise LibraryError(
resource_agent.resource_agent_error_to_report_item(e))
def _get_agent_metadata(
runner: CommandRunner,
report_processor: ReportProcessor,
agent_name: ResourceAgentNameDto,
) -> ResourceAgentMetadata:
agent_factory = ResourceAgentFacadeFactory(runner, report_processor)
try:
return agent_factory.facade_from_parsed_name(
ResourceAgentName.from_dto(agent_name)).metadata
except ResourceAgentError as e:
report_processor.report(resource_agent_error_to_report_item(e))
raise LibraryError() from e
def describe_agent(lib_env, agent_name):
"""
Get agent's description (metadata) in a structure
string agent_name name of the agent (not containing "stonith:" prefix)
"""
try:
metadata = resource_agent.StonithAgent(
lib_env.cmd_runner(),
agent_name
)
return metadata.get_full_info()
except resource_agent.ResourceAgentError as e:
raise LibraryError(
resource_agent.resource_agent_error_to_report_item(e)
)
def get_agent_metadata(
lib_env: LibraryEnvironment,
agent_name: ResourceAgentNameDto) -> ResourceAgentMetadataDto:
"""
Return agent's metadata
agent_name -- name of the agent
"""
runner = lib_env.cmd_runner()
report_processor = lib_env.report_processor
agent_factory = ResourceAgentFacadeFactory(runner, report_processor)
try:
return agent_factory.facade_from_parsed_name(
ResourceAgentName.from_dto(agent_name)).metadata.to_dto()
except ResourceAgentError as e:
lib_env.report_processor.report(resource_agent_error_to_report_item(e))
raise LibraryError() from e
def get_fence_agent_info(argv):
# This is used only by pcsd, will be removed in new architecture
if len(argv) != 1:
utils.err("One parameter expected")
agent = argv[0]
if not agent.startswith("stonith:"):
utils.err("Invalid fence agent name")
runner = utils.cmd_runner()
try:
metadata = lib_ra.StonithAgent(runner, agent[len("stonith:"):])
info = metadata.get_full_info()
info["name"] = "stonith:{0}".format(info["name"])
print(json.dumps(info))
except lib_ra.ResourceAgentError as e:
utils.process_library_reports(
[lib_ra.resource_agent_error_to_report_item(e)])
except LibraryError as e:
utils.process_library_reports(e.args)
def describe_agent(lib_env: LibraryEnvironment,
agent_name: str) -> Dict[str, Any]:
"""
Get agent's description (metadata) in a structure
agent_name -- name of the agent (not containing "stonith:" prefix)
"""
runner = lib_env.cmd_runner()
agent_factory = ResourceAgentFacadeFactory(runner,
lib_env.report_processor)
try:
if ":" in agent_name:
raise InvalidResourceAgentName(agent_name)
return _agent_metadata_to_dict(
agent_factory.facade_from_parsed_name(
ResourceAgentName("stonith", None, agent_name)).metadata,
describe=True,
)
except ResourceAgentError as e:
lib_env.report_processor.report(
resource_agent_error_to_report_item(e, is_stonith=True))
raise LibraryError() from e
def get_fence_agent_info(argv):
# This is used only by pcsd, will be removed in new architecture
if len(argv) != 1:
utils.err("One parameter expected")
agent = argv[0]
if not agent.startswith("stonith:"):
utils.err("Invalid fence agent name")
runner = utils.cmd_runner()
try:
metadata = lib_ra.StonithAgent(runner, agent[len("stonith:"):])
info = metadata.get_full_info()
info["name"] = "stonith:{0}".format(info["name"])
print(json.dumps(info))
except lib_ra.ResourceAgentError as e:
utils.process_library_reports(
[lib_ra.resource_agent_error_to_report_item(e)]
)
except LibraryError as e:
utils.process_library_reports(e.args)
def stonith_create(argv):
if len(argv) < 2:
usage.stonith(["create"])
sys.exit(1)
stonith_id = argv.pop(0)
stonith_type = argv.pop(0)
st_values, op_values, meta_values = resource.parse_resource_options(
argv, with_clone=False
)
try:
metadata = lib_ra.StonithAgent(
utils.cmd_runner(),
stonith_type
)
if metadata.get_provides_unfencing():
meta_values = [
meta for meta in meta_values if not meta.startswith("provides=")
]
meta_values.append("provides=unfencing")
except lib_ra.ResourceAgentError as e:
forced = utils.get_modificators().get("force", False)
if forced:
severity = ReportItemSeverity.WARNING
else:
severity = ReportItemSeverity.ERROR
utils.process_library_reports([
lib_ra.resource_agent_error_to_report_item(
e, severity, not forced
)
])
except LibraryError as e:
utils.process_library_reports(e.args)
resource.resource_create(
stonith_id, "stonith:" + stonith_type, st_values, op_values, meta_values,
group=utils.pcs_options.get("--group", None)
)
def node_add_remote(
env: LibraryEnvironment,
node_name: str,
node_addr: Optional[str],
operations: Iterable[Mapping[str, str]],
meta_attributes: Mapping[str, str],
instance_attributes: Mapping[str, str],
skip_offline_nodes: bool = False,
allow_incomplete_distribution: bool = False,
allow_pacemaker_remote_service_fail: bool = False,
allow_invalid_operation: bool = False,
allow_invalid_instance_attributes: bool = False,
use_default_operations: bool = True,
wait: WaitType = False,
):
# pylint: disable=too-many-arguments
# pylint: disable=too-many-branches
# pylint: disable=too-many-locals
# pylint: disable=too-many-statements
"""
create an ocf:pacemaker:remote resource and use it as a remote node
env -- provides all for communication with externals
node_name -- the name of the new node
node_addr -- the address of the new node or None for default
operations -- attributes for each entered operation
meta_attributes -- attributes for primitive/meta_attributes
instance_attributes -- attributes for primitive/instance_attributes
skip_offline_nodes -- if True, ignore when some nodes are offline
allow_incomplete_distribution -- if True, allow this command to
finish successfully even if file distribution did not succeed
allow_pacemaker_remote_service_fail -- if True, allow this command to
finish successfully even if starting/enabling pacemaker_remote did not
succeed
allow_invalid_operation -- if True, allow to use operations that
are not listed in a resource agent metadata
allow_invalid_instance_attributes -- if True, allow to use instance
attributes that are not listed in a resource agent metadata and allow to
omit required instance_attributes
use_default_operations -- if True, add operations specified in
a resource agent metadata to the resource
wait -- a flag for controlling waiting for pacemaker idle mechanism
"""
wait_timeout = env.ensure_wait_satisfiable(wait)
report_processor = env.report_processor
cib = env.get_cib(
minimal_version=get_required_cib_version_for_primitive(operations))
id_provider = IdProvider(cib)
if env.is_cib_live:
corosync_conf: Optional[CorosyncConfigFacade] = env.get_corosync_conf()
else:
corosync_conf = None
report_processor.report(
ReportItem.info(
reports.messages.CorosyncNodeConflictCheckSkipped(
reports.const.REASON_NOT_LIVE_CIB, )))
(
existing_nodes_names,
existing_nodes_addrs,
report_list,
) = get_existing_nodes_names_addrs(corosync_conf, cib)
if env.is_cib_live:
# We just reported corosync checks are going to be skipped so we
# shouldn't complain about errors related to corosync nodes
report_processor.report_list(report_list)
try:
resource_agent_facade = ResourceAgentFacadeFactory(
env.cmd_runner(),
report_processor).facade_from_parsed_name(remote_node.AGENT_NAME)
except ResourceAgentError as e:
report_processor.report(resource_agent_error_to_report_item(e))
raise LibraryError() from e
existing_target_list = []
if env.is_cib_live:
target_factory = env.get_node_target_factory()
existing_target_list, new_target_list = _get_targets_for_add(
target_factory,
report_processor,
existing_nodes_names,
[node_name],
skip_offline_nodes,
)
new_target = new_target_list[0] if new_target_list else None
# default node_addr to an address from known-hosts
if node_addr is None:
if new_target:
node_addr = new_target.first_addr
node_addr_source = (
reports.const.DEFAULT_ADDRESS_SOURCE_KNOWN_HOSTS)
else:
node_addr = node_name
node_addr_source = (
reports.const.DEFAULT_ADDRESS_SOURCE_HOST_NAME)
report_processor.report(
ReportItem.info(
reports.messages.UsingDefaultAddressForHost(
node_name, node_addr, node_addr_source)))
else:
# default node_addr to an address from known-hosts
if node_addr is None:
known_hosts = env.get_known_hosts([node_name])
if known_hosts:
node_addr = known_hosts[0].dest.addr
node_addr_source = (
reports.const.DEFAULT_ADDRESS_SOURCE_KNOWN_HOSTS)
else:
node_addr = node_name
node_addr_source = (
reports.const.DEFAULT_ADDRESS_SOURCE_HOST_NAME)
report_processor.report(
ReportItem.info(
reports.messages.UsingDefaultAddressForHost(
node_name, node_addr, node_addr_source)))
# validate inputs
report_list = remote_node.validate_create(
existing_nodes_names,
existing_nodes_addrs,
resource_agent_facade.metadata,
node_name,
node_addr,
instance_attributes,
)
if report_processor.report_list(report_list).has_errors:
raise LibraryError()
# validation + cib setup
# TODO extract the validation to a separate function
try:
remote_resource_element = remote_node.create(
env.report_processor,
resource_agent_facade,
get_resources(cib),
id_provider,
node_addr,
node_name,
operations,
meta_attributes,
instance_attributes,
allow_invalid_operation,
allow_invalid_instance_attributes,
use_default_operations,
)
except LibraryError as e:
# Check unique id conflict with check against nodes. Until validation
# resource create is not separated, we need to make unique post
# validation.
already_exists = []
unified_report_list = []
for report_item in report_list + list(e.args):
# pylint: disable=no-member
dto_obj = report_item.message.to_dto()
if dto_obj.code not in (
reports.codes.ID_ALREADY_EXISTS,
reports.codes.RESOURCE_INSTANCE_ATTR_VALUE_NOT_UNIQUE,
):
unified_report_list.append(report_item)
elif ("id" in dto_obj.payload
and dto_obj.payload["id"] not in already_exists):
unified_report_list.append(report_item)
already_exists.append(dto_obj.payload["id"])
report_list = unified_report_list
report_processor.report_list(report_list)
if report_processor.has_errors:
raise LibraryError()
# everything validated, let's set it up
if env.is_cib_live:
_prepare_pacemaker_remote_environment(
env,
report_processor,
existing_target_list,
new_target,
node_name,
skip_offline_nodes,
allow_incomplete_distribution,
allow_pacemaker_remote_service_fail,
)
else:
report_processor.report_list(
_reports_skip_new_node(node_name, "not_live_cib"))
env.push_cib(wait_timeout=wait_timeout)
if wait_timeout >= 0:
_ensure_resource_running(env, remote_resource_element.attrib["id"])
