class AccessRequestsClient(object):
"""
Operator Access Control enables you to control the time duration and the actions an Oracle operator can perform on your Exadata Cloud@Customer infrastructure.
Using logging service, you can view a near real-time audit report of all actions performed by an Oracle operator.
Use the table of contents and search tool to explore the OperatorAccessControl API.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20200630',
'service_endpoint_template':
'https://operator-access-control.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
self.base_client = BaseClient("access_requests", config, signer,
operator_access_control_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def approve_access_request(self, access_request_id,
approve_access_request_details, **kwargs):
"""
Approves an access request.
:param str access_request_id: (required)
unique AccessRequest identifier
:param oci.operator_access_control.models.ApproveAccessRequestDetails approve_access_request_details: (required)
Details regarding the approval of an access request created by the operator.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/operatoraccesscontrol/approve_access_request.py.html>`__ to see an example of how to use approve_access_request API.
"""
resource_path = "/accessRequests/{accessRequestId}/action/approve"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "if_match", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"approve_access_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"accessRequestId": access_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=approve_access_request_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=approve_access_request_details)
def get_access_request(self, access_request_id, **kwargs):
"""
Gets details of an access request.
:param str access_request_id: (required)
unique AccessRequest identifier
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.operator_access_control.models.AccessRequest`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/operatoraccesscontrol/get_access_request.py.html>`__ to see an example of how to use get_access_request API.
"""
resource_path = "/accessRequests/{accessRequestId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_access_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"accessRequestId": access_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AccessRequest")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AccessRequest")
def list_access_request_histories(self, access_request_id, **kwargs):
"""
Returns a history of all status associated with the accessRequestId.
:param str access_request_id: (required)
unique AccessRequest identifier
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.operator_access_control.models.AccessRequestHistoryCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/operatoraccesscontrol/list_access_request_histories.py.html>`__ to see an example of how to use list_access_request_histories API.
"""
resource_path = "/accessRequests/{accessRequestId}/history"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "limit", "page", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_access_request_histories got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"accessRequestId": access_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
query_params = {
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="AccessRequestHistoryCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="AccessRequestHistoryCollection")
def list_access_requests(self, compartment_id, **kwargs):
"""
Lists all access requests in the compartment.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param str resource_name: (optional)
A filter to return only resources that match the given ResourceName.
:param str resource_type: (optional)
A filter to return only lists of resources that match the entire given service type.
:param str lifecycle_state: (optional)
A filter to return only resources whose lifecycleState matches the given AccessRequest lifecycleState.
Allowed values are: "CREATED", "APPROVALWAITING", "PREAPPROVED", "APPROVED", "REJECTED", "DEPLOYED", "DEPLOYFAILED", "UNDEPLOYED", "UNDEPLOYFAILED", "CLOSEFAILED", "REVOKEFAILED", "EXPIRYFAILED", "REVOKING", "REVOKED", "EXTENDING", "EXTENDED", "EXTENSIONREJECTED", "COMPLETING", "COMPLETED", "EXPIRED", "APPROVEDFORFUTURE", "INREVIEW"
:param datetime time_start: (optional)
Query start time in UTC in ISO 8601 format(inclusive).
Example 2019-10-30T00:00:00Z (yyyy-MM-ddThh:mm:ssZ).
timeIntervalStart and timeIntervalEnd parameters are used together.
:param datetime time_end: (optional)
Query start time in UTC in ISO 8601 format(inclusive).
Example 2019-10-30T00:00:00Z (yyyy-MM-ddThh:mm:ssZ).
timeIntervalStart and timeIntervalEnd parameters are used together.
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
Allowed values are: "timeCreated", "displayName"
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.operator_access_control.models.AccessRequestCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/operatoraccesscontrol/list_access_requests.py.html>`__ to see an example of how to use list_access_requests API.
"""
resource_path = "/accessRequests"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "resource_name", "resource_type",
"lifecycle_state", "time_start", "time_end", "limit", "page",
"sort_order", "sort_by", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_access_requests got unknown kwargs: {!r}".format(
extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATED", "APPROVALWAITING", "PREAPPROVED", "APPROVED",
"REJECTED", "DEPLOYED", "DEPLOYFAILED", "UNDEPLOYED",
"UNDEPLOYFAILED", "CLOSEFAILED", "REVOKEFAILED",
"EXPIRYFAILED", "REVOKING", "REVOKED", "EXTENDING", "EXTENDED",
"EXTENSIONREJECTED", "COMPLETING", "COMPLETED", "EXPIRED",
"APPROVEDFORFUTURE", "INREVIEW"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"compartmentId": compartment_id,
"resourceName": kwargs.get("resource_name", missing),
"resourceType": kwargs.get("resource_type", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"timeStart": kwargs.get("time_start", missing),
"timeEnd": kwargs.get("time_end", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="AccessRequestCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="AccessRequestCollection")
def reject_access_request(self, access_request_id,
reject_access_request_details, **kwargs):
"""
Rejects an access request.
:param str access_request_id: (required)
unique AccessRequest identifier
:param oci.operator_access_control.models.RejectAccessRequestDetails reject_access_request_details: (required)
Details regarding the rejection of an access request created by the operator.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/operatoraccesscontrol/reject_access_request.py.html>`__ to see an example of how to use reject_access_request API.
"""
resource_path = "/accessRequests/{accessRequestId}/action/reject"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "if_match", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"reject_access_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"accessRequestId": access_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=reject_access_request_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=reject_access_request_details)
def review_access_request(self, access_request_id,
review_access_request_details, **kwargs):
"""
Reviews the access request.
:param str access_request_id: (required)
unique AccessRequest identifier
:param oci.operator_access_control.models.ReviewAccessRequestDetails review_access_request_details: (required)
Details regarding the approval of an access request created by the operator.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.operator_access_control.models.AccessRequest`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/operatoraccesscontrol/review_access_request.py.html>`__ to see an example of how to use review_access_request API.
"""
resource_path = "/accessRequests/{accessRequestId}/action/review"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "if_match", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"review_access_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"accessRequestId": access_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=review_access_request_details,
response_type="AccessRequest")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=review_access_request_details,
response_type="AccessRequest")
def revoke_access_request(self, access_request_id,
revoke_access_request_details, **kwargs):
"""
Revokes an already approved access request.
:param str access_request_id: (required)
unique AccessRequest identifier
:param oci.operator_access_control.models.RevokeAccessRequestDetails revoke_access_request_details: (required)
Details regarding the revocation of an access request created by the operator.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/operatoraccesscontrol/revoke_access_request.py.html>`__ to see an example of how to use revoke_access_request API.
"""
resource_path = "/accessRequests/{accessRequestId}/action/revoke"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "if_match", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"revoke_access_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"accessRequestId": access_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=revoke_access_request_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=revoke_access_request_details)
class ChannelsClient(object):
"""
The API for the MySQL Database Service
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20190415',
'service_endpoint_template':
'https://mysql.{region}.ocp.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("channels", config, signer,
mysql_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_channel(self, create_channel_details, **kwargs):
"""
Creates a Channel to establish replication from a source to a target.
:param oci.mysql.models.CreateChannelDetails create_channel_details: (required)
The parameters of the request to create the Channel.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated before
then due to conflicting operations (for example, if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Channel`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/channels"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_channel got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_channel_details,
response_type="Channel")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_channel_details,
response_type="Channel")
def delete_channel(self, channel_id, **kwargs):
"""
Deletes the specified Channel.
:param str channel_id: (required)
The Channel `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/channels/{channelId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_channel got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"channelId": channel_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_channel(self, channel_id, **kwargs):
"""
Gets the full details of the specified Channel, including the user-specified
configuration parameters (passwords are omitted), as well as information about
the state of the Channel, its sources and targets.
:param str channel_id: (required)
The Channel `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str if_none_match: (optional)
For conditional requests. In the GET call for a resource, set the
`If-None-Match` header to the value of the ETag from a previous GET (or
POST or PUT) response for that resource. The server will return with
either a 304 Not Modified response if the resource has not changed, or a
200 OK response with the updated representation.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Channel`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/channels/{channelId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "if_none_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_channel got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"channelId": channel_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-none-match": kwargs.get("if_none_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Channel")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Channel")
def list_channels(self, compartment_id, **kwargs):
"""
Lists all the Channels that match the specified filters.
:param str compartment_id: (required)
The compartment `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str db_system_id: (optional)
The DB System `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str channel_id: (optional)
The OCID of the Channel.
:param str display_name: (optional)
A filter to return only the resource matching the given display name exactly.
:param str lifecycle_state: (optional)
The LifecycleState of the Channel.
Allowed values are: "CREATING", "ACTIVE", "NEEDS_ATTENTION", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED"
:param bool is_enabled: (optional)
If true, returns only Channels that are enabled. If false, returns only
Channels that are disabled.
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Time fields are default ordered as descending. Display name is default ordered as ascending.
Allowed values are: "displayName", "timeCreated"
:param str sort_order: (optional)
The sort order to use (ASC or DESC).
Allowed values are: "ASC", "DESC"
:param int limit: (optional)
The maximum number of items to return in a paginated list call. For information about pagination, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/#API/Concepts/usingapi.htm#List_Pagination
:param str page: (optional)
The value of the `opc-next-page` or `opc-prev-page` response header from
the previous list call. For information about pagination, see `List
Pagination`__.
__ https://docs.cloud.oracle.com/#API/Concepts/usingapi.htm#List_Pagination
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.mysql.models.ChannelSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/channels"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "db_system_id", "channel_id",
"display_name", "lifecycle_state", "is_enabled", "sort_by",
"sort_order", "limit", "page"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_channels got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "ACTIVE", "NEEDS_ATTENTION", "INACTIVE",
"UPDATING", "DELETING", "DELETED", "FAILED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["displayName", "timeCreated"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
query_params = {
"compartmentId": compartment_id,
"dbSystemId": kwargs.get("db_system_id", missing),
"channelId": kwargs.get("channel_id", missing),
"displayName": kwargs.get("display_name", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"isEnabled": kwargs.get("is_enabled", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ChannelSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ChannelSummary]")
def reset_channel(self, channel_id, **kwargs):
"""
Resets the specified Channel by purging its cached information, leaving the Channel
as if it had just been created. This operation is only accepted in Inactive Channels.
:param str channel_id: (required)
The Channel `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated before
then due to conflicting operations (for example, if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/channels/{channelId}/actions/reset"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"reset_channel got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"channelId": channel_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def resume_channel(self, channel_id, **kwargs):
"""
Resumes an enabled Channel that has become Inactive due to an error. The resume operation
requires that the error that cause the Channel to become Inactive has already been fixed,
otherwise the operation may fail.
:param str channel_id: (required)
The Channel `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated before
then due to conflicting operations (for example, if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/channels/{channelId}/actions/resume"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"resume_channel got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"channelId": channel_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def update_channel(self, channel_id, update_channel_details, **kwargs):
"""
Updates the properties of the specified Channel.
If the Channel is Active the Update operation will asynchronously apply the new configuration
parameters to the Channel and the Channel may become temporarily unavailable. Otherwise, the
new configuration will be applied the next time the Channel becomes Active.
:param str channel_id: (required)
The Channel `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param oci.mysql.models.UpdateChannelDetails update_channel_details: (required)
The parameters of the request to update the Channel.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated before
then due to conflicting operations (for example, if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/channels/{channelId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_channel got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"channelId": channel_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_channel_details)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_channel_details)
class NotificationDataPlaneClient(object):
"""
Use the Notifications API to broadcast messages to distributed components by topic, using a publish-subscribe pattern.
For information about managing topics, subscriptions, and messages, see [Notifications Overview](/iaas/Content/Notification/Concepts/notificationoverview.htm).
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20181201',
'service_endpoint_template':
'https://notification.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("notification_data_plane", config,
signer, ons_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_subscription_compartment(
self, subscription_id, change_subscription_compartment_details,
**kwargs):
"""
Moves a subscription into a different compartment within the same tenancy. For information about moving
resources between compartments, see
`Moving Resources to a Different Compartment`__.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
__ https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes
:param str subscription_id: (required)
The `OCID`__ of the subscription to move.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param ChangeCompartmentDetails change_subscription_compartment_details: (required)
The configuration details for the move operation.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before that due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
Used for optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions/{subscriptionId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id", "if_match"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_subscription_compartment got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"subscriptionId": subscription_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_subscription_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_subscription_compartment_details)
def create_subscription(self, create_subscription_details, **kwargs):
"""
Creates a subscription for the specified topic and sends a subscription confirmation URL to the endpoint. The subscription remains in \"Pending\" status until it has been confirmed.
For information about confirming subscriptions, see
`To confirm a subscription`__.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
__ https://docs.cloud.oracle.com/iaas/Content/Notification/Tasks/managingtopicsandsubscriptions.htm#confirmSub
:param CreateSubscriptionDetails create_subscription_details: (required)
The subscription to create.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before that due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.Subscription`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_subscription got unknown kwargs: {!r}".format(
extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_subscription_details,
response_type="Subscription")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_subscription_details,
response_type="Subscription")
def delete_subscription(self, subscription_id, **kwargs):
"""
Deletes the specified subscription.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str subscription_id: (required)
The `OCID`__ of the subscription to delete.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
Used for optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions/{subscriptionId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "if_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_subscription got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"subscriptionId": subscription_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_confirm_subscription(self, id, token, protocol, **kwargs):
"""
Gets the confirmation details for the specified subscription.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str id: (required)
The `OCID`__ of the subscription to get the confirmation details for.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str token: (required)
The subscription confirmation token.
:param str protocol: (required)
The protocol used for the subscription.
Allowed values:
* `CUSTOM_HTTPS`
* `EMAIL`
* `HTTPS` (deprecated; for PagerDuty endpoints, use `PAGERDUTY`)
* `PAGERDUTY`
* `SLACK`
* `ORACLE_FUNCTIONS`
For information about subscription protocols, see
`To create a subscription`__.
__ https://docs.cloud.oracle.com/iaas/Content/Notification/Tasks/managingtopicsandsubscriptions.htm#createSub
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.ConfirmationResult`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions/{id}/confirmation"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_confirm_subscription got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
query_params = {"token": token, "protocol": protocol}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="ConfirmationResult")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="ConfirmationResult")
def get_subscription(self, subscription_id, **kwargs):
"""
Gets the specified subscription's configuration information.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str subscription_id: (required)
The `OCID`__ of the subscription to retrieve.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.Subscription`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions/{subscriptionId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_subscription got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"subscriptionId": subscription_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Subscription")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Subscription")
def get_unsubscription(self, id, token, protocol, **kwargs):
"""
Gets the unsubscription details for the specified subscription.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str id: (required)
The `OCID`__ of the subscription to unsubscribe from.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str token: (required)
The subscription confirmation token.
:param str protocol: (required)
The protocol used for the subscription.
Allowed values:
* `CUSTOM_HTTPS`
* `EMAIL`
* `HTTPS` (deprecated; for PagerDuty endpoints, use `PAGERDUTY`)
* `PAGERDUTY`
* `SLACK`
* `ORACLE_FUNCTIONS`
For information about subscription protocols, see
`To create a subscription`__.
__ https://docs.cloud.oracle.com/iaas/Content/Notification/Tasks/managingtopicsandsubscriptions.htm#createSub
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type str
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions/{id}/unsubscription"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_unsubscription got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
query_params = {"token": token, "protocol": protocol}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="str")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="str")
def list_subscriptions(self, compartment_id, **kwargs):
"""
Lists the subscriptions in the specified compartment or topic.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str compartment_id: (required)
The `OCID`__ of the compartment.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str topic_id: (optional)
Return all subscriptions that are subscribed to the given topic OCID. Either this query parameter or the compartmentId query parameter must be set.
:param str page: (optional)
For list pagination. The value of the opc-next-page response header from the previous \"List\" call.
For important details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param int limit: (optional)
For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call.
For important details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.ons.models.SubscriptionSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "topic_id", "page", "limit", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_subscriptions got unknown kwargs: {!r}".format(
extra_kwargs))
query_params = {
"compartmentId": compartment_id,
"topicId": kwargs.get("topic_id", missing),
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SubscriptionSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SubscriptionSummary]")
def publish_message(self, topic_id, message_details, **kwargs):
"""
Publishes a message to the specified topic.
The topic endpoint is required for this operation.
To get the topic endpoint, use :func:`get_topic`
and review the `apiEndpoint` value in the response (:class:`NotificationTopic`).
Limits information follows.
Message size limit per request: 64KB.
Message delivery rate limit per endpoint: 60 messages per minute for HTTP-based protocols, 10 messages per minute for the `EMAIL` protocol.
HTTP-based protocols use URL endpoints that begin with \"http:\" or \"https:\".
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60 per topic.
For more information about publishing messages, see `Publishing Messages`__.
For steps to request a limit increase, see `Requesting a Service Limit Increase`__.
__ https://docs.cloud.oracle.com/iaas/Content/Notification/Tasks/publishingmessages.htm
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/servicelimits.htm#three
:param str topic_id: (required)
The `OCID`__ of the topic.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param MessageDetails message_details: (required)
The message to publish.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str message_type: (optional)
Type of message body in the request.
Allowed values are: "JSON", "RAW_TEXT"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.PublishResult`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/topics/{topicId}/messages"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "message_type"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError("publish_message got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"topicId": topic_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"messageType": kwargs.get("message_type", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=message_details,
response_type="PublishResult")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=message_details,
response_type="PublishResult")
def resend_subscription_confirmation(self, id, **kwargs):
"""
Resends the confirmation details for the specified subscription.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str id: (required)
The `OCID`__ of the subscription to resend the confirmation for.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.Subscription`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions/{id}/resendConfirmation"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"resend_subscription_confirmation got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Subscription")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Subscription")
def update_subscription(self, subscription_id, update_subscription_details,
**kwargs):
"""
Updates the specified subscription's configuration.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str subscription_id: (required)
The `OCID`__ of the subscription to update.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param UpdateSubscriptionDetails update_subscription_details: (required)
The configuration details for updating the subscription.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
Used for optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.UpdateSubscriptionDetails`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/subscriptions/{subscriptionId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "if_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_subscription got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"subscriptionId": subscription_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_subscription_details,
response_type="UpdateSubscriptionDetails")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_subscription_details,
response_type="UpdateSubscriptionDetails")
class TransferPackageClient(object):
"""
Data Transfer Service API Specification
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(
tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(config, "pass_phrase"),
private_key_content=config.get("key_content")
)
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'base_path': '/20171001',
'service_endpoint_template': 'https://datatransfer.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy': kwargs.get('circuit_breaker_strategy', circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs['circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
self.base_client = BaseClient("transfer_package", config, signer, dts_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def attach_devices_to_transfer_package(self, id, transfer_package_label, attach_devices_details, **kwargs):
"""
Attaches Devices to a Transfer Package
:param str id: (required)
ID of the Transfer Job
:param str transfer_package_label: (required)
Label of the Transfer Package
:param oci.dts.models.AttachDevicesDetails attach_devices_details: (required)
Labels of Transfer Devices to attach
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/attach_devices_to_transfer_package.py.html>`__ to see an example of how to use attach_devices_to_transfer_package API.
"""
resource_path = "/transferJobs/{id}/transferPackages/{transferPackageLabel}/actions/attachDevices"
method = "POST"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"attach_devices_to_transfer_package got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"id": id,
"transferPackageLabel": transfer_package_label
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=attach_devices_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=attach_devices_details)
def create_transfer_package(self, id, **kwargs):
"""
Create a new Transfer Package
:param str id: (required)
ID of the Transfer Job
:param str opc_retry_token: (optional)
:param oci.dts.models.CreateTransferPackageDetails create_transfer_package_details: (optional)
Creates a New Transfer Package
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferPackage`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/create_transfer_package.py.html>`__ to see an example of how to use create_transfer_package API.
"""
resource_path = "/transferJobs/{id}/transferPackages"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_retry_token",
"create_transfer_package_details"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_transfer_package got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"id": id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=kwargs.get('create_transfer_package_details'),
response_type="TransferPackage")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=kwargs.get('create_transfer_package_details'),
response_type="TransferPackage")
def delete_transfer_package(self, id, transfer_package_label, **kwargs):
"""
deletes a transfer Package
:param str id: (required)
ID of the Transfer Job
:param str transfer_package_label: (required)
Label of the Transfer Package
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/delete_transfer_package.py.html>`__ to see an example of how to use delete_transfer_package API.
"""
resource_path = "/transferJobs/{id}/transferPackages/{transferPackageLabel}"
method = "DELETE"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"delete_transfer_package got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"id": id,
"transferPackageLabel": transfer_package_label
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def detach_devices_from_transfer_package(self, id, transfer_package_label, detach_devices_details, **kwargs):
"""
Detaches Devices from a Transfer Package
:param str id: (required)
ID of the Transfer Job
:param str transfer_package_label: (required)
Label of the Transfer Package
:param oci.dts.models.DetachDevicesDetails detach_devices_details: (required)
Labels of Transfer Devices to detach
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/detach_devices_from_transfer_package.py.html>`__ to see an example of how to use detach_devices_from_transfer_package API.
"""
resource_path = "/transferJobs/{id}/transferPackages/{transferPackageLabel}/actions/detachDevices"
method = "POST"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"detach_devices_from_transfer_package got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"id": id,
"transferPackageLabel": transfer_package_label
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=detach_devices_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=detach_devices_details)
def get_transfer_package(self, id, transfer_package_label, **kwargs):
"""
Describes a transfer package in detail
:param str id: (required)
ID of the Transfer Job
:param str transfer_package_label: (required)
Label of the Transfer Package
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferPackage`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/get_transfer_package.py.html>`__ to see an example of how to use get_transfer_package API.
"""
resource_path = "/transferJobs/{id}/transferPackages/{transferPackageLabel}"
method = "GET"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_transfer_package got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"id": id,
"transferPackageLabel": transfer_package_label
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferPackage")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferPackage")
def list_transfer_packages(self, id, **kwargs):
"""
Lists Transfer Packages associated with a transferJob
:param str id: (required)
ID of the Transfer Job
:param str lifecycle_state: (optional)
filtering by lifecycleState
Allowed values are: "PREPARING", "SHIPPING", "RECEIVED", "PROCESSING", "PROCESSED", "RETURNED", "DELETED", "CANCELLED", "CANCELLED_RETURNED"
:param str display_name: (optional)
filtering by displayName
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.MultipleTransferPackages`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/list_transfer_packages.py.html>`__ to see an example of how to use list_transfer_packages API.
"""
resource_path = "/transferJobs/{id}/transferPackages"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"lifecycle_state",
"display_name"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_transfer_packages got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"id": id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["PREPARING", "SHIPPING", "RECEIVED", "PROCESSING", "PROCESSED", "RETURNED", "DELETED", "CANCELLED", "CANCELLED_RETURNED"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
)
query_params = {
"lifecycleState": kwargs.get("lifecycle_state", missing),
"displayName": kwargs.get("display_name", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="MultipleTransferPackages")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="MultipleTransferPackages")
def update_transfer_package(self, id, transfer_package_label, update_transfer_package_details, **kwargs):
"""
Updates a Transfer Package
:param str id: (required)
ID of the Transfer Job
:param str transfer_package_label: (required)
Label of the Transfer Package
:param oci.dts.models.UpdateTransferPackageDetails update_transfer_package_details: (required)
fields to update
:param str if_match: (optional)
The entity tag to match. Optional, if set, the update will be successful only if the
object's tag matches the tag specified in the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferPackage`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/update_transfer_package.py.html>`__ to see an example of how to use update_transfer_package API.
"""
resource_path = "/transferJobs/{id}/transferPackages/{transferPackageLabel}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_transfer_package got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"id": id,
"transferPackageLabel": transfer_package_label
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_transfer_package_details,
response_type="TransferPackage")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_transfer_package_details,
response_type="TransferPackage")
class NotificationControlPlaneClient(object):
"""
Use the Notifications API to broadcast messages to distributed components by topic, using a publish-subscribe pattern.
For information about managing topics, subscriptions, and messages, see [Notifications Overview](/iaas/Content/Notification/Concepts/notificationoverview.htm).
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20181201',
'service_endpoint_template':
'https://notification.{region}.oraclecloud.com',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("notification_control_plane", config,
signer, ons_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_topic_compartment(self, topic_id,
change_topic_compartment_details, **kwargs):
"""
Moves a topic into a different compartment within the same tenancy. For information about moving resources
between compartments, see
`Moving Resources to a Different Compartment`__.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
__ https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes
:param str topic_id: (required)
The `OCID`__ of the topic to move.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param ChangeCompartmentDetails change_topic_compartment_details: (required)
The configuration details for the move operation.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before that due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
Used for optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/topics/{topicId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id", "if_match"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_topic_compartment got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"topicId": topic_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_topic_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_topic_compartment_details)
def create_topic(self, create_topic_details, **kwargs):
"""
Creates a topic in the specified compartment. For general information about topics, see
`Managing Topics and Subscriptions`__.
For the purposes of access control, you must provide the OCID of the compartment where you want the topic to reside.
For information about access control and compartments, see `Overview of the IAM Service`__.
You must specify a display name for the topic.
All Oracle Cloud Infrastructure resources, including topics, get an Oracle-assigned, unique ID called an
Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID in the response. You can also
retrieve a resource's OCID by using a List API operation on that resource type, or by viewing the resource in the
Console. For more information, see `Resource Identifiers`__.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
__ https://docs.cloud.oracle.com/iaas/Content/Notification/Tasks/managingtopicsandsubscriptions.htm
__ https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param CreateTopicDetails create_topic_details: (required)
The topic to create.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before that due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.NotificationTopic`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/topics"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_topic got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_topic_details,
response_type="NotificationTopic")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_topic_details,
response_type="NotificationTopic")
def delete_topic(self, topic_id, **kwargs):
"""
Deletes the specified topic.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str topic_id: (required)
The `OCID`__ of the topic to delete.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
Used for optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/topics/{topicId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "if_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_topic got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"topicId": topic_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_topic(self, topic_id, **kwargs):
"""
Gets the specified topic's configuration information.
:param str topic_id: (required)
The `OCID`__ of the topic to retrieve.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 120.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.NotificationTopic`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/topics/{topicId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_topic got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"topicId": topic_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="NotificationTopic")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="NotificationTopic")
def list_topics(self, compartment_id, **kwargs):
"""
Lists topics in the specified compartment.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 120.
:param str compartment_id: (required)
The `OCID`__ of the compartment.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str id: (optional)
A filter to only return resources that match the given id exactly.
:param str name: (optional)
A filter to only return resources that match the given name exactly.
:param str page: (optional)
For list pagination. The value of the opc-next-page response header from the previous \"List\" call.
For important details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param int limit: (optional)
For list pagination. The maximum number of results per page, or items to return in a paginated \"List\" call.
For important details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str sort_by: (optional)
The field to sort by. Only one field can be selected for sorting.
Allowed values are: "TIMECREATED", "LIFECYCLESTATE"
:param str sort_order: (optional)
The sort order to use (ascending or descending).
Allowed values are: "ASC", "DESC"
:param str lifecycle_state: (optional)
Filter returned list by specified lifecycle state. This parameter is case-insensitive.
Allowed values are: "ACTIVE", "DELETING", "CREATING"
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.ons.models.NotificationTopicSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/topics"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "id", "name", "page", "limit", "sort_by",
"sort_order", "lifecycle_state", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_topics got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "LIFECYCLESTATE"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["ACTIVE", "DELETING", "CREATING"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
query_params = {
"compartmentId": compartment_id,
"id": kwargs.get("id", missing),
"name": kwargs.get("name", missing),
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[NotificationTopicSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[NotificationTopicSummary]")
def update_topic(self, topic_id, topic_attributes_details, **kwargs):
"""
Updates the specified topic's configuration.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
:param str topic_id: (required)
The `OCID`__ of the topic to update.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param TopicAttributesDetails topic_attributes_details: (required)
TopicAttributes
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
Used for optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ons.models.NotificationTopic`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/topics/{topicId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "if_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_topic got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"topicId": topic_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=topic_attributes_details,
response_type="NotificationTopic")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=topic_attributes_details,
response_type="NotificationTopic")
class TransferApplianceEntitlementClient(object):
"""
Data Transfer Service API Specification
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20171001',
'service_endpoint_template':
'https://datatransfer.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("transfer_appliance_entitlement", config,
signer, dts_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_transfer_appliance_entitlement(
self, create_transfer_appliance_entitlement_details, **kwargs):
"""
Create the Transfer Appliance Entitlement
Create the Entitlement to use a Transfer Appliance. It requires some offline process of review and signatures before request is granted.
:param CreateTransferApplianceEntitlementDetails create_transfer_appliance_entitlement_details: (required)
Creates a Transfer Appliance Entitlement
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (e.g., if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferApplianceEntitlement`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferApplianceEntitlement"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_transfer_appliance_entitlement got unknown kwargs: {!r}"
.format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_transfer_appliance_entitlement_details,
response_type="TransferApplianceEntitlement")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_transfer_appliance_entitlement_details,
response_type="TransferApplianceEntitlement")
def get_transfer_appliance_entitlement(self, id, **kwargs):
"""
Describes the Transfer Appliance Entitlement in detail
Describes the Transfer Appliance Entitlement in detail
:param str id: (required)
Id of the Transfer Appliance Entitlement
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (e.g., if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferApplianceEntitlement`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferApplianceEntitlement/{id}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_transfer_appliance_entitlement got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferApplianceEntitlement")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferApplianceEntitlement")
def list_transfer_appliance_entitlement(self, compartment_id, **kwargs):
"""
Lists Transfer Transfer Appliance Entitlement
Lists Transfer Transfer Appliance Entitlement
:param str compartment_id: (required)
compartment id
:param str id: (optional)
filtering by Transfer Appliance Entitlement id
:param str display_name: (optional)
filtering by displayName
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.dts.models.TransferApplianceEntitlementSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferApplianceEntitlement"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "id", "display_name", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_transfer_appliance_entitlement got unknown kwargs: {!r}".
format(extra_kwargs))
query_params = {
"compartmentId": compartment_id,
"id": kwargs.get("id", missing),
"displayName": kwargs.get("display_name", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[TransferApplianceEntitlementSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[TransferApplianceEntitlementSummary]")
class BudgetClient(object):
"""
Use the Budgets API to manage budgets and budget alerts.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20190111',
'service_endpoint_template':
'https://usage.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("budget", config, signer,
budget_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_alert_rule(self, budget_id, create_alert_rule_details,
**kwargs):
"""
Creates a new Alert Rule.
:param str budget_id: (required)
The unique Budget OCID
:param CreateAlertRuleDetails create_alert_rule_details: (required)
Details for the new Alert Rule.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.budget.models.AlertRule`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}/alertRules"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_alert_rule got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"budgetId": budget_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_alert_rule_details,
response_type="AlertRule")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_alert_rule_details,
response_type="AlertRule")
def create_budget(self, create_budget_details, **kwargs):
"""
Creates a new Budget.
:param CreateBudgetDetails create_budget_details: (required)
Details for the new Budget.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.budget.models.Budget`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_budget got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_budget_details,
response_type="Budget")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_budget_details,
response_type="Budget")
def delete_alert_rule(self, budget_id, alert_rule_id, **kwargs):
"""
Deletes a specified Alert Rule resource.
:param str budget_id: (required)
The unique Budget OCID
:param str alert_rule_id: (required)
The unique Alert Rule OCID
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}/alertRules/{alertRuleId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_alert_rule got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"budgetId": budget_id, "alertRuleId": alert_rule_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def delete_budget(self, budget_id, **kwargs):
"""
Deletes a specified Budget resource
:param str budget_id: (required)
The unique Budget OCID
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_budget got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"budgetId": budget_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_alert_rule(self, budget_id, alert_rule_id, **kwargs):
"""
Gets an Alert Rule for a specified Budget.
:param str budget_id: (required)
The unique Budget OCID
:param str alert_rule_id: (required)
The unique Alert Rule OCID
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.budget.models.AlertRule`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}/alertRules/{alertRuleId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_alert_rule got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"budgetId": budget_id, "alertRuleId": alert_rule_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AlertRule")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AlertRule")
def get_budget(self, budget_id, **kwargs):
"""
Gets a Budget by identifier
:param str budget_id: (required)
The unique Budget OCID
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.budget.models.Budget`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_budget got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"budgetId": budget_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Budget")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Budget")
def list_alert_rules(self, budget_id, **kwargs):
"""
Returns a list of Alert Rules for a specified Budget.
:param str budget_id: (required)
The unique Budget OCID
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. If not specified, the default is timeCreated.
The default sort order for timeCreated is DESC.
The default sort order for displayName is ASC in alphanumeric order.
Allowed values are: "timeCreated", "displayName"
:param str lifecycle_state: (optional)
The current state of the resource to filter by.
Allowed values are: "ACTIVE", "INACTIVE"
:param str display_name: (optional)
A user-friendly name. Does not have to be unique, and it's changeable.
Example: `My new resource`
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.budget.models.AlertRuleSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}/alertRules"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "limit", "page", "sort_order", "sort_by",
"lifecycle_state", "display_name", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_alert_rules got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"budgetId": budget_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["ACTIVE", "INACTIVE"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
query_params = {
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"displayName": kwargs.get("display_name", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[AlertRuleSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[AlertRuleSummary]")
def list_budgets(self, compartment_id, **kwargs):
"""
Gets a list of Budgets in a compartment.
By default, ListBudgets returns budgets of 'COMPARTMENT' target type and the budget records with only ONE target compartment OCID.
To list ALL budgets, set the targetType query parameter to ALL.
Example:
'targetType=ALL'
Additional targetTypes would be available in future releases. Clients should ignore new targetType
or upgrade to latest version of client SDK to handle new targetType.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. If not specified, the default is timeCreated.
The default sort order for timeCreated is DESC.
The default sort order for displayName is ASC in alphanumeric order.
Allowed values are: "timeCreated", "displayName"
:param str lifecycle_state: (optional)
The current state of the resource to filter by.
Allowed values are: "ACTIVE", "INACTIVE"
:param str display_name: (optional)
A user-friendly name. Does not have to be unique, and it's changeable.
Example: `My new resource`
:param str target_type: (optional)
The type of target to filter by.
* ALL - List all budgets
* COMPARTMENT - List all budgets with targetType == \"COMPARTMENT\"
* TAG - List all budgets with targetType == \"TAG\"
Allowed values are: "ALL", "COMPARTMENT", "TAG"
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.budget.models.BudgetSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "limit", "page", "sort_order", "sort_by",
"lifecycle_state", "display_name", "target_type", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_budgets got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["ACTIVE", "INACTIVE"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'target_type' in kwargs:
target_type_allowed_values = ["ALL", "COMPARTMENT", "TAG"]
if kwargs['target_type'] not in target_type_allowed_values:
raise ValueError(
"Invalid value for `target_type`, must be one of {0}".
format(target_type_allowed_values))
query_params = {
"compartmentId": compartment_id,
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"displayName": kwargs.get("display_name", missing),
"targetType": kwargs.get("target_type", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[BudgetSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[BudgetSummary]")
def update_alert_rule(self, budget_id, alert_rule_id,
update_alert_rule_details, **kwargs):
"""
Update an Alert Rule for the budget identified by the OCID.
:param str budget_id: (required)
The unique Budget OCID
:param str alert_rule_id: (required)
The unique Alert Rule OCID
:param UpdateAlertRuleDetails update_alert_rule_details: (required)
The information to be updated.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.budget.models.AlertRule`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}/alertRules/{alertRuleId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_alert_rule got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"budgetId": budget_id, "alertRuleId": alert_rule_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_alert_rule_details,
response_type="AlertRule")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_alert_rule_details,
response_type="AlertRule")
def update_budget(self, budget_id, update_budget_details, **kwargs):
"""
Update a Budget identified by the OCID
:param str budget_id: (required)
The unique Budget OCID
:param UpdateBudgetDetails update_budget_details: (required)
The information to be updated.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.budget.models.Budget`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/budgets/{budgetId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_budget got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"budgetId": budget_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_budget_details,
response_type="Budget")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_budget_details,
response_type="Budget")
class VaultsClient(object):
"""
API for managing secrets.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(
tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(config, "pass_phrase"),
private_key_content=config.get("key_content")
)
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20180608',
'service_endpoint_template': 'https://vaults.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("vaults", config, signer, vault_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def cancel_secret_deletion(self, secret_id, **kwargs):
"""
Cancels the pending deletion of the specified secret. Canceling
a scheduled deletion restores the secret's lifecycle state to what
it was before you scheduled the secret for deletion.
:param str secret_id: (required)
The OCID of the secret.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}/actions/cancelDeletion"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"cancel_secret_deletion got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def cancel_secret_version_deletion(self, secret_id, secret_version_number, **kwargs):
"""
Cancels the scheduled deletion of a secret version.
:param str secret_id: (required)
The OCID of the secret.
:param int secret_version_number: (required)
The version number of the secret.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}/version/{secretVersionNumber}/actions/cancelDeletion"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"cancel_secret_version_deletion got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id,
"secretVersionNumber": secret_version_number
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def change_secret_compartment(self, secret_id, change_secret_compartment_details, **kwargs):
"""
Moves a secret into a different compartment within the same tenancy. For information about
moving resources between compartments, see `Moving Resources to a Different Compartment`__.
When provided, if-match is checked against the ETag values of the secret.
__ https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes
:param str secret_id: (required)
The OCID of the secret.
:param ChangeSecretCompartmentDetails change_secret_compartment_details: (required)
The updated compartment details.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated
before then due to conflicting operations (e.g., if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id",
"opc_retry_token"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"change_secret_compartment got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_secret_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_secret_compartment_details)
def create_secret(self, create_secret_details, **kwargs):
"""
Creates a new secret according to the details of the request.
This operation is not supported by the Oracle Cloud Infrastructure Terraform Provider.
:param CreateSecretDetails create_secret_details: (required)
Request to create a new secret.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated
before then due to conflicting operations (e.g., if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vault.models.Secret`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"opc_retry_token"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_secret got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_secret_details,
response_type="Secret")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_secret_details,
response_type="Secret")
def get_secret(self, secret_id, **kwargs):
"""
Gets information about the specified secret.
:param str secret_id: (required)
The OCID of the secret.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vault.models.Secret`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_secret got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Secret")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Secret")
def get_secret_version(self, secret_id, secret_version_number, **kwargs):
"""
Gets information about the specified version of a secret.
:param str secret_id: (required)
The OCID of the secret.
:param int secret_version_number: (required)
The version number of the secret.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vault.models.SecretVersion`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}/version/{secretVersionNumber}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_secret_version got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id,
"secretVersionNumber": secret_version_number
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="SecretVersion")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="SecretVersion")
def list_secret_versions(self, secret_id, **kwargs):
"""
Lists all secret versions for the specified secret.
:param str secret_id: (required)
The OCID of the secret.
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call.
:param str page: (optional)
The value of the `opc-next-page` response header
from the previous \"List\" call.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Time created is default ordered as descending. Display name is default ordered as ascending.
Allowed values are: "VERSION_NUMBER"
:param str sort_order: (optional)
The sort order to use, either ascending (`ASC`) or descending (`DESC`).
Allowed values are: "ASC", "DESC"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.vault.models.SecretVersionSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}/versions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"limit",
"page",
"opc_request_id",
"sort_by",
"sort_order"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_secret_versions got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["VERSION_NUMBER"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
)
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
)
query_params = {
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[SecretVersionSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[SecretVersionSummary]")
def list_secrets(self, compartment_id, **kwargs):
"""
Lists all secrets in the specified vault and compartment.
:param str compartment_id: (required)
The OCID of the compartment.
:param str name: (optional)
The secret name.
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call.
:param str page: (optional)
The value of the `opc-next-page` response header
from the previous \"List\" call.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str sort_by: (optional)
The field to sort by. You can specify only one sort order. The default order for
`TIMECREATED` is descending. The default order for `NAME` is ascending.
Allowed values are: "TIMECREATED", "NAME"
:param str sort_order: (optional)
The sort order to use, either ascending (`ASC`) or descending (`DESC`).
Allowed values are: "ASC", "DESC"
:param str vault_id: (optional)
The OCID of the vault.
:param str lifecycle_state: (optional)
A filter that returns only resources that match the specified lifecycle state. The state value is case-insensitive.
Allowed values are: "CREATING", "ACTIVE", "UPDATING", "DELETING", "DELETED", "SCHEDULING_DELETION", "PENDING_DELETION", "CANCELLING_DELETION", "FAILED"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.vault.models.SecretSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"name",
"limit",
"page",
"opc_request_id",
"sort_by",
"sort_order",
"vault_id",
"lifecycle_state"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_secrets got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "NAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
)
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
)
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "UPDATING", "DELETING", "DELETED", "SCHEDULING_DELETION", "PENDING_DELETION", "CANCELLING_DELETION", "FAILED"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
)
query_params = {
"compartmentId": compartment_id,
"name": kwargs.get("name", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing),
"vaultId": kwargs.get("vault_id", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SecretSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SecretSummary]")
def schedule_secret_deletion(self, secret_id, schedule_secret_deletion_details, **kwargs):
"""
Schedules the deletion of the specified secret. This sets the lifecycle state of the secret
to `PENDING_DELETION` and then deletes it after the specified retention period ends.
:param str secret_id: (required)
The OCID of the secret.
:param ScheduleSecretDeletionDetails schedule_secret_deletion_details: (required)
Request to schedule the deletion of a secret.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}/actions/scheduleDeletion"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"schedule_secret_deletion got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=schedule_secret_deletion_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=schedule_secret_deletion_details)
def schedule_secret_version_deletion(self, secret_id, secret_version_number, schedule_secret_version_deletion_details, **kwargs):
"""
Schedules the deletion of the specified secret version. This deletes it after the specified retention period ends. You can only
delete a secret version if the secret version rotation state is marked as `DEPRECATED`.
:param str secret_id: (required)
The OCID of the secret.
:param int secret_version_number: (required)
The version number of the secret.
:param ScheduleSecretVersionDeletionDetails schedule_secret_version_deletion_details: (required)
Request to delete a secret version.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}/version/{secretVersionNumber}/actions/scheduleDeletion"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"schedule_secret_version_deletion got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id,
"secretVersionNumber": secret_version_number
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=schedule_secret_version_deletion_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=schedule_secret_version_deletion_details)
def update_secret(self, secret_id, update_secret_details, **kwargs):
"""
Updates the properties of a secret. Specifically, you can update the version number of the secret to make
that version number the current version. You can also update a secret's description, its free-form or defined tags, rules
and the secret contents. Updating the secret content automatically creates a new secret version. You cannot, however, update the current secret version number and the secret contents and the rules at the
same time. Furthermore, the secret must in an `ACTIVE` lifecycle state to be updated.
This operation is not supported by the Oracle Cloud Infrastructure Terraform Provider.
:param str secret_id: (required)
The OCID of the secret.
:param UpdateSecretDetails update_secret_details: (required)
Request to update a secret.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vault.models.Secret`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/secrets/{secretId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_secret got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"secretId": secret_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_secret_details,
response_type="Secret")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_secret_details,
response_type="Secret")
class DataSafeClient(object):
"""
APIs for using Oracle Data Safe.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(
tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(config, "pass_phrase"),
private_key_content=config.get("key_content")
)
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20181201',
'service_endpoint_template': 'https://datasafe.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("data_safe", config, signer, data_safe_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_data_safe_private_endpoint_compartment(self, data_safe_private_endpoint_id, change_data_safe_private_endpoint_compartment_details, **kwargs):
"""
Moves the Data Safe private endpoint and its dependent resources to the specified compartment.
:param str data_safe_private_endpoint_id: (required)
The OCID of the private endpoint.
:param ChangeDataSafePrivateEndpointCompartmentDetails change_data_safe_private_endpoint_compartment_details: (required)
The details used to change the compartment of a Data Safe private endpoint.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the if-match parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/dataSafePrivateEndpoints/{dataSafePrivateEndpointId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"change_data_safe_private_endpoint_compartment got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"dataSafePrivateEndpointId": data_safe_private_endpoint_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_data_safe_private_endpoint_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_data_safe_private_endpoint_compartment_details)
def create_data_safe_private_endpoint(self, create_data_safe_private_endpoint_details, **kwargs):
"""
Creates a new Data Safe private endpoint.
:param CreateDataSafePrivateEndpointDetails create_data_safe_private_endpoint_details: (required)
Details to create a new private endpoint.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request might be rejected.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/dataSafePrivateEndpoints"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_retry_token",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_data_safe_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_data_safe_private_endpoint_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_data_safe_private_endpoint_details)
def delete_data_safe_private_endpoint(self, data_safe_private_endpoint_id, **kwargs):
"""
Deletes the specified Data Safe private endpoint.
:param str data_safe_private_endpoint_id: (required)
The OCID of the private endpoint.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the if-match parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/dataSafePrivateEndpoints/{dataSafePrivateEndpointId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"delete_data_safe_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"dataSafePrivateEndpointId": data_safe_private_endpoint_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def enable_data_safe_configuration(self, enable_data_safe_configuration_details, **kwargs):
"""
Enables Data Safe in the tenancy and region.
:param EnableDataSafeConfigurationDetails enable_data_safe_configuration_details: (required)
The details used to enable Data Safe.
:param str compartment_id: (optional)
A filter to return only resources that match the specified compartment OCID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the if-match parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/configuration"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"compartment_id",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"enable_data_safe_configuration got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {
"compartmentId": kwargs.get("compartment_id", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
body=enable_data_safe_configuration_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
body=enable_data_safe_configuration_details)
def get_data_safe_configuration(self, **kwargs):
"""
Gets the details of the Data Safe configuration.
:param str compartment_id: (optional)
A filter to return only resources that match the specified compartment OCID.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_safe.models.DataSafeConfiguration`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/configuration"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"compartment_id",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_data_safe_configuration got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {
"compartmentId": kwargs.get("compartment_id", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="DataSafeConfiguration")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="DataSafeConfiguration")
def get_data_safe_private_endpoint(self, data_safe_private_endpoint_id, **kwargs):
"""
Gets the details of the specified Data Safe private endpoint.
:param str data_safe_private_endpoint_id: (required)
The OCID of the private endpoint.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_safe.models.DataSafePrivateEndpoint`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/dataSafePrivateEndpoints/{dataSafePrivateEndpointId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_data_safe_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"dataSafePrivateEndpointId": data_safe_private_endpoint_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="DataSafePrivateEndpoint")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="DataSafePrivateEndpoint")
def get_work_request(self, work_request_id, **kwargs):
"""
Gets the details of the specified work request.
:param str work_request_id: (required)
The OCID of the work request.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_safe.models.WorkRequest`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests/{workRequestId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_work_request got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"workRequestId": work_request_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="WorkRequest")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="WorkRequest")
def list_data_safe_private_endpoints(self, **kwargs):
"""
Gets a list of Data Safe private endpoints.
:param str compartment_id: (optional)
A filter to return only resources that match the specified compartment OCID.
:param str display_name: (optional)
A filter to return only resources that match the specified display name.
:param str vcn_id: (optional)
A filter to return only the private endpoints that match the specified VCN OCID.
:param str lifecycle_state: (optional)
A filter to return only resources that match the specified lifecycle state.
Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED", "NA"
:param int limit: (optional)
For list pagination. The maximum number of items to return per page in a paginated \"List\" call. For details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/usingapi.htm#nine
:param str page: (optional)
The beginning page from which the results start retrieving.
:param str sort_order: (optional)
The sort order to use, either ascending (ASC) or descending (DESC).
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. You can specify only one sort order (sortOrder). The default order for TIMECREATED is descending. The default order for DISPLAYNAME is ascending. The DISPLAYNAME sort order is case sensitive.
Allowed values are: "TIMECREATED", "DISPLAYNAME"
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_safe.models.DataSafePrivateEndpointSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/dataSafePrivateEndpoints"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"compartment_id",
"display_name",
"vcn_id",
"lifecycle_state",
"limit",
"page",
"sort_order",
"sort_by",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_data_safe_private_endpoints got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED", "NA"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
)
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
)
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
)
query_params = {
"compartmentId": kwargs.get("compartment_id", missing),
"displayName": kwargs.get("display_name", missing),
"vcnId": kwargs.get("vcn_id", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[DataSafePrivateEndpointSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[DataSafePrivateEndpointSummary]")
def list_work_request_errors(self, work_request_id, **kwargs):
"""
Gets a list of errors for the specified work request.
:param str work_request_id: (required)
The OCID of the work request.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param str page: (optional)
The beginning page from which the results start retrieving.
:param int limit: (optional)
For list pagination. The maximum number of items to return per page in a paginated \"List\" call. For details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/usingapi.htm#nine
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_safe.models.WorkRequestError`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests/{workRequestId}/errors"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"page",
"limit"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_work_request_errors got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"workRequestId": work_request_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[WorkRequestError]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[WorkRequestError]")
def list_work_request_logs(self, work_request_id, **kwargs):
"""
Gets a list of log entries for the specified work request.
:param str work_request_id: (required)
The OCID of the work request.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param str page: (optional)
The beginning page from which the results start retrieving.
:param int limit: (optional)
For list pagination. The maximum number of items to return per page in a paginated \"List\" call. For details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/usingapi.htm#nine
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_safe.models.WorkRequestLogEntry`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests/{workRequestId}/logs"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"page",
"limit"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_work_request_logs got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"workRequestId": work_request_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[WorkRequestLogEntry]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="list[WorkRequestLogEntry]")
def list_work_requests(self, **kwargs):
"""
Gets a list of work requests.
:param str compartment_id: (optional)
A filter to return only resources that match the specified compartment OCID.
:param str resource_id: (optional)
A filter to return only work requests that match the specified resource OCID.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param str page: (optional)
The beginning page from which the results start retrieving.
:param int limit: (optional)
For list pagination. The maximum number of items to return per page in a paginated \"List\" call. For details about how pagination works, see `List Pagination`__.
__ https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/usingapi.htm#nine
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.data_safe.models.WorkRequestSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"compartment_id",
"resource_id",
"opc_request_id",
"page",
"limit"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_work_requests got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {
"compartmentId": kwargs.get("compartment_id", missing),
"resourceId": kwargs.get("resource_id", missing),
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[WorkRequestSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[WorkRequestSummary]")
def update_data_safe_private_endpoint(self, data_safe_private_endpoint_id, update_data_safe_private_endpoint_details, **kwargs):
"""
Updates one or more attributes of the specified Data Safe private endpoint.
:param str data_safe_private_endpoint_id: (required)
The OCID of the private endpoint.
:param UpdateDataSafePrivateEndpointDetails update_data_safe_private_endpoint_details: (required)
The details used to update a Data Safe private endpoint.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the if-match parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/dataSafePrivateEndpoints/{dataSafePrivateEndpointId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_data_safe_private_endpoint got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"dataSafePrivateEndpointId": data_safe_private_endpoint_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_data_safe_private_endpoint_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_data_safe_private_endpoint_details)
class AppmgmtControlClient(object):
"""
AppMgmt Control API
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20210330',
'service_endpoint_template':
'https://cp.appmgmt.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
self.base_client = BaseClient("appmgmt_control", config, signer,
appmgmt_control_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def activate_monitoring_plugin(self, monitored_instance_id, **kwargs):
"""
Activates Resource Plugin for compute instance identified by the instance ocid.
Stores monitored instances Id and its state. Tries to enable Resource Monitoring plugin by making
remote calls to Oracle Cloud Agent and Management Agent Cloud Service.
:param str monitored_instance_id: (required)
OCID of monitored instance.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/activate_monitoring_plugin.py.html>`__ to see an example of how to use activate_monitoring_plugin API.
"""
resource_path = "/monitoredInstances/{monitoredInstanceId}/actions/activateMonitoringPlugin"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"activate_monitoring_plugin got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"monitoredInstanceId": monitored_instance_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_monitored_instance(self, monitored_instance_id, **kwargs):
"""
Gets a monitored instance by identifier
:param str monitored_instance_id: (required)
OCID of monitored instance.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.appmgmt_control.models.MonitoredInstance`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/get_monitored_instance.py.html>`__ to see an example of how to use get_monitored_instance API.
"""
resource_path = "/monitoredInstances/{monitoredInstanceId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_monitored_instance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"monitoredInstanceId": monitored_instance_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="MonitoredInstance")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="MonitoredInstance")
def get_work_request(self, work_request_id, **kwargs):
"""
Gets the status of the work request with the given ID.
:param str work_request_id: (required)
The ID of the asynchronous request.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.appmgmt_control.models.WorkRequest`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/get_work_request.py.html>`__ to see an example of how to use get_work_request API.
"""
resource_path = "/workRequests/{workRequestId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_work_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"workRequestId": work_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="WorkRequest")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="WorkRequest")
def list_monitored_instances(self, compartment_id, **kwargs):
"""
Returns a list of monitored instances.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param str display_name: (optional)
A filter to return only resources that match the entire display name given.
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either ascending ('ASC') or descending ('DESC').
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
Allowed values are: "timeCreated", "displayName"
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.appmgmt_control.models.MonitoredInstanceCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/list_monitored_instances.py.html>`__ to see an example of how to use list_monitored_instances API.
"""
resource_path = "/monitoredInstances"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "display_name", "limit", "page", "sort_order",
"sort_by", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_monitored_instances got unknown kwargs: {!r}".format(
extra_kwargs))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"compartmentId": compartment_id,
"displayName": kwargs.get("display_name", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="MonitoredInstanceCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="MonitoredInstanceCollection")
def list_work_request_errors(self, work_request_id, **kwargs):
"""
Return a (paginated) list of errors for a given work request.
:param str work_request_id: (required)
The ID of the asynchronous request.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.appmgmt_control.models.WorkRequestErrorCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/list_work_request_errors.py.html>`__ to see an example of how to use list_work_request_errors API.
"""
resource_path = "/workRequests/{workRequestId}/errors"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "page", "limit"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_work_request_errors got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"workRequestId": work_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestErrorCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestErrorCollection")
def list_work_request_logs(self, work_request_id, **kwargs):
"""
Return a (paginated) list of logs for a given work request.
:param str work_request_id: (required)
The ID of the asynchronous request.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.appmgmt_control.models.WorkRequestLogEntryCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/list_work_request_logs.py.html>`__ to see an example of how to use list_work_request_logs API.
"""
resource_path = "/workRequests/{workRequestId}/logs"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "page", "limit"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_work_request_logs got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"workRequestId": work_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestLogEntryCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestLogEntryCollection")
def list_work_requests(self, compartment_id, **kwargs):
"""
Lists the work requests in a compartment.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param str work_request_id: (optional)
The ID of the asynchronous work request.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.appmgmt_control.models.WorkRequestSummaryCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/list_work_requests.py.html>`__ to see an example of how to use list_work_requests API.
"""
resource_path = "/workRequests"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "work_request_id", "opc_request_id", "page",
"limit"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_work_requests got unknown kwargs: {!r}".format(
extra_kwargs))
query_params = {
"compartmentId": compartment_id,
"workRequestId": kwargs.get("work_request_id", missing),
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestSummaryCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestSummaryCollection")
def publish_top_processes_metrics(self, monitored_instance_id, **kwargs):
"""
Starts cpu and memory top processes collection.
:param str monitored_instance_id: (required)
OCID of monitored instance.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/appmgmtcontrol/publish_top_processes_metrics.py.html>`__ to see an example of how to use publish_top_processes_metrics API.
"""
resource_path = "/monitoredInstances/{monitoredInstanceId}/actions/publishTopProcessesMetrics"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"publish_top_processes_metrics got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"monitoredInstanceId": monitored_instance_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
class StreamAdminClient(object):
"""
The API for the Streaming Service.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
The connection and read timeouts for the client. The default is that the client never times out. This keyword argument can be provided
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(
tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(config, "pass_phrase"),
private_key_content=config.get("key_content")
)
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20180418',
'service_endpoint_template': 'https://streaming.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("stream_admin", config, signer, streaming_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_stream_compartment(self, stream_id, change_stream_compartment_details, **kwargs):
"""
Moves a resource into a different compartment.
Moves a resource into a different compartment. When provided, If-Match is checked against ETag values of the resource.
:param str stream_id: (required)
The OCID of the stream to change compatment for.
:param ChangeStreamCompartmentDetails change_stream_compartment_details: (required)
The stream will be moved into the compartment specified within this entity.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"change_stream_compartment got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_stream_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_stream_compartment_details)
def create_archiver(self, stream_id, create_archiver_details, **kwargs):
"""
Create a new stream archiver for the specified stream.
Starts the provisioning of a new stream archiver.
To track the progress of the provisioning, you can periodically call :func:`get_archiver`.
In the response, the `lifecycleState` parameter of the :class:`Archiver` object tells you its current state.
:param str stream_id: (required)
The OCID of the stream.
:param CreateArchiverDetails create_archiver_details: (required)
A stream archiver parameters to create.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations (for example, if a resource has been deleted and purged from the system, then a retry of the original creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Archiver`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}/archiver"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"opc_retry_token"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_archiver got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_archiver_details,
response_type="Archiver")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_archiver_details,
response_type="Archiver")
def create_stream(self, create_stream_details, **kwargs):
"""
Creates a stream.
Starts the provisioning of a new stream.
To track the progress of the provisioning, you can periodically call :func:`get_stream`.
In the response, the `lifecycleState` parameter of the :class:`Stream` object tells you its current state.
:param CreateStreamDetails create_stream_details: (required)
The stream to create.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Stream`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_stream got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_stream_details,
response_type="Stream")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_stream_details,
response_type="Stream")
def delete_stream(self, stream_id, **kwargs):
"""
Deletes a stream.
Deletes a stream and its content. Stream contents are deleted immediately. The service retains records of the stream itself for 90 days after deletion.
The `lifecycleState` parameter of the `Stream` object changes to `DELETING` and the stream becomes inaccessible for read or write operations.
To verify that a stream has been deleted, make a :func:`get_stream` request. If the call returns the stream's
lifecycle state as `DELETED`, then the stream has been deleted. If the call returns a \"404 Not Found\" error, that means all records of the
stream have been deleted.
:param str stream_id: (required)
The OCID of the stream to delete.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"delete_stream got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_archiver(self, stream_id, **kwargs):
"""
Returns the current state of the stream archiver.
Returns the current state of the stream archiver.
:param str stream_id: (required)
The OCID of the stream.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Archiver`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}/archiver"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_archiver got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Archiver")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Archiver")
def get_stream(self, stream_id, **kwargs):
"""
Gets a stream
Gets detailed information about a stream, including the number of partitions.
:param str stream_id: (required)
The OCID of the stream to retrieve.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Stream`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_stream got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Stream")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Stream")
def list_streams(self, compartment_id, **kwargs):
"""
Lists the streams.
Lists the streams.
:param str compartment_id: (required)
The OCID of the compartment.
:param str id: (optional)
A filter to return only resources that match the given ID exactly.
:param str name: (optional)
A filter to return only resources that match the given name exactly.
:param int limit: (optional)
The maximum number of items to return. The value must be between 1 and 50. The default is 10.
:param str page: (optional)
The page at which to start retrieving results.
:param str sort_by: (optional)
The field to sort by. You can provide no more than one sort order. By default, `TIMECREATED` sorts results in descending order and `NAME` sorts results in ascending order.
Allowed values are: "NAME", "TIMECREATED"
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'.
Allowed values are: "ASC", "DESC"
:param str lifecycle_state: (optional)
A filter to only return resources that match the given lifecycle state. The state value is case-insensitive.
Allowed values are: "CREATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.streaming.models.StreamSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"id",
"name",
"limit",
"page",
"sort_by",
"sort_order",
"lifecycle_state",
"opc_request_id"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_streams got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["NAME", "TIMECREATED"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
)
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
)
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "DELETING", "DELETED", "FAILED"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
)
query_params = {
"compartmentId": compartment_id,
"id": kwargs.get("id", missing),
"name": kwargs.get("name", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[StreamSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[StreamSummary]")
def start_archiver(self, stream_id, **kwargs):
"""
Start the archiver for the specified stream.
Start the archiver for the specified stream.
:param str stream_id: (required)
The OCID of the stream.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Archiver`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}/archiver/actions/start"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"start_archiver got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Archiver")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Archiver")
def stop_archiver(self, stream_id, **kwargs):
"""
Stop the archiver for the specified stream.
Stop the archiver for the specified stream.
:param str stream_id: (required)
The OCID of the stream.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Archiver`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}/archiver/actions/stop"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"stop_archiver got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Archiver")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Archiver")
def update_archiver(self, stream_id, update_archiver_details, **kwargs):
"""
Update the stream archiver parameters.
:param str stream_id: (required)
The OCID of the stream.
:param UpdateArchiverDetails update_archiver_details: (required)
The new parameters of the stream archiver.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Archiver`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}/archiver"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_archiver got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_archiver_details,
response_type="Archiver")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_archiver_details,
response_type="Archiver")
def update_stream(self, stream_id, update_stream_details, **kwargs):
"""
Updates a stream.
Updates the tags applied to the stream.
:param str stream_id: (required)
The OCID of the stream to update.
:param UpdateStreamDetails update_stream_details: (required)
The stream is updated with the tags provided.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match parameter to the value of the etag from a previous GET or POST response for that resource. The resource will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.streaming.models.Stream`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/streams/{streamId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_stream got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"streamId": stream_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_stream_details,
response_type="Stream")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_stream_details,
response_type="Stream")
class DbBackupsClient(object):
"""
The API for the MySQL Database Service
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
:param allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
allow control characters to be in the response object.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20190415',
'service_endpoint_template':
'https://mysql.{region}.ocp.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
if 'allow_control_chars' in kwargs:
base_client_init_kwargs['allow_control_chars'] = kwargs.get(
'allow_control_chars')
self.base_client = BaseClient("db_backups", config, signer,
mysql_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def change_backup_compartment(self, backup_id,
change_backup_compartment_details, **kwargs):
"""
Moves a DB System Backup into a different compartment.
When provided, If-Match is checked against ETag values of the Backup.
:param str backup_id: (required)
The OCID of the Backup
:param oci.mysql.models.ChangeBackupCompartmentDetails change_backup_compartment_details: (required)
Target compartment for a DB System Backup.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated before
then due to conflicting operations (for example, if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/change_backup_compartment.py.html>`__ to see an example of how to use change_backup_compartment API.
"""
resource_path = "/backups/{backupId}/actions/changeCompartment"
method = "POST"
operation_name = "change_backup_compartment"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/mysql/20190415/Backup/ChangeBackupCompartment"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "if_match",
"opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_backup_compartment got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"backupId": backup_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_backup_compartment_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_backup_compartment_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def create_backup(self, create_backup_details, **kwargs):
"""
Create a backup of a DB System.
:param oci.mysql.models.CreateBackupDetails create_backup_details: (required)
Create a Backup of a DB System.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated before
then due to conflicting operations (for example, if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Backup`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/create_backup.py.html>`__ to see an example of how to use create_backup API.
"""
resource_path = "/backups"
method = "POST"
operation_name = "create_backup"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/mysql/20190415/Backup/CreateBackup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id",
"opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_backup got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_backup_details,
response_type="Backup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_backup_details,
response_type="Backup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def delete_backup(self, backup_id, **kwargs):
"""
Delete a Backup.
:param str backup_id: (required)
The OCID of the Backup
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/delete_backup.py.html>`__ to see an example of how to use delete_backup API.
"""
resource_path = "/backups/{backupId}"
method = "DELETE"
operation_name = "delete_backup"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/mysql/20190415/Backup/DeleteBackup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "if_match",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_backup got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"backupId": backup_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_backup(self, backup_id, **kwargs):
"""
Get information about the specified Backup
:param str backup_id: (required)
The OCID of the Backup
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str if_none_match: (optional)
For conditional requests. In the GET call for a resource, set the
`If-None-Match` header to the value of the ETag from a previous GET (or
POST or PUT) response for that resource. The server will return with
either a 304 Not Modified response if the resource has not changed, or a
200 OK response with the updated representation.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Backup`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/get_backup.py.html>`__ to see an example of how to use get_backup API.
"""
resource_path = "/backups/{backupId}"
method = "GET"
operation_name = "get_backup"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/mysql/20190415/Backup/GetBackup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id",
"if_none_match"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_backup got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"backupId": backup_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-none-match": kwargs.get("if_none_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Backup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Backup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_backups(self, compartment_id, **kwargs):
"""
Get a list of DB System backups.
:param str compartment_id: (required)
The compartment `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str backup_id: (optional)
Backup OCID
:param str lifecycle_state: (optional)
Backup Lifecycle State
Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED"
:param str db_system_id: (optional)
The DB System `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str display_name: (optional)
A filter to return only the resource matching the given display name exactly.
:param str creation_type: (optional)
Backup creationType
Allowed values are: "MANUAL", "AUTOMATIC", "OPERATOR"
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Time fields are default ordered as descending.
Allowed values are: "timeCreated", "timeUpdated", "displayName"
:param str sort_order: (optional)
The sort order to use (ASC or DESC).
Allowed values are: "ASC", "DESC"
:param int limit: (optional)
The maximum number of items to return in a paginated list call. For information about pagination, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/#API/Concepts/usingapi.htm#List_Pagination
:param str page: (optional)
The value of the `opc-next-page` or `opc-prev-page` response header from
the previous list call. For information about pagination, see `List
Pagination`__.
__ https://docs.cloud.oracle.com/#API/Concepts/usingapi.htm#List_Pagination
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.mysql.models.BackupSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/list_backups.py.html>`__ to see an example of how to use list_backups API.
"""
resource_path = "/backups"
method = "GET"
operation_name = "list_backups"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/mysql/20190415/BackupSummary/ListBackups"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id",
"backup_id", "lifecycle_state", "db_system_id", "display_name",
"creation_type", "sort_by", "sort_order", "limit", "page"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_backups got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING",
"DELETED", "FAILED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'creation_type' in kwargs:
creation_type_allowed_values = ["MANUAL", "AUTOMATIC", "OPERATOR"]
if kwargs['creation_type'] not in creation_type_allowed_values:
raise ValueError(
"Invalid value for `creation_type`, must be one of {0}".
format(creation_type_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = [
"timeCreated", "timeUpdated", "displayName"
]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
query_params = {
"backupId": kwargs.get("backup_id", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"compartmentId": compartment_id,
"dbSystemId": kwargs.get("db_system_id", missing),
"displayName": kwargs.get("display_name", missing),
"creationType": kwargs.get("creation_type", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[BackupSummary]",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[BackupSummary]",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def update_backup(self, backup_id, update_backup_details, **kwargs):
"""
Update the metadata of a Backup. Metadata such as the displayName or description
:param str backup_id: (required)
The OCID of the Backup
:param oci.mysql.models.UpdateBackupDetails update_backup_details: (required)
Request to update a Backup's metadata.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Backup`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/update_backup.py.html>`__ to see an example of how to use update_backup API.
"""
resource_path = "/backups/{backupId}"
method = "PUT"
operation_name = "update_backup"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/mysql/20190415/Backup/UpdateBackup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "if_match",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_backup got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"backupId": backup_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_backup_details,
response_type="Backup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_backup_details,
response_type="Backup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class GatewayClient(object):
"""
API for the API Gateway service. Use this API to manage gateways, deployments, and related items.
For more information, see
[Overview of API Gateway](/iaas/Content/APIGateway/Concepts/apigatewayoverview.htm).
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
:param allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
allow control characters to be in the response object.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20190501',
'service_endpoint_template':
'https://apigateway.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
if 'allow_control_chars' in kwargs:
base_client_init_kwargs['allow_control_chars'] = kwargs.get(
'allow_control_chars')
self.base_client = BaseClient("gateway", config, signer,
apigateway_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def change_gateway_compartment(self, gateway_id,
change_gateway_compartment_details,
**kwargs):
"""
Changes the gateway compartment.
:param str gateway_id: (required)
The ocid of the gateway.
:param oci.apigateway.models.ChangeGatewayCompartmentDetails change_gateway_compartment_details: (required)
Details of the target compartment.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apigateway/change_gateway_compartment.py.html>`__ to see an example of how to use change_gateway_compartment API.
"""
resource_path = "/gateways/{gatewayId}/actions/changeCompartment"
method = "POST"
operation_name = "change_gateway_compartment"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/api-gateway/20190501/Gateway/ChangeGatewayCompartment"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_retry_token",
"if_match", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_gateway_compartment got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"gatewayId": gateway_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_gateway_compartment_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_gateway_compartment_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def create_gateway(self, create_gateway_details, **kwargs):
"""
Creates a new gateway.
:param oci.apigateway.models.CreateGatewayDetails create_gateway_details: (required)
Details for the new gateway.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.apigateway.models.Gateway`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apigateway/create_gateway.py.html>`__ to see an example of how to use create_gateway API.
"""
resource_path = "/gateways"
method = "POST"
operation_name = "create_gateway"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_retry_token",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_gateway got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_gateway_details,
response_type="Gateway",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_gateway_details,
response_type="Gateway",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def delete_gateway(self, gateway_id, **kwargs):
"""
Deletes the gateway with the given identifier.
:param str gateway_id: (required)
The ocid of the gateway.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apigateway/delete_gateway.py.html>`__ to see an example of how to use delete_gateway API.
"""
resource_path = "/gateways/{gatewayId}"
method = "DELETE"
operation_name = "delete_gateway"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/api-gateway/20190501/Gateway/DeleteGateway"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "if_match",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_gateway got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"gatewayId": gateway_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_gateway(self, gateway_id, **kwargs):
"""
Gets a gateway by identifier.
:param str gateway_id: (required)
The ocid of the gateway.
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.apigateway.models.Gateway`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apigateway/get_gateway.py.html>`__ to see an example of how to use get_gateway API.
"""
resource_path = "/gateways/{gatewayId}"
method = "GET"
operation_name = "get_gateway"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/api-gateway/20190501/Gateway/GetGateway"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_gateway got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"gatewayId": gateway_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Gateway",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Gateway",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_gateways(self, compartment_id, **kwargs):
"""
Returns a list of gateways.
:param str compartment_id: (required)
The ocid of the compartment in which to list resources.
:param str certificate_id: (optional)
Filter gateways by the certificate ocid.
:param str display_name: (optional)
A user-friendly name. Does not have to be unique, and it's changeable.
Example: `My new resource`
:param str lifecycle_state: (optional)
A filter to return only resources that match the given lifecycle state.
Example: `SUCCEEDED`
Allowed values are: "CREATING", "ACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED"
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'. The default order depends on the sortBy value.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`).
Default order for `timeCreated` is descending. Default order for
`displayName` is ascending. The `displayName` sort order is case
sensitive.
Allowed values are: "timeCreated", "displayName"
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.apigateway.models.GatewayCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apigateway/list_gateways.py.html>`__ to see an example of how to use list_gateways API.
"""
resource_path = "/gateways"
method = "GET"
operation_name = "list_gateways"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/api-gateway/20190501/GatewaySummary/ListGateways"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "certificate_id",
"display_name", "lifecycle_state", "limit", "page", "sort_order",
"sort_by", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_gateways got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "ACTIVE", "UPDATING", "DELETING", "DELETED",
"FAILED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"compartmentId": compartment_id,
"certificateId": kwargs.get("certificate_id", missing),
"displayName": kwargs.get("display_name", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="GatewayCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="GatewayCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def update_gateway(self, gateway_id, update_gateway_details, **kwargs):
"""
Updates the gateway with the given identifier.
:param str gateway_id: (required)
The ocid of the gateway.
:param oci.apigateway.models.UpdateGatewayDetails update_gateway_details: (required)
The information to be updated.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apigateway/update_gateway.py.html>`__ to see an example of how to use update_gateway API.
"""
resource_path = "/gateways/{gatewayId}"
method = "PUT"
operation_name = "update_gateway"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/api-gateway/20190501/Gateway/UpdateGateway"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "if_match",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_gateway got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"gatewayId": gateway_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_gateway_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_gateway_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class DashboardGroupClient(object):
"""
Use the Oracle Cloud Infrastructure Dashboards service API to manage dashboards in the Console.
Dashboards provide an organized and customizable view of resources and their metrics in the Console.
For more information, see [Dashboards](/Content/Dashboards/home.htm).
**Important:** Resources for the Dashboards service are created in the tenacy's home region.
Although it is possible to create dashboard and dashboard group resources in regions other than the home region,
you won't be able to view those resources in the Console.
Therefore, creating resources outside of the home region is not recommended.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
:param allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
allow control characters to be in the response object.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20210731',
'service_endpoint_template':
'https://dashboard.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
if 'allow_control_chars' in kwargs:
base_client_init_kwargs['allow_control_chars'] = kwargs.get(
'allow_control_chars')
self.base_client = BaseClient("dashboard_group", config, signer,
dashboard_service_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def create_dashboard_group(self, create_dashboard_group_details, **kwargs):
"""
Creates a new dashboard group using the details provided in request body.
**Caution:** Resources for the Dashboard service are created in the tenacy's home region.
Although it is possible to create dashboard group resource in regions other than the home region,
you won't be able to view those resources in the Console.
Therefore, creating resources outside of the home region is not recommended.
:param oci.dashboard_service.models.CreateDashboardGroupDetails create_dashboard_group_details: (required)
Details about the dashboard group being created.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or server
error without risk of executing that same action again.
Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations
(for example, if a resource has been deleted and purged from the system,
then a retry of the original creation request may be rejected).
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_cross_region: (optional)
To identify if the call is cross-regional. In CRUD calls for a resource, to
identify that the call originates from different region, set the
`CrossRegionIdentifierHeader` parameter to a region name (ex - `US-ASHBURN-1`)
The call will be served from a Replicated bucket.
For same-region calls, the value is unassigned.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dashboard_service.models.DashboardGroup`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dashboardservice/create_dashboard_group.py.html>`__ to see an example of how to use create_dashboard_group API.
"""
resource_path = "/dashboardGroups"
method = "POST"
operation_name = "create_dashboard_group"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/dashboard/20210731/DashboardGroup/CreateDashboardGroup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_retry_token",
"opc_request_id", "opc_cross_region"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_dashboard_group got unknown kwargs: {!r}".format(
extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-cross-region": kwargs.get("opc_cross_region", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_dashboard_group_details,
response_type="DashboardGroup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_dashboard_group_details,
response_type="DashboardGroup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def delete_dashboard_group(self, dashboard_group_id, **kwargs):
"""
Deletes the specified dashboard group. Uses the dashboard group's OCID to determine which dashboard group to delete.
:param str dashboard_group_id: (required)
The `OCID`__ of the dashboard group.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_cross_region: (optional)
To identify if the call is cross-regional. In CRUD calls for a resource, to
identify that the call originates from different region, set the
`CrossRegionIdentifierHeader` parameter to a region name (ex - `US-ASHBURN-1`)
The call will be served from a Replicated bucket.
For same-region calls, the value is unassigned.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dashboardservice/delete_dashboard_group.py.html>`__ to see an example of how to use delete_dashboard_group API.
"""
resource_path = "/dashboardGroups/{dashboardGroupId}"
method = "DELETE"
operation_name = "delete_dashboard_group"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/dashboard/20210731/DashboardGroup/DeleteDashboardGroup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "if_match",
"opc_request_id", "opc_cross_region"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_dashboard_group got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"dashboardGroupId": dashboard_group_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-cross-region": kwargs.get("opc_cross_region", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_dashboard_group(self, dashboard_group_id, **kwargs):
"""
Gets the specified dashboard group's information. Uses the dashboard group's OCID to determine which dashboard to retrieve.
:param str dashboard_group_id: (required)
The `OCID`__ of the dashboard group.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_cross_region: (optional)
To identify if the call is cross-regional. In CRUD calls for a resource, to
identify that the call originates from different region, set the
`CrossRegionIdentifierHeader` parameter to a region name (ex - `US-ASHBURN-1`)
The call will be served from a Replicated bucket.
For same-region calls, the value is unassigned.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dashboard_service.models.DashboardGroup`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dashboardservice/get_dashboard_group.py.html>`__ to see an example of how to use get_dashboard_group API.
"""
resource_path = "/dashboardGroups/{dashboardGroupId}"
method = "GET"
operation_name = "get_dashboard_group"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/dashboard/20210731/DashboardGroup/GetDashboardGroup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id",
"opc_cross_region"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_dashboard_group got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"dashboardGroupId": dashboard_group_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-cross-region": kwargs.get("opc_cross_region", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="DashboardGroup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="DashboardGroup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_dashboard_groups(self, compartment_id, **kwargs):
"""
Returns a list of dashboard groups with a specific compartment ID.
:param str compartment_id: (required)
The `OCID`__ of the compartment in which to list resources.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str lifecycle_state: (optional)
A filter that returns dashboard groups that match the lifecycle state specified.
Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
:param str display_name: (optional)
A case-sensitive filter that returns resources that match the entire display name specified.
:param str id: (optional)
The `OCID`__ of the dashboard group.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This value is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either ascending (`ASC`) or descending (`DESC`).
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`).
Default order for TIMECREATED is descending.
Default order for DISPLAYNAME is ascending.
The DISPLAYNAME sort order is case sensitive.
Allowed values are: "timeCreated", "displayName"
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_cross_region: (optional)
To identify if the call is cross-regional. In CRUD calls for a resource, to
identify that the call originates from different region, set the
`CrossRegionIdentifierHeader` parameter to a region name (ex - `US-ASHBURN-1`)
The call will be served from a Replicated bucket.
For same-region calls, the value is unassigned.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation uses :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` as default if no retry strategy is provided.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dashboard_service.models.DashboardGroupCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dashboardservice/list_dashboard_groups.py.html>`__ to see an example of how to use list_dashboard_groups API.
"""
resource_path = "/dashboardGroups"
method = "GET"
operation_name = "list_dashboard_groups"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/dashboard/20210731/DashboardGroupCollection/ListDashboardGroups"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "lifecycle_state",
"display_name", "id", "limit", "page", "sort_order", "sort_by",
"opc_request_id", "opc_cross_region"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_dashboard_groups got unknown kwargs: {!r}".format(
extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED",
"FAILED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"compartmentId": compartment_id,
"lifecycleState": kwargs.get("lifecycle_state", missing),
"displayName": kwargs.get("display_name", missing),
"id": kwargs.get("id", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-cross-region": kwargs.get("opc_cross_region", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy is None:
retry_strategy = retry.DEFAULT_RETRY_STRATEGY
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="DashboardGroupCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="DashboardGroupCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def update_dashboard_group(self, dashboard_group_id,
update_dashboard_group_details, **kwargs):
"""
Updates the specified dashboard group. Uses the dashboard group's OCID to determine which dashboard group to update.
:param str dashboard_group_id: (required)
The `OCID`__ of the dashboard group.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param oci.dashboard_service.models.UpdateDashboardGroupDetails update_dashboard_group_details: (required)
The dashboard group details to be updated.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_cross_region: (optional)
To identify if the call is cross-regional. In CRUD calls for a resource, to
identify that the call originates from different region, set the
`CrossRegionIdentifierHeader` parameter to a region name (ex - `US-ASHBURN-1`)
The call will be served from a Replicated bucket.
For same-region calls, the value is unassigned.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dashboard_service.models.DashboardGroup`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dashboardservice/update_dashboard_group.py.html>`__ to see an example of how to use update_dashboard_group API.
"""
resource_path = "/dashboardGroups/{dashboardGroupId}"
method = "PUT"
operation_name = "update_dashboard_group"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/dashboard/20210731/DashboardGroup/UpdateDashboardGroup"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "if_match",
"opc_request_id", "opc_cross_region"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_dashboard_group got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"dashboardGroupId": dashboard_group_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-cross-region": kwargs.get("opc_cross_region", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_dashboard_group_details,
response_type="DashboardGroup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_dashboard_group_details,
response_type="DashboardGroup",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class SddcClient(object):
"""
Use this API to manage the Oracle Cloud VMware Solution.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20200501',
'service_endpoint_template':
'https://ocvps.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("sddc", config, signer,
ocvp_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_sddc_compartment(self, sddc_id, change_sddc_compartment_details,
**kwargs):
"""
Moves an SDDC into a different compartment within the same tenancy. For information
about moving resources between compartments, see
`Moving Resources to a Different Compartment`__.
__ https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes
:param str sddc_id: (required)
The `OCID`__ of the SDDC.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param ChangeSddcCompartmentDetails change_sddc_compartment_details: (required)
Request to change the compartment of the specified SDDC
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If you need to contact Oracle about a particular
request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/sddcs/{sddcId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_sddc_compartment got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"sddcId": sddc_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_sddc_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_sddc_compartment_details)
def create_sddc(self, create_sddc_details, **kwargs):
"""
Creates a software-defined data center (SDDC).
Use the :class:`WorkRequest` operations to track the
creation of the SDDC.
:param CreateSddcDetails create_sddc_details: (required)
Details for the SDDC.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
Unique identifier for the request. If you need to contact Oracle about a particular
request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/sddcs"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_sddc got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_sddc_details)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_sddc_details)
def delete_sddc(self, sddc_id, **kwargs):
"""
Deletes the specified SDDC, along with the other resources that were
created with the SDDC. For example: the Compute instances, DNS records,
and so on.
Use the :class:`WorkRequest` operations to track the
deletion of the SDDC.
:param str sddc_id: (required)
The `OCID`__ of the SDDC.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If you need to contact Oracle about a particular
request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/sddcs/{sddcId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_sddc got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"sddcId": sddc_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_sddc(self, sddc_id, **kwargs):
"""
Gets the specified SDDC's information.
:param str sddc_id: (required)
The `OCID`__ of the SDDC.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Unique identifier for the request. If you need to contact Oracle about a particular
request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ocvp.models.Sddc`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/sddcs/{sddcId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_sddc got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"sddcId": sddc_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Sddc")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Sddc")
def list_sddcs(self, compartment_id, **kwargs):
"""
Lists the SDDCs in the specified compartment. The list can be
filtered by display name or availability domain.
:param str compartment_id: (required)
The `OCID`__ of the compartment.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str compute_availability_domain: (optional)
The name of the availability domain that the Compute instances are running in.
Example: `Uocm:PHX-AD-1`
:param str display_name: (optional)
A filter to return only resources that match the given display name exactly.
:param int limit: (optional)
For list pagination. The maximum number of results per page, or items to return in a paginated
\"List\" call. For important details about how pagination works, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str page: (optional)
For list pagination. The value of the `opc-next-page` response header from the previous \"List\"
call. For important details about how pagination works, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str sort_order: (optional)
The sort order to use, either ascending (`ASC`) or descending (`DESC`). The DISPLAYNAME sort order
is case sensitive.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`). Default order for
TIMECREATED is descending. Default order for DISPLAYNAME is ascending. The DISPLAYNAME
sort order is case sensitive.
**Note:** In general, some \"List\" operations (for example, `ListInstances`) let you
optionally filter by availability domain if the scope of the resource type is within a
single availability domain. If you call one of these \"List\" operations without specifying
an availability domain, the resources are grouped by availability domain, then sorted.
Allowed values are: "timeCreated", "displayName"
:param str opc_request_id: (optional)
Unique identifier for the request. If you need to contact Oracle about a particular
request, please provide the request ID.
:param str lifecycle_state: (optional)
The lifecycle state of the resource.
Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ocvp.models.SddcCollection`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/sddcs"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "compute_availability_domain", "display_name",
"limit", "page", "sort_order", "sort_by", "opc_request_id",
"lifecycle_state"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_sddcs got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED",
"FAILED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
query_params = {
"compartmentId":
compartment_id,
"computeAvailabilityDomain":
kwargs.get("compute_availability_domain", missing),
"displayName":
kwargs.get("display_name", missing),
"limit":
kwargs.get("limit", missing),
"page":
kwargs.get("page", missing),
"sortOrder":
kwargs.get("sort_order", missing),
"sortBy":
kwargs.get("sort_by", missing),
"lifecycleState":
kwargs.get("lifecycle_state", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="SddcCollection")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="SddcCollection")
def list_supported_vmware_software_versions(self, compartment_id,
**kwargs):
"""
Lists the versions of bundled VMware software supported by the Oracle Cloud
VMware Solution.
:param str compartment_id: (required)
The `OCID`__ of the compartment.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param int limit: (optional)
For list pagination. The maximum number of results per page, or items to return in a paginated
\"List\" call. For important details about how pagination works, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str page: (optional)
For list pagination. The value of the `opc-next-page` response header from the previous \"List\"
call. For important details about how pagination works, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str opc_request_id: (optional)
Unique identifier for the request. If you need to contact Oracle about a particular
request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ocvp.models.SupportedVmwareSoftwareVersionCollection`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/supportedVmwareSoftwareVersions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "limit", "page", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_supported_vmware_software_versions got unknown kwargs: {!r}"
.format(extra_kwargs))
query_params = {
"compartmentId": compartment_id,
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="SupportedVmwareSoftwareVersionCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="SupportedVmwareSoftwareVersionCollection")
def update_sddc(self, sddc_id, update_sddc_details, **kwargs):
"""
Updates the specified SDDC.
**Important:** Updating an SDDC affects only certain attributes in the `Sddc`
object and does not affect the VMware environment currently running in
the SDDC. For more information, see
:func:`update_sddc_details`.
:param str sddc_id: (required)
The `OCID`__ of the SDDC.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param UpdateSddcDetails update_sddc_details: (required)
The information to be updated.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If you need to contact Oracle about a particular
request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.ocvp.models.Sddc`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/sddcs/{sddcId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_sddc got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"sddcId": sddc_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_sddc_details,
response_type="Sddc")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_sddc_details,
response_type="Sddc")
class RefreshActivityClient(object):
"""
Use the Fusion Applications Environment Management API to manage the environments where your Fusion Applications run. For more information, see the [Fusion Applications Environment Management documentation](/iaas/Content/Identity/fusion-applications/home.htm).
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
:param allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
allow control characters to be in the response object.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20211201',
'service_endpoint_template':
'https://fusionapps.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
if 'allow_control_chars' in kwargs:
base_client_init_kwargs['allow_control_chars'] = kwargs.get(
'allow_control_chars')
self.base_client = BaseClient("refresh_activity", config, signer,
fusion_apps_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def create_refresh_activity(self, fusion_environment_id,
create_refresh_activity_details, **kwargs):
"""
Creates a new RefreshActivity.
:param str fusion_environment_id: (required)
unique FusionEnvironment identifier
:param oci.fusion_apps.models.CreateRefreshActivityDetails create_refresh_activity_details: (required)
Details for the new RefreshActivity.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/create_refresh_activity.py.html>`__ to see an example of how to use create_refresh_activity API.
"""
resource_path = "/fusionEnvironments/{fusionEnvironmentId}/refreshActivities"
method = "POST"
operation_name = "create_refresh_activity"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_retry_token",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_refresh_activity got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"fusionEnvironmentId": fusion_environment_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_refresh_activity_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_refresh_activity_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_refresh_activity(self, fusion_environment_id, refresh_activity_id,
**kwargs):
"""
Gets a RefreshActivity by identifier
:param str fusion_environment_id: (required)
unique FusionEnvironment identifier
:param str refresh_activity_id: (required)
The unique identifier (OCID) of the Refresh activity.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.fusion_apps.models.RefreshActivity`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/get_refresh_activity.py.html>`__ to see an example of how to use get_refresh_activity API.
"""
resource_path = "/fusionEnvironments/{fusionEnvironmentId}/refreshActivities/{refreshActivityId}"
method = "GET"
operation_name = "get_refresh_activity"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_refresh_activity got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"fusionEnvironmentId": fusion_environment_id,
"refreshActivityId": refresh_activity_id
}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RefreshActivity",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RefreshActivity",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_refresh_activities(self, fusion_environment_id, **kwargs):
"""
Returns a list of RefreshActivities.
:param str fusion_environment_id: (required)
unique FusionEnvironment identifier
:param str display_name: (optional)
A filter to return only resources that match the entire display name given.
:param datetime time_scheduled_start_greater_than_or_equal_to: (optional)
A filter that returns all resources that are scheduled after this date
:param datetime time_expected_finish_less_than_or_equal_to: (optional)
A filter that returns all resources that end before this date
:param str lifecycle_state: (optional)
A filter that returns all resources that match the specified status
Allowed values are: "ACCEPTED", "IN_PROGRESS", "FAILED", "SUCCEEDED", "CANCELED"
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
Allowed values are: "TIME_CREATED", "DISPLAY_NAME"
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.fusion_apps.models.RefreshActivityCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/list_refresh_activities.py.html>`__ to see an example of how to use list_refresh_activities API.
"""
resource_path = "/fusionEnvironments/{fusionEnvironmentId}/refreshActivities"
method = "GET"
operation_name = "list_refresh_activities"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "display_name",
"time_scheduled_start_greater_than_or_equal_to",
"time_expected_finish_less_than_or_equal_to", "lifecycle_state",
"limit", "page", "sort_order", "sort_by", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_refresh_activities got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"fusionEnvironmentId": fusion_environment_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"ACCEPTED", "IN_PROGRESS", "FAILED", "SUCCEEDED", "CANCELED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"displayName":
kwargs.get("display_name", missing),
"timeScheduledStartGreaterThanOrEqualTo":
kwargs.get("time_scheduled_start_greater_than_or_equal_to",
missing),
"timeExpectedFinishLessThanOrEqualTo":
kwargs.get("time_expected_finish_less_than_or_equal_to", missing),
"lifecycleState":
kwargs.get("lifecycle_state", missing),
"limit":
kwargs.get("limit", missing),
"page":
kwargs.get("page", missing),
"sortOrder":
kwargs.get("sort_order", missing),
"sortBy":
kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="RefreshActivityCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="RefreshActivityCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_time_available_for_refreshes(self, fusion_environment_id,
**kwargs):
"""
Gets available refresh time for this fusion environment
:param str fusion_environment_id: (required)
unique FusionEnvironment identifier
:param str opc_request_id: (optional)
The client request ID for tracing.
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
Allowed values are: "TIME_CREATED", "DISPLAY_NAME"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.fusion_apps.models.TimeAvailableForRefreshCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/list_time_available_for_refreshes.py.html>`__ to see an example of how to use list_time_available_for_refreshes API.
"""
resource_path = "/fusionEnvironments/{fusionEnvironmentId}/timeAvailableForRefresh"
method = "GET"
operation_name = "list_time_available_for_refreshes"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id", "limit",
"page", "sort_order", "sort_by"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_time_available_for_refreshes got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"fusionEnvironmentId": fusion_environment_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIME_CREATED", "DISPLAY_NAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="TimeAvailableForRefreshCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="TimeAvailableForRefreshCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class WorkRequestsClient(object):
"""
API for the API Gateway service. Use this API to manage gateways, deployments, and related items.
For more information, see
[Overview of API Gateway](/iaas/Content/APIGateway/Concepts/apigatewayoverview.htm).
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20190501',
'service_endpoint_template':
'https://apigateway.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("work_requests", config, signer,
apigateway_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def cancel_work_request(self, work_request_id, **kwargs):
"""
Cancels the work request.
:param str work_request_id: (required)
The ocid of the asynchronous request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests/{workRequestId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "if_match", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"cancel_work_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"workRequestId": work_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_work_request(self, work_request_id, **kwargs):
"""
Gets the status of the work request with the given identifier.
:param str work_request_id: (required)
The ocid of the asynchronous request.
:param str opc_request_id: (optional)
The client request id for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.apigateway.models.WorkRequest`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests/{workRequestId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_work_request got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"workRequestId": work_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="WorkRequest")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="WorkRequest")
def list_work_request_errors(self, work_request_id, **kwargs):
"""
Returns a (paginated) list of errors for a given work request.
:param str work_request_id: (required)
The ocid of the asynchronous request.
:param str opc_request_id: (optional)
The client request id for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'. The default order depends on the sortBy value.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`).
Default order for `timeCreated` is descending. Default order for
`displayName` is ascending. The `displayName` sort order is case
sensitive.
Allowed values are: "timeCreated", "displayName"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.apigateway.models.WorkRequestErrorCollection`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests/{workRequestId}/errors"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "page", "limit", "sort_order",
"sort_by"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_work_request_errors got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"workRequestId": work_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestErrorCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestErrorCollection")
def list_work_request_logs(self, work_request_id, **kwargs):
"""
Returns a (paginated) list of logs for a given work request.
:param str work_request_id: (required)
The ocid of the asynchronous request.
:param str opc_request_id: (optional)
The client request id for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'. The default order depends on the sortBy value.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`).
Default order for `timeCreated` is descending. Default order for
`displayName` is ascending. The `displayName` sort order is case
sensitive.
Allowed values are: "timeCreated", "displayName"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.apigateway.models.WorkRequestLogCollection`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests/{workRequestId}/logs"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "page", "limit", "sort_order",
"sort_by"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_work_request_logs got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"workRequestId": work_request_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestLogCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestLogCollection")
def list_work_requests(self, compartment_id, **kwargs):
"""
Lists the work requests in a compartment.
:param str compartment_id: (required)
The ocid of the compartment in which to list resources.
:param str resource_id: (optional)
Filter work requests by the resource ocid.
:param str opc_request_id: (optional)
The client request id for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'. The default order depends on the sortBy value.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`).
Default order for `timeCreated` is descending. Default order for
`displayName` is ascending. The `displayName` sort order is case
sensitive.
Allowed values are: "timeCreated", "displayName"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.apigateway.models.WorkRequestCollection`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "resource_id", "opc_request_id", "page", "limit",
"sort_order", "sort_by"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_work_requests got unknown kwargs: {!r}".format(
extra_kwargs))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"compartmentId": compartment_id,
"resourceId": kwargs.get("resource_id", missing),
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="WorkRequestCollection")
class KmsVaultClient(object):
"""
API for managing and performing operations with keys and vaults.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.us-phoenix-1.oraclecloud.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
The connection and read timeouts for the client. The default is that the client never times out. This keyword argument can be provided
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.us-phoenix-1.oraclecloud.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20180608'
}
self.base_client = BaseClient("kms_vault", config, signer,
key_management_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def cancel_vault_deletion(self, vault_id, **kwargs):
"""
CancelVaultDeletion
Cancels the scheduled deletion of the specified Vault, which must be in PendingDeletion
state. The Vault and all Keys in it will be moved back to their previous states before
the deletion was scheduled.
:param str vault_id: (required)
The OCID of the vault.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated
before then due to conflicting operations (e.g., if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.key_management.models.Vault`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/vaults/{vaultId}/actions/cancelDeletion"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
key for key in six.iterkeys(kwargs) if key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"cancel_vault_deletion got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"vaultId": vault_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Vault")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Vault")
def create_vault(self, create_vault_details, **kwargs):
"""
CreateVault
Creates a new vault. The type of vault you create determines key
placement, pricing, and available options. Options include storage
isolation, a dedicated service endpoint instead of a shared service
endpoint for API calls, and a dedicated HSM or a multitenant HSM.
:param CreateVaultDetails create_vault_details: (required)
CreateVaultDetails
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated
before then due to conflicting operations (e.g., if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.key_management.models.Vault`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/vaults"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
key for key in six.iterkeys(kwargs) if key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_vault got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_vault_details,
response_type="Vault")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_vault_details,
response_type="Vault")
def get_vault(self, vault_id, **kwargs):
"""
GetVault
Gets the specified vault's configuration information.
:param str vault_id: (required)
The OCID of the vault.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.key_management.models.Vault`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/vaults/{vaultId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
key for key in six.iterkeys(kwargs) if key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_vault got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"vaultId": vault_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Vault")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Vault")
def list_vaults(self, compartment_id, **kwargs):
"""
ListVaults
Lists vaults in the specified compartment.
:param str compartment_id: (required)
The OCID of the compartment.
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call.
:param str page: (optional)
The value of the `opc-next-page` response header
from the previous \"List\" call.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str sort_by: (optional)
The field to sort by. You can specify only one sort order. The default
order for TIMECREATED is descending. The default order for DISPLAYNAME
is ascending.
Allowed values are: "TIMECREATED", "DISPLAYNAME"
:param str sort_order: (optional)
The sort order to use, either ascending (`ASC`) or descending (`DESC`).
Allowed values are: "ASC", "DESC"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.key_management.models.VaultSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/vaults"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "limit", "page", "opc_request_id", "sort_by",
"sort_order"
]
extra_kwargs = [
key for key in six.iterkeys(kwargs) if key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_vaults got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
query_params = {
"compartmentId": compartment_id,
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[VaultSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[VaultSummary]")
def schedule_vault_deletion(self, vault_id,
schedule_vault_deletion_details, **kwargs):
"""
ScheduleVaultDeletion
Schedules the deletion of the specified Vault. The Vault and all Keys in it
will be moved to PendingDeletion state and deleted after the retention period.
:param str vault_id: (required)
The OCID of the vault.
:param ScheduleVaultDeletionDetails schedule_vault_deletion_details: (required)
ScheduleVaultDeletionDetails
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated
before then due to conflicting operations (e.g., if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.key_management.models.Vault`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/vaults/{vaultId}/actions/scheduleDeletion"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
key for key in six.iterkeys(kwargs) if key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"schedule_vault_deletion got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"vaultId": vault_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=schedule_vault_deletion_details,
response_type="Vault")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=schedule_vault_deletion_details,
response_type="Vault")
def update_vault(self, vault_id, update_vault_details, **kwargs):
"""
UpdateVault
Updates the properties of a vault. Specifically, you can
only update the `displayName` property. Furthermore, the vault
must be in an `ACTIVE` or `CREATING` state.
:param str vault_id: (required)
The OCID of the vault.
:param UpdateVaultDetails update_vault_details: (required)
UpdateVaultDetails
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `if-match` parameter to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Unique identifier for the request. If provided, the returned request ID
will include this value. Otherwise, a random request ID will be
generated by the service.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.key_management.models.Vault`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/vaults/{vaultId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
key for key in six.iterkeys(kwargs) if key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_vault got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"vaultId": vault_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_vault_details,
response_type="Vault")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_vault_details,
response_type="Vault")
class OrdersClient(object):
"""
The Organizations API allows you to consolidate multiple OCI tenancies into an organization, and centrally manage your tenancies and its resources.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
:param allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
allow control characters to be in the response object.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20200801',
'service_endpoint_template':
'https://organizations.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
if 'allow_control_chars' in kwargs:
base_client_init_kwargs['allow_control_chars'] = kwargs.get(
'allow_control_chars')
self.base_client = BaseClient(
"orders", config, signer,
tenant_manager_control_plane_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def activate_order(self, activate_order_details, activation_token,
**kwargs):
"""
Triggers an order activation workflow on behalf of the tenant, given by compartment ID in the body.
:param oci.tenant_manager_control_plane.models.ActivateOrderDetails activate_order_details: (required)
The information needed to activate an order in a tenancy.
:param str activation_token: (required)
Activation Token containing an order ID. A JWT RFC 7519 formatted string.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request, so it can be retried in case of a timeout or
server error, without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/activate_order.py.html>`__ to see an example of how to use activate_order API.
"""
resource_path = "/orders/{activationToken}/actions/activate"
method = "POST"
operation_name = "activate_order"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/organizations/20200801/Order/ActivateOrder"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_retry_token",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"activate_order got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"activationToken": activation_token}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=activate_order_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=activate_order_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_order(self, activation_token, **kwargs):
"""
Returns the Order Details given by the order ID in the JWT.
:param str activation_token: (required)
Activation Token containing an order ID. A JWT RFC 7519 formatted string.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.tenant_manager_control_plane.models.Order`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/get_order.py.html>`__ to see an example of how to use get_order API.
"""
resource_path = "/orders/{activationToken}"
method = "GET"
operation_name = "get_order"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/organizations/20200801/Order/GetOrder"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_order got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"activationToken": activation_token}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Order",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Order",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class AnnouncementsPreferencesClient(object):
"""
Manage Oracle Cloud Infrastructure console announcements.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
:param allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
allow control characters to be in the response object.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20180904',
'service_endpoint_template':
'https://announcements.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
if 'allow_control_chars' in kwargs:
base_client_init_kwargs['allow_control_chars'] = kwargs.get(
'allow_control_chars')
self.base_client = BaseClient("announcements_preferences", config,
signer,
announcements_service_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def create_announcements_preference(self, announcements_preference_details,
**kwargs):
"""
Creates a request that specifies preferences for the tenancy regarding receiving announcements by email.
This call is subject to an Announcements limit that applies to the total number of requests across all read or write operations. Announcements might throttle this call to reject an otherwise valid request when the total rate of operations exceeds 20 requests per second for a given user. The service might also throttle this call to reject an otherwise valid request when the total rate of operations exceeds 100 requests per second for a given tenancy.
:param oci.announcements_service.models.CreateAnnouncementsPreferencesDetails announcements_preference_details: (required)
The object that contains details about tenancy preferences for receiving announcements by email.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the complete request ID.
:param str opc_retry_token: (optional)
Idempotency token
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.announcements_service.models.AnnouncementsPreferencesSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/announcementsservice/create_announcements_preference.py.html>`__ to see an example of how to use create_announcements_preference API.
"""
resource_path = "/announcementsPreferences"
method = "POST"
operation_name = "create_announcements_preference"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/announcements/0.0.1/AnnouncementsPreferencesSummary/CreateAnnouncementsPreference"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id",
"opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_announcements_preference got unknown kwargs: {!r}".
format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=announcements_preference_details,
response_type="AnnouncementsPreferencesSummary",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=announcements_preference_details,
response_type="AnnouncementsPreferencesSummary",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_announcements_preference(self, preference_id, **kwargs):
"""
Gets the current preferences of the tenancy regarding receiving announcements by email.
This call is subject to an Announcements limit that applies to the total number of requests across all read or write operations. Announcements might throttle this call to reject an otherwise valid request when the total rate of operations exceeds 20 requests per second for a given user. The service might also throttle this call to reject an otherwise valid request when the total rate of operations exceeds 100 requests per second for a given tenancy.
:param str preference_id: (required)
The ID of the preference.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the complete request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.announcements_service.models.AnnouncementsPreferences`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/announcementsservice/get_announcements_preference.py.html>`__ to see an example of how to use get_announcements_preference API.
"""
resource_path = "/announcementsPreferences/{preferenceId}"
method = "GET"
operation_name = "get_announcements_preference"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/announcements/0.0.1/AnnouncementsPreferences/GetAnnouncementsPreference"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_announcements_preference got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"preferenceId": preference_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AnnouncementsPreferences",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AnnouncementsPreferences",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_announcements_preferences(self, compartment_id, **kwargs):
"""
Gets the current preferences of the tenancy regarding receiving announcements by email.
This call is subject to an Announcements limit that applies to the total number of requests across all read or write operations. Announcements might throttle this call to reject an otherwise valid request when the total rate of operations exceeds 20 requests per second for a given user. The service might also throttle this call to reject an otherwise valid request when the total rate of operations exceeds 100 requests per second for a given tenancy.
:param str compartment_id: (required)
The OCID of the compartment.
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call.
:param str page: (optional)
The value of the `opc-next-page` response header from the previous \"List\" call.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the complete request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.announcements_service.models.AnnouncementsPreferencesSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/announcementsservice/list_announcements_preferences.py.html>`__ to see an example of how to use list_announcements_preferences API.
"""
resource_path = "/announcementsPreferences"
method = "GET"
operation_name = "list_announcements_preferences"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/announcements/0.0.1/AnnouncementsPreferencesSummary/ListAnnouncementsPreferences"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "limit", "page",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_announcements_preferences got unknown kwargs: {!r}".
format(extra_kwargs))
query_params = {
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"compartmentId": compartment_id
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[AnnouncementsPreferencesSummary]",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[AnnouncementsPreferencesSummary]",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def update_announcements_preference(self, preference_id,
announcements_preference_details,
**kwargs):
"""
Updates the preferences of the tenancy regarding receiving announcements by email.
This call is subject to an Announcements limit that applies to the total number of requests across all read or write operations. Announcements might throttle this call to reject an otherwise valid request when the total rate of operations exceeds 20 requests per second for a given user. The service might also throttle this call to reject an otherwise valid request when the total rate of operations exceeds 100 requests per second for a given tenancy.
:param str preference_id: (required)
The ID of the preference.
:param oci.announcements_service.models.UpdateAnnouncementsPreferencesDetails announcements_preference_details: (required)
The object that contains details about tenancy preferences for receiving announcements by email.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the complete request ID.
:param str if_match: (optional)
The locking version, used for optimistic concurrency control.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.announcements_service.models.AnnouncementsPreferencesSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/announcementsservice/update_announcements_preference.py.html>`__ to see an example of how to use update_announcements_preference API.
"""
resource_path = "/announcementsPreferences/{preferenceId}"
method = "PUT"
operation_name = "update_announcements_preference"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/announcements/0.0.1/AnnouncementsPreferencesSummary/UpdateAnnouncementsPreference"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id",
"if_match"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_announcements_preference got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"preferenceId": preference_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=announcements_preference_details,
response_type="AnnouncementsPreferencesSummary",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=announcements_preference_details,
response_type="AnnouncementsPreferencesSummary",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class EventsClient(object):
"""
API for the Events Service. Use this API to manage rules and actions that create automation
in your tenancy. For more information, see [Overview of Events](/iaas/Content/Events/Concepts/eventsoverview.htm).
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
The connection and read timeouts for the client. The default is that the client never times out. This keyword argument can be provided
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(
tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(config, "pass_phrase"),
private_key_content=config.get("key_content")
)
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20181201',
'service_endpoint_template': 'https://events.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("events", config, signer, events_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_rule_compartment(self, rule_id, change_rule_compartment_details, **kwargs):
"""
Moves a rule into a different compartment. When provided, If-Match is checked against ETag values of the resource.
Moves a rule into a different compartment within the same tenancy. For information about moving
resources between compartments, see `Moving Resources to a Different Compartment`__.
__ https://docs.cloud.oracle.com/iaas/Content/Identity/Tasks/managingcompartments.htm#moveRes
:param str rule_id: (required)
The `OCID`__ of this rule.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param ChangeRuleCompartmentDetails change_rule_compartment_details: (required)
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/rules/{ruleId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id",
"opc_retry_token"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"change_rule_compartment got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"ruleId": rule_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_rule_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_rule_compartment_details)
def create_rule(self, create_rule_details, **kwargs):
"""
Creates a new rule
Creates a new rule.
:param CreateRuleDetails create_rule_details: (required)
Specification of the rule to create
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.events.models.Rule`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/rules"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_retry_token",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_rule got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_rule_details,
response_type="Rule")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_rule_details,
response_type="Rule")
def delete_rule(self, rule_id, **kwargs):
"""
Deletes a rule
Deletes a rule.
:param str rule_id: (required)
The `OCID`__ of this rule.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/rules/{ruleId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"delete_rule got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"ruleId": rule_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_rule(self, rule_id, **kwargs):
"""
Retrieves a rule
Retrieves a rule.
:param str rule_id: (required)
The `OCID`__ of this rule.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.events.models.Rule`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/rules/{ruleId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_rule got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"ruleId": rule_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Rule")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Rule")
def list_rules(self, compartment_id, **kwargs):
"""
Lists rules for this compartment.
Lists rules for this compartment.
:param str compartment_id: (required)
The `OCID`__ of the compartment to which this rule belongs.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param int limit: (optional)
The maximum number of items to return. 1 is the minimum, 50 is the maximum.
Default: 10
:param str page: (optional)
For list pagination. The value of the opc-next-page response header from the previous
\"List\" call. For important details about how pagination works, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str lifecycle_state: (optional)
A filter to return only rules that match the lifecycle state in this parameter.
Example: `Creating`
Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED"
:param str display_name: (optional)
A filter to return only rules with descriptions that match the displayName string
in this parameter.
Example: `\"This rule sends a notification upon completion of DbaaS backup.\"`
:param str sort_by: (optional)
Specifies the attribute with which to sort the rules.
Default: `timeCreated`
* **TIME_CREATED:** Sorts by timeCreated.
* **DISPLAY_NAME:** Sorts by displayName.
* **ID:** Sorts by id.
Allowed values are: "TIME_CREATED", "ID", "DISPLAY_NAME"
:param str sort_order: (optional)
Specifies sort order.
* **ASC:** Ascending sort order.
* **DESC:** Descending sort order.
Allowed values are: "ASC", "DESC"
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.events.models.RuleSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/rules"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"limit",
"page",
"lifecycle_state",
"display_name",
"sort_by",
"sort_order",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_rules got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "INACTIVE", "UPDATING", "DELETING", "DELETED", "FAILED"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
)
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIME_CREATED", "ID", "DISPLAY_NAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
)
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
)
query_params = {
"compartmentId": compartment_id,
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"displayName": kwargs.get("display_name", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[RuleSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[RuleSummary]")
def update_rule(self, rule_id, update_rule_details, **kwargs):
"""
Updates a rule
Updates a rule.
:param str rule_id: (required)
The `OCID`__ of this rule.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param UpdateRuleDetails update_rule_details: (required)
The new rule spec to apply
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the if-match
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.events.models.Rule`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/rules/{ruleId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_rule got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"ruleId": rule_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_rule_details,
response_type="Rule")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_rule_details,
response_type="Rule")
class MysqlaasClient(object):
"""
The API for the MySQL Database Service
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'base_path': '/20190415',
'service_endpoint_template':
'https://mysql.{region}.ocp.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
self.base_client = BaseClient("mysqlaas", config, signer,
mysql_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_configuration(self, create_configuration_details, **kwargs):
"""
Creates a new Configuration.
:param oci.mysql.models.CreateConfigurationDetails create_configuration_details: (required)
Request to create a Configuration.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case
of a timeout or server error without risk of executing that same action
again. Retry tokens expire after 24 hours, but can be invalidated before
then due to conflicting operations (for example, if a resource has been
deleted and purged from the system, then a retry of the original
creation request may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Configuration`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/create_configuration.py.html>`__ to see an example of how to use create_configuration API.
"""
resource_path = "/configurations"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_configuration got unknown kwargs: {!r}".format(
extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_configuration_details,
response_type="Configuration")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_configuration_details,
response_type="Configuration")
def delete_configuration(self, configuration_id, **kwargs):
"""
Deletes a Configuration.
The Configuration must not be in use by any DB Systems.
:param str configuration_id: (required)
The OCID of the Configuration.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/delete_configuration.py.html>`__ to see an example of how to use delete_configuration API.
"""
resource_path = "/configurations/{configurationId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_configuration got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"configurationId": configuration_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_configuration(self, configuration_id, **kwargs):
"""
Get the full details of the specified Configuration, including the list of MySQL Variables and their values.
:param str configuration_id: (required)
The OCID of the Configuration.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str if_none_match: (optional)
For conditional requests. In the GET call for a resource, set the
`If-None-Match` header to the value of the ETag from a previous GET (or
POST or PUT) response for that resource. The server will return with
either a 304 Not Modified response if the resource has not changed, or a
200 OK response with the updated representation.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Configuration`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/get_configuration.py.html>`__ to see an example of how to use get_configuration API.
"""
resource_path = "/configurations/{configurationId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "if_none_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_configuration got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"configurationId": configuration_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-none-match": kwargs.get("if_none_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Configuration")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Configuration")
def list_configurations(self, compartment_id, **kwargs):
"""
Lists the Configurations available when creating a DB System.
This may include DEFAULT configurations per Shape and CUSTOM configurations.
The default sort order is a multi-part sort by:
- shapeName, ascending
- DEFAULT-before-CUSTOM
- displayName ascending
:param str compartment_id: (required)
The compartment `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param str configuration_id: (optional)
The requested Configuration instance.
:param str lifecycle_state: (optional)
Configuration Lifecycle State
Allowed values are: "ACTIVE", "DELETED"
:param list[str] type: (optional)
The requested Configuration types.
Allowed values are: "DEFAULT", "CUSTOM"
:param str display_name: (optional)
A filter to return only the resource matching the given display name exactly.
:param str shape_name: (optional)
The requested Shape name.
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Time fields are default ordered as descending. Display name is default ordered as ascending.
Allowed values are: "displayName", "shapeName", "timeCreated", "timeUpdated"
:param str sort_order: (optional)
The sort order to use (ASC or DESC).
Allowed values are: "ASC", "DESC"
:param int limit: (optional)
The maximum number of items to return in a paginated list call. For information about pagination, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/#API/Concepts/usingapi.htm#List_Pagination
:param str page: (optional)
The value of the `opc-next-page` or `opc-prev-page` response header from
the previous list call. For information about pagination, see `List
Pagination`__.
__ https://docs.cloud.oracle.com/#API/Concepts/usingapi.htm#List_Pagination
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.mysql.models.ConfigurationSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/list_configurations.py.html>`__ to see an example of how to use list_configurations API.
"""
resource_path = "/configurations"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "configuration_id",
"lifecycle_state", "type", "display_name", "shape_name", "sort_by",
"sort_order", "limit", "page"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_configurations got unknown kwargs: {!r}".format(
extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["ACTIVE", "DELETED"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'type' in kwargs:
type_allowed_values = ["DEFAULT", "CUSTOM"]
for type_item in kwargs['type']:
if type_item not in type_allowed_values:
raise ValueError(
"Invalid value for `type`, must be one of {0}".format(
type_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = [
"displayName", "shapeName", "timeCreated", "timeUpdated"
]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
query_params = {
"compartmentId":
compartment_id,
"configurationId":
kwargs.get("configuration_id", missing),
"lifecycleState":
kwargs.get("lifecycle_state", missing),
"type":
self.base_client.generate_collection_format_param(
kwargs.get("type", missing), 'multi'),
"displayName":
kwargs.get("display_name", missing),
"shapeName":
kwargs.get("shape_name", missing),
"sortBy":
kwargs.get("sort_by", missing),
"sortOrder":
kwargs.get("sort_order", missing),
"limit":
kwargs.get("limit", missing),
"page":
kwargs.get("page", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ConfigurationSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ConfigurationSummary]")
def list_shapes(self, compartment_id, **kwargs):
"""
Gets a list of the shapes you can use to create a new MySQL DB System.
The shape determines the resources allocated to the DB System:
CPU cores and memory for VM shapes; CPU cores, memory and
storage for non-VM (or bare metal) shapes.
:param str compartment_id: (required)
The compartment `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param list[str] is_supported_for: (optional)
Return shapes that are supported by the service feature.
Allowed values are: "DBSYSTEM", "ANALYTICSCLUSTER", "HEATWAVECLUSTER"
:param str availability_domain: (optional)
The name of the Availability Domain.
:param str name: (optional)
Name
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.mysql.models.ShapeSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/list_shapes.py.html>`__ to see an example of how to use list_shapes API.
"""
resource_path = "/shapes"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "is_supported_for",
"availability_domain", "name"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_shapes got unknown kwargs: {!r}".format(extra_kwargs))
if 'is_supported_for' in kwargs:
is_supported_for_allowed_values = [
"DBSYSTEM", "ANALYTICSCLUSTER", "HEATWAVECLUSTER"
]
for is_supported_for_item in kwargs['is_supported_for']:
if is_supported_for_item not in is_supported_for_allowed_values:
raise ValueError(
"Invalid value for `is_supported_for`, must be one of {0}"
.format(is_supported_for_allowed_values))
query_params = {
"isSupportedFor":
self.base_client.generate_collection_format_param(
kwargs.get("is_supported_for", missing), 'multi'),
"availabilityDomain":
kwargs.get("availability_domain", missing),
"compartmentId":
compartment_id,
"name":
kwargs.get("name", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ShapeSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ShapeSummary]")
def list_versions(self, compartment_id, **kwargs):
"""
Get a list of supported and available MySQL database major versions.
The list is sorted by version family.
:param str compartment_id: (required)
The compartment `OCID`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.mysql.models.VersionSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/list_versions.py.html>`__ to see an example of how to use list_versions API.
"""
resource_path = "/versions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_versions got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {"compartmentId": compartment_id}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[VersionSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[VersionSummary]")
def update_configuration(self, configuration_id,
update_configuration_details, **kwargs):
"""
Updates the Configuration details.
:param str configuration_id: (required)
The OCID of the Configuration.
:param oci.mysql.models.UpdateConfigurationDetails update_configuration_details: (required)
Request to update a Configuration.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a
resource, set the `If-Match` header to the value of the etag from a
previous GET or POST response for that resource. The resource will be
updated or deleted only if the etag you provide matches the resource's
current etag value.
:param str opc_request_id: (optional)
Customer-defined unique identifier for the request. If you need to
contact Oracle about a specific request, please provide the request
ID that you supplied in this header with the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.mysql.models.Configuration`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/update_configuration.py.html>`__ to see an example of how to use update_configuration API.
"""
resource_path = "/configurations/{configurationId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_configuration got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"configurationId": configuration_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_configuration_details,
response_type="Configuration")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_configuration_details,
response_type="Configuration")
class ComputeInstanceAgentClient(object):
"""
Instance Agent Service API
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20180530',
'service_endpoint_template':
'https://iaas.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("compute_instance_agent", config, signer,
compute_instance_agent_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def cancel_instance_agent_command(self, instance_agent_command_id,
**kwargs):
"""
Cancel a command. Cancel is best effort attempt. If the commmand has already completed it will skip cancel.
:param str instance_agent_command_id: (required)
The OCID of the command.
:param str opc_request_id: (optional)
Unique identifier for the request.
If you need to contact Oracle about a particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/instanceAgentCommands/{instanceAgentCommandId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "if_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"cancel_instance_agent_command got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"instanceAgentCommandId": instance_agent_command_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def create_instance_agent_command(self,
create_instance_agent_command_details,
**kwargs):
"""
Create command for one or more managed instances
:param oci.compute_instance_agent.models.CreateInstanceAgentCommandDetails create_instance_agent_command_details: (required)
Create Instance agent command details
:param str opc_request_id: (optional)
Unique identifier for the request.
If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (for example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.compute_instance_agent.models.InstanceAgentCommand`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/instanceAgentCommands"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_instance_agent_command got unknown kwargs: {!r}".
format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_instance_agent_command_details,
response_type="InstanceAgentCommand")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_instance_agent_command_details,
response_type="InstanceAgentCommand")
def get_instance_agent_command(self, instance_agent_command_id, **kwargs):
"""
Gets information about the specified instance agent commandId.
:param str instance_agent_command_id: (required)
The OCID of the command.
:param str opc_request_id: (optional)
Unique identifier for the request.
If you need to contact Oracle about a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.compute_instance_agent.models.InstanceAgentCommand`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/instanceAgentCommands/{instanceAgentCommandId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_instance_agent_command got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"instanceAgentCommandId": instance_agent_command_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="InstanceAgentCommand")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="InstanceAgentCommand")
def get_instance_agent_command_execution(self, instance_agent_command_id,
instance_id, **kwargs):
"""
Gets information about the status of specified instance agent commandId for the given instanceId.
:param str instance_agent_command_id: (required)
The OCID of the command.
:param str instance_id: (required)
The OCID of the instance.
:param str opc_request_id: (optional)
Unique identifier for the request.
If you need to contact Oracle about a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.compute_instance_agent.models.InstanceAgentCommandExecution`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/instanceAgentCommands/{instanceAgentCommandId}/status"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_instance_agent_command_execution got unknown kwargs: {!r}"
.format(extra_kwargs))
path_params = {"instanceAgentCommandId": instance_agent_command_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
query_params = {"instanceId": instance_id}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="InstanceAgentCommandExecution")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="InstanceAgentCommandExecution")
def list_instance_agent_command_executions(self, compartment_id,
instance_id, **kwargs):
"""
List all executions of a command, i.e return command execution results from all targeted instances batch by
batch.
:param str compartment_id: (required)
The `OCID`__ of the compartment.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str instance_id: (required)
The OCID of the instance.
:param str opc_request_id: (optional)
Unique identifier for the request.
If you need to contact Oracle about a particular request, please provide the request ID.
:param str page: (optional)
The value of the `opc-next-page` response header from the previous \"List\" call.
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call.
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`). Default order for
TIMECREATED is descending.
**Note:** In general, some \"List\" operations (for example, `ListInstances`) let you
optionally filter by availability domain if the scope of the resource type is within a
single availability domain. If you call one of these \"List\" operations without specifying
an availability domain, the resources are grouped by availability domain, then sorted.
Allowed values are: "TIMECREATED", "DISPLAYNAME"
:param str sort_order: (optional)
The sort order to use, either ascending (`ASC`) or descending (`DESC`). The DISPLAYNAME sort order
is case sensitive.
Allowed values are: "ASC", "DESC"
:param str lifecycle_state: (optional)
A filter to only return resources that match the given lifecycle state. The state value is case-insensitive.
Allowed values are: "ACCEPTED", "IN_PROGRESS", "SUCCEEDED", "FAILED", "TIMED_OUT", "CANCELED"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.compute_instance_agent.models.InstanceAgentCommandExecutionSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/instanceAgentCommandExecutions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "page", "limit", "sort_by",
"sort_order", "lifecycle_state"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_instance_agent_command_executions got unknown kwargs: {!r}"
.format(extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"ACCEPTED", "IN_PROGRESS", "SUCCEEDED", "FAILED", "TIMED_OUT",
"CANCELED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
query_params = {
"compartmentId": compartment_id,
"instanceId": instance_id,
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[InstanceAgentCommandExecutionSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[InstanceAgentCommandExecutionSummary]")
def list_instance_agent_commands(self, compartment_id, **kwargs):
"""
List Instance agent commands issued with the specified filter.
Additonally you can filter commands sent to a particular InstanceId
:param str compartment_id: (required)
The `OCID`__ of the compartment.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
Unique identifier for the request.
If you need to contact Oracle about a particular request, please provide the request ID.
:param str page: (optional)
The value of the `opc-next-page` response header from the previous \"List\" call.
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call.
:param str sort_by: (optional)
The field to sort by. You can provide one sort order (`sortOrder`). Default order for
TIMECREATED is descending.
**Note:** In general, some \"List\" operations (for example, `ListInstances`) let you
optionally filter by availability domain if the scope of the resource type is within a
single availability domain. If you call one of these \"List\" operations without specifying
an availability domain, the resources are grouped by availability domain, then sorted.
Allowed values are: "TIMECREATED", "DISPLAYNAME"
:param str sort_order: (optional)
The sort order to use, either ascending (`ASC`) or descending (`DESC`). The DISPLAYNAME sort order
is case sensitive.
Allowed values are: "ASC", "DESC"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.compute_instance_agent.models.InstanceAgentCommandSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/instanceAgentCommands"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "page", "limit", "sort_by",
"sort_order"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_instance_agent_commands got unknown kwargs: {!r}".format(
extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "DISPLAYNAME"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
query_params = {
"compartmentId": compartment_id,
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[InstanceAgentCommandSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[InstanceAgentCommandSummary]")
class RedirectClient(object):
"""
OCI Web Application Acceleration and Security Services
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20181116',
'service_endpoint_template':
'https://waas.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("redirect", config, signer,
waas_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_http_redirect_compartment(
self, http_redirect_id, change_http_redirect_compartment_details,
**kwargs):
"""
Moves HTTP Redirect into a different compartment. When provided, If-Match is checked against ETag values of the WAAS policy.
:param str http_redirect_id: (required)
The `OCID`__ of the HTTP Redirect.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param oci.waas.models.ChangeHttpRedirectCompartmentDetails change_http_redirect_compartment_details: (required)
:param str if_match: (optional)
For optimistic concurrency control. In the `PUT` or `DELETE` call for a resource, set the `if-match` parameter to the value of the etag from a previous `GET` or `POST` response for that resource. The resource will be updated or deleted only if the etag provided matches the resource's current etag value.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations
*Example:* If a resource has been deleted and purged from the system, then a retry of the original delete request may be rejected.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/waas/change_http_redirect_compartment.py.html>`__ to see an example of how to use change_http_redirect_compartment API.
"""
resource_path = "/httpRedirects/{httpRedirectId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_http_redirect_compartment got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"httpRedirectId": http_redirect_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_http_redirect_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_http_redirect_compartment_details)
def create_http_redirect(self, create_http_redirect_details, **kwargs):
"""
Creates a new HTTP Redirect on the WAF edge.
:param oci.waas.models.CreateHttpRedirectDetails create_http_redirect_details: (required)
The details of the HTTP Redirect.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations
*Example:* If a resource has been deleted and purged from the system, then a retry of the original delete request may be rejected.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/waas/create_http_redirect.py.html>`__ to see an example of how to use create_http_redirect API.
"""
resource_path = "/httpRedirects"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_http_redirect got unknown kwargs: {!r}".format(
extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_http_redirect_details)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_http_redirect_details)
def delete_http_redirect(self, http_redirect_id, **kwargs):
"""
Deletes a redirect.
:param str http_redirect_id: (required)
The `OCID`__ of the HTTP Redirect.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations
*Example:* If a resource has been deleted and purged from the system, then a retry of the original delete request may be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the `PUT` or `DELETE` call for a resource, set the `if-match` parameter to the value of the etag from a previous `GET` or `POST` response for that resource. The resource will be updated or deleted only if the etag provided matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/waas/delete_http_redirect.py.html>`__ to see an example of how to use delete_http_redirect API.
"""
resource_path = "/httpRedirects/{httpRedirectId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token", "if_match"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_http_redirect got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"httpRedirectId": http_redirect_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_http_redirect(self, http_redirect_id, **kwargs):
"""
Gets the details of a HTTP Redirect.
:param str http_redirect_id: (required)
The `OCID`__ of the HTTP Redirect.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.waas.models.HttpRedirect`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/waas/get_http_redirect.py.html>`__ to see an example of how to use get_http_redirect API.
"""
resource_path = "/httpRedirects/{httpRedirectId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_http_redirect got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"httpRedirectId": http_redirect_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="HttpRedirect")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="HttpRedirect")
def list_http_redirects(self, compartment_id, **kwargs):
"""
Gets a list of HTTP Redirects.
:param str compartment_id: (required)
The `OCID`__ of the compartment. This number is generated when the compartment is created.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param int limit: (optional)
The maximum number of items to return in a paginated call. If unspecified, defaults to `10`.
:param str page: (optional)
The value of the `opc-next-page` response header from the previous paginated call.
:param str sort_order: (optional)
The value of the sorting direction of resources in a paginated 'List' call. If unspecified, defaults to `DESC`.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort the results of the List query.
Allowed values are: "id", "domain", "target", "displayName"
:param list[str] id: (optional)
Filter redirects using a list of redirect OCIDs.
:param list[str] display_name: (optional)
Filter redirects using a display name.
:param list[str] lifecycle_state: (optional)
Filter redirects using a list of lifecycle states.
Allowed values are: "CREATING", "ACTIVE", "FAILED", "UPDATING", "DELETING", "DELETED"
:param datetime time_created_greater_than_or_equal_to: (optional)
A filter that matches redirects created on or after the specified date and time.
:param datetime time_created_less_than: (optional)
A filter that matches redirects created before the specified date-time. Default to 1 day before now.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.waas.models.HttpRedirectSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/waas/list_http_redirects.py.html>`__ to see an example of how to use list_http_redirects API.
"""
resource_path = "/httpRedirects"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "limit", "page", "sort_order",
"sort_by", "id", "display_name", "lifecycle_state",
"time_created_greater_than_or_equal_to", "time_created_less_than"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_http_redirects got unknown kwargs: {!r}".format(
extra_kwargs))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["id", "domain", "target", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "ACTIVE", "FAILED", "UPDATING", "DELETING",
"DELETED"
]
for lifecycle_state_item in kwargs['lifecycle_state']:
if lifecycle_state_item not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}"
.format(lifecycle_state_allowed_values))
query_params = {
"compartmentId":
compartment_id,
"limit":
kwargs.get("limit", missing),
"page":
kwargs.get("page", missing),
"sortOrder":
kwargs.get("sort_order", missing),
"sortBy":
kwargs.get("sort_by", missing),
"id":
self.base_client.generate_collection_format_param(
kwargs.get("id", missing), 'multi'),
"displayName":
self.base_client.generate_collection_format_param(
kwargs.get("display_name", missing), 'multi'),
"lifecycleState":
self.base_client.generate_collection_format_param(
kwargs.get("lifecycle_state", missing), 'multi'),
"timeCreatedGreaterThanOrEqualTo":
kwargs.get("time_created_greater_than_or_equal_to", missing),
"timeCreatedLessThan":
kwargs.get("time_created_less_than", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[HttpRedirectSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[HttpRedirectSummary]")
def update_http_redirect(self, http_redirect_id,
update_http_redirect_details, **kwargs):
"""
Updates the details of a HTTP Redirect, including target and tags. Only the fields specified in the request body will be updated; all other properties will remain unchanged.
:param str http_redirect_id: (required)
The `OCID`__ of the HTTP Redirect.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param oci.waas.models.UpdateHttpRedirectDetails update_http_redirect_details: (required)
The details of the HTTP Redirect to update.
:param str opc_request_id: (optional)
The unique Oracle-assigned identifier for the request. If you need to contact Oracle about a particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again. Retry tokens expire after 24 hours, but can be invalidated before then due to conflicting operations
*Example:* If a resource has been deleted and purged from the system, then a retry of the original delete request may be rejected.
:param str if_match: (optional)
For optimistic concurrency control. In the `PUT` or `DELETE` call for a resource, set the `if-match` parameter to the value of the etag from a previous `GET` or `POST` response for that resource. The resource will be updated or deleted only if the etag provided matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/waas/update_http_redirect.py.html>`__ to see an example of how to use update_http_redirect API.
"""
resource_path = "/httpRedirects/{httpRedirectId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "opc_retry_token", "if_match"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_http_redirect got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"httpRedirectId": http_redirect_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_http_redirect_details)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_http_redirect_details)
class QuotasClient(object):
"""
APIs that interact with the resource limits of a specific resource type
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
The connection and read timeouts for the client. The default is that the client never times out. This keyword argument can be provided
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(
tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(config, "pass_phrase"),
private_key_content=config.get("key_content")
)
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/',
'service_endpoint_template': 'https://limits.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("quotas", config, signer, limits_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_quota(self, create_quota_details, **kwargs):
"""
Creates quota
Creates a new quota with the details supplied.
:param CreateQuotaDetails create_quota_details: (required)
Request object for creating a new quota.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (e.g., if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.limits.models.Quota`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20181025/quotas/"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"opc_retry_token"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_quota got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_quota_details,
response_type="Quota")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_quota_details,
response_type="Quota")
def delete_quota(self, quota_id, **kwargs):
"""
Deletes quota
Deletes the quota corresponding to the given OCID.
:param str quota_id: (required)
The OCID of the quota.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20181025/quotas/{quotaId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"delete_quota got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"quotaId": quota_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_quota(self, quota_id, **kwargs):
"""
Gets quota
Gets the quota for the OCID specified.
:param str quota_id: (required)
The OCID of the quota.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.limits.models.Quota`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20181025/quotas/{quotaId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_quota got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"quotaId": quota_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Quota")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Quota")
def list_quotas(self, compartment_id, **kwargs):
"""
Lists quotas
Lists all quotas on resources from the given compartment
:param str compartment_id: (required)
The OCID of the parent compartment (remember that the tenancy is simply the root compartment).
:param str page: (optional)
The value of the `opc-next-page` response header from the previous \"List\" call.
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call.
:param str name: (optional)
name
:param str lifecycle_state: (optional)
Filters returned quotas based on whether the given state.
Allowed values are: "ACTIVE"
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'. By default it will be ascending.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Time created is default ordered as descending. Display name is default ordered as ascending.
Allowed values are: "NAME", "TIMECREATED"
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.limits.models.QuotaSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20181025/quotas/"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"page",
"limit",
"name",
"lifecycle_state",
"sort_order",
"sort_by",
"opc_request_id"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_quotas got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["ACTIVE"]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
)
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
)
if 'sort_by' in kwargs:
sort_by_allowed_values = ["NAME", "TIMECREATED"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
)
query_params = {
"compartmentId": compartment_id,
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"name": kwargs.get("name", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[QuotaSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[QuotaSummary]")
def update_quota(self, quota_id, update_quota_details, **kwargs):
"""
Updates quota
Updates the quota corresponding to given OCID with the details supplied.
:param str quota_id: (required)
The OCID of the quota.
:param UpdateQuotaDetails update_quota_details: (required)
Request object for updating a quota.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about a
particular request, please provide the request ID.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call for a resource, set the `if-match`
parameter to the value of the etag from a previous GET or POST response for that resource. The resource
will be updated or deleted only if the etag you provide matches the resource's current etag value.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.limits.models.Quota`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20181025/quotas/{quotaId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match"
]
extra_kwargs = [key for key in six.iterkeys(kwargs) if key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_quota got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"quotaId": quota_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_quota_details,
response_type="Quota")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_quota_details,
response_type="Quota")
class TransferApplianceClient(object):
"""
Data Transfer Service API Specification
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
The connection and read timeouts for the client. The default is that the client never times out. This keyword argument can be provided
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20171001',
'service_endpoint_template':
'https://datatransfer.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("transfer_appliance", config, signer,
dts_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_transfer_appliance(self, id, **kwargs):
"""
Create a new Transfer Appliance
Create a new Transfer Appliance
:param str id: (required)
ID of the Transfer Job
:param str opc_retry_token: (optional)
:param CreateTransferApplianceDetails create_transfer_appliance_details: (optional)
Creates a New Transfer Appliance
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferAppliance`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token",
"create_transfer_appliance_details"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_transfer_appliance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=kwargs.get('create_transfer_appliance_details'),
response_type="TransferAppliance")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=kwargs.get('create_transfer_appliance_details'),
response_type="TransferAppliance")
def create_transfer_appliance_admin_credentials(self, id,
transfer_appliance_label,
admin_public_key,
**kwargs):
"""
Creates an X.509 certificate from a public key
Creates an X.509 certificate from a public key
:param str id: (required)
ID of the Transfer Job
:param str transfer_appliance_label: (required)
Label of the Transfer Appliance
:param TransferAppliancePublicKey admin_public_key: (required)
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferApplianceCertificate`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances/{transferApplianceLabel}/admin_credentials"
method = "POST"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_transfer_appliance_admin_credentials got unknown kwargs: {!r}"
.format(extra_kwargs))
path_params = {
"id": id,
"transferApplianceLabel": transfer_appliance_label
}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=admin_public_key,
response_type="TransferApplianceCertificate")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=admin_public_key,
response_type="TransferApplianceCertificate")
def delete_transfer_appliance(self, id, transfer_appliance_label,
**kwargs):
"""
deletes a transfer Appliance
deletes a transfer Appliance
:param str id: (required)
ID of the Transfer Job
:param str transfer_appliance_label: (required)
Label of the Transfer Appliance
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances/{transferApplianceLabel}"
method = "DELETE"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_transfer_appliance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"id": id,
"transferApplianceLabel": transfer_appliance_label
}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_transfer_appliance(self, id, transfer_appliance_label, **kwargs):
"""
Describes a transfer appliance in detail
Describes a transfer appliance in detail
:param str id: (required)
ID of the Transfer Job
:param str transfer_appliance_label: (required)
Label of the Transfer Appliance
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferAppliance`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances/{transferApplianceLabel}"
method = "GET"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_transfer_appliance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"id": id,
"transferApplianceLabel": transfer_appliance_label
}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferAppliance")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferAppliance")
def get_transfer_appliance_certificate_authority_certificate(
self, id, transfer_appliance_label, **kwargs):
"""
Gets the x.509 certificate for the Transfer Appliance's dedicated Certificate Authority (CA)
Gets the x.509 certificate for the Transfer Appliance's dedicated Certificate Authority (CA)
:param str id: (required)
ID of the Transfer Job
:param str transfer_appliance_label: (required)
Label of the Transfer Appliance
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferApplianceCertificate`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances/{transferApplianceLabel}/certificate_authority_certificate"
method = "GET"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_transfer_appliance_certificate_authority_certificate got unknown kwargs: {!r}"
.format(extra_kwargs))
path_params = {
"id": id,
"transferApplianceLabel": transfer_appliance_label
}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferApplianceCertificate")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferApplianceCertificate")
def get_transfer_appliance_encryption_passphrase(self, id,
transfer_appliance_label,
**kwargs):
"""
Describes a transfer appliance encryptionPassphrase
Describes a transfer appliance encryptionPassphrase in detail
:param str id: (required)
ID of the Transfer Job
:param str transfer_appliance_label: (required)
Label of the Transfer Appliance
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferApplianceEncryptionPassphrase`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances/{transferApplianceLabel}/encryptionPassphrase"
method = "GET"
expected_kwargs = ["retry_strategy"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_transfer_appliance_encryption_passphrase got unknown kwargs: {!r}"
.format(extra_kwargs))
path_params = {
"id": id,
"transferApplianceLabel": transfer_appliance_label
}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferApplianceEncryptionPassphrase")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferApplianceEncryptionPassphrase")
def list_transfer_appliances(self, id, **kwargs):
"""
Lists Transfer Appliances associated with a transferJob
Lists Transfer Appliances associated with a transferJob
:param str id: (required)
ID of the Transfer Job
:param str lifecycle_state: (optional)
filtering by lifecycleState
Allowed values are: "REQUESTED", "ORACLE_PREPARING", "SHIPPING", "DELIVERED", "PREPARING", "FINALIZED", "RETURN_DELAYED", "RETURN_SHIPPED", "RETURN_SHIPPED_CANCELLED", "ORACLE_RECEIVED", "ORACLE_RECEIVED_CANCELLED", "PROCESSING", "COMPLETE", "CUSTOMER_NEVER_RECEIVED", "ORACLE_NEVER_RECEIVED", "CUSTOMER_LOST", "CANCELLED", "DELETED", "REJECTED", "ERROR"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.MultipleTransferAppliances`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "lifecycle_state"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_transfer_appliances got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"REQUESTED", "ORACLE_PREPARING", "SHIPPING", "DELIVERED",
"PREPARING", "FINALIZED", "RETURN_DELAYED", "RETURN_SHIPPED",
"RETURN_SHIPPED_CANCELLED", "ORACLE_RECEIVED",
"ORACLE_RECEIVED_CANCELLED", "PROCESSING", "COMPLETE",
"CUSTOMER_NEVER_RECEIVED", "ORACLE_NEVER_RECEIVED",
"CUSTOMER_LOST", "CANCELLED", "DELETED", "REJECTED", "ERROR"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
query_params = {
"lifecycleState": kwargs.get("lifecycle_state", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json"
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="MultipleTransferAppliances")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="MultipleTransferAppliances")
def update_transfer_appliance(self, id, transfer_appliance_label,
update_transfer_appliance_details, **kwargs):
"""
Updates a Transfer Appliance
Updates a Transfer Appliance
:param str id: (required)
ID of the Transfer Job
:param str transfer_appliance_label: (required)
Label of the Transfer Appliance
:param UpdateTransferApplianceDetails update_transfer_appliance_details: (required)
fields to update
:param str if_match: (optional)
The entity tag to match. Optional, if set, the update will be successful only if the
object's tag matches the tag specified in the request.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
is also available. The specifics of the default retry strategy are described `here <https://oracle-cloud-infrastructure-python-sdk.readthedocs.io/en/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferAppliance`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferAppliances/{transferApplianceLabel}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_transfer_appliance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"id": id,
"transferApplianceLabel": transfer_appliance_label
}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_transfer_appliance_details,
response_type="TransferAppliance")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_transfer_appliance_details,
response_type="TransferAppliance")
class TransferJobClient(object):
"""
Data Transfer Service API Specification
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'base_path': '/20171001',
'service_endpoint_template':
'https://datatransfer.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
self.base_client = BaseClient("transfer_job", config, signer,
dts_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_transfer_job_compartment(
self, transfer_job_id, change_transfer_job_compartment_details,
**kwargs):
"""
Moves a TransferJob into a different compartment.
:param str transfer_job_id: (required)
ID of the Transfer Job
:param oci.dts.models.ChangeTransferJobCompartmentDetails change_transfer_job_compartment_details: (required)
CompartmentId of the destination compartment
:param str if_match: (optional)
The entity tag to match. Optional, if set, the update will be successful only if the
object's tag matches the tag specified in the request.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations (e.g., if a resource
has been deleted and purged from the system, then a retry of the original creation request
may be rejected).
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/change_transfer_job_compartment.py.html>`__ to see an example of how to use change_transfer_job_compartment API.
"""
resource_path = "/transferJobs/{transferJobId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_transfer_job_compartment got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"transferJobId": transfer_job_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_transfer_job_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_transfer_job_compartment_details)
def create_transfer_job(self, create_transfer_job_details, **kwargs):
"""
Create a new Transfer Job that corresponds with customer's logical dataset e.g. a DB or a filesystem.
:param oci.dts.models.CreateTransferJobDetails create_transfer_job_details: (required)
Creates a New Transfer Job
:param str opc_retry_token: (optional)
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferJob`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/create_transfer_job.py.html>`__ to see an example of how to use create_transfer_job API.
"""
resource_path = "/transferJobs"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_transfer_job got unknown kwargs: {!r}".format(
extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_transfer_job_details,
response_type="TransferJob")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_transfer_job_details,
response_type="TransferJob")
def delete_transfer_job(self, id, **kwargs):
"""
deletes a transfer job
:param str id: (required)
ID of the Transfer Job
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/delete_transfer_job.py.html>`__ to see an example of how to use delete_transfer_job API.
"""
resource_path = "/transferJobs/{id}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_transfer_job got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_transfer_job(self, id, **kwargs):
"""
Describes a transfer job in detail
:param str id: (required)
OCID of the Transfer Job
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferJob`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/get_transfer_job.py.html>`__ to see an example of how to use get_transfer_job API.
"""
resource_path = "/transferJobs/{id}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_transfer_job got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferJob")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferJob")
def list_transfer_jobs(self, compartment_id, **kwargs):
"""
Lists Transfer Jobs in a given compartment
:param str compartment_id: (required)
compartment id
:param str lifecycle_state: (optional)
filtering by lifecycleState
Allowed values are: "INITIATED", "PREPARING", "ACTIVE", "DELETED", "CLOSED"
:param str display_name: (optional)
filtering by displayName
:param int limit: (optional)
For list pagination. The maximum number of results per page, or items to return in a paginated
\"List\" call. For important details about how pagination works, see
`List Pagination`__.
Example: `50`
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str page: (optional)
For list pagination. The value of the `opc-next-page` response header from the previous \"List\"
call. For important details about how pagination works, see
`List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type list of :class:`~oci.dts.models.TransferJobSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/list_transfer_jobs.py.html>`__ to see an example of how to use list_transfer_jobs API.
"""
resource_path = "/transferJobs"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "lifecycle_state", "display_name", "limit",
"page", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_transfer_jobs got unknown kwargs: {!r}".format(
extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"INITIATED", "PREPARING", "ACTIVE", "DELETED", "CLOSED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
query_params = {
"compartmentId": compartment_id,
"lifecycleState": kwargs.get("lifecycle_state", missing),
"displayName": kwargs.get("display_name", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[TransferJobSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[TransferJobSummary]")
def update_transfer_job(self, id, update_transfer_job_details, **kwargs):
"""
Updates a Transfer Job that corresponds with customer's logical dataset e.g. a DB or a filesystem.
:param str id: (required)
ID of the Transfer Job
:param oci.dts.models.UpdateTransferJobDetails update_transfer_job_details: (required)
fields to update
:param str if_match: (optional)
The entity tag to match. Optional, if set, the update will be successful only if the
object's tag matches the tag specified in the request.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If you need to contact Oracle about
a particular request, please provide the request ID.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.dts.models.TransferJob`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dts/update_transfer_job.py.html>`__ to see an example of how to use update_transfer_job API.
"""
resource_path = "/transferJobs/{id}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_transfer_job got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_transfer_job_details,
response_type="TransferJob")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_transfer_job_details,
response_type="TransferJob")
class OrganizationClient(object):
"""
The Organizations API allows you to consolidate multiple OCI tenancies into an organization, and centrally manage your tenancies and its resources.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(
tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(config, "pass_phrase"),
private_key_content=config.get("key_content")
)
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'base_path': '/20200801',
'service_endpoint_template': 'https://organizations.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy': kwargs.get('circuit_breaker_strategy', circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs['circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
self.base_client = BaseClient("organization", config, signer, tenant_manager_control_plane_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def approve_organization_tenancy_for_transfer(self, compartment_id, organization_tenancy_id, **kwargs):
"""
Approve an organization's child tenancy for transfer.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param str organization_tenancy_id: (required)
OCID of the child tenancy.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request, so it can be retried in case of a timeout or
server error, without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.tenant_manager_control_plane.models.OrganizationTenancy`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/approve_organization_tenancy_for_transfer.py.html>`__ to see an example of how to use approve_organization_tenancy_for_transfer API.
"""
resource_path = "/organizationTenancies/{organizationTenancyId}/actions/approveForTransfer"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_retry_token",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"approve_organization_tenancy_for_transfer got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"organizationTenancyId": organization_tenancy_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
query_params = {
"compartmentId": compartment_id
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="OrganizationTenancy")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="OrganizationTenancy")
def create_child_tenancy(self, create_child_tenancy_details, **kwargs):
"""
Creates a child tenancy asynchronously.
:param oci.tenant_manager_control_plane.models.CreateChildTenancyDetails create_child_tenancy_details: (required)
Parameters to create a child tenancy.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request, so it can be retried in case of a timeout or
server error, without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/create_child_tenancy.py.html>`__ to see an example of how to use create_child_tenancy API.
"""
resource_path = "/childTenancies"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_retry_token",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"create_child_tenancy got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_child_tenancy_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_child_tenancy_details)
def delete_organization_tenancy(self, organization_tenancy_id, **kwargs):
"""
If certain validations are successful, initiate tenancy termination.
:param str organization_tenancy_id: (required)
OCID of the tenancy to be terminated.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request, so it can be retried in case of a timeout or
server error, without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/delete_organization_tenancy.py.html>`__ to see an example of how to use delete_organization_tenancy API.
"""
resource_path = "/organizationTenancies/{organizationTenancyId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_request_id",
"opc_retry_token"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"delete_organization_tenancy got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"organizationTenancyId": organization_tenancy_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_organization(self, organization_id, **kwargs):
"""
Gets information about the organization.
:param str organization_id: (required)
OCID of the organization to retrieve.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.tenant_manager_control_plane.models.Organization`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/get_organization.py.html>`__ to see an example of how to use get_organization API.
"""
resource_path = "/organizations/{organizationId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_organization got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"organizationId": organization_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Organization")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Organization")
def get_organization_tenancy(self, organization_id, tenancy_id, **kwargs):
"""
Gets information about the organization's tenancy.
:param str organization_id: (required)
OCID of the organization.
:param str tenancy_id: (required)
OCID of the tenancy to retrieve.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.tenant_manager_control_plane.models.OrganizationTenancy`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/get_organization_tenancy.py.html>`__ to see an example of how to use get_organization_tenancy API.
"""
resource_path = "/organizations/{organizationId}/tenancies/{tenancyId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"get_organization_tenancy got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"organizationId": organization_id,
"tenancyId": tenancy_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="OrganizationTenancy")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="OrganizationTenancy")
def list_organization_tenancies(self, organization_id, **kwargs):
"""
Gets a list of tenancies in the organization.
:param str organization_id: (required)
OCID of the organization.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.tenant_manager_control_plane.models.OrganizationTenancyCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/list_organization_tenancies.py.html>`__ to see an example of how to use list_organization_tenancies API.
"""
resource_path = "/organizations/{organizationId}/tenancies"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"page",
"limit"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_organization_tenancies got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"organizationId": organization_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="OrganizationTenancyCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="OrganizationTenancyCollection")
def list_organizations(self, compartment_id, **kwargs):
"""
Lists organizations associated with the caller.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param int limit: (optional)
The maximum number of items to return.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.tenant_manager_control_plane.models.OrganizationCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/list_organizations.py.html>`__ to see an example of how to use list_organizations API.
"""
resource_path = "/organizations"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"page",
"limit"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_organizations got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {
"compartmentId": compartment_id,
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="OrganizationCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="OrganizationCollection")
def unapprove_organization_tenancy_for_transfer(self, compartment_id, organization_tenancy_id, **kwargs):
"""
Cancel an organization's child tenancy for transfer.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param str organization_tenancy_id: (required)
OCID of the child tenancy.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request, so it can be retried in case of a timeout or
server error, without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.tenant_manager_control_plane.models.OrganizationTenancy`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/unapprove_organization_tenancy_for_transfer.py.html>`__ to see an example of how to use unapprove_organization_tenancy_for_transfer API.
"""
resource_path = "/organizationTenancies/{organizationTenancyId}/actions/unapproveForTransfer"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"if_match",
"opc_retry_token",
"opc_request_id"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"unapprove_organization_tenancy_for_transfer got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"organizationTenancyId": organization_tenancy_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
query_params = {
"compartmentId": compartment_id
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="OrganizationTenancy")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="OrganizationTenancy")
def update_organization(self, organization_id, update_organization_details, **kwargs):
"""
Assign the default subscription to the organization.
:param str organization_id: (required)
OCID of the organization.
:param oci.tenant_manager_control_plane.models.UpdateOrganizationDetails update_organization_details: (required)
The information to be updated.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request, so it can be retried in case of a timeout or
server error, without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/update_organization.py.html>`__ to see an example of how to use update_organization API.
"""
resource_path = "/organizations/{organizationId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"opc_request_id",
"if_match",
"opc_retry_token"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"update_organization got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"organizationId": organization_id
}
path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"if-match": kwargs.get("if_match", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy
)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_organization_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_organization_details)
class RoverClusterClient(object):
"""
A description of the RoverCloudService API.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client': True,
'service_endpoint': kwargs.get('service_endpoint'),
'base_path': '/20201210',
'service_endpoint_template':
'https://rover.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
self.base_client = BaseClient("rover_cluster", config, signer,
rover_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_rover_cluster_compartment(
self, rover_cluster_id, change_rover_cluster_compartment_details,
**kwargs):
"""
Moves a cluster into a different compartment.
:param str rover_cluster_id: (required)
Unique RoverCluster identifier
:param oci.rover.models.ChangeRoverClusterCompartmentDetails change_rover_cluster_compartment_details: (required)
CompartmentId of the destination compartment
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/change_rover_cluster_compartment.py.html>`__ to see an example of how to use change_rover_cluster_compartment API.
"""
resource_path = "/roverClusters/{roverClusterId}/actions/changeCompartment"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "if_match", "opc_request_id", "opc_retry_token"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"change_rover_cluster_compartment got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"roverClusterId": rover_cluster_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_rover_cluster_compartment_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=change_rover_cluster_compartment_details)
def create_rover_cluster(self, create_rover_cluster_details, **kwargs):
"""
Creates a new RoverCluster.
:param oci.rover.models.CreateRoverClusterDetails create_rover_cluster_details: (required)
Details for the new RoverCluster.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or
server error without risk of executing that same action again. Retry tokens expire after 24
hours, but can be invalidated before then due to conflicting operations. For example, if a resource
has been deleted and purged from the system, then a retry of the original creation request
might be rejected.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.rover.models.RoverCluster`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/create_rover_cluster.py.html>`__ to see an example of how to use create_rover_cluster API.
"""
resource_path = "/roverClusters"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_retry_token", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_rover_cluster got unknown kwargs: {!r}".format(
extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-retry-token": kwargs.get("opc_retry_token", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_rover_cluster_details,
response_type="RoverCluster")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_rover_cluster_details,
response_type="RoverCluster")
def delete_rover_cluster(self, rover_cluster_id, **kwargs):
"""
Deletes a RoverCluster resource by identifier
:param str rover_cluster_id: (required)
Unique RoverCluster identifier
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type None
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/delete_rover_cluster.py.html>`__ to see an example of how to use delete_rover_cluster API.
"""
resource_path = "/roverClusters/{roverClusterId}"
method = "DELETE"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"delete_rover_cluster got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverClusterId": rover_cluster_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params)
def get_rover_cluster(self, rover_cluster_id, **kwargs):
"""
Gets a RoverCluster by identifier
:param str rover_cluster_id: (required)
Unique RoverCluster identifier
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.rover.models.RoverCluster`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/get_rover_cluster.py.html>`__ to see an example of how to use get_rover_cluster API.
"""
resource_path = "/roverClusters/{roverClusterId}"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_rover_cluster got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverClusterId": rover_cluster_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverCluster")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverCluster")
def get_rover_cluster_certificate(self, rover_cluster_id, **kwargs):
"""
Get the certificate for a rover cluster
:param str rover_cluster_id: (required)
Unique RoverCluster identifier
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.rover.models.RoverClusterCertificate`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/get_rover_cluster_certificate.py.html>`__ to see an example of how to use get_rover_cluster_certificate API.
"""
resource_path = "/roverClusters/{roverClusterId}/certificate"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_rover_cluster_certificate got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"roverClusterId": rover_cluster_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverClusterCertificate")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverClusterCertificate")
def list_rover_clusters(self, compartment_id, **kwargs):
"""
Returns a list of RoverClusters.
:param str compartment_id: (required)
The OCID of the compartment in which to list resources.
:param str display_name: (optional)
A filter to return only resources that match the entire display name given.
:param int limit: (optional)
The maximum number of items to return.
:param str page: (optional)
The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
:param str lifecycle_state: (optional)
A filter to return only resources their lifecycleState matches the given lifecycleState.
Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
:param str sort_order: (optional)
The sort order to use, either 'asc' or 'desc'.
Allowed values are: "ASC", "DESC"
:param str sort_by: (optional)
The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
Allowed values are: "timeCreated", "displayName"
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.rover.models.RoverClusterCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/list_rover_clusters.py.html>`__ to see an example of how to use list_rover_clusters API.
"""
resource_path = "/roverClusters"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "display_name", "limit", "page",
"lifecycle_state", "sort_order", "sort_by", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_rover_clusters got unknown kwargs: {!r}".format(
extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED",
"FAILED"
]
if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
raise ValueError(
"Invalid value for `lifecycle_state`, must be one of {0}".
format(lifecycle_state_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
query_params = {
"compartmentId": compartment_id,
"displayName": kwargs.get("display_name", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="RoverClusterCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="RoverClusterCollection")
def update_rover_cluster(self, rover_cluster_id,
update_rover_cluster_details, **kwargs):
"""
Updates the RoverCluster
:param str rover_cluster_id: (required)
Unique RoverCluster identifier
:param oci.rover.models.UpdateRoverClusterDetails update_rover_cluster_details: (required)
The information to be updated.
:param str if_match: (optional)
For optimistic concurrency control. In the PUT or DELETE call
for a resource, set the `if-match` parameter to the value of the
etag from a previous GET or POST response for that resource.
The resource will be updated or deleted only if the etag you
provide matches the resource's current etag value.
:param str opc_request_id: (optional)
The client request ID for tracing.
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.rover.models.RoverCluster`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/update_rover_cluster.py.html>`__ to see an example of how to use update_rover_cluster API.
"""
resource_path = "/roverClusters/{roverClusterId}"
method = "PUT"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "if_match", "opc_request_id"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"update_rover_cluster got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverClusterId": rover_cluster_id}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"if-match": kwargs.get("if_match", missing),
"opc-request-id": kwargs.get("opc_request_id", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.retry_strategy
if kwargs.get('retry_strategy'):
retry_strategy = kwargs.get('retry_strategy')
if retry_strategy:
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_rover_cluster_details,
response_type="RoverCluster")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_rover_cluster_details,
response_type="RoverCluster")
class NetworkValidationClient(object):
"""
Use the DCMS APIs to perform Metadata/Data operations.
"""
def __init__(self, config, **kwargs):
"""
Creates a new service client
:param dict config:
Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
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
the dict using :py:meth:`~oci.config.validate_config`
:param str service_endpoint: (optional)
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
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
need to specify a service endpoint.
:param timeout: (optional)
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
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
a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
:type timeout: float or tuple(float, float)
:param signer: (optional)
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
provided in the config parameter.
One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
:type signer: :py:class:`~oci.signer.AbstractBaseSigner`
:param obj retry_strategy: (optional)
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.
Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
Any value provided at the operation level will override whatever is specified at the client level.
This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
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>`__.
:param obj circuit_breaker_strategy: (optional)
A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
This client uses :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` as default if no circuit breaker strategy is provided.
The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
:param function circuit_breaker_callback: (optional)
Callback function to receive any exceptions triggerred by the circuit breaker.
:param allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this client should allow control characters in the response object. By default, the client will not
allow control characters to be in the response object.
"""
validate_config(config, signer=kwargs.get('signer'))
if 'signer' in kwargs:
signer = kwargs['signer']
elif AUTHENTICATION_TYPE_FIELD_NAME in config:
signer = get_signer_from_authentication_type(config)
else:
signer = Signer(tenancy=config["tenancy"],
user=config["user"],
fingerprint=config["fingerprint"],
private_key_file_location=config.get("key_file"),
pass_phrase=get_config_value_or_default(
config, "pass_phrase"),
private_key_content=config.get("key_content"))
base_client_init_kwargs = {
'regional_client':
True,
'service_endpoint':
kwargs.get('service_endpoint'),
'base_path':
'/20210217',
'service_endpoint_template':
'https://dataconnectivity.{region}.oci.{secondLevelDomain}',
'skip_deserialization':
kwargs.get('skip_deserialization', False),
'circuit_breaker_strategy':
kwargs.get('circuit_breaker_strategy',
circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
}
if 'timeout' in kwargs:
base_client_init_kwargs['timeout'] = kwargs.get('timeout')
if base_client_init_kwargs.get('circuit_breaker_strategy') is None:
base_client_init_kwargs[
'circuit_breaker_strategy'] = circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY
if 'allow_control_chars' in kwargs:
base_client_init_kwargs['allow_control_chars'] = kwargs.get(
'allow_control_chars')
self.base_client = BaseClient("network_validation", config, signer,
data_connectivity_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def get_network_connectivity_status_collection(self, registry_id,
endpoint_key, **kwargs):
"""
This api is used to get Network Connectivity Status for all the Data Assets attatched to the provided Private endpoint.
:param str registry_id: (required)
The registry Ocid.
:param str endpoint_key: (required)
The endpoint key.
:param str opc_request_id: (optional)
Unique Oracle-assigned identifier for the request. If
you need to contact Oracle about a particular request,
please provide the request ID.
:param str opc_retry_token: (optional)
A token that uniquely identifies a request so it can be retried in case of a timeout or server error without risk of executing that same action again.
:param str page: (optional)
For list pagination. The value for this parameter is the `opc-next-page` or the `opc-prev-page` response header from the previous `List` call. See `List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param int limit: (optional)
Sets the maximum number of results per page, or items to return in a paginated `List` call. See `List Pagination`__.
__ https://docs.cloud.oracle.com/iaas/Content/API/Concepts/usingapi.htm#nine
:param str sort_by: (optional)
Specifies the field to sort by. Accepts only one field. By default, when you sort by time fields, results are shown in descending order. All other fields default to ascending order. Sorting related parameters are ignored when parameter `query` is present (search operation and sorting order is by relevance score in descending order).
Allowed values are: "id", "timeCreated", "displayName"
:param str sort_order: (optional)
Specifies sort order to use, either `ASC` (ascending) or `DESC` (descending).
Allowed values are: "ASC", "DESC"
:param obj retry_strategy: (optional)
A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
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.
The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
:param bool allow_control_chars: (optional)
allow_control_chars is a boolean to indicate whether or not this request should allow control characters in the response object.
By default, the response will not allow control characters in strings
:return: A :class:`~oci.response.Response` object with data of type :class:`~oci.data_connectivity.models.NetworkConnectivityStatusCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/dataconnectivity/get_network_connectivity_status_collection.py.html>`__ to see an example of how to use get_network_connectivity_status_collection API.
"""
resource_path = "/registries/{registryId}/endpoints/{endpointKey}/networkConnectivityStatusCollection"
method = "GET"
operation_name = "get_network_connectivity_status_collection"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "opc_request_id",
"opc_retry_token", "page", "limit", "sort_by", "sort_order"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_network_connectivity_status_collection got unknown kwargs: {!r}"
.format(extra_kwargs))
path_params = {"registryId": registry_id, "endpointKey": endpoint_key}
path_params = {
k: v
for (k, v) in six.iteritems(path_params) if v is not missing
}
for (k, v) in six.iteritems(path_params):
if v is None or (isinstance(v, six.string_types)
and len(v.strip()) == 0):
raise ValueError(
'Parameter {} cannot be None, whitespace or empty string'.
format(k))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["id", "timeCreated", "displayName"]
if kwargs['sort_by'] not in sort_by_allowed_values:
raise ValueError(
"Invalid value for `sort_by`, must be one of {0}".format(
sort_by_allowed_values))
if 'sort_order' in kwargs:
sort_order_allowed_values = ["ASC", "DESC"]
if kwargs['sort_order'] not in sort_order_allowed_values:
raise ValueError(
"Invalid value for `sort_order`, must be one of {0}".
format(sort_order_allowed_values))
query_params = {
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"sortBy": kwargs.get("sort_by", missing),
"sortOrder": kwargs.get("sort_order", missing)
}
query_params = {
k: v
for (k, v) in six.iteritems(query_params)
if v is not missing and v is not None
}
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-request-id": kwargs.get("opc_request_id", missing),
"opc-retry-token": kwargs.get("opc_retry_token", missing)
}
header_params = {
k: v
for (k, v) in six.iteritems(header_params)
if v is not missing and v is not None
}
retry_strategy = self.base_client.get_preferred_retry_strategy(
operation_retry_strategy=kwargs.get('retry_strategy'),
client_retry_strategy=self.retry_strategy)
if retry_strategy:
if not isinstance(retry_strategy, retry.NoneRetryStrategy):
self.base_client.add_opc_retry_token_if_needed(header_params)
self.base_client.add_opc_client_retries_header(header_params)
retry_strategy.add_circuit_breaker_callback(
self.circuit_breaker_callback)
return retry_strategy.make_retrying_call(
self.base_client.call_api,
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="NetworkConnectivityStatusCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="NetworkConnectivityStatusCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
