def is_action_necessary(self, action, resource=None):
resource_dict = to_dict(resource)
if action == self.GENERATE_ACTION_KEY:
keys_to_generate = []
if self.module.params.get("generate_data_keys_list_details"):
for data_key in self.module.params.get(
"generate_data_keys_list_details"):
if not oci_common_utils.is_in_list(resource_dict,
data_key):
keys_to_generate.append(data_key)
if keys_to_generate:
self.module.params[
"generate_data_keys_list_details"] = keys_to_generate
return True
return False
elif action == self.REMOVE_ACTION_KEY:
keys_to_remove = []
if self.module.params.get("remove_data_keys_list_details"):
for data_key in self.module.params.get(
"remove_data_keys_list_details"):
if oci_common_utils.is_in_list(resource_dict, data_key):
keys_to_remove.append(data_key)
if keys_to_remove:
self.module.params[
"remove_data_keys_list_details"] = keys_to_remove
return True
return False
return super(DataKeysActionsHelperCustom,
self).is_action_necessary(action, resource)
def _add_network_security_group_rules_idempotency_check(self):
existing_security_rules = self.list_security_rules()
provided_security_rules = self.module.params.get("security_rules", [])
provided_security_rules_to_add = []
existing_security_rules_as_dicts = [
to_dict(security_rule) for security_rule in existing_security_rules
]
for provided_security_rule in provided_security_rules:
if not oci_common_utils.is_in_list(
existing_security_rules_as_dicts,
element=provided_security_rule):
provided_security_rules_to_add.append(provided_security_rule)
if len(provided_security_rules_to_add) == 0:
resource = AddedNetworkSecurityGroupSecurityRules(
security_rules=self.list_security_rules())
return oci_common_utils.get_result(
changed=False,
resource_type=self.resource_type,
resource=to_dict(resource),
)
else:
self.module.params[
"security_rules"] = provided_security_rules_to_add
def get_update_model(self):
update_model = super(RouteTableHelperCustom, self).get_update_model()
existing_route_table = self.get_resource().data
existing_route_rules = getattr(existing_route_table, "route_rules",
[]) or []
existing_route_rules_dict = to_dict(existing_route_rules)
if self.module.params.get("purge_route_rules") is False:
if existing_route_rules:
update_model.route_rules = (getattr(update_model,
"route_rules", []) or [])
update_model.route_rules = existing_route_rules + [
route_rule for route_rule in update_model.route_rules
if not oci_common_utils.is_in_list(
existing_route_rules_dict, to_dict(route_rule))
]
elif self.module.params.get("delete_route_rules") is True:
update_model.route_rules = getattr(update_model, "route_rules",
[]) or []
if not update_model.route_rules:
update_model.route_rules = existing_route_rules
else:
existing_route_rules = existing_route_rules or []
update_model.route_rules = [
existing_route_rule
for existing_route_rule in existing_route_rules
if not any([
oci_common_utils.compare_dicts(
to_dict(route_rule), to_dict(existing_route_rule))
for route_rule in update_model.route_rules
])
]
return update_model
def get_update_model(self):
update_model = super(SecurityListHelperCustom, self).get_update_model()
existing_security_list = self.get_resource().data
existing_ingress_security_rules = existing_security_list.ingress_security_rules
existing_ingress_security_rules_dict = to_dict(
existing_ingress_security_rules)
existing_egress_security_rules = existing_security_list.egress_security_rules
existing_egress_security_rules_dict = to_dict(
existing_egress_security_rules)
if self.module.params.get("purge_security_rules") is False:
if existing_ingress_security_rules:
update_model.ingress_security_rules = (
update_model.ingress_security_rules or [])
update_model.ingress_security_rules = (
existing_ingress_security_rules + [
security_rule for security_rule in update_model.
ingress_security_rules if not oci_common_utils.
is_in_list(existing_ingress_security_rules_dict,
to_dict(security_rule))
])
if existing_egress_security_rules:
update_model.egress_security_rules = (
update_model.egress_security_rules or [])
update_model.egress_security_rules = existing_egress_security_rules + [
security_rule
for security_rule in update_model.egress_security_rules
if not oci_common_utils.is_in_list(
existing_egress_security_rules_dict,
to_dict(security_rule))
]
elif self.module.params.get("delete_security_rules") is True:
if update_model.ingress_security_rules is None:
update_model.ingress_security_rules = existing_ingress_security_rules
else:
existing_ingress_security_rules = existing_ingress_security_rules or []
update_model.ingress_security_rules = [
existing_security_rule for existing_security_rule in
existing_ingress_security_rules if not any([
oci_common_utils.compare_dicts(
to_dict(security_rule),
to_dict(existing_security_rule)) for security_rule
in update_model.ingress_security_rules
])
]
if update_model.egress_security_rules is None:
update_model.egress_security_rules = existing_egress_security_rules
else:
existing_egress_security_rules = existing_egress_security_rules or []
update_model.egress_security_rules = [
existing_security_rule for existing_security_rule in
existing_egress_security_rules if not any([
oci_common_utils.compare_dicts(
to_dict(security_rule),
to_dict(existing_security_rule))
for security_rule in update_model.egress_security_rules
])
]
return update_model
def is_update_necessary(self, existing_resource_dict):
vpc_users_source_list = self.module.params.get("vpc_users")
vpc_users_target_list = existing_resource_dict["vpc_users"]
if vpc_users_source_list is not None and not all([
oci_common_utils.is_in_list(
vpc_users_target_list,
element,
ignore_attr_if_not_in_target=False,
) for element in vpc_users_source_list
]):
return True
return super(BackupDestinationHelperCustom,
self).is_update_necessary(existing_resource_dict)
def _update_network_security_group_rules_idempotency_check(self):
existing_security_rules = self.list_security_rules()
provided_security_rules = self.module.params.get("security_rules", [])
existing_security_rules_as_dicts = [
to_dict(security_rule) for security_rule in existing_security_rules
]
all_rules_to_update_already_exist_and_match = True
for provided_security_rule in provided_security_rules:
if not oci_common_utils.is_in_list(
existing_security_rules_as_dicts,
element=provided_security_rule):
all_rules_to_update_already_exist_and_match = False
if all_rules_to_update_already_exist_and_match:
resource = UpdatedNetworkSecurityGroupSecurityRules(
security_rules=self.list_security_rules())
return oci_common_utils.get_result(
changed=False,
resource_type=self.resource_type,
resource=to_dict(resource),
)
def is_action_necessary(self, action, resource=None):
existing_route_rules = to_dict(resource or self.get_resource().data)
logger.debug("Existing rules: {0}".format(existing_route_rules))
if action == self.ADD_KEY:
if not self.module.params.get("route_rules"):
return False
logger.debug("Original route rules to add: {0}".format(
self.module.params.get("route_rules")))
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, AddDrgRouteRulesDetails)
route_rules = to_dict(
getattr(action_details, "route_rules", []) or [])
route_rules_to_add = []
for route_rule in route_rules:
if not oci_common_utils.is_in_list(existing_route_rules,
route_rule):
route_rules_to_add.append(route_rule)
logger.debug("Route rules to add: {0}".format(route_rules_to_add))
if route_rules_to_add:
self.module.params["route_rules"] = route_rules_to_add
return True
return False
elif action == self.UPDATE_KEY:
if not self.module.params.get("route_rules"):
return False
logger.debug("Original route rules to update: {0}".format(
self.module.params.get("route_rules")))
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, UpdateDrgRouteRulesDetails)
route_rules = to_dict(
getattr(action_details, "route_rules", []) or [])
route_rules_to_update = []
for route_rule in route_rules:
existing_route_rule = None
for existing_rule in existing_route_rules:
if existing_rule.get("id") == route_rule.get("id"):
existing_route_rule = existing_rule
if not existing_route_rule:
self.module.fail_json(
msg="Could not find an existing rule with id: {0}".
format(route_rule.get("id")))
if not oci_common_utils.compare_dicts(route_rule,
existing_route_rule):
route_rules_to_update.append(route_rule)
logger.debug(
"Route rules to update: {0}".format(route_rules_to_update))
if route_rules_to_update:
self.module.params["route_rules"] = route_rules_to_update
return True
return False
elif action == self.REMOVE_KEY:
route_rule_ids = self.module.params.get("route_rule_ids")
if not route_rule_ids:
return False
existing_route_rule_ids = [
existing_route_rule.get("id")
for existing_route_rule in existing_route_rules
]
logger.debug("Original route_rule_ids to remove: {0}".format(
route_rule_ids))
route_rule_ids_to_remove = []
for route_rule_id in route_rule_ids:
if route_rule_id in existing_route_rule_ids:
route_rule_ids_to_remove.append(route_rule_id)
logger.debug("route_rule_ids to remove: {0}".format(
route_rule_ids_to_remove))
if route_rule_ids_to_remove:
self.module.params["route_rule_ids"] = route_rule_ids_to_remove
return True
return False
return super(DrgRouteRulesActionsHelperCustom,
self).is_action_necessary(action, resource)
def is_action_necessary(self, action, resource=None):
existing_statements = to_dict(resource or self.get_resource().data)
logger.debug("Existing statements: {0}".format(existing_statements))
if action == self.ADD_DRG_ROUTE_DISTRIBUTION_STATEMENTS_KEY:
if not self.module.params.get("statements"):
return False
logger.debug("Original statements to add: {0}".format(
self.module.params.get("statements")))
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params, AddDrgRouteDistributionStatementsDetails)
statements = to_dict(
getattr(action_details, "statements", []) or [])
statements_to_add = []
for statement in statements:
if not oci_common_utils.is_in_list(existing_statements,
statement):
statements_to_add.append(statement)
logger.debug("Statements to add: {0}".format(statements_to_add))
if statements_to_add:
self.module.params["statements"] = statements_to_add
return True
return False
elif action == self.UPDATE_DRG_ROUTE_DISTRIBUTION_STATEMENTS_KEY:
if not self.module.params.get("statements"):
return False
logger.debug("Original statements to update: {0}".format(
self.module.params.get("statements")))
action_details = oci_common_utils.convert_input_data_to_model_class(
self.module.params,
UpdateDrgRouteDistributionStatementsDetails)
statements = to_dict(
getattr(action_details, "statements", []) or [])
statements_to_update = []
for statement in statements:
existing_statement = None
for existing_stmt in existing_statements:
if existing_stmt.get("id") == statement.get("id"):
existing_statement = existing_stmt
if not existing_statement:
self.module.fail_json(
msg="Could not find an existing statement with id: {0}"
.format(statement.get("id")))
if not oci_common_utils.compare_dicts(statement,
existing_statement):
statements_to_update.append(statement)
logger.debug(
"Statements to update: {0}".format(statements_to_update))
if statements_to_update:
self.module.params["statements"] = statements_to_update
return True
return False
elif action == self.REMOVE_DRG_ROUTE_DISTRIBUTION_STATEMENTS_KEY:
statement_ids = self.module.params.get("statement_ids")
if not statement_ids:
return False
existing_statement_ids = [
existing_statement.get("id")
for existing_statement in existing_statements
]
logger.debug(
"Original statement_ids to remove: {0}".format(statement_ids))
statement_ids_to_remove = []
for statement_id in statement_ids:
if statement_id in existing_statement_ids:
statement_ids_to_remove.append(statement_id)
logger.debug(
"statement_ids to remove: {0}".format(statement_ids_to_remove))
if statement_ids_to_remove:
self.module.params["statement_ids"] = statement_ids_to_remove
return True
return False
return super(DrgRouteDistributionStatementsActionsHelperCustom,
self).is_action_necessary(action, resource)
