def create_or_update_route_table(virtual_network_client, module):
result = dict(changed=False, route_table="")
rt_id = module.params.get("rt_id")
exclude_attributes = {"display_name": True}
try:
if rt_id:
existing_route_table = oci_utils.get_existing_resource(
virtual_network_client.get_route_table, module, rt_id=rt_id
)
result = update_route_table(
virtual_network_client, existing_route_table, module
)
else:
result = oci_utils.check_and_create_resource(
resource_type="route_table",
create_fn=create_route_table,
kwargs_create={
"virtual_network_client": virtual_network_client,
"module": module,
},
list_fn=virtual_network_client.list_route_tables,
kwargs_list={
"compartment_id": module.params.get("compartment_id"),
"vcn_id": module.params.get("vcn_id"),
},
module=module,
exclude_attributes=exclude_attributes,
model=CreateRouteTableDetails(),
)
except ServiceError as ex:
module.fail_json(msg=ex.message)
except MaximumWaitTimeExceeded as ex:
module.fail_json(msg=str(ex))
return result
def create_route_table(virtual_network_client, module):
route_rules = []
input_route_rules = module.params["route_rules"]
if input_route_rules:
route_rules = get_route_rules(input_route_rules)
create_route_table_details = CreateRouteTableDetails()
for attribute in create_route_table_details.attribute_map:
create_route_table_details.__setattr__(attribute, module.params.get(attribute))
create_route_table_details.route_rules = route_rules
result = oci_utils.create_and_wait(
resource_type="route_table",
create_fn=virtual_network_client.create_route_table,
kwargs_create={"create_route_table_details": create_route_table_details},
client=virtual_network_client,
get_fn=virtual_network_client.get_route_table,
get_param="rt_id",
module=module,
)
return result
def validate_options(cls, options):
if not isinstance(options, dict):
raise ValueError("options is not a dictionary")
expected_profile_keys = [
"compartment_id",
"name",
]
expected_instance_keys = [
"availability_domain",
"shape",
"operating_system",
"operating_system_version",
]
optional_instance_metadata_keys = ["ssh_authorized_keys"]
optional_instance_keys = ["display_name"]
expected_vcn_keys = ["dns_label", "display_name"]
optional_vcn_keys = [
k for k, v in CreateVcnDetails().attribute_map.items()
if k not in expected_vcn_keys
]
optional_vcn_keys.append("id")
expected_subnet_keys = ["dns_label", "display_name"]
optional_subnet_keys = [
k for k, v in CreateSubnetDetails().attribute_map.items()
if k not in expected_subnet_keys
]
optional_subnet_keys.append("id")
expected_route_table_keys = ["routerules"]
optional_route_table_keys = [
k for k, v in CreateRouteTableDetails().attribute_map.items()
if k not in expected_route_table_keys
]
optional_route_table_keys.append("id")
# optional_route_rule_keys = [k for k, v in RouteRule().attribute_map.items()]
expected_gateway_keys = ["is_enabled"]
optional_gateway_keys = [
k for k, v in CreateInternetGatewayDetails().attribute_map.items()
if k not in expected_gateway_keys
]
optional_gateway_keys.append("id")
expected_groups = {
"profile": expected_profile_keys,
"instance": expected_instance_keys +
optional_instance_metadata_keys + optional_instance_keys,
"vcn": expected_vcn_keys + optional_vcn_keys,
"routetable":
expected_route_table_keys + optional_route_table_keys,
# "route_rule": optional_route_rule_keys,
"internetgateway": expected_gateway_keys + optional_gateway_keys,
"subnet": expected_subnet_keys + optional_subnet_keys,
}
# TODO, flatten the dict before the validation
# -> avoid recursion for nested structures
for group, keys in expected_groups.items():
if group not in options:
raise KeyError("Missing group: {}".format(group))
if not isinstance(options[group], dict):
raise TypeError("Group: {} must be a dictionary".format(group))
for key, _ in options[group].items():
if key not in keys:
raise KeyError("Incorrect key: {} is not in: {}".format(
key, keys))