1# coding: utf-8 2# Copyright (c) 2016, 2021, Oracle and/or its affiliates. All rights reserved. 3# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license. 4 5from __future__ import absolute_import 6 7from oci._vendor import requests # noqa: F401 8from oci._vendor import six 9 10from oci import retry, circuit_breaker # noqa: F401 11from oci.base_client import BaseClient 12from oci.config import get_config_value_or_default, validate_config 13from oci.signer import Signer 14from oci.util import Sentinel, get_signer_from_authentication_type, AUTHENTICATION_TYPE_FIELD_NAME 15from .models import load_balancer_type_mapping 16missing = Sentinel("Missing") 17 18 19class LoadBalancerClient(object): 20 """ 21 API for the Load Balancing service. Use this API to manage load balancers, backend sets, and related items. For more 22 information, see [Overview of Load Balancing](/iaas/Content/Balance/Concepts/balanceoverview.htm). 23 """ 24 25 def __init__(self, config, **kwargs): 26 """ 27 Creates a new service client 28 29 :param dict config: 30 Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__. 31 The :py:meth:`~oci.config.from_file` method can be used to load configuration from a file. Alternatively, a ``dict`` can be passed. You can validate_config 32 the dict using :py:meth:`~oci.config.validate_config` 33 34 :param str service_endpoint: (optional) 35 The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is 36 not provided then it will be derived using the region in the config parameter. You should only provide this keyword argument if you have an explicit 37 need to specify a service endpoint. 38 39 :param timeout: (optional) 40 The connection and read timeouts for the client. The default values are connection timeout 10 seconds and read timeout 60 seconds. This keyword argument can be provided 41 as a single float, in which case the value provided is used for both the read and connection timeouts, or as a tuple of two floats. If 42 a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout. 43 :type timeout: float or tuple(float, float) 44 45 :param signer: (optional) 46 The signer to use when signing requests made by the service client. The default is to use a :py:class:`~oci.signer.Signer` based on the values 47 provided in the config parameter. 48 49 One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__ 50 by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument 51 :type signer: :py:class:`~oci.signer.AbstractBaseSigner` 52 53 :param obj retry_strategy: (optional) 54 A retry strategy to apply to all calls made by this service client (i.e. at the client level). There is no retry strategy applied by default. 55 Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation. 56 Any value provided at the operation level will override whatever is specified at the client level. 57 58 This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` 59 is also available. The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 60 61 :param obj circuit_breaker_strategy: (optional) 62 A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level). 63 This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided. 64 The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__. 65 66 :param function circuit_breaker_callback: (optional) 67 Callback function to receive any exceptions triggerred by the circuit breaker. 68 """ 69 validate_config(config, signer=kwargs.get('signer')) 70 if 'signer' in kwargs: 71 signer = kwargs['signer'] 72 73 elif AUTHENTICATION_TYPE_FIELD_NAME in config: 74 signer = get_signer_from_authentication_type(config) 75 76 else: 77 signer = Signer( 78 tenancy=config["tenancy"], 79 user=config["user"], 80 fingerprint=config["fingerprint"], 81 private_key_file_location=config.get("key_file"), 82 pass_phrase=get_config_value_or_default(config, "pass_phrase"), 83 private_key_content=config.get("key_content") 84 ) 85 86 base_client_init_kwargs = { 87 'regional_client': True, 88 'service_endpoint': kwargs.get('service_endpoint'), 89 'base_path': '/20170115', 90 'service_endpoint_template': 'https://iaas.{region}.{secondLevelDomain}', 91 'skip_deserialization': kwargs.get('skip_deserialization', False), 92 'circuit_breaker_strategy': kwargs.get('circuit_breaker_strategy', circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY) 93 } 94 if 'timeout' in kwargs: 95 base_client_init_kwargs['timeout'] = kwargs.get('timeout') 96 if base_client_init_kwargs.get('circuit_breaker_strategy') is None: 97 base_client_init_kwargs['circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY 98 self.base_client = BaseClient("load_balancer", config, signer, load_balancer_type_mapping, **base_client_init_kwargs) 99 self.retry_strategy = kwargs.get('retry_strategy') 100 self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback') 101 102 def change_load_balancer_compartment(self, load_balancer_id, change_load_balancer_compartment_details, **kwargs): 103 """ 104 Moves a load balancer into a different compartment within the same tenancy. For information about moving resources 105 between compartments, see `Moving Resources to a Different Compartment`__. 106 107 __ https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes 108 109 110 :param str load_balancer_id: (required) 111 The `OCID`__ of the load balancer to move. 112 113 __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm 114 115 :param oci.load_balancer.models.ChangeLoadBalancerCompartmentDetails change_load_balancer_compartment_details: (required) 116 The configuration details for moving a load balancer to a different compartment. 117 118 :param str opc_request_id: (optional) 119 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 120 particular request, please provide the request ID. 121 122 :param str opc_retry_token: (optional) 123 A token that uniquely identifies a request so it can be retried in case of a timeout or 124 server error without risk of executing that same action again. Retry tokens expire after 24 125 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 126 has been deleted and purged from the system, then a retry of the original creation request 127 may be rejected). 128 129 :param str if_match: (optional) 130 For optimistic concurrency control. Set the if-match parameter to the value of the ETag from a 131 previous GET or POST response for that resource. The resource is moved only if the ETag you 132 provide matches the resource's current ETag value. 133 134 Example: `example-etag` 135 136 :param obj retry_strategy: (optional) 137 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 138 139 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 140 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 141 142 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 143 144 :return: A :class:`~oci.response.Response` object with data of type None 145 :rtype: :class:`~oci.response.Response` 146 147 :example: 148 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/change_load_balancer_compartment.py.html>`__ to see an example of how to use change_load_balancer_compartment API. 149 """ 150 resource_path = "/loadBalancers/{loadBalancerId}/changeCompartment" 151 method = "POST" 152 153 # Don't accept unknown kwargs 154 expected_kwargs = [ 155 "retry_strategy", 156 "opc_request_id", 157 "opc_retry_token", 158 "if_match" 159 ] 160 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 161 if extra_kwargs: 162 raise ValueError( 163 "change_load_balancer_compartment got unknown kwargs: {!r}".format(extra_kwargs)) 164 165 path_params = { 166 "loadBalancerId": load_balancer_id 167 } 168 169 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 170 171 for (k, v) in six.iteritems(path_params): 172 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 173 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 174 175 header_params = { 176 "accept": "application/json", 177 "content-type": "application/json", 178 "opc-request-id": kwargs.get("opc_request_id", missing), 179 "opc-retry-token": kwargs.get("opc_retry_token", missing), 180 "if-match": kwargs.get("if_match", missing) 181 } 182 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 183 184 retry_strategy = self.base_client.get_preferred_retry_strategy( 185 operation_retry_strategy=kwargs.get('retry_strategy'), 186 client_retry_strategy=self.retry_strategy 187 ) 188 189 if retry_strategy: 190 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 191 self.base_client.add_opc_retry_token_if_needed(header_params) 192 self.base_client.add_opc_client_retries_header(header_params) 193 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 194 return retry_strategy.make_retrying_call( 195 self.base_client.call_api, 196 resource_path=resource_path, 197 method=method, 198 path_params=path_params, 199 header_params=header_params, 200 body=change_load_balancer_compartment_details) 201 else: 202 return self.base_client.call_api( 203 resource_path=resource_path, 204 method=method, 205 path_params=path_params, 206 header_params=header_params, 207 body=change_load_balancer_compartment_details) 208 209 def create_backend(self, create_backend_details, load_balancer_id, backend_set_name, **kwargs): 210 """ 211 Adds a backend server to a backend set. 212 213 214 :param oci.load_balancer.models.CreateBackendDetails create_backend_details: (required) 215 The details to add a backend server to a backend set. 216 217 :param str load_balancer_id: (required) 218 The `OCID`__ of the load balancer associated with the backend set and servers. 219 220 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 221 222 :param str backend_set_name: (required) 223 The name of the backend set to add the backend server to. 224 225 Example: `example_backend_set` 226 227 :param str opc_request_id: (optional) 228 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 229 particular request, please provide the request ID. 230 231 :param str opc_retry_token: (optional) 232 A token that uniquely identifies a request so it can be retried in case of a timeout or 233 server error without risk of executing that same action again. Retry tokens expire after 24 234 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 235 has been deleted and purged from the system, then a retry of the original creation request 236 may be rejected). 237 238 :param obj retry_strategy: (optional) 239 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 240 241 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 242 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 243 244 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 245 246 :return: A :class:`~oci.response.Response` object with data of type None 247 :rtype: :class:`~oci.response.Response` 248 249 :example: 250 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_backend.py.html>`__ to see an example of how to use create_backend API. 251 """ 252 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends" 253 method = "POST" 254 255 # Don't accept unknown kwargs 256 expected_kwargs = [ 257 "retry_strategy", 258 "opc_request_id", 259 "opc_retry_token" 260 ] 261 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 262 if extra_kwargs: 263 raise ValueError( 264 "create_backend got unknown kwargs: {!r}".format(extra_kwargs)) 265 266 path_params = { 267 "loadBalancerId": load_balancer_id, 268 "backendSetName": backend_set_name 269 } 270 271 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 272 273 for (k, v) in six.iteritems(path_params): 274 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 275 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 276 277 header_params = { 278 "accept": "application/json", 279 "content-type": "application/json", 280 "opc-request-id": kwargs.get("opc_request_id", missing), 281 "opc-retry-token": kwargs.get("opc_retry_token", missing) 282 } 283 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 284 285 retry_strategy = self.base_client.get_preferred_retry_strategy( 286 operation_retry_strategy=kwargs.get('retry_strategy'), 287 client_retry_strategy=self.retry_strategy 288 ) 289 290 if retry_strategy: 291 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 292 self.base_client.add_opc_retry_token_if_needed(header_params) 293 self.base_client.add_opc_client_retries_header(header_params) 294 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 295 return retry_strategy.make_retrying_call( 296 self.base_client.call_api, 297 resource_path=resource_path, 298 method=method, 299 path_params=path_params, 300 header_params=header_params, 301 body=create_backend_details) 302 else: 303 return self.base_client.call_api( 304 resource_path=resource_path, 305 method=method, 306 path_params=path_params, 307 header_params=header_params, 308 body=create_backend_details) 309 310 def create_backend_set(self, create_backend_set_details, load_balancer_id, **kwargs): 311 """ 312 Adds a backend set to a load balancer. 313 314 315 :param oci.load_balancer.models.CreateBackendSetDetails create_backend_set_details: (required) 316 The details for adding a backend set. 317 318 :param str load_balancer_id: (required) 319 The `OCID`__ of the load balancer on which to add a backend set. 320 321 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 322 323 :param str opc_request_id: (optional) 324 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 325 particular request, please provide the request ID. 326 327 :param str opc_retry_token: (optional) 328 A token that uniquely identifies a request so it can be retried in case of a timeout or 329 server error without risk of executing that same action again. Retry tokens expire after 24 330 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 331 has been deleted and purged from the system, then a retry of the original creation request 332 may be rejected). 333 334 :param obj retry_strategy: (optional) 335 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 336 337 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 338 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 339 340 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 341 342 :return: A :class:`~oci.response.Response` object with data of type None 343 :rtype: :class:`~oci.response.Response` 344 345 :example: 346 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_backend_set.py.html>`__ to see an example of how to use create_backend_set API. 347 """ 348 resource_path = "/loadBalancers/{loadBalancerId}/backendSets" 349 method = "POST" 350 351 # Don't accept unknown kwargs 352 expected_kwargs = [ 353 "retry_strategy", 354 "opc_request_id", 355 "opc_retry_token" 356 ] 357 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 358 if extra_kwargs: 359 raise ValueError( 360 "create_backend_set got unknown kwargs: {!r}".format(extra_kwargs)) 361 362 path_params = { 363 "loadBalancerId": load_balancer_id 364 } 365 366 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 367 368 for (k, v) in six.iteritems(path_params): 369 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 370 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 371 372 header_params = { 373 "accept": "application/json", 374 "content-type": "application/json", 375 "opc-request-id": kwargs.get("opc_request_id", missing), 376 "opc-retry-token": kwargs.get("opc_retry_token", missing) 377 } 378 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 379 380 retry_strategy = self.base_client.get_preferred_retry_strategy( 381 operation_retry_strategy=kwargs.get('retry_strategy'), 382 client_retry_strategy=self.retry_strategy 383 ) 384 385 if retry_strategy: 386 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 387 self.base_client.add_opc_retry_token_if_needed(header_params) 388 self.base_client.add_opc_client_retries_header(header_params) 389 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 390 return retry_strategy.make_retrying_call( 391 self.base_client.call_api, 392 resource_path=resource_path, 393 method=method, 394 path_params=path_params, 395 header_params=header_params, 396 body=create_backend_set_details) 397 else: 398 return self.base_client.call_api( 399 resource_path=resource_path, 400 method=method, 401 path_params=path_params, 402 header_params=header_params, 403 body=create_backend_set_details) 404 405 def create_certificate(self, create_certificate_details, load_balancer_id, **kwargs): 406 """ 407 Creates an asynchronous request to add an SSL certificate bundle. 408 409 410 :param oci.load_balancer.models.CreateCertificateDetails create_certificate_details: (required) 411 The details of the certificate bundle to add. 412 413 :param str load_balancer_id: (required) 414 The `OCID`__ of the load balancer on which to add the certificate bundle. 415 416 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 417 418 :param str opc_request_id: (optional) 419 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 420 particular request, please provide the request ID. 421 422 :param str opc_retry_token: (optional) 423 A token that uniquely identifies a request so it can be retried in case of a timeout or 424 server error without risk of executing that same action again. Retry tokens expire after 24 425 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 426 has been deleted and purged from the system, then a retry of the original creation request 427 may be rejected). 428 429 :param obj retry_strategy: (optional) 430 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 431 432 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 433 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 434 435 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 436 437 :return: A :class:`~oci.response.Response` object with data of type None 438 :rtype: :class:`~oci.response.Response` 439 440 :example: 441 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_certificate.py.html>`__ to see an example of how to use create_certificate API. 442 """ 443 resource_path = "/loadBalancers/{loadBalancerId}/certificates" 444 method = "POST" 445 446 # Don't accept unknown kwargs 447 expected_kwargs = [ 448 "retry_strategy", 449 "opc_request_id", 450 "opc_retry_token" 451 ] 452 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 453 if extra_kwargs: 454 raise ValueError( 455 "create_certificate got unknown kwargs: {!r}".format(extra_kwargs)) 456 457 path_params = { 458 "loadBalancerId": load_balancer_id 459 } 460 461 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 462 463 for (k, v) in six.iteritems(path_params): 464 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 465 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 466 467 header_params = { 468 "accept": "application/json", 469 "content-type": "application/json", 470 "opc-request-id": kwargs.get("opc_request_id", missing), 471 "opc-retry-token": kwargs.get("opc_retry_token", missing) 472 } 473 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 474 475 retry_strategy = self.base_client.get_preferred_retry_strategy( 476 operation_retry_strategy=kwargs.get('retry_strategy'), 477 client_retry_strategy=self.retry_strategy 478 ) 479 480 if retry_strategy: 481 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 482 self.base_client.add_opc_retry_token_if_needed(header_params) 483 self.base_client.add_opc_client_retries_header(header_params) 484 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 485 return retry_strategy.make_retrying_call( 486 self.base_client.call_api, 487 resource_path=resource_path, 488 method=method, 489 path_params=path_params, 490 header_params=header_params, 491 body=create_certificate_details) 492 else: 493 return self.base_client.call_api( 494 resource_path=resource_path, 495 method=method, 496 path_params=path_params, 497 header_params=header_params, 498 body=create_certificate_details) 499 500 def create_hostname(self, create_hostname_details, load_balancer_id, **kwargs): 501 """ 502 Adds a hostname resource to the specified load balancer. For more information, see 503 `Managing Request Routing`__. 504 505 __ https://docs.cloud.oracle.com/Content/Balance/Tasks/managingrequest.htm 506 507 508 :param oci.load_balancer.models.CreateHostnameDetails create_hostname_details: (required) 509 The details of the hostname resource to add to the specified load balancer. 510 511 :param str load_balancer_id: (required) 512 The `OCID`__ of the load balancer to add the hostname to. 513 514 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 515 516 :param str opc_request_id: (optional) 517 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 518 particular request, please provide the request ID. 519 520 :param str opc_retry_token: (optional) 521 A token that uniquely identifies a request so it can be retried in case of a timeout or 522 server error without risk of executing that same action again. Retry tokens expire after 24 523 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 524 has been deleted and purged from the system, then a retry of the original creation request 525 may be rejected). 526 527 :param obj retry_strategy: (optional) 528 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 529 530 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 531 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 532 533 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 534 535 :return: A :class:`~oci.response.Response` object with data of type None 536 :rtype: :class:`~oci.response.Response` 537 538 :example: 539 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_hostname.py.html>`__ to see an example of how to use create_hostname API. 540 """ 541 resource_path = "/loadBalancers/{loadBalancerId}/hostnames" 542 method = "POST" 543 544 # Don't accept unknown kwargs 545 expected_kwargs = [ 546 "retry_strategy", 547 "opc_request_id", 548 "opc_retry_token" 549 ] 550 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 551 if extra_kwargs: 552 raise ValueError( 553 "create_hostname got unknown kwargs: {!r}".format(extra_kwargs)) 554 555 path_params = { 556 "loadBalancerId": load_balancer_id 557 } 558 559 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 560 561 for (k, v) in six.iteritems(path_params): 562 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 563 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 564 565 header_params = { 566 "accept": "application/json", 567 "content-type": "application/json", 568 "opc-request-id": kwargs.get("opc_request_id", missing), 569 "opc-retry-token": kwargs.get("opc_retry_token", missing) 570 } 571 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 572 573 retry_strategy = self.base_client.get_preferred_retry_strategy( 574 operation_retry_strategy=kwargs.get('retry_strategy'), 575 client_retry_strategy=self.retry_strategy 576 ) 577 578 if retry_strategy: 579 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 580 self.base_client.add_opc_retry_token_if_needed(header_params) 581 self.base_client.add_opc_client_retries_header(header_params) 582 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 583 return retry_strategy.make_retrying_call( 584 self.base_client.call_api, 585 resource_path=resource_path, 586 method=method, 587 path_params=path_params, 588 header_params=header_params, 589 body=create_hostname_details) 590 else: 591 return self.base_client.call_api( 592 resource_path=resource_path, 593 method=method, 594 path_params=path_params, 595 header_params=header_params, 596 body=create_hostname_details) 597 598 def create_listener(self, create_listener_details, load_balancer_id, **kwargs): 599 """ 600 Adds a listener to a load balancer. 601 602 603 :param oci.load_balancer.models.CreateListenerDetails create_listener_details: (required) 604 Details to add a listener. 605 606 :param str load_balancer_id: (required) 607 The `OCID`__ of the load balancer on which to add a listener. 608 609 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 610 611 :param str opc_request_id: (optional) 612 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 613 particular request, please provide the request ID. 614 615 :param str opc_retry_token: (optional) 616 A token that uniquely identifies a request so it can be retried in case of a timeout or 617 server error without risk of executing that same action again. Retry tokens expire after 24 618 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 619 has been deleted and purged from the system, then a retry of the original creation request 620 may be rejected). 621 622 :param obj retry_strategy: (optional) 623 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 624 625 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 626 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 627 628 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 629 630 :return: A :class:`~oci.response.Response` object with data of type None 631 :rtype: :class:`~oci.response.Response` 632 633 :example: 634 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_listener.py.html>`__ to see an example of how to use create_listener API. 635 """ 636 resource_path = "/loadBalancers/{loadBalancerId}/listeners" 637 method = "POST" 638 639 # Don't accept unknown kwargs 640 expected_kwargs = [ 641 "retry_strategy", 642 "opc_request_id", 643 "opc_retry_token" 644 ] 645 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 646 if extra_kwargs: 647 raise ValueError( 648 "create_listener got unknown kwargs: {!r}".format(extra_kwargs)) 649 650 path_params = { 651 "loadBalancerId": load_balancer_id 652 } 653 654 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 655 656 for (k, v) in six.iteritems(path_params): 657 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 658 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 659 660 header_params = { 661 "accept": "application/json", 662 "content-type": "application/json", 663 "opc-request-id": kwargs.get("opc_request_id", missing), 664 "opc-retry-token": kwargs.get("opc_retry_token", missing) 665 } 666 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 667 668 retry_strategy = self.base_client.get_preferred_retry_strategy( 669 operation_retry_strategy=kwargs.get('retry_strategy'), 670 client_retry_strategy=self.retry_strategy 671 ) 672 673 if retry_strategy: 674 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 675 self.base_client.add_opc_retry_token_if_needed(header_params) 676 self.base_client.add_opc_client_retries_header(header_params) 677 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 678 return retry_strategy.make_retrying_call( 679 self.base_client.call_api, 680 resource_path=resource_path, 681 method=method, 682 path_params=path_params, 683 header_params=header_params, 684 body=create_listener_details) 685 else: 686 return self.base_client.call_api( 687 resource_path=resource_path, 688 method=method, 689 path_params=path_params, 690 header_params=header_params, 691 body=create_listener_details) 692 693 def create_load_balancer(self, create_load_balancer_details, **kwargs): 694 """ 695 Creates a new load balancer in the specified compartment. For general information about load balancers, 696 see `Overview of the Load Balancing Service`__. 697 698 For the purposes of access control, you must provide the OCID of the compartment where you want 699 the load balancer to reside. Notice that the load balancer doesn't have to be in the same compartment as the VCN 700 or backend set. If you're not sure which compartment to use, put the load balancer in the same compartment as the VCN. 701 For information about access control and compartments, see 702 `Overview of the IAM Service`__. 703 704 You must specify a display name for the load balancer. It does not have to be unique, and you can change it. 705 706 For information about Availability Domains, see 707 `Regions and Availability Domains`__. 708 To get a list of Availability Domains, use the `ListAvailabilityDomains` operation 709 in the Identity and Access Management Service API. 710 711 All Oracle Cloud Infrastructure resources, including load balancers, get an Oracle-assigned, 712 unique ID called an Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID 713 in the response. You can also retrieve a resource's OCID by using a List API operation on that resource type, 714 or by viewing the resource in the Console. Fore more information, see 715 `Resource Identifiers`__. 716 717 After you send your request, the new object's state will temporarily be PROVISIONING. Before using the 718 object, first make sure its state has changed to RUNNING. 719 720 When you create a load balancer, the system assigns an IP address. 721 To get the IP address, use the :func:`get_load_balancer` operation. 722 723 __ https://docs.cloud.oracle.com/Content/Balance/Concepts/balanceoverview.htm 724 __ https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm 725 __ https://docs.cloud.oracle.com/Content/General/Concepts/regions.htm 726 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 727 728 729 :param oci.load_balancer.models.CreateLoadBalancerDetails create_load_balancer_details: (required) 730 The configuration details for creating a load balancer. 731 732 :param str opc_request_id: (optional) 733 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 734 particular request, please provide the request ID. 735 736 :param str opc_retry_token: (optional) 737 A token that uniquely identifies a request so it can be retried in case of a timeout or 738 server error without risk of executing that same action again. Retry tokens expire after 24 739 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 740 has been deleted and purged from the system, then a retry of the original creation request 741 may be rejected). 742 743 :param obj retry_strategy: (optional) 744 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 745 746 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 747 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 748 749 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 750 751 :return: A :class:`~oci.response.Response` object with data of type None 752 :rtype: :class:`~oci.response.Response` 753 754 :example: 755 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_load_balancer.py.html>`__ to see an example of how to use create_load_balancer API. 756 """ 757 resource_path = "/loadBalancers" 758 method = "POST" 759 760 # Don't accept unknown kwargs 761 expected_kwargs = [ 762 "retry_strategy", 763 "opc_request_id", 764 "opc_retry_token" 765 ] 766 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 767 if extra_kwargs: 768 raise ValueError( 769 "create_load_balancer got unknown kwargs: {!r}".format(extra_kwargs)) 770 771 header_params = { 772 "accept": "application/json", 773 "content-type": "application/json", 774 "opc-request-id": kwargs.get("opc_request_id", missing), 775 "opc-retry-token": kwargs.get("opc_retry_token", missing) 776 } 777 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 778 779 retry_strategy = self.base_client.get_preferred_retry_strategy( 780 operation_retry_strategy=kwargs.get('retry_strategy'), 781 client_retry_strategy=self.retry_strategy 782 ) 783 784 if retry_strategy: 785 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 786 self.base_client.add_opc_retry_token_if_needed(header_params) 787 self.base_client.add_opc_client_retries_header(header_params) 788 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 789 return retry_strategy.make_retrying_call( 790 self.base_client.call_api, 791 resource_path=resource_path, 792 method=method, 793 header_params=header_params, 794 body=create_load_balancer_details) 795 else: 796 return self.base_client.call_api( 797 resource_path=resource_path, 798 method=method, 799 header_params=header_params, 800 body=create_load_balancer_details) 801 802 def create_path_route_set(self, create_path_route_set_details, load_balancer_id, **kwargs): 803 """ 804 Adds a path route set to a load balancer. For more information, see 805 `Managing Request Routing`__. 806 807 __ https://docs.cloud.oracle.com/Content/Balance/Tasks/managingrequest.htm 808 809 810 :param oci.load_balancer.models.CreatePathRouteSetDetails create_path_route_set_details: (required) 811 The details of the path route set to add. 812 813 :param str load_balancer_id: (required) 814 The `OCID`__ of the load balancer to add the path route set to. 815 816 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 817 818 :param str opc_request_id: (optional) 819 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 820 particular request, please provide the request ID. 821 822 :param str opc_retry_token: (optional) 823 A token that uniquely identifies a request so it can be retried in case of a timeout or 824 server error without risk of executing that same action again. Retry tokens expire after 24 825 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 826 has been deleted and purged from the system, then a retry of the original creation request 827 may be rejected). 828 829 :param obj retry_strategy: (optional) 830 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 831 832 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 833 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 834 835 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 836 837 :return: A :class:`~oci.response.Response` object with data of type None 838 :rtype: :class:`~oci.response.Response` 839 840 :example: 841 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_path_route_set.py.html>`__ to see an example of how to use create_path_route_set API. 842 """ 843 resource_path = "/loadBalancers/{loadBalancerId}/pathRouteSets" 844 method = "POST" 845 846 # Don't accept unknown kwargs 847 expected_kwargs = [ 848 "retry_strategy", 849 "opc_request_id", 850 "opc_retry_token" 851 ] 852 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 853 if extra_kwargs: 854 raise ValueError( 855 "create_path_route_set got unknown kwargs: {!r}".format(extra_kwargs)) 856 857 path_params = { 858 "loadBalancerId": load_balancer_id 859 } 860 861 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 862 863 for (k, v) in six.iteritems(path_params): 864 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 865 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 866 867 header_params = { 868 "accept": "application/json", 869 "content-type": "application/json", 870 "opc-request-id": kwargs.get("opc_request_id", missing), 871 "opc-retry-token": kwargs.get("opc_retry_token", missing) 872 } 873 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 874 875 retry_strategy = self.base_client.get_preferred_retry_strategy( 876 operation_retry_strategy=kwargs.get('retry_strategy'), 877 client_retry_strategy=self.retry_strategy 878 ) 879 880 if retry_strategy: 881 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 882 self.base_client.add_opc_retry_token_if_needed(header_params) 883 self.base_client.add_opc_client_retries_header(header_params) 884 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 885 return retry_strategy.make_retrying_call( 886 self.base_client.call_api, 887 resource_path=resource_path, 888 method=method, 889 path_params=path_params, 890 header_params=header_params, 891 body=create_path_route_set_details) 892 else: 893 return self.base_client.call_api( 894 resource_path=resource_path, 895 method=method, 896 path_params=path_params, 897 header_params=header_params, 898 body=create_path_route_set_details) 899 900 def create_routing_policy(self, create_routing_policy_details, load_balancer_id, **kwargs): 901 """ 902 Adds a routing policy to a load balancer. For more information, see 903 `Managing Request Routing`__. 904 905 __ https://docs.cloud.oracle.com/Content/Balance/Tasks/managingrequest.htm 906 907 908 :param oci.load_balancer.models.CreateRoutingPolicyDetails create_routing_policy_details: (required) 909 The details of the routing policy rules to add. 910 911 :param str load_balancer_id: (required) 912 The `OCID`__ of the load balancer to add the routing policy rule list to. 913 914 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 915 916 :param str opc_request_id: (optional) 917 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 918 particular request, please provide the request ID. 919 920 :param str opc_retry_token: (optional) 921 A token that uniquely identifies a request so it can be retried in case of a timeout or 922 server error without risk of executing that same action again. Retry tokens expire after 24 923 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 924 has been deleted and purged from the system, then a retry of the original creation request 925 may be rejected). 926 927 :param obj retry_strategy: (optional) 928 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 929 930 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 931 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 932 933 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 934 935 :return: A :class:`~oci.response.Response` object with data of type None 936 :rtype: :class:`~oci.response.Response` 937 938 :example: 939 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_routing_policy.py.html>`__ to see an example of how to use create_routing_policy API. 940 """ 941 resource_path = "/loadBalancers/{loadBalancerId}/routingPolicies" 942 method = "POST" 943 944 # Don't accept unknown kwargs 945 expected_kwargs = [ 946 "retry_strategy", 947 "opc_request_id", 948 "opc_retry_token" 949 ] 950 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 951 if extra_kwargs: 952 raise ValueError( 953 "create_routing_policy got unknown kwargs: {!r}".format(extra_kwargs)) 954 955 path_params = { 956 "loadBalancerId": load_balancer_id 957 } 958 959 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 960 961 for (k, v) in six.iteritems(path_params): 962 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 963 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 964 965 header_params = { 966 "accept": "application/json", 967 "content-type": "application/json", 968 "opc-request-id": kwargs.get("opc_request_id", missing), 969 "opc-retry-token": kwargs.get("opc_retry_token", missing) 970 } 971 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 972 973 retry_strategy = self.base_client.get_preferred_retry_strategy( 974 operation_retry_strategy=kwargs.get('retry_strategy'), 975 client_retry_strategy=self.retry_strategy 976 ) 977 978 if retry_strategy: 979 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 980 self.base_client.add_opc_retry_token_if_needed(header_params) 981 self.base_client.add_opc_client_retries_header(header_params) 982 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 983 return retry_strategy.make_retrying_call( 984 self.base_client.call_api, 985 resource_path=resource_path, 986 method=method, 987 path_params=path_params, 988 header_params=header_params, 989 body=create_routing_policy_details) 990 else: 991 return self.base_client.call_api( 992 resource_path=resource_path, 993 method=method, 994 path_params=path_params, 995 header_params=header_params, 996 body=create_routing_policy_details) 997 998 def create_rule_set(self, load_balancer_id, create_rule_set_details, **kwargs): 999 """ 1000 Creates a new rule set associated with the specified load balancer. For more information, see 1001 `Managing Rule Sets`__. 1002 1003 __ https://docs.cloud.oracle.com/Content/Balance/Tasks/managingrulesets.htm 1004 1005 1006 :param str load_balancer_id: (required) 1007 The `OCID`__ of the specified load balancer. 1008 1009 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1010 1011 :param oci.load_balancer.models.CreateRuleSetDetails create_rule_set_details: (required) 1012 The configuration details for the rule set to create. 1013 1014 :param str opc_request_id: (optional) 1015 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1016 particular request, please provide the request ID. 1017 1018 :param obj retry_strategy: (optional) 1019 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1020 1021 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1022 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1023 1024 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1025 1026 :return: A :class:`~oci.response.Response` object with data of type None 1027 :rtype: :class:`~oci.response.Response` 1028 1029 :example: 1030 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_rule_set.py.html>`__ to see an example of how to use create_rule_set API. 1031 """ 1032 resource_path = "/loadBalancers/{loadBalancerId}/ruleSets" 1033 method = "POST" 1034 1035 # Don't accept unknown kwargs 1036 expected_kwargs = [ 1037 "retry_strategy", 1038 "opc_request_id" 1039 ] 1040 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1041 if extra_kwargs: 1042 raise ValueError( 1043 "create_rule_set got unknown kwargs: {!r}".format(extra_kwargs)) 1044 1045 path_params = { 1046 "loadBalancerId": load_balancer_id 1047 } 1048 1049 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1050 1051 for (k, v) in six.iteritems(path_params): 1052 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1053 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1054 1055 header_params = { 1056 "accept": "application/json", 1057 "content-type": "application/json", 1058 "opc-request-id": kwargs.get("opc_request_id", missing) 1059 } 1060 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1061 1062 retry_strategy = self.base_client.get_preferred_retry_strategy( 1063 operation_retry_strategy=kwargs.get('retry_strategy'), 1064 client_retry_strategy=self.retry_strategy 1065 ) 1066 1067 if retry_strategy: 1068 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1069 self.base_client.add_opc_client_retries_header(header_params) 1070 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1071 return retry_strategy.make_retrying_call( 1072 self.base_client.call_api, 1073 resource_path=resource_path, 1074 method=method, 1075 path_params=path_params, 1076 header_params=header_params, 1077 body=create_rule_set_details) 1078 else: 1079 return self.base_client.call_api( 1080 resource_path=resource_path, 1081 method=method, 1082 path_params=path_params, 1083 header_params=header_params, 1084 body=create_rule_set_details) 1085 1086 def create_ssl_cipher_suite(self, create_ssl_cipher_suite_details, load_balancer_id, **kwargs): 1087 """ 1088 Creates a custom SSL cipher suite. 1089 1090 1091 :param oci.load_balancer.models.CreateSSLCipherSuiteDetails create_ssl_cipher_suite_details: (required) 1092 The details of the SSL cipher suite to add. 1093 1094 :param str load_balancer_id: (required) 1095 The `OCID`__ of the associated load balancer. 1096 1097 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1098 1099 :param str opc_request_id: (optional) 1100 Unique Oracle-assigned identifier for the request. If you need to contact Oracle about 1101 a particular request, please provide the request ID. 1102 1103 :param str opc_retry_token: (optional) 1104 A token that uniquely identifies a request so it can be retried in case of a timeout or 1105 server error without risk of executing that same action again. Retry tokens expire after 24 1106 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 1107 has been deleted and purged from the system, then a retry of the original creation request 1108 may be rejected). 1109 1110 :param obj retry_strategy: (optional) 1111 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1112 1113 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1114 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1115 1116 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1117 1118 :return: A :class:`~oci.response.Response` object with data of type None 1119 :rtype: :class:`~oci.response.Response` 1120 1121 :example: 1122 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/create_ssl_cipher_suite.py.html>`__ to see an example of how to use create_ssl_cipher_suite API. 1123 """ 1124 resource_path = "/loadBalancers/{loadBalancerId}/sslCipherSuites" 1125 method = "POST" 1126 1127 # Don't accept unknown kwargs 1128 expected_kwargs = [ 1129 "retry_strategy", 1130 "opc_request_id", 1131 "opc_retry_token" 1132 ] 1133 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1134 if extra_kwargs: 1135 raise ValueError( 1136 "create_ssl_cipher_suite got unknown kwargs: {!r}".format(extra_kwargs)) 1137 1138 path_params = { 1139 "loadBalancerId": load_balancer_id 1140 } 1141 1142 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1143 1144 for (k, v) in six.iteritems(path_params): 1145 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1146 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1147 1148 header_params = { 1149 "accept": "application/json", 1150 "content-type": "application/json", 1151 "opc-request-id": kwargs.get("opc_request_id", missing), 1152 "opc-retry-token": kwargs.get("opc_retry_token", missing) 1153 } 1154 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1155 1156 retry_strategy = self.base_client.get_preferred_retry_strategy( 1157 operation_retry_strategy=kwargs.get('retry_strategy'), 1158 client_retry_strategy=self.retry_strategy 1159 ) 1160 1161 if retry_strategy: 1162 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1163 self.base_client.add_opc_retry_token_if_needed(header_params) 1164 self.base_client.add_opc_client_retries_header(header_params) 1165 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1166 return retry_strategy.make_retrying_call( 1167 self.base_client.call_api, 1168 resource_path=resource_path, 1169 method=method, 1170 path_params=path_params, 1171 header_params=header_params, 1172 body=create_ssl_cipher_suite_details) 1173 else: 1174 return self.base_client.call_api( 1175 resource_path=resource_path, 1176 method=method, 1177 path_params=path_params, 1178 header_params=header_params, 1179 body=create_ssl_cipher_suite_details) 1180 1181 def delete_backend(self, load_balancer_id, backend_set_name, backend_name, **kwargs): 1182 """ 1183 Removes a backend server from a given load balancer and backend set. 1184 1185 1186 :param str load_balancer_id: (required) 1187 The `OCID`__ of the load balancer associated with the backend set and server. 1188 1189 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1190 1191 :param str backend_set_name: (required) 1192 The name of the backend set associated with the backend server. 1193 1194 Example: `example_backend_set` 1195 1196 :param str backend_name: (required) 1197 The IP address and port of the backend server to remove. 1198 1199 Example: `10.0.0.3:8080` 1200 1201 :param str opc_request_id: (optional) 1202 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1203 particular request, please provide the request ID. 1204 1205 :param obj retry_strategy: (optional) 1206 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1207 1208 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1209 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1210 1211 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1212 1213 :return: A :class:`~oci.response.Response` object with data of type None 1214 :rtype: :class:`~oci.response.Response` 1215 1216 :example: 1217 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_backend.py.html>`__ to see an example of how to use delete_backend API. 1218 """ 1219 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}" 1220 method = "DELETE" 1221 1222 # Don't accept unknown kwargs 1223 expected_kwargs = [ 1224 "retry_strategy", 1225 "opc_request_id" 1226 ] 1227 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1228 if extra_kwargs: 1229 raise ValueError( 1230 "delete_backend got unknown kwargs: {!r}".format(extra_kwargs)) 1231 1232 path_params = { 1233 "loadBalancerId": load_balancer_id, 1234 "backendSetName": backend_set_name, 1235 "backendName": backend_name 1236 } 1237 1238 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1239 1240 for (k, v) in six.iteritems(path_params): 1241 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1242 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1243 1244 header_params = { 1245 "accept": "application/json", 1246 "content-type": "application/json", 1247 "opc-request-id": kwargs.get("opc_request_id", missing) 1248 } 1249 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1250 1251 retry_strategy = self.base_client.get_preferred_retry_strategy( 1252 operation_retry_strategy=kwargs.get('retry_strategy'), 1253 client_retry_strategy=self.retry_strategy 1254 ) 1255 1256 if retry_strategy: 1257 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1258 self.base_client.add_opc_client_retries_header(header_params) 1259 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1260 return retry_strategy.make_retrying_call( 1261 self.base_client.call_api, 1262 resource_path=resource_path, 1263 method=method, 1264 path_params=path_params, 1265 header_params=header_params) 1266 else: 1267 return self.base_client.call_api( 1268 resource_path=resource_path, 1269 method=method, 1270 path_params=path_params, 1271 header_params=header_params) 1272 1273 def delete_backend_set(self, load_balancer_id, backend_set_name, **kwargs): 1274 """ 1275 Deletes the specified backend set. Note that deleting a backend set removes its backend servers from the load balancer. 1276 1277 Before you can delete a backend set, you must remove it from any active listeners. 1278 1279 1280 :param str load_balancer_id: (required) 1281 The `OCID`__ of the load balancer associated with the backend set. 1282 1283 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1284 1285 :param str backend_set_name: (required) 1286 The name of the backend set to delete. 1287 1288 Example: `example_backend_set` 1289 1290 :param str opc_request_id: (optional) 1291 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1292 particular request, please provide the request ID. 1293 1294 :param obj retry_strategy: (optional) 1295 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1296 1297 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1298 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1299 1300 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1301 1302 :return: A :class:`~oci.response.Response` object with data of type None 1303 :rtype: :class:`~oci.response.Response` 1304 1305 :example: 1306 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_backend_set.py.html>`__ to see an example of how to use delete_backend_set API. 1307 """ 1308 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}" 1309 method = "DELETE" 1310 1311 # Don't accept unknown kwargs 1312 expected_kwargs = [ 1313 "retry_strategy", 1314 "opc_request_id" 1315 ] 1316 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1317 if extra_kwargs: 1318 raise ValueError( 1319 "delete_backend_set got unknown kwargs: {!r}".format(extra_kwargs)) 1320 1321 path_params = { 1322 "loadBalancerId": load_balancer_id, 1323 "backendSetName": backend_set_name 1324 } 1325 1326 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1327 1328 for (k, v) in six.iteritems(path_params): 1329 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1330 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1331 1332 header_params = { 1333 "accept": "application/json", 1334 "content-type": "application/json", 1335 "opc-request-id": kwargs.get("opc_request_id", missing) 1336 } 1337 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1338 1339 retry_strategy = self.base_client.get_preferred_retry_strategy( 1340 operation_retry_strategy=kwargs.get('retry_strategy'), 1341 client_retry_strategy=self.retry_strategy 1342 ) 1343 1344 if retry_strategy: 1345 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1346 self.base_client.add_opc_client_retries_header(header_params) 1347 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1348 return retry_strategy.make_retrying_call( 1349 self.base_client.call_api, 1350 resource_path=resource_path, 1351 method=method, 1352 path_params=path_params, 1353 header_params=header_params) 1354 else: 1355 return self.base_client.call_api( 1356 resource_path=resource_path, 1357 method=method, 1358 path_params=path_params, 1359 header_params=header_params) 1360 1361 def delete_certificate(self, load_balancer_id, certificate_name, **kwargs): 1362 """ 1363 Deletes an SSL certificate bundle from a load balancer. 1364 1365 1366 :param str load_balancer_id: (required) 1367 The `OCID`__ of the load balancer associated with the certificate bundle 1368 to be deleted. 1369 1370 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1371 1372 :param str certificate_name: (required) 1373 The name of the certificate bundle to delete. 1374 1375 Example: `example_certificate_bundle` 1376 1377 :param str opc_request_id: (optional) 1378 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1379 particular request, please provide the request ID. 1380 1381 :param obj retry_strategy: (optional) 1382 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1383 1384 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1385 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1386 1387 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1388 1389 :return: A :class:`~oci.response.Response` object with data of type None 1390 :rtype: :class:`~oci.response.Response` 1391 1392 :example: 1393 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_certificate.py.html>`__ to see an example of how to use delete_certificate API. 1394 """ 1395 resource_path = "/loadBalancers/{loadBalancerId}/certificates/{certificateName}" 1396 method = "DELETE" 1397 1398 # Don't accept unknown kwargs 1399 expected_kwargs = [ 1400 "retry_strategy", 1401 "opc_request_id" 1402 ] 1403 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1404 if extra_kwargs: 1405 raise ValueError( 1406 "delete_certificate got unknown kwargs: {!r}".format(extra_kwargs)) 1407 1408 path_params = { 1409 "loadBalancerId": load_balancer_id, 1410 "certificateName": certificate_name 1411 } 1412 1413 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1414 1415 for (k, v) in six.iteritems(path_params): 1416 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1417 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1418 1419 header_params = { 1420 "accept": "application/json", 1421 "content-type": "application/json", 1422 "opc-request-id": kwargs.get("opc_request_id", missing) 1423 } 1424 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1425 1426 retry_strategy = self.base_client.get_preferred_retry_strategy( 1427 operation_retry_strategy=kwargs.get('retry_strategy'), 1428 client_retry_strategy=self.retry_strategy 1429 ) 1430 1431 if retry_strategy: 1432 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1433 self.base_client.add_opc_client_retries_header(header_params) 1434 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1435 return retry_strategy.make_retrying_call( 1436 self.base_client.call_api, 1437 resource_path=resource_path, 1438 method=method, 1439 path_params=path_params, 1440 header_params=header_params) 1441 else: 1442 return self.base_client.call_api( 1443 resource_path=resource_path, 1444 method=method, 1445 path_params=path_params, 1446 header_params=header_params) 1447 1448 def delete_hostname(self, load_balancer_id, name, **kwargs): 1449 """ 1450 Deletes a hostname resource from the specified load balancer. 1451 1452 1453 :param str load_balancer_id: (required) 1454 The `OCID`__ of the load balancer associated with the hostname to delete. 1455 1456 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1457 1458 :param str name: (required) 1459 The name of the hostname resource to delete. 1460 1461 Example: `example_hostname_001` 1462 1463 :param str opc_request_id: (optional) 1464 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1465 particular request, please provide the request ID. 1466 1467 :param obj retry_strategy: (optional) 1468 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1469 1470 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1471 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1472 1473 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1474 1475 :return: A :class:`~oci.response.Response` object with data of type None 1476 :rtype: :class:`~oci.response.Response` 1477 1478 :example: 1479 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_hostname.py.html>`__ to see an example of how to use delete_hostname API. 1480 """ 1481 resource_path = "/loadBalancers/{loadBalancerId}/hostnames/{name}" 1482 method = "DELETE" 1483 1484 # Don't accept unknown kwargs 1485 expected_kwargs = [ 1486 "retry_strategy", 1487 "opc_request_id" 1488 ] 1489 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1490 if extra_kwargs: 1491 raise ValueError( 1492 "delete_hostname got unknown kwargs: {!r}".format(extra_kwargs)) 1493 1494 path_params = { 1495 "loadBalancerId": load_balancer_id, 1496 "name": name 1497 } 1498 1499 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1500 1501 for (k, v) in six.iteritems(path_params): 1502 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1503 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1504 1505 header_params = { 1506 "accept": "application/json", 1507 "content-type": "application/json", 1508 "opc-request-id": kwargs.get("opc_request_id", missing) 1509 } 1510 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1511 1512 retry_strategy = self.base_client.get_preferred_retry_strategy( 1513 operation_retry_strategy=kwargs.get('retry_strategy'), 1514 client_retry_strategy=self.retry_strategy 1515 ) 1516 1517 if retry_strategy: 1518 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1519 self.base_client.add_opc_client_retries_header(header_params) 1520 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1521 return retry_strategy.make_retrying_call( 1522 self.base_client.call_api, 1523 resource_path=resource_path, 1524 method=method, 1525 path_params=path_params, 1526 header_params=header_params) 1527 else: 1528 return self.base_client.call_api( 1529 resource_path=resource_path, 1530 method=method, 1531 path_params=path_params, 1532 header_params=header_params) 1533 1534 def delete_listener(self, load_balancer_id, listener_name, **kwargs): 1535 """ 1536 Deletes a listener from a load balancer. 1537 1538 1539 :param str load_balancer_id: (required) 1540 The `OCID`__ of the load balancer associated with the listener to delete. 1541 1542 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1543 1544 :param str listener_name: (required) 1545 The name of the listener to delete. 1546 1547 Example: `example_listener` 1548 1549 :param str opc_request_id: (optional) 1550 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1551 particular request, please provide the request ID. 1552 1553 :param obj retry_strategy: (optional) 1554 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1555 1556 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1557 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1558 1559 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1560 1561 :return: A :class:`~oci.response.Response` object with data of type None 1562 :rtype: :class:`~oci.response.Response` 1563 1564 :example: 1565 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_listener.py.html>`__ to see an example of how to use delete_listener API. 1566 """ 1567 resource_path = "/loadBalancers/{loadBalancerId}/listeners/{listenerName}" 1568 method = "DELETE" 1569 1570 # Don't accept unknown kwargs 1571 expected_kwargs = [ 1572 "retry_strategy", 1573 "opc_request_id" 1574 ] 1575 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1576 if extra_kwargs: 1577 raise ValueError( 1578 "delete_listener got unknown kwargs: {!r}".format(extra_kwargs)) 1579 1580 path_params = { 1581 "loadBalancerId": load_balancer_id, 1582 "listenerName": listener_name 1583 } 1584 1585 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1586 1587 for (k, v) in six.iteritems(path_params): 1588 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1589 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1590 1591 header_params = { 1592 "accept": "application/json", 1593 "content-type": "application/json", 1594 "opc-request-id": kwargs.get("opc_request_id", missing) 1595 } 1596 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1597 1598 retry_strategy = self.base_client.get_preferred_retry_strategy( 1599 operation_retry_strategy=kwargs.get('retry_strategy'), 1600 client_retry_strategy=self.retry_strategy 1601 ) 1602 1603 if retry_strategy: 1604 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1605 self.base_client.add_opc_client_retries_header(header_params) 1606 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1607 return retry_strategy.make_retrying_call( 1608 self.base_client.call_api, 1609 resource_path=resource_path, 1610 method=method, 1611 path_params=path_params, 1612 header_params=header_params) 1613 else: 1614 return self.base_client.call_api( 1615 resource_path=resource_path, 1616 method=method, 1617 path_params=path_params, 1618 header_params=header_params) 1619 1620 def delete_load_balancer(self, load_balancer_id, **kwargs): 1621 """ 1622 Stops a load balancer and removes it from service. 1623 1624 1625 :param str load_balancer_id: (required) 1626 The `OCID`__ of the load balancer to delete. 1627 1628 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1629 1630 :param str opc_request_id: (optional) 1631 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1632 particular request, please provide the request ID. 1633 1634 :param obj retry_strategy: (optional) 1635 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1636 1637 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1638 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1639 1640 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1641 1642 :return: A :class:`~oci.response.Response` object with data of type None 1643 :rtype: :class:`~oci.response.Response` 1644 1645 :example: 1646 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_load_balancer.py.html>`__ to see an example of how to use delete_load_balancer API. 1647 """ 1648 resource_path = "/loadBalancers/{loadBalancerId}" 1649 method = "DELETE" 1650 1651 # Don't accept unknown kwargs 1652 expected_kwargs = [ 1653 "retry_strategy", 1654 "opc_request_id" 1655 ] 1656 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1657 if extra_kwargs: 1658 raise ValueError( 1659 "delete_load_balancer got unknown kwargs: {!r}".format(extra_kwargs)) 1660 1661 path_params = { 1662 "loadBalancerId": load_balancer_id 1663 } 1664 1665 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1666 1667 for (k, v) in six.iteritems(path_params): 1668 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1669 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1670 1671 header_params = { 1672 "accept": "application/json", 1673 "content-type": "application/json", 1674 "opc-request-id": kwargs.get("opc_request_id", missing) 1675 } 1676 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1677 1678 retry_strategy = self.base_client.get_preferred_retry_strategy( 1679 operation_retry_strategy=kwargs.get('retry_strategy'), 1680 client_retry_strategy=self.retry_strategy 1681 ) 1682 1683 if retry_strategy: 1684 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1685 self.base_client.add_opc_client_retries_header(header_params) 1686 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1687 return retry_strategy.make_retrying_call( 1688 self.base_client.call_api, 1689 resource_path=resource_path, 1690 method=method, 1691 path_params=path_params, 1692 header_params=header_params) 1693 else: 1694 return self.base_client.call_api( 1695 resource_path=resource_path, 1696 method=method, 1697 path_params=path_params, 1698 header_params=header_params) 1699 1700 def delete_path_route_set(self, load_balancer_id, path_route_set_name, **kwargs): 1701 """ 1702 Deletes a path route set from the specified load balancer. 1703 1704 To delete a path route rule from a path route set, use the 1705 :func:`update_path_route_set` operation. 1706 1707 1708 :param str load_balancer_id: (required) 1709 The `OCID`__ of the load balancer associated with the path route set to delete. 1710 1711 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1712 1713 :param str path_route_set_name: (required) 1714 The name of the path route set to delete. 1715 1716 Example: `example_path_route_set` 1717 1718 :param str opc_request_id: (optional) 1719 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1720 particular request, please provide the request ID. 1721 1722 :param obj retry_strategy: (optional) 1723 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1724 1725 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1726 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1727 1728 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1729 1730 :return: A :class:`~oci.response.Response` object with data of type None 1731 :rtype: :class:`~oci.response.Response` 1732 1733 :example: 1734 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_path_route_set.py.html>`__ to see an example of how to use delete_path_route_set API. 1735 """ 1736 resource_path = "/loadBalancers/{loadBalancerId}/pathRouteSets/{pathRouteSetName}" 1737 method = "DELETE" 1738 1739 # Don't accept unknown kwargs 1740 expected_kwargs = [ 1741 "retry_strategy", 1742 "opc_request_id" 1743 ] 1744 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1745 if extra_kwargs: 1746 raise ValueError( 1747 "delete_path_route_set got unknown kwargs: {!r}".format(extra_kwargs)) 1748 1749 path_params = { 1750 "loadBalancerId": load_balancer_id, 1751 "pathRouteSetName": path_route_set_name 1752 } 1753 1754 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1755 1756 for (k, v) in six.iteritems(path_params): 1757 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1758 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1759 1760 header_params = { 1761 "accept": "application/json", 1762 "content-type": "application/json", 1763 "opc-request-id": kwargs.get("opc_request_id", missing) 1764 } 1765 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1766 1767 retry_strategy = self.base_client.get_preferred_retry_strategy( 1768 operation_retry_strategy=kwargs.get('retry_strategy'), 1769 client_retry_strategy=self.retry_strategy 1770 ) 1771 1772 if retry_strategy: 1773 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1774 self.base_client.add_opc_client_retries_header(header_params) 1775 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1776 return retry_strategy.make_retrying_call( 1777 self.base_client.call_api, 1778 resource_path=resource_path, 1779 method=method, 1780 path_params=path_params, 1781 header_params=header_params) 1782 else: 1783 return self.base_client.call_api( 1784 resource_path=resource_path, 1785 method=method, 1786 path_params=path_params, 1787 header_params=header_params) 1788 1789 def delete_routing_policy(self, load_balancer_id, routing_policy_name, **kwargs): 1790 """ 1791 Deletes a routing policy from the specified load balancer. 1792 1793 To delete a routing rule from a routing policy, use the 1794 :func:`update_routing_policy` operation. 1795 1796 1797 :param str load_balancer_id: (required) 1798 The `OCID`__ of the load balancer associated with the routing policy to delete. 1799 1800 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1801 1802 :param str routing_policy_name: (required) 1803 The name of the routing policy to delete. 1804 1805 Example: `example_routing_policy` 1806 1807 :param str opc_request_id: (optional) 1808 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1809 particular request, please provide the request ID. 1810 1811 :param obj retry_strategy: (optional) 1812 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1813 1814 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1815 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1816 1817 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1818 1819 :return: A :class:`~oci.response.Response` object with data of type None 1820 :rtype: :class:`~oci.response.Response` 1821 1822 :example: 1823 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_routing_policy.py.html>`__ to see an example of how to use delete_routing_policy API. 1824 """ 1825 resource_path = "/loadBalancers/{loadBalancerId}/routingPolicies/{routingPolicyName}" 1826 method = "DELETE" 1827 1828 # Don't accept unknown kwargs 1829 expected_kwargs = [ 1830 "retry_strategy", 1831 "opc_request_id" 1832 ] 1833 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1834 if extra_kwargs: 1835 raise ValueError( 1836 "delete_routing_policy got unknown kwargs: {!r}".format(extra_kwargs)) 1837 1838 path_params = { 1839 "loadBalancerId": load_balancer_id, 1840 "routingPolicyName": routing_policy_name 1841 } 1842 1843 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1844 1845 for (k, v) in six.iteritems(path_params): 1846 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1847 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1848 1849 header_params = { 1850 "accept": "application/json", 1851 "content-type": "application/json", 1852 "opc-request-id": kwargs.get("opc_request_id", missing) 1853 } 1854 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1855 1856 retry_strategy = self.base_client.get_preferred_retry_strategy( 1857 operation_retry_strategy=kwargs.get('retry_strategy'), 1858 client_retry_strategy=self.retry_strategy 1859 ) 1860 1861 if retry_strategy: 1862 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1863 self.base_client.add_opc_client_retries_header(header_params) 1864 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1865 return retry_strategy.make_retrying_call( 1866 self.base_client.call_api, 1867 resource_path=resource_path, 1868 method=method, 1869 path_params=path_params, 1870 header_params=header_params) 1871 else: 1872 return self.base_client.call_api( 1873 resource_path=resource_path, 1874 method=method, 1875 path_params=path_params, 1876 header_params=header_params) 1877 1878 def delete_rule_set(self, load_balancer_id, rule_set_name, **kwargs): 1879 """ 1880 Deletes a rule set from the specified load balancer. 1881 1882 To delete a rule from a rule set, use the 1883 :func:`update_rule_set` operation. 1884 1885 1886 :param str load_balancer_id: (required) 1887 The `OCID`__ of the specified load balancer. 1888 1889 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1890 1891 :param str rule_set_name: (required) 1892 The name of the rule set to delete. 1893 1894 Example: `example_rule_set` 1895 1896 :param str opc_request_id: (optional) 1897 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 1898 particular request, please provide the request ID. 1899 1900 :param obj retry_strategy: (optional) 1901 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1902 1903 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1904 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1905 1906 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1907 1908 :return: A :class:`~oci.response.Response` object with data of type None 1909 :rtype: :class:`~oci.response.Response` 1910 1911 :example: 1912 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_rule_set.py.html>`__ to see an example of how to use delete_rule_set API. 1913 """ 1914 resource_path = "/loadBalancers/{loadBalancerId}/ruleSets/{ruleSetName}" 1915 method = "DELETE" 1916 1917 # Don't accept unknown kwargs 1918 expected_kwargs = [ 1919 "retry_strategy", 1920 "opc_request_id" 1921 ] 1922 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 1923 if extra_kwargs: 1924 raise ValueError( 1925 "delete_rule_set got unknown kwargs: {!r}".format(extra_kwargs)) 1926 1927 path_params = { 1928 "loadBalancerId": load_balancer_id, 1929 "ruleSetName": rule_set_name 1930 } 1931 1932 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 1933 1934 for (k, v) in six.iteritems(path_params): 1935 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 1936 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 1937 1938 header_params = { 1939 "accept": "application/json", 1940 "content-type": "application/json", 1941 "opc-request-id": kwargs.get("opc_request_id", missing) 1942 } 1943 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 1944 1945 retry_strategy = self.base_client.get_preferred_retry_strategy( 1946 operation_retry_strategy=kwargs.get('retry_strategy'), 1947 client_retry_strategy=self.retry_strategy 1948 ) 1949 1950 if retry_strategy: 1951 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 1952 self.base_client.add_opc_client_retries_header(header_params) 1953 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 1954 return retry_strategy.make_retrying_call( 1955 self.base_client.call_api, 1956 resource_path=resource_path, 1957 method=method, 1958 path_params=path_params, 1959 header_params=header_params) 1960 else: 1961 return self.base_client.call_api( 1962 resource_path=resource_path, 1963 method=method, 1964 path_params=path_params, 1965 header_params=header_params) 1966 1967 def delete_ssl_cipher_suite(self, load_balancer_id, name, **kwargs): 1968 """ 1969 Deletes an SSL cipher suite from a load balancer. 1970 1971 1972 :param str load_balancer_id: (required) 1973 The `OCID`__ of the associated load balancer. 1974 1975 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 1976 1977 :param str name: (required) 1978 The name of the SSL cipher suite to delete. 1979 1980 example: `example_cipher_suite` 1981 1982 :param str opc_request_id: (optional) 1983 Unique Oracle-assigned identifier for the request. If you need to contact Oracle about 1984 a particular request, please provide the request ID. 1985 1986 :param obj retry_strategy: (optional) 1987 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 1988 1989 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 1990 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 1991 1992 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 1993 1994 :return: A :class:`~oci.response.Response` object with data of type None 1995 :rtype: :class:`~oci.response.Response` 1996 1997 :example: 1998 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/delete_ssl_cipher_suite.py.html>`__ to see an example of how to use delete_ssl_cipher_suite API. 1999 """ 2000 resource_path = "/loadBalancers/{loadBalancerId}/sslCipherSuites/{name}" 2001 method = "DELETE" 2002 2003 # Don't accept unknown kwargs 2004 expected_kwargs = [ 2005 "retry_strategy", 2006 "opc_request_id" 2007 ] 2008 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2009 if extra_kwargs: 2010 raise ValueError( 2011 "delete_ssl_cipher_suite got unknown kwargs: {!r}".format(extra_kwargs)) 2012 2013 path_params = { 2014 "loadBalancerId": load_balancer_id, 2015 "name": name 2016 } 2017 2018 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2019 2020 for (k, v) in six.iteritems(path_params): 2021 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2022 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2023 2024 header_params = { 2025 "accept": "application/json", 2026 "content-type": "application/json", 2027 "opc-request-id": kwargs.get("opc_request_id", missing) 2028 } 2029 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2030 2031 retry_strategy = self.base_client.get_preferred_retry_strategy( 2032 operation_retry_strategy=kwargs.get('retry_strategy'), 2033 client_retry_strategy=self.retry_strategy 2034 ) 2035 2036 if retry_strategy: 2037 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2038 self.base_client.add_opc_client_retries_header(header_params) 2039 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2040 return retry_strategy.make_retrying_call( 2041 self.base_client.call_api, 2042 resource_path=resource_path, 2043 method=method, 2044 path_params=path_params, 2045 header_params=header_params) 2046 else: 2047 return self.base_client.call_api( 2048 resource_path=resource_path, 2049 method=method, 2050 path_params=path_params, 2051 header_params=header_params) 2052 2053 def get_backend(self, load_balancer_id, backend_set_name, backend_name, **kwargs): 2054 """ 2055 Gets the specified backend server's configuration information. 2056 2057 2058 :param str load_balancer_id: (required) 2059 The `OCID`__ of the load balancer associated with the backend set and server. 2060 2061 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2062 2063 :param str backend_set_name: (required) 2064 The name of the backend set that includes the backend server. 2065 2066 Example: `example_backend_set` 2067 2068 :param str backend_name: (required) 2069 The IP address and port of the backend server to retrieve. 2070 2071 Example: `10.0.0.3:8080` 2072 2073 :param str opc_request_id: (optional) 2074 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2075 particular request, please provide the request ID. 2076 2077 :param obj retry_strategy: (optional) 2078 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2079 2080 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2081 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2082 2083 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2084 2085 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.Backend` 2086 :rtype: :class:`~oci.response.Response` 2087 2088 :example: 2089 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_backend.py.html>`__ to see an example of how to use get_backend API. 2090 """ 2091 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}" 2092 method = "GET" 2093 2094 # Don't accept unknown kwargs 2095 expected_kwargs = [ 2096 "retry_strategy", 2097 "opc_request_id" 2098 ] 2099 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2100 if extra_kwargs: 2101 raise ValueError( 2102 "get_backend got unknown kwargs: {!r}".format(extra_kwargs)) 2103 2104 path_params = { 2105 "loadBalancerId": load_balancer_id, 2106 "backendSetName": backend_set_name, 2107 "backendName": backend_name 2108 } 2109 2110 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2111 2112 for (k, v) in six.iteritems(path_params): 2113 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2114 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2115 2116 header_params = { 2117 "accept": "application/json", 2118 "content-type": "application/json", 2119 "opc-request-id": kwargs.get("opc_request_id", missing) 2120 } 2121 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2122 2123 retry_strategy = self.base_client.get_preferred_retry_strategy( 2124 operation_retry_strategy=kwargs.get('retry_strategy'), 2125 client_retry_strategy=self.retry_strategy 2126 ) 2127 2128 if retry_strategy: 2129 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2130 self.base_client.add_opc_client_retries_header(header_params) 2131 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2132 return retry_strategy.make_retrying_call( 2133 self.base_client.call_api, 2134 resource_path=resource_path, 2135 method=method, 2136 path_params=path_params, 2137 header_params=header_params, 2138 response_type="Backend") 2139 else: 2140 return self.base_client.call_api( 2141 resource_path=resource_path, 2142 method=method, 2143 path_params=path_params, 2144 header_params=header_params, 2145 response_type="Backend") 2146 2147 def get_backend_health(self, load_balancer_id, backend_set_name, backend_name, **kwargs): 2148 """ 2149 Gets the current health status of the specified backend server. 2150 2151 2152 :param str load_balancer_id: (required) 2153 The `OCID`__ of the load balancer associated with the backend server health status to be retrieved. 2154 2155 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2156 2157 :param str backend_set_name: (required) 2158 The name of the backend set associated with the backend server to retrieve the health status for. 2159 2160 Example: `example_backend_set` 2161 2162 :param str backend_name: (required) 2163 The IP address and port of the backend server to retrieve the health status for. 2164 2165 Example: `10.0.0.3:8080` 2166 2167 :param str opc_request_id: (optional) 2168 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2169 particular request, please provide the request ID. 2170 2171 :param obj retry_strategy: (optional) 2172 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2173 2174 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2175 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2176 2177 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2178 2179 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.BackendHealth` 2180 :rtype: :class:`~oci.response.Response` 2181 2182 :example: 2183 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_backend_health.py.html>`__ to see an example of how to use get_backend_health API. 2184 """ 2185 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}/health" 2186 method = "GET" 2187 2188 # Don't accept unknown kwargs 2189 expected_kwargs = [ 2190 "retry_strategy", 2191 "opc_request_id" 2192 ] 2193 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2194 if extra_kwargs: 2195 raise ValueError( 2196 "get_backend_health got unknown kwargs: {!r}".format(extra_kwargs)) 2197 2198 path_params = { 2199 "loadBalancerId": load_balancer_id, 2200 "backendSetName": backend_set_name, 2201 "backendName": backend_name 2202 } 2203 2204 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2205 2206 for (k, v) in six.iteritems(path_params): 2207 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2208 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2209 2210 header_params = { 2211 "accept": "application/json", 2212 "content-type": "application/json", 2213 "opc-request-id": kwargs.get("opc_request_id", missing) 2214 } 2215 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2216 2217 retry_strategy = self.base_client.get_preferred_retry_strategy( 2218 operation_retry_strategy=kwargs.get('retry_strategy'), 2219 client_retry_strategy=self.retry_strategy 2220 ) 2221 2222 if retry_strategy: 2223 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2224 self.base_client.add_opc_client_retries_header(header_params) 2225 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2226 return retry_strategy.make_retrying_call( 2227 self.base_client.call_api, 2228 resource_path=resource_path, 2229 method=method, 2230 path_params=path_params, 2231 header_params=header_params, 2232 response_type="BackendHealth") 2233 else: 2234 return self.base_client.call_api( 2235 resource_path=resource_path, 2236 method=method, 2237 path_params=path_params, 2238 header_params=header_params, 2239 response_type="BackendHealth") 2240 2241 def get_backend_set(self, load_balancer_id, backend_set_name, **kwargs): 2242 """ 2243 Gets the specified backend set's configuration information. 2244 2245 2246 :param str load_balancer_id: (required) 2247 The `OCID`__ of the specified load balancer. 2248 2249 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2250 2251 :param str backend_set_name: (required) 2252 The name of the backend set to retrieve. 2253 2254 Example: `example_backend_set` 2255 2256 :param str opc_request_id: (optional) 2257 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2258 particular request, please provide the request ID. 2259 2260 :param obj retry_strategy: (optional) 2261 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2262 2263 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2264 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2265 2266 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2267 2268 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.BackendSet` 2269 :rtype: :class:`~oci.response.Response` 2270 2271 :example: 2272 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_backend_set.py.html>`__ to see an example of how to use get_backend_set API. 2273 """ 2274 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}" 2275 method = "GET" 2276 2277 # Don't accept unknown kwargs 2278 expected_kwargs = [ 2279 "retry_strategy", 2280 "opc_request_id" 2281 ] 2282 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2283 if extra_kwargs: 2284 raise ValueError( 2285 "get_backend_set got unknown kwargs: {!r}".format(extra_kwargs)) 2286 2287 path_params = { 2288 "loadBalancerId": load_balancer_id, 2289 "backendSetName": backend_set_name 2290 } 2291 2292 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2293 2294 for (k, v) in six.iteritems(path_params): 2295 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2296 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2297 2298 header_params = { 2299 "accept": "application/json", 2300 "content-type": "application/json", 2301 "opc-request-id": kwargs.get("opc_request_id", missing) 2302 } 2303 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2304 2305 retry_strategy = self.base_client.get_preferred_retry_strategy( 2306 operation_retry_strategy=kwargs.get('retry_strategy'), 2307 client_retry_strategy=self.retry_strategy 2308 ) 2309 2310 if retry_strategy: 2311 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2312 self.base_client.add_opc_client_retries_header(header_params) 2313 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2314 return retry_strategy.make_retrying_call( 2315 self.base_client.call_api, 2316 resource_path=resource_path, 2317 method=method, 2318 path_params=path_params, 2319 header_params=header_params, 2320 response_type="BackendSet") 2321 else: 2322 return self.base_client.call_api( 2323 resource_path=resource_path, 2324 method=method, 2325 path_params=path_params, 2326 header_params=header_params, 2327 response_type="BackendSet") 2328 2329 def get_backend_set_health(self, load_balancer_id, backend_set_name, **kwargs): 2330 """ 2331 Gets the health status for the specified backend set. 2332 2333 2334 :param str load_balancer_id: (required) 2335 The `OCID`__ of the load balancer associated with the backend set health status to be retrieved. 2336 2337 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2338 2339 :param str backend_set_name: (required) 2340 The name of the backend set to retrieve the health status for. 2341 2342 Example: `example_backend_set` 2343 2344 :param str opc_request_id: (optional) 2345 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2346 particular request, please provide the request ID. 2347 2348 :param obj retry_strategy: (optional) 2349 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2350 2351 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2352 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2353 2354 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2355 2356 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.BackendSetHealth` 2357 :rtype: :class:`~oci.response.Response` 2358 2359 :example: 2360 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_backend_set_health.py.html>`__ to see an example of how to use get_backend_set_health API. 2361 """ 2362 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/health" 2363 method = "GET" 2364 2365 # Don't accept unknown kwargs 2366 expected_kwargs = [ 2367 "retry_strategy", 2368 "opc_request_id" 2369 ] 2370 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2371 if extra_kwargs: 2372 raise ValueError( 2373 "get_backend_set_health got unknown kwargs: {!r}".format(extra_kwargs)) 2374 2375 path_params = { 2376 "loadBalancerId": load_balancer_id, 2377 "backendSetName": backend_set_name 2378 } 2379 2380 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2381 2382 for (k, v) in six.iteritems(path_params): 2383 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2384 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2385 2386 header_params = { 2387 "accept": "application/json", 2388 "content-type": "application/json", 2389 "opc-request-id": kwargs.get("opc_request_id", missing) 2390 } 2391 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2392 2393 retry_strategy = self.base_client.get_preferred_retry_strategy( 2394 operation_retry_strategy=kwargs.get('retry_strategy'), 2395 client_retry_strategy=self.retry_strategy 2396 ) 2397 2398 if retry_strategy: 2399 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2400 self.base_client.add_opc_client_retries_header(header_params) 2401 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2402 return retry_strategy.make_retrying_call( 2403 self.base_client.call_api, 2404 resource_path=resource_path, 2405 method=method, 2406 path_params=path_params, 2407 header_params=header_params, 2408 response_type="BackendSetHealth") 2409 else: 2410 return self.base_client.call_api( 2411 resource_path=resource_path, 2412 method=method, 2413 path_params=path_params, 2414 header_params=header_params, 2415 response_type="BackendSetHealth") 2416 2417 def get_health_checker(self, load_balancer_id, backend_set_name, **kwargs): 2418 """ 2419 Gets the health check policy information for a given load balancer and backend set. 2420 2421 2422 :param str load_balancer_id: (required) 2423 The `OCID`__ of the load balancer associated with the health check policy to be retrieved. 2424 2425 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2426 2427 :param str backend_set_name: (required) 2428 The name of the backend set associated with the health check policy to be retrieved. 2429 2430 Example: `example_backend_set` 2431 2432 :param str opc_request_id: (optional) 2433 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2434 particular request, please provide the request ID. 2435 2436 :param obj retry_strategy: (optional) 2437 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2438 2439 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2440 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2441 2442 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2443 2444 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.HealthChecker` 2445 :rtype: :class:`~oci.response.Response` 2446 2447 :example: 2448 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_health_checker.py.html>`__ to see an example of how to use get_health_checker API. 2449 """ 2450 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/healthChecker" 2451 method = "GET" 2452 2453 # Don't accept unknown kwargs 2454 expected_kwargs = [ 2455 "retry_strategy", 2456 "opc_request_id" 2457 ] 2458 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2459 if extra_kwargs: 2460 raise ValueError( 2461 "get_health_checker got unknown kwargs: {!r}".format(extra_kwargs)) 2462 2463 path_params = { 2464 "loadBalancerId": load_balancer_id, 2465 "backendSetName": backend_set_name 2466 } 2467 2468 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2469 2470 for (k, v) in six.iteritems(path_params): 2471 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2472 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2473 2474 header_params = { 2475 "accept": "application/json", 2476 "content-type": "application/json", 2477 "opc-request-id": kwargs.get("opc_request_id", missing) 2478 } 2479 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2480 2481 retry_strategy = self.base_client.get_preferred_retry_strategy( 2482 operation_retry_strategy=kwargs.get('retry_strategy'), 2483 client_retry_strategy=self.retry_strategy 2484 ) 2485 2486 if retry_strategy: 2487 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2488 self.base_client.add_opc_client_retries_header(header_params) 2489 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2490 return retry_strategy.make_retrying_call( 2491 self.base_client.call_api, 2492 resource_path=resource_path, 2493 method=method, 2494 path_params=path_params, 2495 header_params=header_params, 2496 response_type="HealthChecker") 2497 else: 2498 return self.base_client.call_api( 2499 resource_path=resource_path, 2500 method=method, 2501 path_params=path_params, 2502 header_params=header_params, 2503 response_type="HealthChecker") 2504 2505 def get_hostname(self, load_balancer_id, name, **kwargs): 2506 """ 2507 Gets the specified hostname resource's configuration information. 2508 2509 2510 :param str load_balancer_id: (required) 2511 The `OCID`__ of the specified load balancer. 2512 2513 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2514 2515 :param str name: (required) 2516 The name of the hostname resource to retrieve. 2517 2518 Example: `example_hostname_001` 2519 2520 :param str opc_request_id: (optional) 2521 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2522 particular request, please provide the request ID. 2523 2524 :param obj retry_strategy: (optional) 2525 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2526 2527 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2528 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2529 2530 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2531 2532 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.Hostname` 2533 :rtype: :class:`~oci.response.Response` 2534 2535 :example: 2536 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_hostname.py.html>`__ to see an example of how to use get_hostname API. 2537 """ 2538 resource_path = "/loadBalancers/{loadBalancerId}/hostnames/{name}" 2539 method = "GET" 2540 2541 # Don't accept unknown kwargs 2542 expected_kwargs = [ 2543 "retry_strategy", 2544 "opc_request_id" 2545 ] 2546 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2547 if extra_kwargs: 2548 raise ValueError( 2549 "get_hostname got unknown kwargs: {!r}".format(extra_kwargs)) 2550 2551 path_params = { 2552 "loadBalancerId": load_balancer_id, 2553 "name": name 2554 } 2555 2556 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2557 2558 for (k, v) in six.iteritems(path_params): 2559 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2560 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2561 2562 header_params = { 2563 "accept": "application/json", 2564 "content-type": "application/json", 2565 "opc-request-id": kwargs.get("opc_request_id", missing) 2566 } 2567 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2568 2569 retry_strategy = self.base_client.get_preferred_retry_strategy( 2570 operation_retry_strategy=kwargs.get('retry_strategy'), 2571 client_retry_strategy=self.retry_strategy 2572 ) 2573 2574 if retry_strategy: 2575 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2576 self.base_client.add_opc_client_retries_header(header_params) 2577 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2578 return retry_strategy.make_retrying_call( 2579 self.base_client.call_api, 2580 resource_path=resource_path, 2581 method=method, 2582 path_params=path_params, 2583 header_params=header_params, 2584 response_type="Hostname") 2585 else: 2586 return self.base_client.call_api( 2587 resource_path=resource_path, 2588 method=method, 2589 path_params=path_params, 2590 header_params=header_params, 2591 response_type="Hostname") 2592 2593 def get_load_balancer(self, load_balancer_id, **kwargs): 2594 """ 2595 Gets the specified load balancer's configuration information. 2596 2597 2598 :param str load_balancer_id: (required) 2599 The `OCID`__ of the load balancer to retrieve. 2600 2601 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2602 2603 :param str opc_request_id: (optional) 2604 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2605 particular request, please provide the request ID. 2606 2607 :param obj retry_strategy: (optional) 2608 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2609 2610 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2611 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2612 2613 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2614 2615 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.LoadBalancer` 2616 :rtype: :class:`~oci.response.Response` 2617 2618 :example: 2619 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_load_balancer.py.html>`__ to see an example of how to use get_load_balancer API. 2620 """ 2621 resource_path = "/loadBalancers/{loadBalancerId}" 2622 method = "GET" 2623 2624 # Don't accept unknown kwargs 2625 expected_kwargs = [ 2626 "retry_strategy", 2627 "opc_request_id" 2628 ] 2629 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2630 if extra_kwargs: 2631 raise ValueError( 2632 "get_load_balancer got unknown kwargs: {!r}".format(extra_kwargs)) 2633 2634 path_params = { 2635 "loadBalancerId": load_balancer_id 2636 } 2637 2638 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2639 2640 for (k, v) in six.iteritems(path_params): 2641 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2642 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2643 2644 header_params = { 2645 "accept": "application/json", 2646 "content-type": "application/json", 2647 "opc-request-id": kwargs.get("opc_request_id", missing) 2648 } 2649 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2650 2651 retry_strategy = self.base_client.get_preferred_retry_strategy( 2652 operation_retry_strategy=kwargs.get('retry_strategy'), 2653 client_retry_strategy=self.retry_strategy 2654 ) 2655 2656 if retry_strategy: 2657 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2658 self.base_client.add_opc_client_retries_header(header_params) 2659 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2660 return retry_strategy.make_retrying_call( 2661 self.base_client.call_api, 2662 resource_path=resource_path, 2663 method=method, 2664 path_params=path_params, 2665 header_params=header_params, 2666 response_type="LoadBalancer") 2667 else: 2668 return self.base_client.call_api( 2669 resource_path=resource_path, 2670 method=method, 2671 path_params=path_params, 2672 header_params=header_params, 2673 response_type="LoadBalancer") 2674 2675 def get_load_balancer_health(self, load_balancer_id, **kwargs): 2676 """ 2677 Gets the health status for the specified load balancer. 2678 2679 2680 :param str load_balancer_id: (required) 2681 The `OCID`__ of the load balancer to return health status for. 2682 2683 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2684 2685 :param str opc_request_id: (optional) 2686 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2687 particular request, please provide the request ID. 2688 2689 :param obj retry_strategy: (optional) 2690 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2691 2692 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2693 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2694 2695 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2696 2697 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.LoadBalancerHealth` 2698 :rtype: :class:`~oci.response.Response` 2699 2700 :example: 2701 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_load_balancer_health.py.html>`__ to see an example of how to use get_load_balancer_health API. 2702 """ 2703 resource_path = "/loadBalancers/{loadBalancerId}/health" 2704 method = "GET" 2705 2706 # Don't accept unknown kwargs 2707 expected_kwargs = [ 2708 "retry_strategy", 2709 "opc_request_id" 2710 ] 2711 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2712 if extra_kwargs: 2713 raise ValueError( 2714 "get_load_balancer_health got unknown kwargs: {!r}".format(extra_kwargs)) 2715 2716 path_params = { 2717 "loadBalancerId": load_balancer_id 2718 } 2719 2720 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2721 2722 for (k, v) in six.iteritems(path_params): 2723 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2724 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2725 2726 header_params = { 2727 "accept": "application/json", 2728 "content-type": "application/json", 2729 "opc-request-id": kwargs.get("opc_request_id", missing) 2730 } 2731 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2732 2733 retry_strategy = self.base_client.get_preferred_retry_strategy( 2734 operation_retry_strategy=kwargs.get('retry_strategy'), 2735 client_retry_strategy=self.retry_strategy 2736 ) 2737 2738 if retry_strategy: 2739 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2740 self.base_client.add_opc_client_retries_header(header_params) 2741 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2742 return retry_strategy.make_retrying_call( 2743 self.base_client.call_api, 2744 resource_path=resource_path, 2745 method=method, 2746 path_params=path_params, 2747 header_params=header_params, 2748 response_type="LoadBalancerHealth") 2749 else: 2750 return self.base_client.call_api( 2751 resource_path=resource_path, 2752 method=method, 2753 path_params=path_params, 2754 header_params=header_params, 2755 response_type="LoadBalancerHealth") 2756 2757 def get_path_route_set(self, load_balancer_id, path_route_set_name, **kwargs): 2758 """ 2759 Gets the specified path route set's configuration information. 2760 2761 2762 :param str load_balancer_id: (required) 2763 The `OCID`__ of the specified load balancer. 2764 2765 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2766 2767 :param str path_route_set_name: (required) 2768 The name of the path route set to retrieve. 2769 2770 Example: `example_path_route_set` 2771 2772 :param str opc_request_id: (optional) 2773 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2774 particular request, please provide the request ID. 2775 2776 :param obj retry_strategy: (optional) 2777 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2778 2779 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2780 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2781 2782 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2783 2784 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.PathRouteSet` 2785 :rtype: :class:`~oci.response.Response` 2786 2787 :example: 2788 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_path_route_set.py.html>`__ to see an example of how to use get_path_route_set API. 2789 """ 2790 resource_path = "/loadBalancers/{loadBalancerId}/pathRouteSets/{pathRouteSetName}" 2791 method = "GET" 2792 2793 # Don't accept unknown kwargs 2794 expected_kwargs = [ 2795 "retry_strategy", 2796 "opc_request_id" 2797 ] 2798 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2799 if extra_kwargs: 2800 raise ValueError( 2801 "get_path_route_set got unknown kwargs: {!r}".format(extra_kwargs)) 2802 2803 path_params = { 2804 "loadBalancerId": load_balancer_id, 2805 "pathRouteSetName": path_route_set_name 2806 } 2807 2808 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2809 2810 for (k, v) in six.iteritems(path_params): 2811 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2812 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2813 2814 header_params = { 2815 "accept": "application/json", 2816 "content-type": "application/json", 2817 "opc-request-id": kwargs.get("opc_request_id", missing) 2818 } 2819 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2820 2821 retry_strategy = self.base_client.get_preferred_retry_strategy( 2822 operation_retry_strategy=kwargs.get('retry_strategy'), 2823 client_retry_strategy=self.retry_strategy 2824 ) 2825 2826 if retry_strategy: 2827 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2828 self.base_client.add_opc_client_retries_header(header_params) 2829 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2830 return retry_strategy.make_retrying_call( 2831 self.base_client.call_api, 2832 resource_path=resource_path, 2833 method=method, 2834 path_params=path_params, 2835 header_params=header_params, 2836 response_type="PathRouteSet") 2837 else: 2838 return self.base_client.call_api( 2839 resource_path=resource_path, 2840 method=method, 2841 path_params=path_params, 2842 header_params=header_params, 2843 response_type="PathRouteSet") 2844 2845 def get_routing_policy(self, load_balancer_id, routing_policy_name, **kwargs): 2846 """ 2847 Gets the specified routing policy. 2848 2849 2850 :param str load_balancer_id: (required) 2851 The `OCID`__ of the specified load balancer. 2852 2853 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2854 2855 :param str routing_policy_name: (required) 2856 The name of the routing policy to retrieve. 2857 2858 Example: `example_routing_policy` 2859 2860 :param str opc_request_id: (optional) 2861 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2862 particular request, please provide the request ID. 2863 2864 :param obj retry_strategy: (optional) 2865 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2866 2867 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2868 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2869 2870 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2871 2872 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.RoutingPolicy` 2873 :rtype: :class:`~oci.response.Response` 2874 2875 :example: 2876 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_routing_policy.py.html>`__ to see an example of how to use get_routing_policy API. 2877 """ 2878 resource_path = "/loadBalancers/{loadBalancerId}/routingPolicies/{routingPolicyName}" 2879 method = "GET" 2880 2881 # Don't accept unknown kwargs 2882 expected_kwargs = [ 2883 "retry_strategy", 2884 "opc_request_id" 2885 ] 2886 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2887 if extra_kwargs: 2888 raise ValueError( 2889 "get_routing_policy got unknown kwargs: {!r}".format(extra_kwargs)) 2890 2891 path_params = { 2892 "loadBalancerId": load_balancer_id, 2893 "routingPolicyName": routing_policy_name 2894 } 2895 2896 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2897 2898 for (k, v) in six.iteritems(path_params): 2899 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2900 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2901 2902 header_params = { 2903 "accept": "application/json", 2904 "content-type": "application/json", 2905 "opc-request-id": kwargs.get("opc_request_id", missing) 2906 } 2907 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2908 2909 retry_strategy = self.base_client.get_preferred_retry_strategy( 2910 operation_retry_strategy=kwargs.get('retry_strategy'), 2911 client_retry_strategy=self.retry_strategy 2912 ) 2913 2914 if retry_strategy: 2915 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 2916 self.base_client.add_opc_client_retries_header(header_params) 2917 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 2918 return retry_strategy.make_retrying_call( 2919 self.base_client.call_api, 2920 resource_path=resource_path, 2921 method=method, 2922 path_params=path_params, 2923 header_params=header_params, 2924 response_type="RoutingPolicy") 2925 else: 2926 return self.base_client.call_api( 2927 resource_path=resource_path, 2928 method=method, 2929 path_params=path_params, 2930 header_params=header_params, 2931 response_type="RoutingPolicy") 2932 2933 def get_rule_set(self, load_balancer_id, rule_set_name, **kwargs): 2934 """ 2935 Gets the specified set of rules. 2936 2937 2938 :param str load_balancer_id: (required) 2939 The `OCID`__ of the specified load balancer. 2940 2941 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 2942 2943 :param str rule_set_name: (required) 2944 The name of the rule set to retrieve. 2945 2946 Example: `example_rule_set` 2947 2948 :param str opc_request_id: (optional) 2949 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 2950 particular request, please provide the request ID. 2951 2952 :param obj retry_strategy: (optional) 2953 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 2954 2955 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 2956 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 2957 2958 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 2959 2960 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.RuleSet` 2961 :rtype: :class:`~oci.response.Response` 2962 2963 :example: 2964 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_rule_set.py.html>`__ to see an example of how to use get_rule_set API. 2965 """ 2966 resource_path = "/loadBalancers/{loadBalancerId}/ruleSets/{ruleSetName}" 2967 method = "GET" 2968 2969 # Don't accept unknown kwargs 2970 expected_kwargs = [ 2971 "retry_strategy", 2972 "opc_request_id" 2973 ] 2974 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 2975 if extra_kwargs: 2976 raise ValueError( 2977 "get_rule_set got unknown kwargs: {!r}".format(extra_kwargs)) 2978 2979 path_params = { 2980 "loadBalancerId": load_balancer_id, 2981 "ruleSetName": rule_set_name 2982 } 2983 2984 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 2985 2986 for (k, v) in six.iteritems(path_params): 2987 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 2988 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 2989 2990 header_params = { 2991 "accept": "application/json", 2992 "content-type": "application/json", 2993 "opc-request-id": kwargs.get("opc_request_id", missing) 2994 } 2995 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 2996 2997 retry_strategy = self.base_client.get_preferred_retry_strategy( 2998 operation_retry_strategy=kwargs.get('retry_strategy'), 2999 client_retry_strategy=self.retry_strategy 3000 ) 3001 3002 if retry_strategy: 3003 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3004 self.base_client.add_opc_client_retries_header(header_params) 3005 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3006 return retry_strategy.make_retrying_call( 3007 self.base_client.call_api, 3008 resource_path=resource_path, 3009 method=method, 3010 path_params=path_params, 3011 header_params=header_params, 3012 response_type="RuleSet") 3013 else: 3014 return self.base_client.call_api( 3015 resource_path=resource_path, 3016 method=method, 3017 path_params=path_params, 3018 header_params=header_params, 3019 response_type="RuleSet") 3020 3021 def get_ssl_cipher_suite(self, load_balancer_id, name, **kwargs): 3022 """ 3023 Gets the specified SSL cipher suite's configuration information. 3024 3025 3026 :param str load_balancer_id: (required) 3027 The `OCID`__ of the associated load balancer. 3028 3029 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3030 3031 :param str name: (required) 3032 The name of the SSL cipher suite to retrieve. 3033 3034 example: `example_cipher_suite` 3035 3036 :param str opc_request_id: (optional) 3037 Unique Oracle-assigned identifier for the request. If you need to contact Oracle about 3038 a particular request, please provide the request ID. 3039 3040 :param obj retry_strategy: (optional) 3041 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3042 3043 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3044 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3045 3046 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3047 3048 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.SSLCipherSuite` 3049 :rtype: :class:`~oci.response.Response` 3050 3051 :example: 3052 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_ssl_cipher_suite.py.html>`__ to see an example of how to use get_ssl_cipher_suite API. 3053 """ 3054 resource_path = "/loadBalancers/{loadBalancerId}/sslCipherSuites/{name}" 3055 method = "GET" 3056 3057 # Don't accept unknown kwargs 3058 expected_kwargs = [ 3059 "retry_strategy", 3060 "opc_request_id" 3061 ] 3062 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3063 if extra_kwargs: 3064 raise ValueError( 3065 "get_ssl_cipher_suite got unknown kwargs: {!r}".format(extra_kwargs)) 3066 3067 path_params = { 3068 "loadBalancerId": load_balancer_id, 3069 "name": name 3070 } 3071 3072 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3073 3074 for (k, v) in six.iteritems(path_params): 3075 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3076 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3077 3078 header_params = { 3079 "accept": "application/json", 3080 "content-type": "application/json", 3081 "opc-request-id": kwargs.get("opc_request_id", missing) 3082 } 3083 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3084 3085 retry_strategy = self.base_client.get_preferred_retry_strategy( 3086 operation_retry_strategy=kwargs.get('retry_strategy'), 3087 client_retry_strategy=self.retry_strategy 3088 ) 3089 3090 if retry_strategy: 3091 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3092 self.base_client.add_opc_client_retries_header(header_params) 3093 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3094 return retry_strategy.make_retrying_call( 3095 self.base_client.call_api, 3096 resource_path=resource_path, 3097 method=method, 3098 path_params=path_params, 3099 header_params=header_params, 3100 response_type="SSLCipherSuite") 3101 else: 3102 return self.base_client.call_api( 3103 resource_path=resource_path, 3104 method=method, 3105 path_params=path_params, 3106 header_params=header_params, 3107 response_type="SSLCipherSuite") 3108 3109 def get_work_request(self, work_request_id, **kwargs): 3110 """ 3111 Gets the details of a work request. 3112 3113 3114 :param str work_request_id: (required) 3115 The `OCID`__ of the work request to retrieve. 3116 3117 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3118 3119 :param str opc_request_id: (optional) 3120 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3121 particular request, please provide the request ID. 3122 3123 :param obj retry_strategy: (optional) 3124 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3125 3126 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3127 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3128 3129 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3130 3131 :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.load_balancer.models.WorkRequest` 3132 :rtype: :class:`~oci.response.Response` 3133 3134 :example: 3135 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/get_work_request.py.html>`__ to see an example of how to use get_work_request API. 3136 """ 3137 resource_path = "/loadBalancerWorkRequests/{workRequestId}" 3138 method = "GET" 3139 3140 # Don't accept unknown kwargs 3141 expected_kwargs = [ 3142 "retry_strategy", 3143 "opc_request_id" 3144 ] 3145 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3146 if extra_kwargs: 3147 raise ValueError( 3148 "get_work_request got unknown kwargs: {!r}".format(extra_kwargs)) 3149 3150 path_params = { 3151 "workRequestId": work_request_id 3152 } 3153 3154 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3155 3156 for (k, v) in six.iteritems(path_params): 3157 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3158 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3159 3160 header_params = { 3161 "accept": "application/json", 3162 "content-type": "application/json", 3163 "opc-request-id": kwargs.get("opc_request_id", missing) 3164 } 3165 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3166 3167 retry_strategy = self.base_client.get_preferred_retry_strategy( 3168 operation_retry_strategy=kwargs.get('retry_strategy'), 3169 client_retry_strategy=self.retry_strategy 3170 ) 3171 3172 if retry_strategy: 3173 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3174 self.base_client.add_opc_client_retries_header(header_params) 3175 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3176 return retry_strategy.make_retrying_call( 3177 self.base_client.call_api, 3178 resource_path=resource_path, 3179 method=method, 3180 path_params=path_params, 3181 header_params=header_params, 3182 response_type="WorkRequest") 3183 else: 3184 return self.base_client.call_api( 3185 resource_path=resource_path, 3186 method=method, 3187 path_params=path_params, 3188 header_params=header_params, 3189 response_type="WorkRequest") 3190 3191 def list_backend_sets(self, load_balancer_id, **kwargs): 3192 """ 3193 Lists all backend sets associated with a given load balancer. 3194 3195 3196 :param str load_balancer_id: (required) 3197 The `OCID`__ of the load balancer associated with the backend sets to retrieve. 3198 3199 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3200 3201 :param str opc_request_id: (optional) 3202 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3203 particular request, please provide the request ID. 3204 3205 :param obj retry_strategy: (optional) 3206 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3207 3208 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3209 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3210 3211 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3212 3213 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.BackendSet` 3214 :rtype: :class:`~oci.response.Response` 3215 3216 :example: 3217 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_backend_sets.py.html>`__ to see an example of how to use list_backend_sets API. 3218 """ 3219 resource_path = "/loadBalancers/{loadBalancerId}/backendSets" 3220 method = "GET" 3221 3222 # Don't accept unknown kwargs 3223 expected_kwargs = [ 3224 "retry_strategy", 3225 "opc_request_id" 3226 ] 3227 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3228 if extra_kwargs: 3229 raise ValueError( 3230 "list_backend_sets got unknown kwargs: {!r}".format(extra_kwargs)) 3231 3232 path_params = { 3233 "loadBalancerId": load_balancer_id 3234 } 3235 3236 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3237 3238 for (k, v) in six.iteritems(path_params): 3239 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3240 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3241 3242 header_params = { 3243 "accept": "application/json", 3244 "content-type": "application/json", 3245 "opc-request-id": kwargs.get("opc_request_id", missing) 3246 } 3247 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3248 3249 retry_strategy = self.base_client.get_preferred_retry_strategy( 3250 operation_retry_strategy=kwargs.get('retry_strategy'), 3251 client_retry_strategy=self.retry_strategy 3252 ) 3253 3254 if retry_strategy: 3255 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3256 self.base_client.add_opc_client_retries_header(header_params) 3257 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3258 return retry_strategy.make_retrying_call( 3259 self.base_client.call_api, 3260 resource_path=resource_path, 3261 method=method, 3262 path_params=path_params, 3263 header_params=header_params, 3264 response_type="list[BackendSet]") 3265 else: 3266 return self.base_client.call_api( 3267 resource_path=resource_path, 3268 method=method, 3269 path_params=path_params, 3270 header_params=header_params, 3271 response_type="list[BackendSet]") 3272 3273 def list_backends(self, load_balancer_id, backend_set_name, **kwargs): 3274 """ 3275 Lists the backend servers for a given load balancer and backend set. 3276 3277 3278 :param str load_balancer_id: (required) 3279 The `OCID`__ of the load balancer associated with the backend set and servers. 3280 3281 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3282 3283 :param str backend_set_name: (required) 3284 The name of the backend set associated with the backend servers. 3285 3286 Example: `example_backend_set` 3287 3288 :param str opc_request_id: (optional) 3289 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3290 particular request, please provide the request ID. 3291 3292 :param obj retry_strategy: (optional) 3293 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3294 3295 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3296 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3297 3298 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3299 3300 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.Backend` 3301 :rtype: :class:`~oci.response.Response` 3302 3303 :example: 3304 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_backends.py.html>`__ to see an example of how to use list_backends API. 3305 """ 3306 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends" 3307 method = "GET" 3308 3309 # Don't accept unknown kwargs 3310 expected_kwargs = [ 3311 "retry_strategy", 3312 "opc_request_id" 3313 ] 3314 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3315 if extra_kwargs: 3316 raise ValueError( 3317 "list_backends got unknown kwargs: {!r}".format(extra_kwargs)) 3318 3319 path_params = { 3320 "loadBalancerId": load_balancer_id, 3321 "backendSetName": backend_set_name 3322 } 3323 3324 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3325 3326 for (k, v) in six.iteritems(path_params): 3327 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3328 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3329 3330 header_params = { 3331 "accept": "application/json", 3332 "content-type": "application/json", 3333 "opc-request-id": kwargs.get("opc_request_id", missing) 3334 } 3335 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3336 3337 retry_strategy = self.base_client.get_preferred_retry_strategy( 3338 operation_retry_strategy=kwargs.get('retry_strategy'), 3339 client_retry_strategy=self.retry_strategy 3340 ) 3341 3342 if retry_strategy: 3343 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3344 self.base_client.add_opc_client_retries_header(header_params) 3345 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3346 return retry_strategy.make_retrying_call( 3347 self.base_client.call_api, 3348 resource_path=resource_path, 3349 method=method, 3350 path_params=path_params, 3351 header_params=header_params, 3352 response_type="list[Backend]") 3353 else: 3354 return self.base_client.call_api( 3355 resource_path=resource_path, 3356 method=method, 3357 path_params=path_params, 3358 header_params=header_params, 3359 response_type="list[Backend]") 3360 3361 def list_certificates(self, load_balancer_id, **kwargs): 3362 """ 3363 Lists all SSL certificates bundles associated with a given load balancer. 3364 3365 3366 :param str load_balancer_id: (required) 3367 The `OCID`__ of the load balancer associated with the certificate bundles 3368 to be listed. 3369 3370 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3371 3372 :param str opc_request_id: (optional) 3373 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3374 particular request, please provide the request ID. 3375 3376 :param obj retry_strategy: (optional) 3377 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3378 3379 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3380 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3381 3382 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3383 3384 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.Certificate` 3385 :rtype: :class:`~oci.response.Response` 3386 3387 :example: 3388 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_certificates.py.html>`__ to see an example of how to use list_certificates API. 3389 """ 3390 resource_path = "/loadBalancers/{loadBalancerId}/certificates" 3391 method = "GET" 3392 3393 # Don't accept unknown kwargs 3394 expected_kwargs = [ 3395 "retry_strategy", 3396 "opc_request_id" 3397 ] 3398 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3399 if extra_kwargs: 3400 raise ValueError( 3401 "list_certificates got unknown kwargs: {!r}".format(extra_kwargs)) 3402 3403 path_params = { 3404 "loadBalancerId": load_balancer_id 3405 } 3406 3407 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3408 3409 for (k, v) in six.iteritems(path_params): 3410 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3411 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3412 3413 header_params = { 3414 "accept": "application/json", 3415 "content-type": "application/json", 3416 "opc-request-id": kwargs.get("opc_request_id", missing) 3417 } 3418 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3419 3420 retry_strategy = self.base_client.get_preferred_retry_strategy( 3421 operation_retry_strategy=kwargs.get('retry_strategy'), 3422 client_retry_strategy=self.retry_strategy 3423 ) 3424 3425 if retry_strategy: 3426 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3427 self.base_client.add_opc_client_retries_header(header_params) 3428 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3429 return retry_strategy.make_retrying_call( 3430 self.base_client.call_api, 3431 resource_path=resource_path, 3432 method=method, 3433 path_params=path_params, 3434 header_params=header_params, 3435 response_type="list[Certificate]") 3436 else: 3437 return self.base_client.call_api( 3438 resource_path=resource_path, 3439 method=method, 3440 path_params=path_params, 3441 header_params=header_params, 3442 response_type="list[Certificate]") 3443 3444 def list_hostnames(self, load_balancer_id, **kwargs): 3445 """ 3446 Lists all hostname resources associated with the specified load balancer. 3447 3448 3449 :param str load_balancer_id: (required) 3450 The `OCID`__ of the load balancer associated with the hostnames 3451 to retrieve. 3452 3453 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3454 3455 :param str opc_request_id: (optional) 3456 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3457 particular request, please provide the request ID. 3458 3459 :param obj retry_strategy: (optional) 3460 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3461 3462 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3463 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3464 3465 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3466 3467 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.Hostname` 3468 :rtype: :class:`~oci.response.Response` 3469 3470 :example: 3471 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_hostnames.py.html>`__ to see an example of how to use list_hostnames API. 3472 """ 3473 resource_path = "/loadBalancers/{loadBalancerId}/hostnames" 3474 method = "GET" 3475 3476 # Don't accept unknown kwargs 3477 expected_kwargs = [ 3478 "retry_strategy", 3479 "opc_request_id" 3480 ] 3481 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3482 if extra_kwargs: 3483 raise ValueError( 3484 "list_hostnames got unknown kwargs: {!r}".format(extra_kwargs)) 3485 3486 path_params = { 3487 "loadBalancerId": load_balancer_id 3488 } 3489 3490 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3491 3492 for (k, v) in six.iteritems(path_params): 3493 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3494 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3495 3496 header_params = { 3497 "accept": "application/json", 3498 "content-type": "application/json", 3499 "opc-request-id": kwargs.get("opc_request_id", missing) 3500 } 3501 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3502 3503 retry_strategy = self.base_client.get_preferred_retry_strategy( 3504 operation_retry_strategy=kwargs.get('retry_strategy'), 3505 client_retry_strategy=self.retry_strategy 3506 ) 3507 3508 if retry_strategy: 3509 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3510 self.base_client.add_opc_client_retries_header(header_params) 3511 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3512 return retry_strategy.make_retrying_call( 3513 self.base_client.call_api, 3514 resource_path=resource_path, 3515 method=method, 3516 path_params=path_params, 3517 header_params=header_params, 3518 response_type="list[Hostname]") 3519 else: 3520 return self.base_client.call_api( 3521 resource_path=resource_path, 3522 method=method, 3523 path_params=path_params, 3524 header_params=header_params, 3525 response_type="list[Hostname]") 3526 3527 def list_listener_rules(self, load_balancer_id, listener_name, **kwargs): 3528 """ 3529 Lists all of the rules from all of the rule sets associated with the specified listener. The response organizes 3530 the rules in the following order: 3531 3532 * Access control rules 3533 * Allow method rules 3534 * Request header rules 3535 * Response header rules 3536 3537 3538 :param str load_balancer_id: (required) 3539 The `OCID`__ of the load balancer associated with the listener. 3540 3541 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3542 3543 :param str listener_name: (required) 3544 The name of the listener the rules are associated with. 3545 3546 :param str opc_request_id: (optional) 3547 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3548 particular request, please provide the request ID. 3549 3550 :param obj retry_strategy: (optional) 3551 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3552 3553 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3554 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3555 3556 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3557 3558 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.ListenerRuleSummary` 3559 :rtype: :class:`~oci.response.Response` 3560 3561 :example: 3562 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_listener_rules.py.html>`__ to see an example of how to use list_listener_rules API. 3563 """ 3564 resource_path = "/loadBalancers/{loadBalancerId}/listeners/{listenerName}/rules" 3565 method = "GET" 3566 3567 # Don't accept unknown kwargs 3568 expected_kwargs = [ 3569 "retry_strategy", 3570 "opc_request_id" 3571 ] 3572 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3573 if extra_kwargs: 3574 raise ValueError( 3575 "list_listener_rules got unknown kwargs: {!r}".format(extra_kwargs)) 3576 3577 path_params = { 3578 "loadBalancerId": load_balancer_id, 3579 "listenerName": listener_name 3580 } 3581 3582 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3583 3584 for (k, v) in six.iteritems(path_params): 3585 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3586 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3587 3588 header_params = { 3589 "accept": "application/json", 3590 "content-type": "application/json", 3591 "opc-request-id": kwargs.get("opc_request_id", missing) 3592 } 3593 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3594 3595 retry_strategy = self.base_client.get_preferred_retry_strategy( 3596 operation_retry_strategy=kwargs.get('retry_strategy'), 3597 client_retry_strategy=self.retry_strategy 3598 ) 3599 3600 if retry_strategy: 3601 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3602 self.base_client.add_opc_client_retries_header(header_params) 3603 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3604 return retry_strategy.make_retrying_call( 3605 self.base_client.call_api, 3606 resource_path=resource_path, 3607 method=method, 3608 path_params=path_params, 3609 header_params=header_params, 3610 response_type="list[ListenerRuleSummary]") 3611 else: 3612 return self.base_client.call_api( 3613 resource_path=resource_path, 3614 method=method, 3615 path_params=path_params, 3616 header_params=header_params, 3617 response_type="list[ListenerRuleSummary]") 3618 3619 def list_load_balancer_healths(self, compartment_id, **kwargs): 3620 """ 3621 Lists the summary health statuses for all load balancers in the specified compartment. 3622 3623 3624 :param str compartment_id: (required) 3625 The `OCID`__ of the compartment containing the load balancers to return health status information for. 3626 3627 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3628 3629 :param str opc_request_id: (optional) 3630 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3631 particular request, please provide the request ID. 3632 3633 :param int limit: (optional) 3634 For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call. 3635 For important details about how pagination works, see `List Pagination`__. 3636 3637 Example: `50` 3638 3639 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 3640 3641 :param str page: (optional) 3642 For list pagination. The value of the `opc-next-page` response header from the previous \"List\" call. 3643 For important details about how pagination works, see `List Pagination`__. 3644 3645 Example: `3` 3646 3647 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 3648 3649 :param obj retry_strategy: (optional) 3650 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3651 3652 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3653 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3654 3655 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3656 3657 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.LoadBalancerHealthSummary` 3658 :rtype: :class:`~oci.response.Response` 3659 3660 :example: 3661 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_load_balancer_healths.py.html>`__ to see an example of how to use list_load_balancer_healths API. 3662 """ 3663 resource_path = "/loadBalancerHealths" 3664 method = "GET" 3665 3666 # Don't accept unknown kwargs 3667 expected_kwargs = [ 3668 "retry_strategy", 3669 "opc_request_id", 3670 "limit", 3671 "page" 3672 ] 3673 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3674 if extra_kwargs: 3675 raise ValueError( 3676 "list_load_balancer_healths got unknown kwargs: {!r}".format(extra_kwargs)) 3677 3678 query_params = { 3679 "limit": kwargs.get("limit", missing), 3680 "page": kwargs.get("page", missing), 3681 "compartmentId": compartment_id 3682 } 3683 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 3684 3685 header_params = { 3686 "accept": "application/json", 3687 "content-type": "application/json", 3688 "opc-request-id": kwargs.get("opc_request_id", missing) 3689 } 3690 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3691 3692 retry_strategy = self.base_client.get_preferred_retry_strategy( 3693 operation_retry_strategy=kwargs.get('retry_strategy'), 3694 client_retry_strategy=self.retry_strategy 3695 ) 3696 3697 if retry_strategy: 3698 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3699 self.base_client.add_opc_client_retries_header(header_params) 3700 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3701 return retry_strategy.make_retrying_call( 3702 self.base_client.call_api, 3703 resource_path=resource_path, 3704 method=method, 3705 query_params=query_params, 3706 header_params=header_params, 3707 response_type="list[LoadBalancerHealthSummary]") 3708 else: 3709 return self.base_client.call_api( 3710 resource_path=resource_path, 3711 method=method, 3712 query_params=query_params, 3713 header_params=header_params, 3714 response_type="list[LoadBalancerHealthSummary]") 3715 3716 def list_load_balancers(self, compartment_id, **kwargs): 3717 """ 3718 Lists all load balancers in the specified compartment. 3719 3720 3721 :param str compartment_id: (required) 3722 The `OCID`__ of the compartment containing the load balancers to list. 3723 3724 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3725 3726 :param str opc_request_id: (optional) 3727 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3728 particular request, please provide the request ID. 3729 3730 :param int limit: (optional) 3731 For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call. 3732 For important details about how pagination works, see `List Pagination`__. 3733 3734 Example: `50` 3735 3736 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 3737 3738 :param str page: (optional) 3739 For list pagination. The value of the `opc-next-page` response header from the previous \"List\" call. 3740 For important details about how pagination works, see `List Pagination`__. 3741 3742 Example: `3` 3743 3744 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 3745 3746 :param str detail: (optional) 3747 The level of detail to return for each result. Can be `full` or `simple`. 3748 3749 Example: `full` 3750 3751 :param str sort_by: (optional) 3752 The field to sort by. You can provide one sort order (`sortOrder`). Default order for TIMECREATED is descending. 3753 Default order for DISPLAYNAME is ascending. The DISPLAYNAME sort order is case sensitive. 3754 3755 Allowed values are: "TIMECREATED", "DISPLAYNAME" 3756 3757 :param str sort_order: (optional) 3758 The sort order to use, either ascending (`ASC`) or descending (`DESC`). The DISPLAYNAME sort order is case sensitive. 3759 3760 Allowed values are: "ASC", "DESC" 3761 3762 :param str display_name: (optional) 3763 A filter to return only resources that match the given display name exactly. 3764 3765 Example: `example_load_balancer` 3766 3767 :param str lifecycle_state: (optional) 3768 A filter to return only resources that match the given lifecycle state. 3769 3770 Example: `SUCCEEDED` 3771 3772 Allowed values are: "CREATING", "FAILED", "ACTIVE", "DELETING", "DELETED" 3773 3774 :param obj retry_strategy: (optional) 3775 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3776 3777 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3778 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3779 3780 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3781 3782 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.LoadBalancer` 3783 :rtype: :class:`~oci.response.Response` 3784 3785 :example: 3786 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_load_balancers.py.html>`__ to see an example of how to use list_load_balancers API. 3787 """ 3788 resource_path = "/loadBalancers" 3789 method = "GET" 3790 3791 # Don't accept unknown kwargs 3792 expected_kwargs = [ 3793 "retry_strategy", 3794 "opc_request_id", 3795 "limit", 3796 "page", 3797 "detail", 3798 "sort_by", 3799 "sort_order", 3800 "display_name", 3801 "lifecycle_state" 3802 ] 3803 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3804 if extra_kwargs: 3805 raise ValueError( 3806 "list_load_balancers got unknown kwargs: {!r}".format(extra_kwargs)) 3807 3808 if 'sort_by' in kwargs: 3809 sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"] 3810 if kwargs['sort_by'] not in sort_by_allowed_values: 3811 raise ValueError( 3812 "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values) 3813 ) 3814 3815 if 'sort_order' in kwargs: 3816 sort_order_allowed_values = ["ASC", "DESC"] 3817 if kwargs['sort_order'] not in sort_order_allowed_values: 3818 raise ValueError( 3819 "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values) 3820 ) 3821 3822 if 'lifecycle_state' in kwargs: 3823 lifecycle_state_allowed_values = ["CREATING", "FAILED", "ACTIVE", "DELETING", "DELETED"] 3824 if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values: 3825 raise ValueError( 3826 "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values) 3827 ) 3828 3829 query_params = { 3830 "limit": kwargs.get("limit", missing), 3831 "page": kwargs.get("page", missing), 3832 "compartmentId": compartment_id, 3833 "detail": kwargs.get("detail", missing), 3834 "sortBy": kwargs.get("sort_by", missing), 3835 "sortOrder": kwargs.get("sort_order", missing), 3836 "displayName": kwargs.get("display_name", missing), 3837 "lifecycleState": kwargs.get("lifecycle_state", missing) 3838 } 3839 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 3840 3841 header_params = { 3842 "accept": "application/json", 3843 "content-type": "application/json", 3844 "opc-request-id": kwargs.get("opc_request_id", missing) 3845 } 3846 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3847 3848 retry_strategy = self.base_client.get_preferred_retry_strategy( 3849 operation_retry_strategy=kwargs.get('retry_strategy'), 3850 client_retry_strategy=self.retry_strategy 3851 ) 3852 3853 if retry_strategy: 3854 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3855 self.base_client.add_opc_client_retries_header(header_params) 3856 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3857 return retry_strategy.make_retrying_call( 3858 self.base_client.call_api, 3859 resource_path=resource_path, 3860 method=method, 3861 query_params=query_params, 3862 header_params=header_params, 3863 response_type="list[LoadBalancer]") 3864 else: 3865 return self.base_client.call_api( 3866 resource_path=resource_path, 3867 method=method, 3868 query_params=query_params, 3869 header_params=header_params, 3870 response_type="list[LoadBalancer]") 3871 3872 def list_path_route_sets(self, load_balancer_id, **kwargs): 3873 """ 3874 Lists all path route sets associated with the specified load balancer. 3875 3876 3877 :param str load_balancer_id: (required) 3878 The `OCID`__ of the load balancer associated with the path route sets 3879 to retrieve. 3880 3881 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3882 3883 :param str opc_request_id: (optional) 3884 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3885 particular request, please provide the request ID. 3886 3887 :param obj retry_strategy: (optional) 3888 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3889 3890 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3891 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3892 3893 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3894 3895 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.PathRouteSet` 3896 :rtype: :class:`~oci.response.Response` 3897 3898 :example: 3899 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_path_route_sets.py.html>`__ to see an example of how to use list_path_route_sets API. 3900 """ 3901 resource_path = "/loadBalancers/{loadBalancerId}/pathRouteSets" 3902 method = "GET" 3903 3904 # Don't accept unknown kwargs 3905 expected_kwargs = [ 3906 "retry_strategy", 3907 "opc_request_id" 3908 ] 3909 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 3910 if extra_kwargs: 3911 raise ValueError( 3912 "list_path_route_sets got unknown kwargs: {!r}".format(extra_kwargs)) 3913 3914 path_params = { 3915 "loadBalancerId": load_balancer_id 3916 } 3917 3918 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 3919 3920 for (k, v) in six.iteritems(path_params): 3921 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 3922 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 3923 3924 header_params = { 3925 "accept": "application/json", 3926 "content-type": "application/json", 3927 "opc-request-id": kwargs.get("opc_request_id", missing) 3928 } 3929 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 3930 3931 retry_strategy = self.base_client.get_preferred_retry_strategy( 3932 operation_retry_strategy=kwargs.get('retry_strategy'), 3933 client_retry_strategy=self.retry_strategy 3934 ) 3935 3936 if retry_strategy: 3937 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 3938 self.base_client.add_opc_client_retries_header(header_params) 3939 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 3940 return retry_strategy.make_retrying_call( 3941 self.base_client.call_api, 3942 resource_path=resource_path, 3943 method=method, 3944 path_params=path_params, 3945 header_params=header_params, 3946 response_type="list[PathRouteSet]") 3947 else: 3948 return self.base_client.call_api( 3949 resource_path=resource_path, 3950 method=method, 3951 path_params=path_params, 3952 header_params=header_params, 3953 response_type="list[PathRouteSet]") 3954 3955 def list_policies(self, compartment_id, **kwargs): 3956 """ 3957 Lists the available load balancer policies. 3958 3959 3960 :param str compartment_id: (required) 3961 The `OCID`__ of the compartment containing the load balancer policies to list. 3962 3963 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 3964 3965 :param str opc_request_id: (optional) 3966 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 3967 particular request, please provide the request ID. 3968 3969 :param int limit: (optional) 3970 For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call. 3971 For important details about how pagination works, see `List Pagination`__. 3972 3973 Example: `50` 3974 3975 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 3976 3977 :param str page: (optional) 3978 For list pagination. The value of the `opc-next-page` response header from the previous \"List\" call. 3979 For important details about how pagination works, see `List Pagination`__. 3980 3981 Example: `3` 3982 3983 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 3984 3985 :param obj retry_strategy: (optional) 3986 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 3987 3988 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 3989 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 3990 3991 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 3992 3993 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.LoadBalancerPolicy` 3994 :rtype: :class:`~oci.response.Response` 3995 3996 :example: 3997 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_policies.py.html>`__ to see an example of how to use list_policies API. 3998 """ 3999 resource_path = "/loadBalancerPolicies" 4000 method = "GET" 4001 4002 # Don't accept unknown kwargs 4003 expected_kwargs = [ 4004 "retry_strategy", 4005 "opc_request_id", 4006 "limit", 4007 "page" 4008 ] 4009 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4010 if extra_kwargs: 4011 raise ValueError( 4012 "list_policies got unknown kwargs: {!r}".format(extra_kwargs)) 4013 4014 query_params = { 4015 "compartmentId": compartment_id, 4016 "limit": kwargs.get("limit", missing), 4017 "page": kwargs.get("page", missing) 4018 } 4019 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 4020 4021 header_params = { 4022 "accept": "application/json", 4023 "content-type": "application/json", 4024 "opc-request-id": kwargs.get("opc_request_id", missing) 4025 } 4026 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4027 4028 retry_strategy = self.base_client.get_preferred_retry_strategy( 4029 operation_retry_strategy=kwargs.get('retry_strategy'), 4030 client_retry_strategy=self.retry_strategy 4031 ) 4032 4033 if retry_strategy: 4034 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4035 self.base_client.add_opc_client_retries_header(header_params) 4036 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4037 return retry_strategy.make_retrying_call( 4038 self.base_client.call_api, 4039 resource_path=resource_path, 4040 method=method, 4041 query_params=query_params, 4042 header_params=header_params, 4043 response_type="list[LoadBalancerPolicy]") 4044 else: 4045 return self.base_client.call_api( 4046 resource_path=resource_path, 4047 method=method, 4048 query_params=query_params, 4049 header_params=header_params, 4050 response_type="list[LoadBalancerPolicy]") 4051 4052 def list_protocols(self, compartment_id, **kwargs): 4053 """ 4054 Lists all supported traffic protocols. 4055 4056 4057 :param str compartment_id: (required) 4058 The `OCID`__ of the compartment containing the load balancer protocols to list. 4059 4060 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4061 4062 :param str opc_request_id: (optional) 4063 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4064 particular request, please provide the request ID. 4065 4066 :param int limit: (optional) 4067 For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call. 4068 For important details about how pagination works, see `List Pagination`__. 4069 4070 Example: `50` 4071 4072 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4073 4074 :param str page: (optional) 4075 For list pagination. The value of the `opc-next-page` response header from the previous \"List\" call. 4076 For important details about how pagination works, see `List Pagination`__. 4077 4078 Example: `3` 4079 4080 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4081 4082 :param obj retry_strategy: (optional) 4083 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4084 4085 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4086 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4087 4088 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4089 4090 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.LoadBalancerProtocol` 4091 :rtype: :class:`~oci.response.Response` 4092 4093 :example: 4094 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_protocols.py.html>`__ to see an example of how to use list_protocols API. 4095 """ 4096 resource_path = "/loadBalancerProtocols" 4097 method = "GET" 4098 4099 # Don't accept unknown kwargs 4100 expected_kwargs = [ 4101 "retry_strategy", 4102 "opc_request_id", 4103 "limit", 4104 "page" 4105 ] 4106 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4107 if extra_kwargs: 4108 raise ValueError( 4109 "list_protocols got unknown kwargs: {!r}".format(extra_kwargs)) 4110 4111 query_params = { 4112 "compartmentId": compartment_id, 4113 "limit": kwargs.get("limit", missing), 4114 "page": kwargs.get("page", missing) 4115 } 4116 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 4117 4118 header_params = { 4119 "accept": "application/json", 4120 "content-type": "application/json", 4121 "opc-request-id": kwargs.get("opc_request_id", missing) 4122 } 4123 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4124 4125 retry_strategy = self.base_client.get_preferred_retry_strategy( 4126 operation_retry_strategy=kwargs.get('retry_strategy'), 4127 client_retry_strategy=self.retry_strategy 4128 ) 4129 4130 if retry_strategy: 4131 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4132 self.base_client.add_opc_client_retries_header(header_params) 4133 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4134 return retry_strategy.make_retrying_call( 4135 self.base_client.call_api, 4136 resource_path=resource_path, 4137 method=method, 4138 query_params=query_params, 4139 header_params=header_params, 4140 response_type="list[LoadBalancerProtocol]") 4141 else: 4142 return self.base_client.call_api( 4143 resource_path=resource_path, 4144 method=method, 4145 query_params=query_params, 4146 header_params=header_params, 4147 response_type="list[LoadBalancerProtocol]") 4148 4149 def list_routing_policies(self, load_balancer_id, **kwargs): 4150 """ 4151 Lists all routing policies associated with the specified load balancer. 4152 4153 4154 :param str load_balancer_id: (required) 4155 The `OCID`__ of the load balancer associated with the routing policies. 4156 4157 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4158 4159 :param str opc_request_id: (optional) 4160 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4161 particular request, please provide the request ID. 4162 4163 :param int limit: (optional) 4164 For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call. 4165 For important details about how pagination works, see `List Pagination`__. 4166 4167 Example: `50` 4168 4169 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4170 4171 :param str page: (optional) 4172 For list pagination. The value of the `opc-next-page` response header from the previous \"List\" call. 4173 For important details about how pagination works, see `List Pagination`__. 4174 4175 Example: `3` 4176 4177 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4178 4179 :param obj retry_strategy: (optional) 4180 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4181 4182 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4183 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4184 4185 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4186 4187 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.RoutingPolicy` 4188 :rtype: :class:`~oci.response.Response` 4189 4190 :example: 4191 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_routing_policies.py.html>`__ to see an example of how to use list_routing_policies API. 4192 """ 4193 resource_path = "/loadBalancers/{loadBalancerId}/routingPolicies" 4194 method = "GET" 4195 4196 # Don't accept unknown kwargs 4197 expected_kwargs = [ 4198 "retry_strategy", 4199 "opc_request_id", 4200 "limit", 4201 "page" 4202 ] 4203 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4204 if extra_kwargs: 4205 raise ValueError( 4206 "list_routing_policies got unknown kwargs: {!r}".format(extra_kwargs)) 4207 4208 path_params = { 4209 "loadBalancerId": load_balancer_id 4210 } 4211 4212 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4213 4214 for (k, v) in six.iteritems(path_params): 4215 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4216 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4217 4218 query_params = { 4219 "limit": kwargs.get("limit", missing), 4220 "page": kwargs.get("page", missing) 4221 } 4222 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 4223 4224 header_params = { 4225 "accept": "application/json", 4226 "content-type": "application/json", 4227 "opc-request-id": kwargs.get("opc_request_id", missing) 4228 } 4229 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4230 4231 retry_strategy = self.base_client.get_preferred_retry_strategy( 4232 operation_retry_strategy=kwargs.get('retry_strategy'), 4233 client_retry_strategy=self.retry_strategy 4234 ) 4235 4236 if retry_strategy: 4237 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4238 self.base_client.add_opc_client_retries_header(header_params) 4239 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4240 return retry_strategy.make_retrying_call( 4241 self.base_client.call_api, 4242 resource_path=resource_path, 4243 method=method, 4244 path_params=path_params, 4245 query_params=query_params, 4246 header_params=header_params, 4247 response_type="list[RoutingPolicy]") 4248 else: 4249 return self.base_client.call_api( 4250 resource_path=resource_path, 4251 method=method, 4252 path_params=path_params, 4253 query_params=query_params, 4254 header_params=header_params, 4255 response_type="list[RoutingPolicy]") 4256 4257 def list_rule_sets(self, load_balancer_id, **kwargs): 4258 """ 4259 Lists all rule sets associated with the specified load balancer. 4260 4261 4262 :param str load_balancer_id: (required) 4263 The `OCID`__ of the specified load balancer. 4264 4265 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4266 4267 :param str opc_request_id: (optional) 4268 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4269 particular request, please provide the request ID. 4270 4271 :param obj retry_strategy: (optional) 4272 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4273 4274 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4275 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4276 4277 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4278 4279 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.RuleSet` 4280 :rtype: :class:`~oci.response.Response` 4281 4282 :example: 4283 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_rule_sets.py.html>`__ to see an example of how to use list_rule_sets API. 4284 """ 4285 resource_path = "/loadBalancers/{loadBalancerId}/ruleSets" 4286 method = "GET" 4287 4288 # Don't accept unknown kwargs 4289 expected_kwargs = [ 4290 "retry_strategy", 4291 "opc_request_id" 4292 ] 4293 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4294 if extra_kwargs: 4295 raise ValueError( 4296 "list_rule_sets got unknown kwargs: {!r}".format(extra_kwargs)) 4297 4298 path_params = { 4299 "loadBalancerId": load_balancer_id 4300 } 4301 4302 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4303 4304 for (k, v) in six.iteritems(path_params): 4305 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4306 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4307 4308 header_params = { 4309 "accept": "application/json", 4310 "content-type": "application/json", 4311 "opc-request-id": kwargs.get("opc_request_id", missing) 4312 } 4313 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4314 4315 retry_strategy = self.base_client.get_preferred_retry_strategy( 4316 operation_retry_strategy=kwargs.get('retry_strategy'), 4317 client_retry_strategy=self.retry_strategy 4318 ) 4319 4320 if retry_strategy: 4321 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4322 self.base_client.add_opc_client_retries_header(header_params) 4323 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4324 return retry_strategy.make_retrying_call( 4325 self.base_client.call_api, 4326 resource_path=resource_path, 4327 method=method, 4328 path_params=path_params, 4329 header_params=header_params, 4330 response_type="list[RuleSet]") 4331 else: 4332 return self.base_client.call_api( 4333 resource_path=resource_path, 4334 method=method, 4335 path_params=path_params, 4336 header_params=header_params, 4337 response_type="list[RuleSet]") 4338 4339 def list_shapes(self, compartment_id, **kwargs): 4340 """ 4341 Lists the valid load balancer shapes. 4342 4343 4344 :param str compartment_id: (required) 4345 The `OCID`__ of the compartment containing the load balancer shapes to list. 4346 4347 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4348 4349 :param str opc_request_id: (optional) 4350 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4351 particular request, please provide the request ID. 4352 4353 :param int limit: (optional) 4354 For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call. 4355 For important details about how pagination works, see `List Pagination`__. 4356 4357 Example: `50` 4358 4359 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4360 4361 :param str page: (optional) 4362 For list pagination. The value of the `opc-next-page` response header from the previous \"List\" call. 4363 For important details about how pagination works, see `List Pagination`__. 4364 4365 Example: `3` 4366 4367 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4368 4369 :param obj retry_strategy: (optional) 4370 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4371 4372 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4373 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4374 4375 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4376 4377 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.LoadBalancerShape` 4378 :rtype: :class:`~oci.response.Response` 4379 4380 :example: 4381 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_shapes.py.html>`__ to see an example of how to use list_shapes API. 4382 """ 4383 resource_path = "/loadBalancerShapes" 4384 method = "GET" 4385 4386 # Don't accept unknown kwargs 4387 expected_kwargs = [ 4388 "retry_strategy", 4389 "opc_request_id", 4390 "limit", 4391 "page" 4392 ] 4393 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4394 if extra_kwargs: 4395 raise ValueError( 4396 "list_shapes got unknown kwargs: {!r}".format(extra_kwargs)) 4397 4398 query_params = { 4399 "compartmentId": compartment_id, 4400 "limit": kwargs.get("limit", missing), 4401 "page": kwargs.get("page", missing) 4402 } 4403 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 4404 4405 header_params = { 4406 "accept": "application/json", 4407 "content-type": "application/json", 4408 "opc-request-id": kwargs.get("opc_request_id", missing) 4409 } 4410 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4411 4412 retry_strategy = self.base_client.get_preferred_retry_strategy( 4413 operation_retry_strategy=kwargs.get('retry_strategy'), 4414 client_retry_strategy=self.retry_strategy 4415 ) 4416 4417 if retry_strategy: 4418 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4419 self.base_client.add_opc_client_retries_header(header_params) 4420 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4421 return retry_strategy.make_retrying_call( 4422 self.base_client.call_api, 4423 resource_path=resource_path, 4424 method=method, 4425 query_params=query_params, 4426 header_params=header_params, 4427 response_type="list[LoadBalancerShape]") 4428 else: 4429 return self.base_client.call_api( 4430 resource_path=resource_path, 4431 method=method, 4432 query_params=query_params, 4433 header_params=header_params, 4434 response_type="list[LoadBalancerShape]") 4435 4436 def list_ssl_cipher_suites(self, load_balancer_id, **kwargs): 4437 """ 4438 Lists all SSL cipher suites associated with the specified load balancer. 4439 4440 4441 :param str load_balancer_id: (required) 4442 The `OCID`__ of the associated load balancer. 4443 4444 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4445 4446 :param str opc_request_id: (optional) 4447 Unique Oracle-assigned identifier for the request. If you need to contact Oracle about 4448 a particular request, please provide the request ID. 4449 4450 :param obj retry_strategy: (optional) 4451 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4452 4453 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4454 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4455 4456 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4457 4458 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.SSLCipherSuite` 4459 :rtype: :class:`~oci.response.Response` 4460 4461 :example: 4462 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_ssl_cipher_suites.py.html>`__ to see an example of how to use list_ssl_cipher_suites API. 4463 """ 4464 resource_path = "/loadBalancers/{loadBalancerId}/sslCipherSuites" 4465 method = "GET" 4466 4467 # Don't accept unknown kwargs 4468 expected_kwargs = [ 4469 "retry_strategy", 4470 "opc_request_id" 4471 ] 4472 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4473 if extra_kwargs: 4474 raise ValueError( 4475 "list_ssl_cipher_suites got unknown kwargs: {!r}".format(extra_kwargs)) 4476 4477 path_params = { 4478 "loadBalancerId": load_balancer_id 4479 } 4480 4481 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4482 4483 for (k, v) in six.iteritems(path_params): 4484 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4485 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4486 4487 header_params = { 4488 "accept": "application/json", 4489 "content-type": "application/json", 4490 "opc-request-id": kwargs.get("opc_request_id", missing) 4491 } 4492 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4493 4494 retry_strategy = self.base_client.get_preferred_retry_strategy( 4495 operation_retry_strategy=kwargs.get('retry_strategy'), 4496 client_retry_strategy=self.retry_strategy 4497 ) 4498 4499 if retry_strategy: 4500 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4501 self.base_client.add_opc_client_retries_header(header_params) 4502 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4503 return retry_strategy.make_retrying_call( 4504 self.base_client.call_api, 4505 resource_path=resource_path, 4506 method=method, 4507 path_params=path_params, 4508 header_params=header_params, 4509 response_type="list[SSLCipherSuite]") 4510 else: 4511 return self.base_client.call_api( 4512 resource_path=resource_path, 4513 method=method, 4514 path_params=path_params, 4515 header_params=header_params, 4516 response_type="list[SSLCipherSuite]") 4517 4518 def list_work_requests(self, load_balancer_id, **kwargs): 4519 """ 4520 Lists the work requests for a given load balancer. 4521 4522 4523 :param str load_balancer_id: (required) 4524 The `OCID`__ of the load balancer associated with the work requests to retrieve. 4525 4526 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4527 4528 :param str opc_request_id: (optional) 4529 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4530 particular request, please provide the request ID. 4531 4532 :param int limit: (optional) 4533 For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call. 4534 For important details about how pagination works, see `List Pagination`__. 4535 4536 Example: `50` 4537 4538 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4539 4540 :param str page: (optional) 4541 For list pagination. The value of the `opc-next-page` response header from the previous \"List\" call. 4542 For important details about how pagination works, see `List Pagination`__. 4543 4544 Example: `3` 4545 4546 __ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine 4547 4548 :param obj retry_strategy: (optional) 4549 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4550 4551 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4552 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4553 4554 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4555 4556 :return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.load_balancer.models.WorkRequest` 4557 :rtype: :class:`~oci.response.Response` 4558 4559 :example: 4560 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/list_work_requests.py.html>`__ to see an example of how to use list_work_requests API. 4561 """ 4562 resource_path = "/loadBalancers/{loadBalancerId}/workRequests" 4563 method = "GET" 4564 4565 # Don't accept unknown kwargs 4566 expected_kwargs = [ 4567 "retry_strategy", 4568 "opc_request_id", 4569 "limit", 4570 "page" 4571 ] 4572 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4573 if extra_kwargs: 4574 raise ValueError( 4575 "list_work_requests got unknown kwargs: {!r}".format(extra_kwargs)) 4576 4577 path_params = { 4578 "loadBalancerId": load_balancer_id 4579 } 4580 4581 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4582 4583 for (k, v) in six.iteritems(path_params): 4584 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4585 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4586 4587 query_params = { 4588 "limit": kwargs.get("limit", missing), 4589 "page": kwargs.get("page", missing) 4590 } 4591 query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None} 4592 4593 header_params = { 4594 "accept": "application/json", 4595 "content-type": "application/json", 4596 "opc-request-id": kwargs.get("opc_request_id", missing) 4597 } 4598 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4599 4600 retry_strategy = self.base_client.get_preferred_retry_strategy( 4601 operation_retry_strategy=kwargs.get('retry_strategy'), 4602 client_retry_strategy=self.retry_strategy 4603 ) 4604 4605 if retry_strategy: 4606 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4607 self.base_client.add_opc_client_retries_header(header_params) 4608 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4609 return retry_strategy.make_retrying_call( 4610 self.base_client.call_api, 4611 resource_path=resource_path, 4612 method=method, 4613 path_params=path_params, 4614 query_params=query_params, 4615 header_params=header_params, 4616 response_type="list[WorkRequest]") 4617 else: 4618 return self.base_client.call_api( 4619 resource_path=resource_path, 4620 method=method, 4621 path_params=path_params, 4622 query_params=query_params, 4623 header_params=header_params, 4624 response_type="list[WorkRequest]") 4625 4626 def update_backend(self, update_backend_details, load_balancer_id, backend_set_name, backend_name, **kwargs): 4627 """ 4628 Updates the configuration of a backend server within the specified backend set. 4629 4630 4631 :param oci.load_balancer.models.UpdateBackendDetails update_backend_details: (required) 4632 Details for updating a backend server. 4633 4634 :param str load_balancer_id: (required) 4635 The `OCID`__ of the load balancer associated with the backend set and server. 4636 4637 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4638 4639 :param str backend_set_name: (required) 4640 The name of the backend set associated with the backend server. 4641 4642 Example: `example_backend_set` 4643 4644 :param str backend_name: (required) 4645 The IP address and port of the backend server to update. 4646 4647 Example: `10.0.0.3:8080` 4648 4649 :param str opc_request_id: (optional) 4650 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4651 particular request, please provide the request ID. 4652 4653 :param str opc_retry_token: (optional) 4654 A token that uniquely identifies a request so it can be retried in case of a timeout or 4655 server error without risk of executing that same action again. Retry tokens expire after 24 4656 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 4657 has been deleted and purged from the system, then a retry of the original creation request 4658 may be rejected). 4659 4660 :param obj retry_strategy: (optional) 4661 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4662 4663 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4664 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4665 4666 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4667 4668 :return: A :class:`~oci.response.Response` object with data of type None 4669 :rtype: :class:`~oci.response.Response` 4670 4671 :example: 4672 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_backend.py.html>`__ to see an example of how to use update_backend API. 4673 """ 4674 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/backends/{backendName}" 4675 method = "PUT" 4676 4677 # Don't accept unknown kwargs 4678 expected_kwargs = [ 4679 "retry_strategy", 4680 "opc_request_id", 4681 "opc_retry_token" 4682 ] 4683 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4684 if extra_kwargs: 4685 raise ValueError( 4686 "update_backend got unknown kwargs: {!r}".format(extra_kwargs)) 4687 4688 path_params = { 4689 "loadBalancerId": load_balancer_id, 4690 "backendSetName": backend_set_name, 4691 "backendName": backend_name 4692 } 4693 4694 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4695 4696 for (k, v) in six.iteritems(path_params): 4697 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4698 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4699 4700 header_params = { 4701 "accept": "application/json", 4702 "content-type": "application/json", 4703 "opc-request-id": kwargs.get("opc_request_id", missing), 4704 "opc-retry-token": kwargs.get("opc_retry_token", missing) 4705 } 4706 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4707 4708 retry_strategy = self.base_client.get_preferred_retry_strategy( 4709 operation_retry_strategy=kwargs.get('retry_strategy'), 4710 client_retry_strategy=self.retry_strategy 4711 ) 4712 4713 if retry_strategy: 4714 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4715 self.base_client.add_opc_retry_token_if_needed(header_params) 4716 self.base_client.add_opc_client_retries_header(header_params) 4717 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4718 return retry_strategy.make_retrying_call( 4719 self.base_client.call_api, 4720 resource_path=resource_path, 4721 method=method, 4722 path_params=path_params, 4723 header_params=header_params, 4724 body=update_backend_details) 4725 else: 4726 return self.base_client.call_api( 4727 resource_path=resource_path, 4728 method=method, 4729 path_params=path_params, 4730 header_params=header_params, 4731 body=update_backend_details) 4732 4733 def update_backend_set(self, update_backend_set_details, load_balancer_id, backend_set_name, **kwargs): 4734 """ 4735 Updates a backend set. 4736 4737 4738 :param oci.load_balancer.models.UpdateBackendSetDetails update_backend_set_details: (required) 4739 The details to update a backend set. 4740 4741 :param str load_balancer_id: (required) 4742 The `OCID`__ of the load balancer associated with the backend set. 4743 4744 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4745 4746 :param str backend_set_name: (required) 4747 The name of the backend set to update. 4748 4749 Example: `example_backend_set` 4750 4751 :param str opc_request_id: (optional) 4752 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4753 particular request, please provide the request ID. 4754 4755 :param str opc_retry_token: (optional) 4756 A token that uniquely identifies a request so it can be retried in case of a timeout or 4757 server error without risk of executing that same action again. Retry tokens expire after 24 4758 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 4759 has been deleted and purged from the system, then a retry of the original creation request 4760 may be rejected). 4761 4762 :param obj retry_strategy: (optional) 4763 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4764 4765 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4766 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4767 4768 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4769 4770 :return: A :class:`~oci.response.Response` object with data of type None 4771 :rtype: :class:`~oci.response.Response` 4772 4773 :example: 4774 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_backend_set.py.html>`__ to see an example of how to use update_backend_set API. 4775 """ 4776 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}" 4777 method = "PUT" 4778 4779 # Don't accept unknown kwargs 4780 expected_kwargs = [ 4781 "retry_strategy", 4782 "opc_request_id", 4783 "opc_retry_token" 4784 ] 4785 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4786 if extra_kwargs: 4787 raise ValueError( 4788 "update_backend_set got unknown kwargs: {!r}".format(extra_kwargs)) 4789 4790 path_params = { 4791 "loadBalancerId": load_balancer_id, 4792 "backendSetName": backend_set_name 4793 } 4794 4795 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4796 4797 for (k, v) in six.iteritems(path_params): 4798 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4799 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4800 4801 header_params = { 4802 "accept": "application/json", 4803 "content-type": "application/json", 4804 "opc-request-id": kwargs.get("opc_request_id", missing), 4805 "opc-retry-token": kwargs.get("opc_retry_token", missing) 4806 } 4807 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4808 4809 retry_strategy = self.base_client.get_preferred_retry_strategy( 4810 operation_retry_strategy=kwargs.get('retry_strategy'), 4811 client_retry_strategy=self.retry_strategy 4812 ) 4813 4814 if retry_strategy: 4815 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4816 self.base_client.add_opc_retry_token_if_needed(header_params) 4817 self.base_client.add_opc_client_retries_header(header_params) 4818 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4819 return retry_strategy.make_retrying_call( 4820 self.base_client.call_api, 4821 resource_path=resource_path, 4822 method=method, 4823 path_params=path_params, 4824 header_params=header_params, 4825 body=update_backend_set_details) 4826 else: 4827 return self.base_client.call_api( 4828 resource_path=resource_path, 4829 method=method, 4830 path_params=path_params, 4831 header_params=header_params, 4832 body=update_backend_set_details) 4833 4834 def update_health_checker(self, health_checker, load_balancer_id, backend_set_name, **kwargs): 4835 """ 4836 Updates the health check policy for a given load balancer and backend set. 4837 4838 4839 :param oci.load_balancer.models.UpdateHealthCheckerDetails health_checker: (required) 4840 The health check policy configuration details. 4841 4842 :param str load_balancer_id: (required) 4843 The `OCID`__ of the load balancer associated with the health check policy to be updated. 4844 4845 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4846 4847 :param str backend_set_name: (required) 4848 The name of the backend set associated with the health check policy to be retrieved. 4849 4850 Example: `example_backend_set` 4851 4852 :param str opc_request_id: (optional) 4853 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4854 particular request, please provide the request ID. 4855 4856 :param str opc_retry_token: (optional) 4857 A token that uniquely identifies a request so it can be retried in case of a timeout or 4858 server error without risk of executing that same action again. Retry tokens expire after 24 4859 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 4860 has been deleted and purged from the system, then a retry of the original creation request 4861 may be rejected). 4862 4863 :param obj retry_strategy: (optional) 4864 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4865 4866 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4867 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4868 4869 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4870 4871 :return: A :class:`~oci.response.Response` object with data of type None 4872 :rtype: :class:`~oci.response.Response` 4873 4874 :example: 4875 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_health_checker.py.html>`__ to see an example of how to use update_health_checker API. 4876 """ 4877 resource_path = "/loadBalancers/{loadBalancerId}/backendSets/{backendSetName}/healthChecker" 4878 method = "PUT" 4879 4880 # Don't accept unknown kwargs 4881 expected_kwargs = [ 4882 "retry_strategy", 4883 "opc_request_id", 4884 "opc_retry_token" 4885 ] 4886 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4887 if extra_kwargs: 4888 raise ValueError( 4889 "update_health_checker got unknown kwargs: {!r}".format(extra_kwargs)) 4890 4891 path_params = { 4892 "loadBalancerId": load_balancer_id, 4893 "backendSetName": backend_set_name 4894 } 4895 4896 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4897 4898 for (k, v) in six.iteritems(path_params): 4899 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4900 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4901 4902 header_params = { 4903 "accept": "application/json", 4904 "content-type": "application/json", 4905 "opc-request-id": kwargs.get("opc_request_id", missing), 4906 "opc-retry-token": kwargs.get("opc_retry_token", missing) 4907 } 4908 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 4909 4910 retry_strategy = self.base_client.get_preferred_retry_strategy( 4911 operation_retry_strategy=kwargs.get('retry_strategy'), 4912 client_retry_strategy=self.retry_strategy 4913 ) 4914 4915 if retry_strategy: 4916 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 4917 self.base_client.add_opc_retry_token_if_needed(header_params) 4918 self.base_client.add_opc_client_retries_header(header_params) 4919 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 4920 return retry_strategy.make_retrying_call( 4921 self.base_client.call_api, 4922 resource_path=resource_path, 4923 method=method, 4924 path_params=path_params, 4925 header_params=header_params, 4926 body=health_checker) 4927 else: 4928 return self.base_client.call_api( 4929 resource_path=resource_path, 4930 method=method, 4931 path_params=path_params, 4932 header_params=header_params, 4933 body=health_checker) 4934 4935 def update_hostname(self, update_hostname_details, load_balancer_id, name, **kwargs): 4936 """ 4937 Overwrites an existing hostname resource on the specified load balancer. Use this operation to change a 4938 virtual hostname. 4939 4940 4941 :param oci.load_balancer.models.UpdateHostnameDetails update_hostname_details: (required) 4942 The configuration details to update a virtual hostname. 4943 4944 :param str load_balancer_id: (required) 4945 The `OCID`__ of the load balancer associated with the virtual hostname 4946 to update. 4947 4948 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 4949 4950 :param str name: (required) 4951 The name of the hostname resource to update. 4952 4953 Example: `example_hostname_001` 4954 4955 :param str opc_request_id: (optional) 4956 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 4957 particular request, please provide the request ID. 4958 4959 :param obj retry_strategy: (optional) 4960 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 4961 4962 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 4963 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 4964 4965 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 4966 4967 :return: A :class:`~oci.response.Response` object with data of type None 4968 :rtype: :class:`~oci.response.Response` 4969 4970 :example: 4971 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_hostname.py.html>`__ to see an example of how to use update_hostname API. 4972 """ 4973 resource_path = "/loadBalancers/{loadBalancerId}/hostnames/{name}" 4974 method = "PUT" 4975 4976 # Don't accept unknown kwargs 4977 expected_kwargs = [ 4978 "retry_strategy", 4979 "opc_request_id" 4980 ] 4981 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 4982 if extra_kwargs: 4983 raise ValueError( 4984 "update_hostname got unknown kwargs: {!r}".format(extra_kwargs)) 4985 4986 path_params = { 4987 "loadBalancerId": load_balancer_id, 4988 "name": name 4989 } 4990 4991 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 4992 4993 for (k, v) in six.iteritems(path_params): 4994 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 4995 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 4996 4997 header_params = { 4998 "accept": "application/json", 4999 "content-type": "application/json", 5000 "opc-request-id": kwargs.get("opc_request_id", missing) 5001 } 5002 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5003 5004 retry_strategy = self.base_client.get_preferred_retry_strategy( 5005 operation_retry_strategy=kwargs.get('retry_strategy'), 5006 client_retry_strategy=self.retry_strategy 5007 ) 5008 5009 if retry_strategy: 5010 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5011 self.base_client.add_opc_client_retries_header(header_params) 5012 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5013 return retry_strategy.make_retrying_call( 5014 self.base_client.call_api, 5015 resource_path=resource_path, 5016 method=method, 5017 path_params=path_params, 5018 header_params=header_params, 5019 body=update_hostname_details) 5020 else: 5021 return self.base_client.call_api( 5022 resource_path=resource_path, 5023 method=method, 5024 path_params=path_params, 5025 header_params=header_params, 5026 body=update_hostname_details) 5027 5028 def update_listener(self, update_listener_details, load_balancer_id, listener_name, **kwargs): 5029 """ 5030 Updates a listener for a given load balancer. 5031 5032 5033 :param oci.load_balancer.models.UpdateListenerDetails update_listener_details: (required) 5034 Details to update a listener. 5035 5036 :param str load_balancer_id: (required) 5037 The `OCID`__ of the load balancer associated with the listener to update. 5038 5039 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 5040 5041 :param str listener_name: (required) 5042 The name of the listener to update. 5043 5044 Example: `example_listener` 5045 5046 :param str opc_request_id: (optional) 5047 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 5048 particular request, please provide the request ID. 5049 5050 :param str opc_retry_token: (optional) 5051 A token that uniquely identifies a request so it can be retried in case of a timeout or 5052 server error without risk of executing that same action again. Retry tokens expire after 24 5053 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 5054 has been deleted and purged from the system, then a retry of the original creation request 5055 may be rejected). 5056 5057 :param obj retry_strategy: (optional) 5058 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5059 5060 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5061 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5062 5063 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5064 5065 :return: A :class:`~oci.response.Response` object with data of type None 5066 :rtype: :class:`~oci.response.Response` 5067 5068 :example: 5069 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_listener.py.html>`__ to see an example of how to use update_listener API. 5070 """ 5071 resource_path = "/loadBalancers/{loadBalancerId}/listeners/{listenerName}" 5072 method = "PUT" 5073 5074 # Don't accept unknown kwargs 5075 expected_kwargs = [ 5076 "retry_strategy", 5077 "opc_request_id", 5078 "opc_retry_token" 5079 ] 5080 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5081 if extra_kwargs: 5082 raise ValueError( 5083 "update_listener got unknown kwargs: {!r}".format(extra_kwargs)) 5084 5085 path_params = { 5086 "loadBalancerId": load_balancer_id, 5087 "listenerName": listener_name 5088 } 5089 5090 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5091 5092 for (k, v) in six.iteritems(path_params): 5093 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5094 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5095 5096 header_params = { 5097 "accept": "application/json", 5098 "content-type": "application/json", 5099 "opc-request-id": kwargs.get("opc_request_id", missing), 5100 "opc-retry-token": kwargs.get("opc_retry_token", missing) 5101 } 5102 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5103 5104 retry_strategy = self.base_client.get_preferred_retry_strategy( 5105 operation_retry_strategy=kwargs.get('retry_strategy'), 5106 client_retry_strategy=self.retry_strategy 5107 ) 5108 5109 if retry_strategy: 5110 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5111 self.base_client.add_opc_retry_token_if_needed(header_params) 5112 self.base_client.add_opc_client_retries_header(header_params) 5113 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5114 return retry_strategy.make_retrying_call( 5115 self.base_client.call_api, 5116 resource_path=resource_path, 5117 method=method, 5118 path_params=path_params, 5119 header_params=header_params, 5120 body=update_listener_details) 5121 else: 5122 return self.base_client.call_api( 5123 resource_path=resource_path, 5124 method=method, 5125 path_params=path_params, 5126 header_params=header_params, 5127 body=update_listener_details) 5128 5129 def update_load_balancer(self, update_load_balancer_details, load_balancer_id, **kwargs): 5130 """ 5131 Updates a load balancer's configuration. 5132 5133 5134 :param oci.load_balancer.models.UpdateLoadBalancerDetails update_load_balancer_details: (required) 5135 The details for updating a load balancer's configuration. 5136 5137 :param str load_balancer_id: (required) 5138 The `OCID`__ of the load balancer to update. 5139 5140 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 5141 5142 :param str opc_request_id: (optional) 5143 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 5144 particular request, please provide the request ID. 5145 5146 :param str opc_retry_token: (optional) 5147 A token that uniquely identifies a request so it can be retried in case of a timeout or 5148 server error without risk of executing that same action again. Retry tokens expire after 24 5149 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 5150 has been deleted and purged from the system, then a retry of the original creation request 5151 may be rejected). 5152 5153 :param obj retry_strategy: (optional) 5154 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5155 5156 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5157 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5158 5159 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5160 5161 :return: A :class:`~oci.response.Response` object with data of type None 5162 :rtype: :class:`~oci.response.Response` 5163 5164 :example: 5165 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_load_balancer.py.html>`__ to see an example of how to use update_load_balancer API. 5166 """ 5167 resource_path = "/loadBalancers/{loadBalancerId}" 5168 method = "PUT" 5169 5170 # Don't accept unknown kwargs 5171 expected_kwargs = [ 5172 "retry_strategy", 5173 "opc_request_id", 5174 "opc_retry_token" 5175 ] 5176 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5177 if extra_kwargs: 5178 raise ValueError( 5179 "update_load_balancer got unknown kwargs: {!r}".format(extra_kwargs)) 5180 5181 path_params = { 5182 "loadBalancerId": load_balancer_id 5183 } 5184 5185 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5186 5187 for (k, v) in six.iteritems(path_params): 5188 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5189 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5190 5191 header_params = { 5192 "accept": "application/json", 5193 "content-type": "application/json", 5194 "opc-request-id": kwargs.get("opc_request_id", missing), 5195 "opc-retry-token": kwargs.get("opc_retry_token", missing) 5196 } 5197 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5198 5199 retry_strategy = self.base_client.get_preferred_retry_strategy( 5200 operation_retry_strategy=kwargs.get('retry_strategy'), 5201 client_retry_strategy=self.retry_strategy 5202 ) 5203 5204 if retry_strategy: 5205 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5206 self.base_client.add_opc_retry_token_if_needed(header_params) 5207 self.base_client.add_opc_client_retries_header(header_params) 5208 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5209 return retry_strategy.make_retrying_call( 5210 self.base_client.call_api, 5211 resource_path=resource_path, 5212 method=method, 5213 path_params=path_params, 5214 header_params=header_params, 5215 body=update_load_balancer_details) 5216 else: 5217 return self.base_client.call_api( 5218 resource_path=resource_path, 5219 method=method, 5220 path_params=path_params, 5221 header_params=header_params, 5222 body=update_load_balancer_details) 5223 5224 def update_load_balancer_shape(self, load_balancer_id, update_load_balancer_shape_details, **kwargs): 5225 """ 5226 Update the shape of a load balancer. The new shape can be larger or smaller compared to existing shape of the 5227 LB. The service will try to perform this operation in the least disruptive way to existing connections, but 5228 there is a possibility that they might be lost during the LB resizing process. The new shape becomes effective 5229 as soon as the related work request completes successfully, i.e. when reshaping to a larger shape, the LB will 5230 start accepting larger bandwidth and when reshaping to a smaller one, the LB will be accepting smaller 5231 bandwidth. 5232 5233 5234 :param str load_balancer_id: (required) 5235 The `OCID`__ of the load balancer whose shape will be updated. 5236 5237 __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm 5238 5239 :param oci.load_balancer.models.UpdateLoadBalancerShapeDetails update_load_balancer_shape_details: (required) 5240 The details for updating a load balancer's shape. This contains the new, desired shape. 5241 5242 :param str opc_request_id: (optional) 5243 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 5244 particular request, please provide the request ID. 5245 5246 :param str opc_retry_token: (optional) 5247 A token that uniquely identifies a request so it can be retried in case of a timeout or 5248 server error without risk of executing that same action again. Retry tokens expire after 24 5249 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 5250 has been deleted and purged from the system, then a retry of the original creation request 5251 may be rejected). 5252 5253 :param obj retry_strategy: (optional) 5254 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5255 5256 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5257 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5258 5259 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5260 5261 :return: A :class:`~oci.response.Response` object with data of type None 5262 :rtype: :class:`~oci.response.Response` 5263 5264 :example: 5265 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_load_balancer_shape.py.html>`__ to see an example of how to use update_load_balancer_shape API. 5266 """ 5267 resource_path = "/loadBalancers/{loadBalancerId}/updateShape" 5268 method = "PUT" 5269 5270 # Don't accept unknown kwargs 5271 expected_kwargs = [ 5272 "retry_strategy", 5273 "opc_request_id", 5274 "opc_retry_token" 5275 ] 5276 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5277 if extra_kwargs: 5278 raise ValueError( 5279 "update_load_balancer_shape got unknown kwargs: {!r}".format(extra_kwargs)) 5280 5281 path_params = { 5282 "loadBalancerId": load_balancer_id 5283 } 5284 5285 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5286 5287 for (k, v) in six.iteritems(path_params): 5288 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5289 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5290 5291 header_params = { 5292 "accept": "application/json", 5293 "content-type": "application/json", 5294 "opc-request-id": kwargs.get("opc_request_id", missing), 5295 "opc-retry-token": kwargs.get("opc_retry_token", missing) 5296 } 5297 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5298 5299 retry_strategy = self.base_client.get_preferred_retry_strategy( 5300 operation_retry_strategy=kwargs.get('retry_strategy'), 5301 client_retry_strategy=self.retry_strategy 5302 ) 5303 5304 if retry_strategy: 5305 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5306 self.base_client.add_opc_retry_token_if_needed(header_params) 5307 self.base_client.add_opc_client_retries_header(header_params) 5308 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5309 return retry_strategy.make_retrying_call( 5310 self.base_client.call_api, 5311 resource_path=resource_path, 5312 method=method, 5313 path_params=path_params, 5314 header_params=header_params, 5315 body=update_load_balancer_shape_details) 5316 else: 5317 return self.base_client.call_api( 5318 resource_path=resource_path, 5319 method=method, 5320 path_params=path_params, 5321 header_params=header_params, 5322 body=update_load_balancer_shape_details) 5323 5324 def update_network_security_groups(self, update_network_security_groups_details, load_balancer_id, **kwargs): 5325 """ 5326 Updates the network security groups associated with the specified load balancer. 5327 5328 5329 :param oci.load_balancer.models.UpdateNetworkSecurityGroupsDetails update_network_security_groups_details: (required) 5330 The details for updating the NSGs associated with the specified load balancer. 5331 5332 :param str load_balancer_id: (required) 5333 The `OCID`__ of the load balancer to update the NSGs for. 5334 5335 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 5336 5337 :param str opc_request_id: (optional) 5338 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 5339 particular request, please provide the request ID. 5340 5341 :param str opc_retry_token: (optional) 5342 A token that uniquely identifies a request so it can be retried in case of a timeout or 5343 server error without risk of executing that same action again. Retry tokens expire after 24 5344 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 5345 has been deleted and purged from the system, then a retry of the original creation request 5346 may be rejected). 5347 5348 :param obj retry_strategy: (optional) 5349 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5350 5351 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5352 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5353 5354 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5355 5356 :return: A :class:`~oci.response.Response` object with data of type None 5357 :rtype: :class:`~oci.response.Response` 5358 5359 :example: 5360 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_network_security_groups.py.html>`__ to see an example of how to use update_network_security_groups API. 5361 """ 5362 resource_path = "/loadBalancers/{loadBalancerId}/networkSecurityGroups" 5363 method = "PUT" 5364 5365 # Don't accept unknown kwargs 5366 expected_kwargs = [ 5367 "retry_strategy", 5368 "opc_request_id", 5369 "opc_retry_token" 5370 ] 5371 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5372 if extra_kwargs: 5373 raise ValueError( 5374 "update_network_security_groups got unknown kwargs: {!r}".format(extra_kwargs)) 5375 5376 path_params = { 5377 "loadBalancerId": load_balancer_id 5378 } 5379 5380 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5381 5382 for (k, v) in six.iteritems(path_params): 5383 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5384 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5385 5386 header_params = { 5387 "accept": "application/json", 5388 "content-type": "application/json", 5389 "opc-request-id": kwargs.get("opc_request_id", missing), 5390 "opc-retry-token": kwargs.get("opc_retry_token", missing) 5391 } 5392 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5393 5394 retry_strategy = self.base_client.get_preferred_retry_strategy( 5395 operation_retry_strategy=kwargs.get('retry_strategy'), 5396 client_retry_strategy=self.retry_strategy 5397 ) 5398 5399 if retry_strategy: 5400 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5401 self.base_client.add_opc_retry_token_if_needed(header_params) 5402 self.base_client.add_opc_client_retries_header(header_params) 5403 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5404 return retry_strategy.make_retrying_call( 5405 self.base_client.call_api, 5406 resource_path=resource_path, 5407 method=method, 5408 path_params=path_params, 5409 header_params=header_params, 5410 body=update_network_security_groups_details) 5411 else: 5412 return self.base_client.call_api( 5413 resource_path=resource_path, 5414 method=method, 5415 path_params=path_params, 5416 header_params=header_params, 5417 body=update_network_security_groups_details) 5418 5419 def update_path_route_set(self, update_path_route_set_details, load_balancer_id, path_route_set_name, **kwargs): 5420 """ 5421 Overwrites an existing path route set on the specified load balancer. Use this operation to add, delete, or alter 5422 path route rules in a path route set. 5423 5424 To add a new path route rule to a path route set, the `pathRoutes` in the 5425 :func:`update_path_route_set_details` object must include 5426 both the new path route rule to add and the existing path route rules to retain. 5427 5428 5429 :param oci.load_balancer.models.UpdatePathRouteSetDetails update_path_route_set_details: (required) 5430 The configuration details to update a path route set. 5431 5432 :param str load_balancer_id: (required) 5433 The `OCID`__ of the load balancer associated with the path route set to update. 5434 5435 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 5436 5437 :param str path_route_set_name: (required) 5438 The name of the path route set to update. 5439 5440 Example: `example_path_route_set` 5441 5442 :param str opc_request_id: (optional) 5443 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 5444 particular request, please provide the request ID. 5445 5446 :param str opc_retry_token: (optional) 5447 A token that uniquely identifies a request so it can be retried in case of a timeout or 5448 server error without risk of executing that same action again. Retry tokens expire after 24 5449 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 5450 has been deleted and purged from the system, then a retry of the original creation request 5451 may be rejected). 5452 5453 :param obj retry_strategy: (optional) 5454 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5455 5456 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5457 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5458 5459 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5460 5461 :return: A :class:`~oci.response.Response` object with data of type None 5462 :rtype: :class:`~oci.response.Response` 5463 5464 :example: 5465 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_path_route_set.py.html>`__ to see an example of how to use update_path_route_set API. 5466 """ 5467 resource_path = "/loadBalancers/{loadBalancerId}/pathRouteSets/{pathRouteSetName}" 5468 method = "PUT" 5469 5470 # Don't accept unknown kwargs 5471 expected_kwargs = [ 5472 "retry_strategy", 5473 "opc_request_id", 5474 "opc_retry_token" 5475 ] 5476 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5477 if extra_kwargs: 5478 raise ValueError( 5479 "update_path_route_set got unknown kwargs: {!r}".format(extra_kwargs)) 5480 5481 path_params = { 5482 "loadBalancerId": load_balancer_id, 5483 "pathRouteSetName": path_route_set_name 5484 } 5485 5486 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5487 5488 for (k, v) in six.iteritems(path_params): 5489 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5490 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5491 5492 header_params = { 5493 "accept": "application/json", 5494 "content-type": "application/json", 5495 "opc-request-id": kwargs.get("opc_request_id", missing), 5496 "opc-retry-token": kwargs.get("opc_retry_token", missing) 5497 } 5498 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5499 5500 retry_strategy = self.base_client.get_preferred_retry_strategy( 5501 operation_retry_strategy=kwargs.get('retry_strategy'), 5502 client_retry_strategy=self.retry_strategy 5503 ) 5504 5505 if retry_strategy: 5506 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5507 self.base_client.add_opc_retry_token_if_needed(header_params) 5508 self.base_client.add_opc_client_retries_header(header_params) 5509 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5510 return retry_strategy.make_retrying_call( 5511 self.base_client.call_api, 5512 resource_path=resource_path, 5513 method=method, 5514 path_params=path_params, 5515 header_params=header_params, 5516 body=update_path_route_set_details) 5517 else: 5518 return self.base_client.call_api( 5519 resource_path=resource_path, 5520 method=method, 5521 path_params=path_params, 5522 header_params=header_params, 5523 body=update_path_route_set_details) 5524 5525 def update_routing_policy(self, update_routing_policy_details, load_balancer_id, routing_policy_name, **kwargs): 5526 """ 5527 Overwrites an existing routing policy on the specified load balancer. Use this operation to add, delete, or alter 5528 routing policy rules in a routing policy. 5529 5530 To add a new routing rule to a routing policy, the body must include both the new routing rule to add and the existing rules to retain. 5531 5532 5533 :param oci.load_balancer.models.UpdateRoutingPolicyDetails update_routing_policy_details: (required) 5534 The configuration details needed to update a routing policy. 5535 5536 :param str load_balancer_id: (required) 5537 The `OCID`__ of the load balancer associated with the routing policy to update. 5538 5539 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 5540 5541 :param str routing_policy_name: (required) 5542 The name of the routing policy to update. 5543 5544 Example: `example_routing_policy_name` 5545 5546 :param str opc_request_id: (optional) 5547 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 5548 particular request, please provide the request ID. 5549 5550 :param str opc_retry_token: (optional) 5551 A token that uniquely identifies a request so it can be retried in case of a timeout or 5552 server error without risk of executing that same action again. Retry tokens expire after 24 5553 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 5554 has been deleted and purged from the system, then a retry of the original creation request 5555 may be rejected). 5556 5557 :param obj retry_strategy: (optional) 5558 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5559 5560 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5561 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5562 5563 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5564 5565 :return: A :class:`~oci.response.Response` object with data of type None 5566 :rtype: :class:`~oci.response.Response` 5567 5568 :example: 5569 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_routing_policy.py.html>`__ to see an example of how to use update_routing_policy API. 5570 """ 5571 resource_path = "/loadBalancers/{loadBalancerId}/routingPolicies/{routingPolicyName}" 5572 method = "PUT" 5573 5574 # Don't accept unknown kwargs 5575 expected_kwargs = [ 5576 "retry_strategy", 5577 "opc_request_id", 5578 "opc_retry_token" 5579 ] 5580 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5581 if extra_kwargs: 5582 raise ValueError( 5583 "update_routing_policy got unknown kwargs: {!r}".format(extra_kwargs)) 5584 5585 path_params = { 5586 "loadBalancerId": load_balancer_id, 5587 "routingPolicyName": routing_policy_name 5588 } 5589 5590 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5591 5592 for (k, v) in six.iteritems(path_params): 5593 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5594 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5595 5596 header_params = { 5597 "accept": "application/json", 5598 "content-type": "application/json", 5599 "opc-request-id": kwargs.get("opc_request_id", missing), 5600 "opc-retry-token": kwargs.get("opc_retry_token", missing) 5601 } 5602 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5603 5604 retry_strategy = self.base_client.get_preferred_retry_strategy( 5605 operation_retry_strategy=kwargs.get('retry_strategy'), 5606 client_retry_strategy=self.retry_strategy 5607 ) 5608 5609 if retry_strategy: 5610 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5611 self.base_client.add_opc_retry_token_if_needed(header_params) 5612 self.base_client.add_opc_client_retries_header(header_params) 5613 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5614 return retry_strategy.make_retrying_call( 5615 self.base_client.call_api, 5616 resource_path=resource_path, 5617 method=method, 5618 path_params=path_params, 5619 header_params=header_params, 5620 body=update_routing_policy_details) 5621 else: 5622 return self.base_client.call_api( 5623 resource_path=resource_path, 5624 method=method, 5625 path_params=path_params, 5626 header_params=header_params, 5627 body=update_routing_policy_details) 5628 5629 def update_rule_set(self, load_balancer_id, rule_set_name, update_rule_set_details, **kwargs): 5630 """ 5631 Overwrites an existing set of rules on the specified load balancer. Use this operation to add or alter 5632 the rules in a rule set. 5633 5634 To add a new rule to a set, the body must include both the new rule to add and the existing rules to retain. 5635 5636 5637 :param str load_balancer_id: (required) 5638 The `OCID`__ of the specified load balancer. 5639 5640 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 5641 5642 :param str rule_set_name: (required) 5643 The name of the rule set to update. 5644 5645 Example: `example_rule_set` 5646 5647 :param oci.load_balancer.models.UpdateRuleSetDetails update_rule_set_details: (required) 5648 The configuration details to update a set of rules. 5649 5650 :param str opc_request_id: (optional) 5651 The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a 5652 particular request, please provide the request ID. 5653 5654 :param obj retry_strategy: (optional) 5655 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5656 5657 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5658 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5659 5660 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5661 5662 :return: A :class:`~oci.response.Response` object with data of type None 5663 :rtype: :class:`~oci.response.Response` 5664 5665 :example: 5666 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_rule_set.py.html>`__ to see an example of how to use update_rule_set API. 5667 """ 5668 resource_path = "/loadBalancers/{loadBalancerId}/ruleSets/{ruleSetName}" 5669 method = "PUT" 5670 5671 # Don't accept unknown kwargs 5672 expected_kwargs = [ 5673 "retry_strategy", 5674 "opc_request_id" 5675 ] 5676 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5677 if extra_kwargs: 5678 raise ValueError( 5679 "update_rule_set got unknown kwargs: {!r}".format(extra_kwargs)) 5680 5681 path_params = { 5682 "loadBalancerId": load_balancer_id, 5683 "ruleSetName": rule_set_name 5684 } 5685 5686 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5687 5688 for (k, v) in six.iteritems(path_params): 5689 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5690 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5691 5692 header_params = { 5693 "accept": "application/json", 5694 "content-type": "application/json", 5695 "opc-request-id": kwargs.get("opc_request_id", missing) 5696 } 5697 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5698 5699 retry_strategy = self.base_client.get_preferred_retry_strategy( 5700 operation_retry_strategy=kwargs.get('retry_strategy'), 5701 client_retry_strategy=self.retry_strategy 5702 ) 5703 5704 if retry_strategy: 5705 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5706 self.base_client.add_opc_client_retries_header(header_params) 5707 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5708 return retry_strategy.make_retrying_call( 5709 self.base_client.call_api, 5710 resource_path=resource_path, 5711 method=method, 5712 path_params=path_params, 5713 header_params=header_params, 5714 body=update_rule_set_details) 5715 else: 5716 return self.base_client.call_api( 5717 resource_path=resource_path, 5718 method=method, 5719 path_params=path_params, 5720 header_params=header_params, 5721 body=update_rule_set_details) 5722 5723 def update_ssl_cipher_suite(self, update_ssl_cipher_suite_details, load_balancer_id, name, **kwargs): 5724 """ 5725 Updates an existing SSL cipher suite for the specified load balancer. 5726 5727 5728 :param oci.load_balancer.models.UpdateSSLCipherSuiteDetails update_ssl_cipher_suite_details: (required) 5729 The configuration details to update an SSL cipher suite. 5730 5731 :param str load_balancer_id: (required) 5732 The `OCID`__ of the associated load balancer. 5733 5734 __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm 5735 5736 :param str name: (required) 5737 The name of the SSL cipher suite to update. 5738 5739 example: `example_cipher_suite` 5740 5741 :param str opc_request_id: (optional) 5742 Unique Oracle-assigned identifier for the request. If you need to contact Oracle about 5743 a particular request, please provide the request ID. 5744 5745 :param str opc_retry_token: (optional) 5746 A token that uniquely identifies a request so it can be retried in case of a timeout or 5747 server error without risk of executing that same action again. Retry tokens expire after 24 5748 hours, but can be invalidated before then due to conflicting operations (e.g., if a resource 5749 has been deleted and purged from the system, then a retry of the original creation request 5750 may be rejected). 5751 5752 :param obj retry_strategy: (optional) 5753 A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level. 5754 5755 This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it. 5756 The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__. 5757 5758 To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`. 5759 5760 :return: A :class:`~oci.response.Response` object with data of type None 5761 :rtype: :class:`~oci.response.Response` 5762 5763 :example: 5764 Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/2.53.1/loadbalancer/update_ssl_cipher_suite.py.html>`__ to see an example of how to use update_ssl_cipher_suite API. 5765 """ 5766 resource_path = "/loadBalancers/{loadBalancerId}/sslCipherSuites/{name}" 5767 method = "PUT" 5768 5769 # Don't accept unknown kwargs 5770 expected_kwargs = [ 5771 "retry_strategy", 5772 "opc_request_id", 5773 "opc_retry_token" 5774 ] 5775 extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs] 5776 if extra_kwargs: 5777 raise ValueError( 5778 "update_ssl_cipher_suite got unknown kwargs: {!r}".format(extra_kwargs)) 5779 5780 path_params = { 5781 "loadBalancerId": load_balancer_id, 5782 "name": name 5783 } 5784 5785 path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing} 5786 5787 for (k, v) in six.iteritems(path_params): 5788 if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0): 5789 raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k)) 5790 5791 header_params = { 5792 "accept": "application/json", 5793 "content-type": "application/json", 5794 "opc-request-id": kwargs.get("opc_request_id", missing), 5795 "opc-retry-token": kwargs.get("opc_retry_token", missing) 5796 } 5797 header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None} 5798 5799 retry_strategy = self.base_client.get_preferred_retry_strategy( 5800 operation_retry_strategy=kwargs.get('retry_strategy'), 5801 client_retry_strategy=self.retry_strategy 5802 ) 5803 5804 if retry_strategy: 5805 if not isinstance(retry_strategy, retry.NoneRetryStrategy): 5806 self.base_client.add_opc_retry_token_if_needed(header_params) 5807 self.base_client.add_opc_client_retries_header(header_params) 5808 retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback) 5809 return retry_strategy.make_retrying_call( 5810 self.base_client.call_api, 5811 resource_path=resource_path, 5812 method=method, 5813 path_params=path_params, 5814 header_params=header_params, 5815 body=update_ssl_cipher_suite_details) 5816 else: 5817 return self.base_client.call_api( 5818 resource_path=resource_path, 5819 method=method, 5820 path_params=path_params, 5821 header_params=header_params, 5822 body=update_ssl_cipher_suite_details) 5823