def create_path_routes(path_routes_list):
if path_routes_list is None:
raise ClientError(
'path_routes is mandatory attribute for path_route_set and can not be empty.'
)
HashedPathMatchType = oci_utils.generate_subclass(PathMatchType)
path_match_type = dict(
EXACT_MATCH=HashedPathMatchType(
match_type=PathMatchType.MATCH_TYPE_EXACT_MATCH),
FORCE_LONGEST_PREFIX_MATCH=HashedPathMatchType(
match_type=PathMatchType.MATCH_TYPE_FORCE_LONGEST_PREFIX_MATCH),
PREFIX_MATCH=HashedPathMatchType(
match_type=PathMatchType.MATCH_TYPE_PREFIX_MATCH),
SUFFIX_MATCH=HashedPathMatchType(
match_type=PathMatchType.MATCH_TYPE_SUFFIX_MATCH))
result_path_routes = list()
HashedPathRoute = oci_utils.generate_subclass(PathRoute)
for path_route_entry in path_routes_list:
path_route = HashedPathRoute()
backend_set_name = path_route_entry.get('backend_set_name', None)
path = path_route_entry.get('path', None)
path_match_type = path_match_type.get(
path_route_entry.get('path_match_type',
None).get('match_type', None))
if backend_set_name is None or path is None or path_match_type is None:
raise ClientError(
Exception(
"backend_set_name, path and path_match_type are mandatory attributes for"
" back_ends and can not be empty."))
path_route.backend_set_name = backend_set_name
path_route.path = path
path_route.path_match_type = path_match_type
result_path_routes.append(path_route)
return result_path_routes
def create_health_checker(health_checker_details):
if health_checker_details is None:
return None
HashedHealthCheckerDetails = oci_utils.generate_subclass(HealthCheckerDetails)
health_checker = HashedHealthCheckerDetails()
attribute_to_default_value_dict = dict(
{
"interval_in_millis": 10000,
"port": 0,
"response_body_regex": ".*",
"retries": 3,
"return_code": 200,
"timeout_in_millis": 3000,
}
)
protocol = health_checker_details.get("protocol", None)
url_path = health_checker_details.get("url_path", None)
if protocol is None or url_path is None:
raise ClientError(
Exception(
"protocol and url_path are mandatory attributes for health_checker and can not be empty."
)
)
health_checker.protocol = protocol
health_checker.url_path = url_path
for key, value in six.iteritems(attribute_to_default_value_dict):
health_checker.__setattr__(key, health_checker_details.get(key, value))
return health_checker
def create_backends(backends_list):
if backends_list is None:
return None
result_backends = list()
attribute_to_default_value_dict = dict(
{"backup": False, "drain": False, "offline": False, "weight": 1}
)
HashedBackendDetails = oci_utils.generate_subclass(BackendDetails)
for backend_entry in backends_list:
backend = HashedBackendDetails()
ip_address = backend_entry.get("ip_address", None)
port = backend_entry.get("port", None)
if ip_address is None or port is None:
raise ClientError(
Exception(
"ip_address and port are mandatory attributes for back_ends and can not "
"be empty."
)
)
backend.ip_address = ip_address
backend.port = port
for key, value in six.iteritems(attribute_to_default_value_dict):
backend.__setattr__(key, backend_entry.get(key, value))
result_backends.append(backend)
return result_backends
def get_hashed_object(class_type, object_with_value):
if object_with_value is None:
return None
HashedClass = oci_utils.generate_subclass(class_type)
hashed_class_instance = HashedClass()
for attribute in hashed_class_instance.attribute_map.keys():
hashed_class_instance.__setattr__(
attribute, getattr(object_with_value, attribute))
return hashed_class_instance
def get_hashed_object_list(class_type, object_with_values):
if object_with_values is None:
return None
hashed_class_instances = []
HashedClass = oci_utils.generate_subclass(class_type)
for object_with_value in object_with_values:
hashed_class_instance = HashedClass()
for attribute in hashed_class_instance.attribute_map.keys():
hashed_class_instance.__setattr__(
attribute, getattr(object_with_value, attribute))
hashed_class_instances.append(hashed_class_instance)
return hashed_class_instances
def create_connection_configuration(connection_configuration_details):
if connection_configuration_details is None:
return None
HashedConnectionConfiguration = oci_utils.generate_subclass(ConnectionConfiguration)
result_connection_configuration = HashedConnectionConfiguration()
idle_timeout = connection_configuration_details.get("idle_timeout")
if idle_timeout is None:
raise ClientError(
Exception(
"idle_timeout is mandatory attributes for connection_configuration and can not be empty."
)
)
result_connection_configuration.idle_timeout = idle_timeout
return result_connection_configuration
def get_export_options(export_options):
if export_options is None:
return None
HashedClientOptions = oci_utils.generate_subclass(ClientOptions)
result_client_options = []
for export_option_entry in export_options:
client_options = HashedClientOptions()
if export_option_entry.get('source') is None:
raise ClientError('Export Options attribute source must contain a valid value')
client_options.source = export_option_entry.get('source')
client_options.require_privileged_source_port = export_option_entry.get('require_privileged_source_port', True)
client_options.access = export_option_entry.get('access', 'READ_ONLY')
client_options.identity_squash = export_option_entry.get('identity_squash', 'ROOT')
client_options.anonymous_uid = export_option_entry.get('anonymous_uid', 65534)
client_options.anonymous_gid = export_option_entry.get('anonymous_gid', 65534)
result_client_options.append(client_options)
return result_client_options
def create_ssl_configuration(ssl_configuration_details):
if ssl_configuration_details is None:
return None
HashedSSLConfigurationDetails = oci_utils.generate_subclass(
SSLConfigurationDetails)
result_ssl_configuration = HashedSSLConfigurationDetails()
attributes = ['verify_depth', 'verify_peer_certificate']
certificate_name = ssl_configuration_details.get('certificate_name')
if certificate_name is None:
raise ClientError(
Exception(
"certificate_name is mandatory attributes for ssl_configuration and can not be empty."
))
result_ssl_configuration.certificate_name = certificate_name
for attribute in attributes:
result_ssl_configuration.__setattr__(
attribute, ssl_configuration_details.get(attribute))
return result_ssl_configuration
def create_session_persistence_configuration(
session_persistence_configuration):
if session_persistence_configuration is None:
return None
HashedSessionPersistenceConfigurationDetails = oci_utils.generate_subclass(
SessionPersistenceConfigurationDetails)
result_session_persistence_configuration = HashedSessionPersistenceConfigurationDetails(
)
cookie_name = session_persistence_configuration.get('cookie_name')
if cookie_name is None:
raise ClientError(
Exception(
"cookie_name is mandatory attributes for session_persistence_configuration and can not be empty."
))
result_session_persistence_configuration.cookie_name = cookie_name
result_session_persistence_configuration.disable_fallback = session_persistence_configuration.get(
'disable_fallback', False)
return result_session_persistence_configuration
def get_export_options(export_options):
if export_options is None:
return None
HashedClientOptions = oci_utils.generate_subclass(ClientOptions)
result_client_options = []
for export_option_entry in export_options:
client_options = HashedClientOptions()
if export_option_entry.get("source") is None:
raise ClientError(
"Export Options attribute source must contain a valid value")
client_options.source = export_option_entry.get("source")
client_options.require_privileged_source_port = export_option_entry.get(
"require_privileged_source_port", True)
client_options.access = export_option_entry.get("access", "READ_ONLY")
client_options.identity_squash = export_option_entry.get(
"identity_squash", "ROOT")
client_options.anonymous_uid = export_option_entry.get(
"anonymous_uid", 65534)
client_options.anonymous_gid = export_option_entry.get(
"anonymous_gid", 65534)
result_client_options.append(client_options)
return result_client_options
