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': '/20160918'
}
self.base_client = BaseClient("audit", config, signer, audit_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/create_channel.py.html>`__ to see an example of how to use create_channel API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/delete_channel.py.html>`__ to see an example of how to use delete_channel API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/get_channel.py.html>`__ to see an example of how to use get_channel API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/list_channels.py.html>`__ to see an example of how to use list_channels API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/reset_channel.py.html>`__ to see an example of how to use reset_channel API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/resume_channel.py.html>`__ to see an example of how to use resume_channel API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/mysql/update_channel.py.html>`__ to see an example of how to use update_channel API.
"""
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 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 oci.budget.models.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 oci.budget.models.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 oci.budget.models.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 oci.budget.models.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 IntegrationInstanceClient(object):
"""
Oracle Integration 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']
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': '/20190131',
'service_endpoint_template':
'https://integration.{region}.ocp.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("integration_instance", config, signer,
integration_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_integration_instance_compartment(
self, integration_instance_id,
change_integration_instance_compartment_details, **kwargs):
"""
Change the compartment for an integration instance
:param str integration_instance_id: (required)
Unique Integration Instance identifier.
:param ChangeIntegrationInstanceCompartmentDetails change_integration_instance_compartment_details: (required)
Details for the update integration 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. 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 = "/integrationInstances/{integrationInstanceId}/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_integration_instance_compartment got unknown kwargs: {!r}"
.format(extra_kwargs))
path_params = {"integrationInstanceId": integration_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.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_integration_instance_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_integration_instance_compartment_details)
def create_integration_instance(self, create_integration_instance_details,
**kwargs):
"""
Creates a new Integration Instance.
:param CreateIntegrationInstanceDetails create_integration_instance_details: (required)
Details for the new Integration Instance.
: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 None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/integrationInstances"
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_integration_instance 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_integration_instance_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_integration_instance_details)
def delete_integration_instance(self, integration_instance_id, **kwargs):
"""
Deletes an Integration Instance resource by identifier.
:param str integration_instance_id: (required)
Unique Integration Instance 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://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 = "/integrationInstances/{integrationInstanceId}"
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_integration_instance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"integrationInstanceId": integration_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.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_integration_instance(self, integration_instance_id, **kwargs):
"""
Gets a IntegrationInstance by identifier
:param str integration_instance_id: (required)
Unique Integration Instance 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://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.integration.models.IntegrationInstance`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/integrationInstances/{integrationInstanceId}"
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_integration_instance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"integrationInstanceId": integration_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.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="IntegrationInstance")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="IntegrationInstance")
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. 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.integration.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_integration_instances(self, compartment_id, **kwargs):
"""
Returns a list of Integration Instances.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
: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)
Life cycle state to query on.
Allowed values are: "CREATING", "UPDATING", "ACTIVE", "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'.
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://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.integration.models.IntegrationInstanceSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/integrationInstances"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "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_integration_instances 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),
"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[IntegrationInstanceSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[IntegrationInstanceSummary]")
def list_work_request_errors(self, compartment_id, work_request_id,
**kwargs):
"""
Get the errors of a work request.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
: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 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 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.integration.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", "limit", "page"]
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 = {
"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,
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, compartment_id, work_request_id,
**kwargs):
"""
Get the logs of a work request.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
: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 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 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.integration.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", "limit", "page"]
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 = {
"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,
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, 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 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 integration_instance_id: (optional)
The Integration Instance identifier to use to filter results
: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.integration.models.WorkRequestSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/workRequests"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "page", "limit",
"integration_instance_id"
]
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,
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", missing),
"integrationInstanceId": kwargs.get("integration_instance_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="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_integration_instance(self, integration_instance_id,
update_integration_instance_details,
**kwargs):
"""
Updates the Integration Instance.
:param str integration_instance_id: (required)
Unique Integration Instance identifier.
:param UpdateIntegrationInstanceDetails update_integration_instance_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 None
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/integrationInstances/{integrationInstanceId}"
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_integration_instance got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"integrationInstanceId": integration_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.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_integration_instance_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_integration_instance_details)
class UserClient(object):
"""
Use the Support Management API to manage support requests. For more information, see [Getting Help and Contacting Support](/iaas/Content/GSG/Tasks/contactingsupport.htm). **Note**: Before you can create service requests with this API, you need to have an Oracle Single Sign On (SSO) account, and you need to register your Customer Support Identifier (CSI) with My Oracle Support.
"""
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':
'/20181231',
'service_endpoint_template':
'https://incidentmanagement.{region}.{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("user", config, signer,
cims_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def create_user(self, create_user_details, ocid, **kwargs):
"""
Create user to request Customer Support Identifier(CSI) to Customer User Administrator(CUA).
:param oci.cims.models.CreateUserDetails create_user_details: (required)
User information
:param str ocid: (required)
User OCID for Oracle Identity Cloud Service (IDCS) users who also have a federated Oracle Cloud Infrastructure account.
: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 homeregion: (optional)
The region of the tenancy.
: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.cims.models.User`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/cims/create_user.py.html>`__ to see an example of how to use create_user API.
"""
resource_path = "/v2/users"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "homeregion"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_user 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),
"ocid": ocid,
"homeregion": kwargs.get("homeregion", 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,
header_params=header_params,
body=create_user_details,
response_type="User")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_user_details,
response_type="User")
class DiagnoseToolsClient(object):
"""
A description of the XACP 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 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': '/20180301',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("diagnose_tools", config, signer,
client_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def get_stats(self, **kwargs):
"""
Get resource stats from the transfer appliance
Get resource stats from the transfer appliance
:param int delay: (optional)
:param int count: (optional)
:param str mem: (optional)
:param str cpu: (optional)
:param str network: (optional)
:param str disk: (optional)
: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 stream
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/diagnose/stats"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "delay", "count", "mem", "cpu", "network", "disk"
]
extra_kwargs = [
key for key in six.iterkeys(kwargs) if key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_stats got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {
"delay": kwargs.get("delay", missing),
"count": kwargs.get("count", missing),
"mem": kwargs.get("mem", missing),
"cpu": kwargs.get("cpu", missing),
"network": kwargs.get("network", missing),
"disk": kwargs.get("disk", 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": "text/plain; charset=utf-8",
"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,
query_params=query_params,
header_params=header_params,
response_type="stream")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="stream")
class TransferDeviceClient(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']
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': '/20171001',
'service_endpoint_template':
'https://datatransfer.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("transfer_device", config, signer,
dts_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_transfer_device(self, id, create_transfer_device_details,
**kwargs):
"""
Create a new Transfer Device
:param str id: (required)
ID of the Transfer Job
:param CreateTransferDeviceDetails create_transfer_device_details: (required)
Creates a New Transfer Device
:param str opc_retry_token: (optional)
: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.NewTransferDevice`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferDevices"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_retry_token"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"create_transfer_device 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=create_transfer_device_details,
response_type="NewTransferDevice")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_transfer_device_details,
response_type="NewTransferDevice")
def delete_transfer_device(self, id, transfer_device_label, **kwargs):
"""
deletes a transfer Device
:param str id: (required)
ID of the Transfer Job
:param str transfer_device_label: (required)
Label of the Transfer Device
: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}/transferDevices/{transferDeviceLabel}"
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_device got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id, "transferDeviceLabel": transfer_device_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_device(self, id, transfer_device_label, **kwargs):
"""
Describes a transfer package in detail
:param str id: (required)
ID of the Transfer Job
:param str transfer_device_label: (required)
Label of the Transfer Device
: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.TransferDevice`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferDevices/{transferDeviceLabel}"
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_device got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id, "transferDeviceLabel": transfer_device_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="TransferDevice")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="TransferDevice")
def list_transfer_devices(self, id, **kwargs):
"""
Lists Transfer Devices 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", "READY", "PACKAGED", "ACTIVE", "PROCESSING", "COMPLETE", "MISSING", "ERROR", "DELETED", "CANCELLED"
: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. 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.MultipleTransferDevices`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferDevices"
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_devices 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", "READY", "PACKAGED", "ACTIVE", "PROCESSING",
"COMPLETE", "MISSING", "ERROR", "DELETED", "CANCELLED"
]
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.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="MultipleTransferDevices")
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="MultipleTransferDevices")
def update_transfer_device(self, id, transfer_device_label,
update_transfer_device_details, **kwargs):
"""
Updates a Transfer Device
:param str id: (required)
ID of the Transfer Job
:param str transfer_device_label: (required)
Label of the Transfer Device
:param UpdateTransferDeviceDetails update_transfer_device_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.TransferDevice`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/transferJobs/{id}/transferDevices/{transferDeviceLabel}"
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_device got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"id": id, "transferDeviceLabel": transfer_device_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_device_details,
response_type="TransferDevice")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_transfer_device_details,
response_type="TransferDevice")
class LinkClient(object):
"""
A description of the TenantManager 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': '/20200801',
'service_endpoint_template':
'https://organizations.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient(
"link", config, signer, tenant_manager_control_plane_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def delete_link(self, link_id, **kwargs):
"""
Terminate the link.
:param str link_id: (required)
OCID of the link to terminate.
: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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/delete_link.py.html>`__ to see an example of how to use delete_link API.
"""
resource_path = "/links/{linkId}"
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_link got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"linkId": link_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_link(self, link_id, **kwargs):
"""
Gets information about the link.
:param str link_id: (required)
OCID of the link 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. 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.tenant_manager_control_plane.models.Link`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/get_link.py.html>`__ to see an example of how to use get_link API.
"""
resource_path = "/links/{linkId}"
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_link got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"linkId": link_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="Link")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Link")
def list_links(self, **kwargs):
"""
Return a (paginated) list of links.
:param str parent_tenancy_id: (optional)
The ID of the parent tenancy this link is associated with.
:param str child_tenancy_id: (optional)
The ID of the child tenancy this link is associated with.
:param str lifecycle_state: (optional)
The lifecycle state of the resource.
Allowed values are: "CREATING", "ACTIVE", "INACTIVE", "UPDATING", "FAILED", "TERMINATED"
: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'.
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 :class:`~oci.tenant_manager_control_plane.models.LinkCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/tenantmanagercontrolplane/list_links.py.html>`__ to see an example of how to use list_links API.
"""
resource_path = "/links"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "parent_tenancy_id", "child_tenancy_id",
"lifecycle_state", "opc_request_id", "page", "limit", "sort_order"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"list_links got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "ACTIVE", "INACTIVE", "UPDATING", "FAILED",
"TERMINATED"
]
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))
query_params = {
"parentTenancyId": kwargs.get("parent_tenancy_id", missing),
"childTenancyId": kwargs.get("child_tenancy_id", missing),
"lifecycleState": kwargs.get("lifecycle_state", missing),
"page": kwargs.get("page", missing),
"limit": kwargs.get("limit", 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="LinkCollection")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="LinkCollection")
class TraceClient(object):
"""
API for APM Trace service. Use this API to query the Traces and associated Spans.
"""
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://apm-trace.{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("trace", config, signer, apm_traces_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def get_span(self, apm_domain_id, span_key, trace_key, **kwargs):
"""
Get the span details identified by spanId
:param str apm_domain_id: (required)
The APM Domain Id the request is intended for.
:param str span_key: (required)
Unique APM span identifier(spanId).
:param str trace_key: (required)
Unique APM trace identifier(traceId).
: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. 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.apm_traces.models.Span`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apmtraces/get_span.py.html>`__ to see an example of how to use get_span API.
"""
resource_path = "/spans/{traceKey}/{spanKey}"
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_span got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"spanKey": span_key,
"traceKey": trace_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))
query_params = {
"apmDomainId": apm_domain_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,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="Span")
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="Span")
def get_trace(self, apm_domain_id, trace_key, **kwargs):
"""
Get the trace details identified by traceId
:param str apm_domain_id: (required)
The APM Domain Id the request is intended for.
:param str trace_key: (required)
Unique APM trace identifier(traceId).
: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. 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.apm_traces.models.Trace`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/apmtraces/get_trace.py.html>`__ to see an example of how to use get_trace API.
"""
resource_path = "/traces/{traceKey}"
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_trace got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"traceKey": trace_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))
query_params = {
"apmDomainId": apm_domain_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,
path_params=path_params,
query_params=query_params,
header_params=header_params,
response_type="Trace")
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="Trace")
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': '/oalapp/service/onesubs/proxy/20210501',
'service_endpoint_template': 'https://csaap-e.oracle.com',
'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("ratecard", config, signer, osub_subscription_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
class RatecardClient(object):
"""
Set of APIs that return the Subscription Details, Commitment and Effective Rate Card Details
"""
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': '/oalapp/service/onesubs/proxy/20210501',
'service_endpoint_template': 'https://csaap-e.oracle.com',
'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("ratecard", config, signer, osub_subscription_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def list_rate_cards(self, subscription_id, compartment_id, **kwargs):
"""
List API that returns all ratecards for given Subscription Id and Account ID (if provided) and
for a particular date range
:param str subscription_id: (required)
Line level Subscription Id
:param str compartment_id: (required)
The OCID of the compartment.
:param datetime time_from: (optional)
This param is used to get the rate card(s) whose effective start date starts on or after a particular date
:param datetime time_to: (optional)
This param is used to get the rate card(s) whose effective end date ends on or before a particular date
:param str part_number: (optional)
This param is used to get the rate card(s) filterd by the partNumber
:param int limit: (optional)
The maximum number of items to return in a paginated \"List\" call. Default: (`50`)
Example: `500`
:param str page: (optional)
The value of the `opc-next-page` response header from the 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`).
Allowed values are: "TIMECREATED", "TIMESTART"
: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 x_one_origin_region: (optional)
The OCI home region name in case home region is not us-ashburn-1 (IAD), e.g. ap-mumbai-1, us-phoenix-1 etc.
: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.osub_subscription.models.RateCardSummary`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/osubsubscription/list_rate_cards.py.html>`__ to see an example of how to use list_rate_cards API.
"""
resource_path = "/ratecards"
method = "GET"
operation_name = "list_rate_cards"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars",
"retry_strategy",
"time_from",
"time_to",
"part_number",
"limit",
"page",
"sort_order",
"sort_by",
"opc_request_id",
"x_one_origin_region"
]
extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
if extra_kwargs:
raise ValueError(
"list_rate_cards 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", "TIMESTART"]
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 = {
"subscriptionId": subscription_id,
"timeFrom": kwargs.get("time_from", missing),
"timeTo": kwargs.get("time_to", missing),
"partNumber": kwargs.get("part_number", missing),
"limit": kwargs.get("limit", missing),
"page": kwargs.get("page", missing),
"sortOrder": kwargs.get("sort_order", missing),
"sortBy": kwargs.get("sort_by", 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),
"x-one-origin-region": kwargs.get("x_one_origin_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,
query_params=query_params,
header_params=header_params,
response_type="list[RateCardSummary]",
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[RateCardSummary]",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class FunctionsInvokeClient(object):
"""
API for the Functions 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':
'/20181201',
'service_endpoint_template':
'https://functions.{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("functions_invoke", config, signer,
functions_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def invoke_function(self, function_id, **kwargs):
"""
Invokes a function
:param str function_id: (required)
The `OCID`__ of this function.
__ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
:param stream invoke_function_body: (optional)
The body of the function invocation.
Note: The maximum size of the request is limited. This limit is currently 6MB and the endpoint will not accept requests that are bigger than this limit.
:param str fn_intent: (optional)
An optional intent header that indicates to the FDK the way the event should be interpreted. E.g. 'httprequest', 'cloudevent'.
Allowed values are: "httprequest", "cloudevent"
:param str fn_invoke_type: (optional)
Indicates whether Oracle Functions should execute the request and return the result ('sync') of the execution,
or whether Oracle Functions should return as soon as processing has begun ('detached') and leave result handling to the function.
Allowed values are: "detached", "sync"
: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. 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
:param int buffer_limit: (optional)
A buffer limit for the stream to be buffered. buffer_limit is used to set the buffer size capacity. Streams will be read until the size of the buffer reaches the buffer_limit.
If the stream size is greater than the buffer_limit, a BufferError exception will be thrown.
The buffer_limit parameter is used when the stream object does not have a `seek`, `tell`, or `fileno` property for the Python Request library to calculate out the content length.
If buffer_limit is not passed, then the buffer_limit will be defaulted to 100MB.
Large streams can cause the process to freeze, consider passing in content-length for large streams instead.
:return: A :class:`~oci.response.Response` object with data of type stream
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/functions/invoke_function.py.html>`__ to see an example of how to use invoke_function API.
"""
resource_path = "/functions/{functionId}/actions/invoke"
method = "POST"
operation_name = "invoke_function"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/functions/20181201/Function/InvokeFunction"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars", "retry_strategy", "buffer_limit",
"invoke_function_body", "fn_intent", "fn_invoke_type",
"opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError("invoke_function got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"functionId": function_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": "*/*",
"fn-intent": kwargs.get("fn_intent", missing),
"fn-invoke-type": kwargs.get("fn_invoke_type", 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
}
# If the body parameter is optional we need to assign it to a variable so additional type checking can be performed.
try:
invoke_function_body
except NameError:
invoke_function_body = kwargs.get("invoke_function_body", missing)
if invoke_function_body is not missing and invoke_function_body is not None:
if (not isinstance(invoke_function_body,
(six.binary_type, six.string_types))
and not hasattr(invoke_function_body, "read")):
raise TypeError(
'The body must be a string, bytes, or provide a read() method.'
)
if hasattr(invoke_function_body, 'fileno') and hasattr(
invoke_function_body,
'name') and invoke_function_body.name != '<stdin>':
if requests.utils.super_len(invoke_function_body) == 0:
header_params['Content-Length'] = '0'
# If content length is not given and stream object have no 'fileno' and is not a string or bytes, try to calculate content length
elif 'Content-Length' not in header_params and not is_content_length_calculable_by_req_util(
invoke_function_body):
calculated_obj = back_up_body_calculate_stream_content_length(
invoke_function_body, kwargs.get("buffer_limit"))
header_params['Content-Length'] = calculated_obj[
"content_length"]
invoke_function_body = calculated_obj["byte_content"]
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=kwargs.get('invoke_function_body'),
response_type="stream",
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=kwargs.get('invoke_function_body'),
response_type="stream",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
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://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("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://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.Configuration`
:rtype: :class:`~oci.response.Response`
"""
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://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 = "/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://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.Configuration`
:rtype: :class:`~oci.response.Response`
"""
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://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.ConfigurationSummary`
:rtype: :class:`~oci.response.Response`
"""
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"
: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://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.ShapeSummary`
:rtype: :class:`~oci.response.Response`
"""
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"]
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://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.VersionSummary`
:rtype: :class:`~oci.response.Response`
"""
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://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.Configuration`
:rtype: :class:`~oci.response.Response`
"""
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 EsxiHostClient(object):
"""
Use the Oracle Cloud VMware API to create SDDCs and manage ESXi hosts and software.
For more information, see [Oracle Cloud VMware Solution](/iaas/Content/VMware/Concepts/ocvsoverview.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': '/20200501',
'service_endpoint_template': 'https://ocvps.{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("esxi_host", config, signer, ocvp_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
def create_esxi_host(self, create_esxi_host_details, **kwargs):
"""
Adds another ESXi host to an existing SDDC. The attributes of the specified
`Sddc` determine the VMware software and other configuration settings used
by the ESXi host.
Use the :class:`WorkRequest` operations to track the
creation of the ESXi host.
:param oci.ocvp.models.CreateEsxiHostDetails create_esxi_host_details: (required)
Details for the ESXi host.
: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. 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/ocvp/create_esxi_host.py.html>`__ to see an example of how to use create_esxi_host API.
"""
resource_path = "/esxiHosts"
method = "POST"
operation_name = "create_esxi_host"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/vmware/20200501/EsxiHost/CreateEsxiHost"
# 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_esxi_host 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_esxi_host_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,
header_params=header_params,
body=create_esxi_host_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def delete_esxi_host(self, esxi_host_id, **kwargs):
"""
Deletes the specified ESXi host. Before deleting the host, back up or
migrate any VMware workloads running on it.
When you delete an ESXi host, Oracle does not remove the node
configuration within the VMware environment itself. That is
your responsibility.
**Note:** If you delete EXSi hosts from the SDDC to total less than 3,
you are still billed for the 3 minimum recommended EXSi hosts. Also,
you cannot add more VMware workloads to the SDDC until it again has at
least 3 ESXi hosts.
Use the :class:`WorkRequest` operations to track the
deletion of the ESXi host.
:param str esxi_host_id: (required)
The `OCID`__ of the ESXi host.
__ 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. 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/ocvp/delete_esxi_host.py.html>`__ to see an example of how to use delete_esxi_host API.
"""
resource_path = "/esxiHosts/{esxiHostId}"
method = "DELETE"
operation_name = "delete_esxi_host"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/vmware/20200501/EsxiHost/DeleteEsxiHost"
# 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_esxi_host got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"esxiHostId": esxi_host_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_esxi_host(self, esxi_host_id, **kwargs):
"""
Gets the specified ESXi host's information.
:param str esxi_host_id: (required)
The `OCID`__ of the ESXi host.
__ 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. 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.ocvp.models.EsxiHost`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/ocvp/get_esxi_host.py.html>`__ to see an example of how to use get_esxi_host API.
"""
resource_path = "/esxiHosts/{esxiHostId}"
method = "GET"
operation_name = "get_esxi_host"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/vmware/20200501/EsxiHost/GetEsxiHost"
# 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_esxi_host got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"esxiHostId": esxi_host_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="EsxiHost",
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="EsxiHost",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_esxi_hosts(self, **kwargs):
"""
Lists the ESXi hosts in the specified SDDC. The list can be filtered
by Compute instance OCID or ESXi display name.
Remember that in terms of implementation, an ESXi host is a Compute instance that
is configured with the chosen bundle of VMware software. Each `EsxiHost`
object has its own OCID (`id`), and a separate attribute for the OCID of
the Compute instance (`computeInstanceId`). When filtering the list of
ESXi hosts, you can specify the OCID of the Compute instance, not the
ESXi host OCID.
:param str sddc_id: (optional)
The `OCID`__ of the SDDC.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str compute_instance_id: (optional)
The `OCID`__ of the Compute instance.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
: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. 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.ocvp.models.EsxiHostCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/ocvp/list_esxi_hosts.py.html>`__ to see an example of how to use list_esxi_hosts API.
"""
resource_path = "/esxiHosts"
method = "GET"
operation_name = "list_esxi_hosts"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/vmware/20200501/EsxiHostSummary/ListEsxiHosts"
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars",
"retry_strategy",
"sddc_id",
"compute_instance_id",
"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_esxi_hosts 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 = {
"sddcId": kwargs.get("sddc_id", missing),
"computeInstanceId": kwargs.get("compute_instance_id", 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.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="EsxiHostCollection",
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="EsxiHostCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def update_esxi_host(self, esxi_host_id, update_esxi_host_details, **kwargs):
"""
Updates the specified ESXi host.
:param str esxi_host_id: (required)
The `OCID`__ of the ESXi host.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param oci.ocvp.models.UpdateEsxiHostDetails update_esxi_host_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. 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.ocvp.models.EsxiHost`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/ocvp/update_esxi_host.py.html>`__ to see an example of how to use update_esxi_host API.
"""
resource_path = "/esxiHosts/{esxiHostId}"
method = "PUT"
operation_name = "update_esxi_host"
api_reference_link = "https://docs.oracle.com/iaas/api/#/en/vmware/20200501/EsxiHost/UpdateEsxiHost"
# 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_esxi_host got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"esxiHostId": esxi_host_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_esxi_host_details,
response_type="EsxiHost",
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_esxi_host_details,
response_type="EsxiHost",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class AuditClient(object):
"""
API for the Audit Service. You can use this API for queries, but not bulk-export 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.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': '/20160918'
}
self.base_client = BaseClient("audit", config, signer, audit_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def get_configuration(self, compartment_id, **kwargs):
"""
GetConfiguration
Get the configuration
:param str compartment_id: (required)
ID of the root compartment (tenancy)
: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.audit.models.Configuration`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/configuration"
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_configuration 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}
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,
query_params=query_params,
header_params=header_params,
response_type="Configuration")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="Configuration")
def list_events(self, compartment_id, start_time, end_time, **kwargs):
"""
ListEvents
Returns all audit events for the specified compartment that were processed within the specified time range.
:param str compartment_id: (required)
The OCID of the compartment.
:param datetime start_time: (required)
Returns events that were processed at or after this start date and time, expressed in `RFC 3339`__ timestamp format.
For example, a start value of `2017-01-15T11:30:00Z` will retrieve a list of all events processed since 30 minutes after the 11th hour of January 15, 2017, in Coordinated Universal Time (UTC).
You can specify a value with granularity to the minute. Seconds (and milliseconds, if included) must be set to `0`.
__ https://tools.ietf.org/html/rfc3339
:param datetime end_time: (required)
Returns events that were processed before this end date and time, expressed in `RFC 3339`__ timestamp format. For example, a start value of `2017-01-01T00:00:00Z` and an end value of `2017-01-02T00:00:00Z` will retrieve a list of all events processed on January 1, 2017.
Similarly, a start value of `2017-01-01T00:00:00Z` and an end value of `2017-02-01T00:00:00Z` will result in a list of all events processed between January 1, 2017 and January 31, 2017.
You can specify a value with granularity to the minute. Seconds (and milliseconds, if included) must be set to `0`.
__ https://tools.ietf.org/html/rfc3339
:param str page: (optional)
The value of the `opc-next-page` response header from the previous list query.
: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.audit.models.AuditEvent`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/auditEvents"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"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_events got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {
"compartmentId": compartment_id,
"startTime": start_time,
"endTime": end_time,
"page": kwargs.get("page", missing)
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing}
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}
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[AuditEvent]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[AuditEvent]")
def update_configuration(self, compartment_id, update_configuration_details, **kwargs):
"""
UpdateConfiguration
Update the configuration
:param str compartment_id: (required)
ID of the root compartment (tenancy)
:param UpdateConfigurationDetails update_configuration_details: (required)
The configuration properties
: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"
expected_kwargs = ["retry_strategy"]
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))
query_params = {
"compartmentId": compartment_id
}
query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing}
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,
query_params=query_params,
header_params=header_params,
body=update_configuration_details)
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
body=update_configuration_details)
class QuotasClient(object):
"""
APIs for managing Compartment Resource Quotas.
"""
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': '/20181025',
'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 = "/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 = "/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 = "/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'.
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 = "/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 = "/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 KmsCryptoClient(object):
"""
API for managing and performing operations with keys and vaults.
"""
def __init__(self, config, service_endpoint, **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:
The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``.
: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': False,
'service_endpoint': service_endpoint,
'timeout': kwargs.get('timeout'),
'base_path': '/',
'service_endpoint_template':
'https://kms.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("kms_crypto", config, signer,
key_management_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def decrypt(self, decrypt_data_details, **kwargs):
"""
Decrypt
Decrypts data using the given `DecryptDataDetails`__ resource.
__ https://docs.cloud.oracle.com/api/#/en/key/release/datatypes/DecryptDataDetails
:param DecryptDataDetails decrypt_data_details: (required)
DecryptDataDetails
: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.DecryptedData`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20180608/decrypt"
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(
"decrypt 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=decrypt_data_details,
response_type="DecryptedData")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=decrypt_data_details,
response_type="DecryptedData")
def encrypt(self, encrypt_data_details, **kwargs):
"""
Encrypt
Encrypts data using the given `EncryptDataDetails`__ resource.
Plaintext included in the example request is a base64-encoded value of a UTF-8 string.
__ https://docs.cloud.oracle.com/api/#/en/key/release/datatypes/EncryptDataDetails
:param EncryptDataDetails encrypt_data_details: (required)
EncryptDataDetails
: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.EncryptedData`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20180608/encrypt"
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(
"encrypt 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=encrypt_data_details,
response_type="EncryptedData")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=encrypt_data_details,
response_type="EncryptedData")
def generate_data_encryption_key(self, generate_key_details, **kwargs):
"""
GenerateDataEncryptionKey
Generates a key that you can use to encrypt or decrypt data.
:param GenerateKeyDetails generate_key_details: (required)
GenerateKeyDetails
: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.GeneratedKey`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20180608/generateDataEncryptionKey"
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(
"generate_data_encryption_key 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=generate_key_details,
response_type="GeneratedKey")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=generate_key_details,
response_type="GeneratedKey")
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']
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': '/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 FusionEnvironmentFamilyClient(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("fusion_environment_family", 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 change_fusion_environment_family_compartment(self, fusion_environment_family_id, change_fusion_environment_family_compartment_details, **kwargs):
"""
Moves a FusionEnvironmentFamily into a different compartment. When provided, If-Match is checked against ETag
values of the resource.
:param str fusion_environment_family_id: (required)
The unique identifier (OCID) of the FusionEnvironmentFamily.
:param oci.fusion_apps.models.ChangeFusionEnvironmentFamilyCompartmentDetails change_fusion_environment_family_compartment_details: (required)
Details for the compartment move.
: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`.
: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/change_fusion_environment_family_compartment.py.html>`__ to see an example of how to use change_fusion_environment_family_compartment API.
"""
resource_path = "/fusionEnvironmentFamilies/{fusionEnvironmentFamilyId}/actions/changeCompartment"
method = "POST"
operation_name = "change_fusion_environment_family_compartment"
api_reference_link = ""
# 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_fusion_environment_family_compartment got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"fusionEnvironmentFamilyId": fusion_environment_family_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_fusion_environment_family_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_fusion_environment_family_compartment_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def create_fusion_environment_family(self, create_fusion_environment_family_details, **kwargs):
"""
Creates a new FusionEnvironmentFamily.
:param oci.fusion_apps.models.CreateFusionEnvironmentFamilyDetails create_fusion_environment_family_details: (required)
Details for the new FusionEnvironmentFamily.
:param str opc_provision_option: (optional)
For Oracle internal use only.
: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_fusion_environment_family.py.html>`__ to see an example of how to use create_fusion_environment_family API.
"""
resource_path = "/fusionEnvironmentFamilies"
method = "POST"
operation_name = "create_fusion_environment_family"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars",
"retry_strategy",
"opc_provision_option",
"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_fusion_environment_family got unknown kwargs: {!r}".format(extra_kwargs))
header_params = {
"accept": "application/json",
"content-type": "application/json",
"opc-provision-option": kwargs.get("opc_provision_option", 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,
header_params=header_params,
body=create_fusion_environment_family_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,
header_params=header_params,
body=create_fusion_environment_family_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def delete_fusion_environment_family(self, fusion_environment_family_id, **kwargs):
"""
Deletes a FusionEnvironmentFamily resource by identifier
:param str fusion_environment_family_id: (required)
The unique identifier (OCID) of the FusionEnvironmentFamily.
: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/fusionapps/delete_fusion_environment_family.py.html>`__ to see an example of how to use delete_fusion_environment_family API.
"""
resource_path = "/fusionEnvironmentFamilies/{fusionEnvironmentFamilyId}"
method = "DELETE"
operation_name = "delete_fusion_environment_family"
api_reference_link = ""
# 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_fusion_environment_family got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"fusionEnvironmentFamilyId": fusion_environment_family_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_fusion_environment_family(self, fusion_environment_family_id, **kwargs):
"""
Retrieves a fusion environment family identified by its OCID.
:param str fusion_environment_family_id: (required)
The unique identifier (OCID) of the FusionEnvironmentFamily.
: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.FusionEnvironmentFamily`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/get_fusion_environment_family.py.html>`__ to see an example of how to use get_fusion_environment_family API.
"""
resource_path = "/fusionEnvironmentFamilies/{fusionEnvironmentFamilyId}"
method = "GET"
operation_name = "get_fusion_environment_family"
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_fusion_environment_family got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"fusionEnvironmentFamilyId": fusion_environment_family_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="FusionEnvironmentFamily",
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="FusionEnvironmentFamily",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_fusion_environment_family_limits_and_usage(self, fusion_environment_family_id, **kwargs):
"""
Gets the number of environments (usage) of each type in the fusion environment family, as well as the limit that's allowed to be created based on the group's associated subscriptions.
:param str fusion_environment_family_id: (required)
The unique identifier (OCID) of the FusionEnvironmentFamily.
: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.FusionEnvironmentFamilyLimitsAndUsage`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/get_fusion_environment_family_limits_and_usage.py.html>`__ to see an example of how to use get_fusion_environment_family_limits_and_usage API.
"""
resource_path = "/fusionEnvironmentFamilies/{fusionEnvironmentFamilyId}/limitsAndUsage"
method = "GET"
operation_name = "get_fusion_environment_family_limits_and_usage"
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_fusion_environment_family_limits_and_usage got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"fusionEnvironmentFamilyId": fusion_environment_family_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="FusionEnvironmentFamilyLimitsAndUsage",
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="FusionEnvironmentFamilyLimitsAndUsage",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def get_fusion_environment_family_subscription_detail(self, fusion_environment_family_id, **kwargs):
"""
Gets the subscription details of an fusion environment family.
:param str fusion_environment_family_id: (required)
The unique identifier (OCID) of the FusionEnvironmentFamily.
: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.SubscriptionDetail`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/get_fusion_environment_family_subscription_detail.py.html>`__ to see an example of how to use get_fusion_environment_family_subscription_detail API.
"""
resource_path = "/fusionEnvironmentFamilies/{fusionEnvironmentFamilyId}/subscriptionDetails"
method = "GET"
operation_name = "get_fusion_environment_family_subscription_detail"
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_fusion_environment_family_subscription_detail got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"fusionEnvironmentFamilyId": fusion_environment_family_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="SubscriptionDetail",
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="SubscriptionDetail",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def list_fusion_environment_families(self, compartment_id, **kwargs):
"""
Returns a list of FusionEnvironmentFamilies.
:param str compartment_id: (required)
The ID of the compartment in which to list resources.
:param str fusion_environment_family_id: (optional)
The ID of the fusion environment family in which to list resources.
:param str display_name: (optional)
A filter to return only resources that match the entire display name given.
:param str lifecycle_state: (optional)
A filter that returns all resources that match the specified lifecycle state.
Allowed values are: "CREATING", "UPDATING", "ACTIVE", "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'.
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.FusionEnvironmentFamilyCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/fusionapps/list_fusion_environment_families.py.html>`__ to see an example of how to use list_fusion_environment_families API.
"""
resource_path = "/fusionEnvironmentFamilies"
method = "GET"
operation_name = "list_fusion_environment_families"
api_reference_link = ""
# Don't accept unknown kwargs
expected_kwargs = [
"allow_control_chars",
"retry_strategy",
"fusion_environment_family_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_fusion_environment_families 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 = ["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 = {
"fusionEnvironmentFamilyId": kwargs.get("fusion_environment_family_id", missing),
"compartmentId": compartment_id,
"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:
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="FusionEnvironmentFamilyCollection",
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="FusionEnvironmentFamilyCollection",
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
def update_fusion_environment_family(self, fusion_environment_family_id, update_fusion_environment_family_details, **kwargs):
"""
Updates the FusionEnvironmentFamily
:param str fusion_environment_family_id: (required)
The unique identifier (OCID) of the FusionEnvironmentFamily.
:param oci.fusion_apps.models.UpdateFusionEnvironmentFamilyDetails update_fusion_environment_family_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/fusionapps/update_fusion_environment_family.py.html>`__ to see an example of how to use update_fusion_environment_family API.
"""
resource_path = "/fusionEnvironmentFamilies/{fusionEnvironmentFamilyId}"
method = "PUT"
operation_name = "update_fusion_environment_family"
api_reference_link = ""
# 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_fusion_environment_family got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"fusionEnvironmentFamilyId": fusion_environment_family_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_fusion_environment_family_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_fusion_environment_family_details,
allow_control_chars=kwargs.get('allow_control_chars'),
operation_name=operation_name,
api_reference_link=api_reference_link)
class LogSearchClient(object):
"""
Search for logs in your compartements / log groups / log objects.
"""
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': '/20190909',
'service_endpoint_template':
'https://logging.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("log_search", config, signer,
loggingsearch_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def search_logs(self, search_logs_details, **kwargs):
"""
Submit a query to search logs.
:param SearchLogsDetails search_logs_details: (required)
Search 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 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` 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 :class:`~oci.loggingsearch.models.SearchResponse`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/search"
method = "POST"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "opc_request_id", "limit", "page"]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"search_logs got unknown kwargs: {!r}".format(extra_kwargs))
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.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=search_logs_details,
response_type="SearchResponse")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
body=search_logs_details,
response_type="SearchResponse")
class RoverNodeClient(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_node", config, signer,
rover_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_rover_node_compartment(self, rover_node_id,
change_rover_node_compartment_details,
**kwargs):
"""
Moves a rover node into a different compartment.
:param str rover_node_id: (required)
Unique RoverNode identifier
:param oci.rover.models.ChangeRoverNodeCompartmentDetails change_rover_node_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_node_compartment.py.html>`__ to see an example of how to use change_rover_node_compartment API.
"""
resource_path = "/roverNodes/{roverNodeId}/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_node_compartment got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"roverNodeId": rover_node_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_node_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_node_compartment_details)
def create_rover_node(self, create_rover_node_details, **kwargs):
"""
Creates a new RoverNode.
:param oci.rover.models.CreateRoverNodeDetails create_rover_node_details: (required)
Details for the new RoverNode.
: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.RoverNode`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/create_rover_node.py.html>`__ to see an example of how to use create_rover_node API.
"""
resource_path = "/roverNodes"
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_node 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_node_details,
response_type="RoverNode")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_rover_node_details,
response_type="RoverNode")
def delete_rover_node(self, rover_node_id, **kwargs):
"""
Deletes a RoverNode resource by identifier
:param str rover_node_id: (required)
Unique RoverNode 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_node.py.html>`__ to see an example of how to use delete_rover_node API.
"""
resource_path = "/roverNodes/{roverNodeId}"
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_node got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverNodeId": rover_node_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_node(self, rover_node_id, **kwargs):
"""
Gets a RoverNode by identifier.
:param str rover_node_id: (required)
Unique RoverNode 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.RoverNode`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/get_rover_node.py.html>`__ to see an example of how to use get_rover_node API.
"""
resource_path = "/roverNodes/{roverNodeId}"
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_node got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"roverNodeId": rover_node_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="RoverNode")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverNode")
def get_rover_node_certificate(self, rover_node_id, **kwargs):
"""
Get the certificate for a rover node
:param str rover_node_id: (required)
Unique RoverNode 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.RoverNodeCertificate`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/get_rover_node_certificate.py.html>`__ to see an example of how to use get_rover_node_certificate API.
"""
resource_path = "/roverNodes/{roverNodeId}/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_node_certificate got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverNodeId": rover_node_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="RoverNodeCertificate")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverNodeCertificate")
def get_rover_node_encryption_key(self, rover_node_id, **kwargs):
"""
Get the data encryption key for a rover node.
:param str rover_node_id: (required)
Serial number of the rover node.
: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.RoverNodeEncryptionKey`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/get_rover_node_encryption_key.py.html>`__ to see an example of how to use get_rover_node_encryption_key API.
"""
resource_path = "/roverNodes/{roverNodeId}/encryptionKey"
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_node_encryption_key got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {"roverNodeId": rover_node_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="RoverNodeEncryptionKey")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverNodeEncryptionKey")
def get_rover_node_get_rpt(self, rover_node_id, jwt, **kwargs):
"""
Get the resource principal token for a rover node
:param str rover_node_id: (required)
Unique RoverNode identifier
:param str jwt: (required)
The Java Web Token which is a signature of the request that is signed with the resource's private key
This is meant solely in the context of getRpt
: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.RoverNodeGetRpt`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/get_rover_node_get_rpt.py.html>`__ to see an example of how to use get_rover_node_get_rpt API.
"""
resource_path = "/roverNodes/{roverNodeId}/getRpt"
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_node_get_rpt got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverNodeId": rover_node_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",
"jwt": jwt,
"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="RoverNodeGetRpt")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="RoverNodeGetRpt")
def list_rover_nodes(self, compartment_id, **kwargs):
"""
Returns a list of RoverNodes.
: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.RoverNodeCollection`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/list_rover_nodes.py.html>`__ to see an example of how to use list_rover_nodes API.
"""
resource_path = "/roverNodes"
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_nodes 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="RoverNodeCollection")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="RoverNodeCollection")
def rover_node_action_set_key(self, rover_node_id, jwt,
rover_node_action_set_key_details, **kwargs):
"""
Get the resource principal public key for a rover node
:param str rover_node_id: (required)
Unique RoverNode identifier
:param str jwt: (required)
The Java Web Token which is a signature of the request that is signed with the resource's private key
This is meant solely in the context of getRpt
:param oci.rover.models.RoverNodeActionSetKeyDetails rover_node_action_set_key_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 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 :class:`~oci.rover.models.RoverNodeSetKey`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/rover_node_action_set_key.py.html>`__ to see an example of how to use rover_node_action_set_key API.
"""
resource_path = "/roverNodes/{roverNodeId}/actions/setKey"
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(
"rover_node_action_set_key got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverNodeId": rover_node_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",
"jwt": jwt,
"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=rover_node_action_set_key_details,
response_type="RoverNodeSetKey")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=rover_node_action_set_key_details,
response_type="RoverNodeSetKey")
def update_rover_node(self, rover_node_id, update_rover_node_details,
**kwargs):
"""
Updates the RoverNode
:param str rover_node_id: (required)
Unique RoverNode identifier
:param oci.rover.models.UpdateRoverNodeDetails update_rover_node_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.RoverNode`
:rtype: :class:`~oci.response.Response`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/rover/update_rover_node.py.html>`__ to see an example of how to use update_rover_node API.
"""
resource_path = "/roverNodes/{roverNodeId}"
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_node got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"roverNodeId": rover_node_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_node_details,
response_type="RoverNode")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_rover_node_details,
response_type="RoverNode")
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 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
: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
: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 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 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://events.{region}.oci.{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 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.
: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.
: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.
: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.
: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.
: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 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 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://notification.{region}.oraclecloud.com',
'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.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
: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 subscription protocol. Valid values: EMAIL, HTTPS.
: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 subscription protocol. Valid values: EMAIL, HTTPS.
: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. Limits information follows.
Message size limit per request: 64KB.
Message delivery rate limit per endpoint: 60 messages per minute for HTTPS (PagerDuty) protocol, 10 messages per minute for Email protocol.
Transactions Per Minute (TPM) per-tenancy limit for this operation: 60 per topic.
For more information about publishing messages, see `Publishing Messages`__.
__ https://docs.cloud.oracle.com/iaas/Content/Notification/Tasks/publishingmessages.htm
: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 AutoScalingClient(object):
"""
APIs for dynamically scaling Compute resources to meet application requirements.
For information about the Compute service, see [Overview of the Compute Service](/Content/Compute/Concepts/computeoverview.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': '/20181001',
'service_endpoint_template':
'https://autoscaling.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("auto_scaling", config, signer,
autoscaling_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_auto_scaling_configuration(
self, create_auto_scaling_configuration_details, **kwargs):
"""
CreateAutoScalingConfiguration
Creates an autoscaling configuration.
:param CreateAutoScalingConfigurationDetails create_auto_scaling_configuration_details: (required)
Creation details for an autoscaling configuration.
:param str opc_request_id: (optional)
: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.autoscaling.models.AutoScalingConfiguration`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations"
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_auto_scaling_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_auto_scaling_configuration_details,
response_type="AutoScalingConfiguration")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_auto_scaling_configuration_details,
response_type="AutoScalingConfiguration")
def create_auto_scaling_policy(self, auto_scaling_configuration_id,
create_auto_scaling_policy_details,
**kwargs):
"""
CreateAutoScalingPolicy
Creates an autoscaling policy for the specified autoscaling configuration.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param CreateAutoScalingPolicyDetails create_auto_scaling_policy_details: (required)
Creation details for an autoscaling policy.
:param str opc_request_id: (optional)
: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.autoscaling.models.AutoScalingPolicy`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations/{autoScalingConfigurationId}/policies"
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_auto_scaling_policy got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_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),
"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_auto_scaling_policy_details,
response_type="AutoScalingPolicy")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=create_auto_scaling_policy_details,
response_type="AutoScalingPolicy")
def delete_auto_scaling_configuration(self, auto_scaling_configuration_id,
**kwargs):
"""
DeleteAutoScalingConfiguration
Deletes an autoscaling configuration.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ 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)
: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 = "/autoScalingConfigurations/{autoScalingConfigurationId}"
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_auto_scaling_configuration got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_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 delete_auto_scaling_policy(self, auto_scaling_configuration_id,
auto_scaling_policy_id, **kwargs):
"""
DeleteAutoScalingPolicy
Deletes an autoscaling policy for the specified autoscaling configuration.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str auto_scaling_policy_id: (required)
The ID of the autoscaling policy.
: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)
: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 = "/autoScalingConfigurations/{autoScalingConfigurationId}/policies/{autoScalingPolicyId}"
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_auto_scaling_policy got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_configuration_id,
"autoScalingPolicyId": auto_scaling_policy_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_auto_scaling_configuration(self, auto_scaling_configuration_id,
**kwargs):
"""
GetAutoScalingConfiguration
Gets information about the specified autoscaling configuration.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str opc_request_id: (optional)
: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.autoscaling.models.AutoScalingConfiguration`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations/{autoScalingConfigurationId}"
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_auto_scaling_configuration got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_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)
}
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="AutoScalingConfiguration")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AutoScalingConfiguration")
def get_auto_scaling_policy(self, auto_scaling_configuration_id,
auto_scaling_policy_id, **kwargs):
"""
GetAutoScalingPolicy
Gets information about the specified autoscaling policy in the specified autoscaling configuration.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str auto_scaling_policy_id: (required)
The ID of the autoscaling policy.
:param str opc_request_id: (optional)
: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.autoscaling.models.AutoScalingPolicy`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations/{autoScalingConfigurationId}/policies/{autoScalingPolicyId}"
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_auto_scaling_policy got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_configuration_id,
"autoScalingPolicyId": auto_scaling_policy_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="AutoScalingPolicy")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="AutoScalingPolicy")
def list_auto_scaling_configurations(self, compartment_id, **kwargs):
"""
ListAutoScalingConfigurations
Lists autoscaling configurations in the specifed compartment.
:param str compartment_id: (required)
The `OCID`__ of the compartment containing the
resources monitored by the metric that you are searching for. Use tenancyId to search in
the root compartment.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str display_name: (optional)
A filter to return only resources that match the given display name exactly.
:param str opc_request_id: (optional)
:param int limit: (optional)
For list pagination. The maximum number of 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_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 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.autoscaling.models.AutoScalingConfigurationSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "display_name", "opc_request_id", "limit",
"page", "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_auto_scaling_configurations 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,
"displayName": kwargs.get("display_name", missing),
"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[AutoScalingConfigurationSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[AutoScalingConfigurationSummary]")
def list_auto_scaling_policies(self, auto_scaling_configuration_id,
**kwargs):
"""
ListAutoScalingPolicies
Lists the autoscaling policies in the specified autoscaling configuration.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str display_name: (optional)
A filter to return only resources that match the given display name exactly.
:param str opc_request_id: (optional)
:param int limit: (optional)
For list pagination. The maximum number of 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_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 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.autoscaling.models.AutoScalingPolicySummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations/{autoScalingConfigurationId}/policies"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "display_name", "opc_request_id", "limit",
"page", "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_auto_scaling_policies got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_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))
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 = {
"displayName": kwargs.get("display_name", missing),
"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[AutoScalingPolicySummary]")
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[AutoScalingPolicySummary]")
def update_auto_scaling_configuration(
self, auto_scaling_configuration_id,
update_auto_scaling_configuration_details, **kwargs):
"""
UpdateAutoScalingConfiguration
Updates certain fields on the specified autoscaling configuration, such as the name, the cooldown period,
and whether the autoscaling configuration is enabled.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param UpdateAutoScalingConfigurationDetails update_auto_scaling_configuration_details: (required)
Update details for an autoscaling configuration.
: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)
: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.autoscaling.models.AutoScalingConfiguration`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations/{autoScalingConfigurationId}"
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_auto_scaling_configuration got unknown kwargs: {!r}".
format(extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_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),
"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_auto_scaling_configuration_details,
response_type="AutoScalingConfiguration")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_auto_scaling_configuration_details,
response_type="AutoScalingConfiguration")
def update_auto_scaling_policy(self, auto_scaling_configuration_id,
auto_scaling_policy_id,
update_auto_scaling_policy_details,
**kwargs):
"""
UpdateAutoScalingPolicy
Updates an autoscaling policy in the specified autoscaling configuration.
:param str auto_scaling_configuration_id: (required)
The `OCID`__ of the autoscaling configuration.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param str auto_scaling_policy_id: (required)
The ID of the autoscaling policy.
:param UpdateAutoScalingPolicyDetails update_auto_scaling_policy_details: (required)
Update details for an autoscaling policy.
: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)
: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.autoscaling.models.AutoScalingPolicy`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/autoScalingConfigurations/{autoScalingConfigurationId}/policies/{autoScalingPolicyId}"
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_auto_scaling_policy got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {
"autoScalingConfigurationId": auto_scaling_configuration_id,
"autoScalingPolicyId": auto_scaling_policy_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_auto_scaling_policy_details,
response_type="AutoScalingPolicy")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_auto_scaling_policy_details,
response_type="AutoScalingPolicy")
class EmailClient(object):
"""
API for the Email Delivery service. Use this API to send high-volume, application-generated
emails. For more information, see [Overview of the Email Delivery Service](/iaas/Content/Email/Concepts/overview.htm).
**Note:** Write actions (POST, UPDATE, DELETE) may take several minutes to propagate and be reflected by the API. If a subsequent read request fails to reflect your changes, wait a few minutes and try again.
"""
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': '/20170907',
'service_endpoint_template':
'https://email.{region}.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("email", config, signer,
email_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_sender_compartment(self, sender_id,
change_sender_compartment_details, **kwargs):
"""
Moves a sender into a different compartment. When provided, If-Match is checked against ETag values of the resource.
:param str sender_id: (required)
The unique OCID of the sender.
:param ChangeSenderCompartmentDetails change_sender_compartment_details: (required)
Details for moving a sender into a different compartment.
:param str if_match: (optional)
Used for optimistic concurrency control. In the update or delete call for a resource, set the `if-match`
parameter to the value of the etag from a previous get, create, or update 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 request ID for tracing from the system
: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 = "/senders/{senderId}/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_sender_compartment got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"senderId": sender_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_sender_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_sender_compartment_details)
def create_sender(self, create_sender_details, **kwargs):
"""
Creates a sender for a tenancy in a given compartment.
:param CreateSenderDetails create_sender_details: (required)
Create a sender.
:param str opc_request_id: (optional)
The request ID for tracing from the system
: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.email.models.Sender`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/senders"
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_sender 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_sender_details,
response_type="Sender")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_sender_details,
response_type="Sender")
def create_suppression(self, create_suppression_details, **kwargs):
"""
Adds recipient email addresses to the suppression list for a tenancy.
Addresses added to the suppression list via the API are denoted as
\"MANUAL\" in the `reason` field. *Note:* All email addresses added to the
suppression list are normalized to include only lowercase letters.
:param CreateSuppressionDetails create_suppression_details: (required)
Adds a single email address to the suppression list for a compartment's tenancy.
:param str opc_request_id: (optional)
The request ID for tracing from the system
: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.email.models.Suppression`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/suppressions"
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_suppression 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_suppression_details,
response_type="Suppression")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_suppression_details,
response_type="Suppression")
def delete_sender(self, sender_id, **kwargs):
"""
Deletes an approved sender for a tenancy in a given compartment for a
provided `senderId`.
:param str sender_id: (required)
The unique OCID of the sender.
:param str if_match: (optional)
Used for optimistic concurrency control. In the update or delete call for a resource, set the `if-match`
parameter to the value of the etag from a previous get, create, or update 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 request ID for tracing from the system
: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 = "/senders/{senderId}"
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_sender got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"senderId": sender_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_suppression(self, suppression_id, **kwargs):
"""
Removes a suppressed recipient email address from the suppression list
for a tenancy in a given compartment for a provided `suppressionId`.
:param str suppression_id: (required)
The unique OCID of the suppression.
:param str opc_request_id: (optional)
The request ID for tracing from the system
: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 = "/suppressions/{suppressionId}"
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_suppression got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"suppressionId": suppression_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_sender(self, sender_id, **kwargs):
"""
Gets an approved sender for a given `senderId`.
:param str sender_id: (required)
The unique OCID of the sender.
:param str opc_request_id: (optional)
The request ID for tracing from the system
: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.email.models.Sender`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/senders/{senderId}"
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_sender got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"senderId": sender_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="Sender")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Sender")
def get_suppression(self, suppression_id, **kwargs):
"""
Gets the details of a suppressed recipient email address for a given
`suppressionId`. Each suppression is given a unique OCID.
:param str suppression_id: (required)
The unique OCID of the suppression.
:param str opc_request_id: (optional)
The request ID for tracing from the system
: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.email.models.Suppression`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/suppressions/{suppressionId}"
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_suppression got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"suppressionId": suppression_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="Suppression")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Suppression")
def list_senders(self, compartment_id, **kwargs):
"""
Gets a collection of approved sender email addresses and sender IDs.
:param str compartment_id: (required)
The OCID for the compartment.
:param str opc_request_id: (optional)
The request ID for tracing from the system
:param str lifecycle_state: (optional)
The current state of a sender.
Allowed values are: "CREATING", "ACTIVE", "DELETING", "DELETED"
:param str email_address: (optional)
The email address of the approved sender.
: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. `1` is the minimum, `1000` is the maximum. 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. The `TIMECREATED` value returns the list in in
descending order by default. The `EMAILADDRESS` value returns the list in
ascending order by default. Use the `SortOrderQueryParam` to change the
direction of the returned list of items.
Allowed values are: "TIMECREATED", "EMAILADDRESS"
:param str sort_order: (optional)
The sort order to use, either ascending or descending order.
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.email.models.SenderSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/senders"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "lifecycle_state",
"email_address", "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_senders got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "ACTIVE", "DELETING", "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 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "EMAILADDRESS"]
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,
"lifecycleState": kwargs.get("lifecycle_state", missing),
"emailAddress": kwargs.get("email_address", missing),
"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[SenderSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SenderSummary]")
def list_suppressions(self, compartment_id, **kwargs):
"""
Gets a list of suppressed recipient email addresses for a user. The
`compartmentId` for suppressions must be a tenancy OCID. The returned list
is sorted by creation time in descending order.
:param str compartment_id: (required)
The OCID for the compartment.
:param str opc_request_id: (optional)
The request ID for tracing from the system
:param str email_address: (optional)
The email address of the suppression.
:param datetime time_created_greater_than_or_equal_to: (optional)
Search for suppressions that were created within a specific date range,
using this parameter to specify the earliest creation date for the
returned list (inclusive). Specifying this parameter without the
corresponding `timeCreatedLessThan` parameter will retrieve suppressions created from the
given `timeCreatedGreaterThanOrEqualTo` to the current time, in \"YYYY-MM-ddThh:mmZ\" format with a
Z offset, as defined by RFC 3339.
**Example:** 2016-12-19T16:39:57.600Z
:param datetime time_created_less_than: (optional)
Search for suppressions that were created within a specific date range,
using this parameter to specify the latest creation date for the returned
list (exclusive). Specifying this parameter without the corresponding
`timeCreatedGreaterThanOrEqualTo` parameter will retrieve all suppressions created before the
specified end date, in \"YYYY-MM-ddThh:mmZ\" format with a Z offset, as
defined by RFC 3339.
**Example:** 2016-12-19T16:39:57.600Z
: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. `1` is the minimum, `1000` is the maximum. 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. The `TIMECREATED` value returns the list in in
descending order by default. The `EMAILADDRESS` value returns the list in
ascending order by default. Use the `SortOrderQueryParam` to change the
direction of the returned list of items.
Allowed values are: "TIMECREATED", "EMAILADDRESS"
:param str sort_order: (optional)
The sort order to use, either ascending or descending order.
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.email.models.SuppressionSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/suppressions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "opc_request_id", "email_address",
"time_created_greater_than_or_equal_to", "time_created_less_than",
"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_suppressions got unknown kwargs: {!r}".format(
extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "EMAILADDRESS"]
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,
"emailAddress":
kwargs.get("email_address", missing),
"timeCreatedGreaterThanOrEqualTo":
kwargs.get("time_created_greater_than_or_equal_to", missing),
"timeCreatedLessThan":
kwargs.get("time_created_less_than", missing),
"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[SuppressionSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SuppressionSummary]")
def update_sender(self, sender_id, update_sender_details, **kwargs):
"""
Replaces the set of tags for a sender with the tags provided. If either freeform
or defined tags are omitted, the tags for that set remain the same. Each set must
include the full set of tags for the sender, partial updates are not permitted.
For more information about tagging, see `Resource Tags`__.
__ https://docs.cloud.oracle.com/Content/General/Concepts/resourcetags.htm
:param str sender_id: (required)
The unique OCID of the sender.
:param UpdateSenderDetails update_sender_details: (required)
update details for sender.
:param str if_match: (optional)
Used for optimistic concurrency control. In the update or delete call for a resource, set the `if-match`
parameter to the value of the etag from a previous get, create, or update 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 request ID for tracing from the system
: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.email.models.Sender`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/senders/{senderId}"
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_sender got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"senderId": sender_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_sender_details,
response_type="Sender")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_sender_details,
response_type="Sender")
class LimitsClient(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 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': '/',
'service_endpoint_template':
'https://limits.{region}.oci.{secondLevelDomain}',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("limits", config, signer,
limits_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def get_resource_availability(self, service_name, limit_name,
compartment_id, **kwargs):
"""
For a given compartmentId, resource limit name, and scope, returns the following:
- the number of available resources associated with the given limit
- the usage in the selected compartment for the given limit
Note: not all resource limits support this API. If the value is not available, the API will return 404.
:param str service_name: (required)
The service name of the target quota.
:param str limit_name: (required)
The limit name for which to fetch the data.
:param str compartment_id: (required)
The OCID of the compartment for which data is being fetched.
:param str availability_domain: (optional)
This field is mandatory if the scopeType of the target resource limit is AD.
Otherwise, this field should be omitted.
If the above requirements are not met, the API will return a 400 - InvalidParameter response.
: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.ResourceAvailability`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20190729/services/{serviceName}/limits/{limitName}/resourceAvailability"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "availability_domain", "opc_request_id"
]
extra_kwargs = [
_key for _key in six.iterkeys(kwargs)
if _key not in expected_kwargs
]
if extra_kwargs:
raise ValueError(
"get_resource_availability got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"serviceName": service_name, "limitName": limit_name}
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,
"availabilityDomain": kwargs.get("availability_domain", 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="ResourceAvailability")
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="ResourceAvailability")
def list_limit_definitions(self, compartment_id, **kwargs):
"""
Includes a list of resource limits that are currently supported.
If the 'areQuotasSupported' property is true, you can create quota policies on top of this limit at the
compartment level.
:param str compartment_id: (required)
The OCID of the parent compartment (remember that the tenancy is simply the root compartment).
:param str service_name: (optional)
The target service name.
:param str name: (optional)
Optional field, filter for a specific resource limit.
:param str sort_by: (optional)
The field to sort by.
Allowed values are: "name", "description"
: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 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 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.LimitDefinitionSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20190729/limitDefinitions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "service_name", "name", "sort_by", "sort_order",
"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_limit_definitions got unknown kwargs: {!r}".format(
extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["name", "description"]
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,
"serviceName": kwargs.get("service_name", missing),
"name": kwargs.get("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[LimitDefinitionSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[LimitDefinitionSummary]")
def list_limit_values(self, compartment_id, service_name, **kwargs):
"""
Includes a full list of resource limits belonging to a given service.
:param str compartment_id: (required)
The OCID of the parent compartment (remember that the tenancy is simply the root compartment).
:param str service_name: (required)
The target service name
:param str scope_type: (optional)
Filter entries by scope type.
Allowed values are: "GLOBAL", "REGION", "AD"
:param str availability_domain: (optional)
Filter entries by availability domain. This implies that only AD-specific values will be returned.
:param str name: (optional)
Optional field, can be used to see a specific resource limit value.
:param str sort_by: (optional)
The field to sort by. We will be implicitly sorting by availabilityDomain, as a second level field, if available.
Allowed values are: "name"
: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 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 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.LimitValueSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20190729/limitValues"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "scope_type", "availability_domain", "name",
"sort_by", "sort_order", "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_limit_values got unknown kwargs: {!r}".format(
extra_kwargs))
if 'scope_type' in kwargs:
scope_type_allowed_values = ["GLOBAL", "REGION", "AD"]
if kwargs['scope_type'] not in scope_type_allowed_values:
raise ValueError(
"Invalid value for `scope_type`, must be one of {0}".
format(scope_type_allowed_values))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["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,
"serviceName": service_name,
"scopeType": kwargs.get("scope_type", missing),
"availabilityDomain": kwargs.get("availability_domain", missing),
"name": kwargs.get("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[LimitValueSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[LimitValueSummary]")
def list_services(self, compartment_id, **kwargs):
"""
Returns the list of supported services.
This will include the programmatic service name, along with the friendly service name.
:param str compartment_id: (required)
The OCID of the parent compartment (remember that the tenancy is simply the root compartment).
:param str sort_by: (optional)
The field to sort by.
Allowed values are: "name", "description"
: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 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 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.ServiceSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/20190729/services"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy", "sort_by", "sort_order", "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_services got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["name", "description"]
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,
"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[ServiceSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ServiceSummary]")
class KmsManagementClient(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': False,
'service_endpoint': kwargs.get('service_endpoint'),
'timeout': kwargs.get('timeout'),
'base_path': '/20180608',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("kms_management", config, signer,
key_management_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_key(self, create_key_details, **kwargs):
"""
CreateKey
Creates a new key.
:param CreateKeyDetails create_key_details: (required)
CreateKeyDetails
: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.Key`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys"
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_key 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_key_details,
response_type="Key")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
header_params=header_params,
body=create_key_details,
response_type="Key")
def create_key_version(self, key_id, **kwargs):
"""
Create new KeyVersion and rotate the key to use it for encryption.
Generates new cryptographic material for a key. Key must be in an `ENABLED` state to be
rotated.
:param str key_id: (required)
The OCID of the key.
: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.KeyVersion`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys/{keyId}/keyVersions"
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_key_version got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"keyId": key_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,
response_type="KeyVersion")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="KeyVersion")
def disable_key(self, key_id, **kwargs):
"""
DisableKey
Disables a key to make it unavailable for encryption
or decryption.
:param str key_id: (required)
The OCID of the key.
: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.Key`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys/{keyId}/actions/disable"
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(
"disable_key got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"keyId": key_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="Key")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Key")
def enable_key(self, key_id, **kwargs):
"""
EnableKey
Enables a key to make it available for encryption or
decryption.
:param str key_id: (required)
The OCID of the key.
: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.Key`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys/{keyId}/actions/enable"
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(
"enable_key got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"keyId": key_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="Key")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Key")
def get_key(self, key_id, **kwargs):
"""
GetKey
Gets information about the specified key.
:param str key_id: (required)
The OCID of the key.
: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.Key`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys/{keyId}"
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_key got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"keyId": key_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="Key")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Key")
def get_key_version(self, key_id, key_version_id, **kwargs):
"""
GetKeyVersion
Gets information about the specified key version.
:param str key_id: (required)
The OCID of the key.
:param str key_version_id: (required)
The OCID of the key version.
: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.KeyVersion`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys/{keyId}/keyVersions/{keyVersionId}"
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_key_version got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"keyId": key_id, "keyVersionId": key_version_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="KeyVersion")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="KeyVersion")
def list_key_versions(self, key_id, **kwargs):
"""
ListKeyVersions
Lists all key versions for the specified key.
:param str key_id: (required)
The OCID of the key.
: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.KeyVersionSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys/{keyId}/keyVersions"
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_key_versions got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"keyId": key_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 = ["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 = {
"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[KeyVersionSummary]")
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[KeyVersionSummary]")
def list_keys(self, compartment_id, **kwargs):
"""
ListKeys
Lists the keys in the specified vault and 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.KeySummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys"
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_keys 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[KeySummary]")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[KeySummary]")
def update_key(self, key_id, update_key_details, **kwargs):
"""
UpdateKey
Updates the properties of a key. Specifically, you can
only update the `displayName` property. Furthermore, the
key must in an `ACTIVE` or `CREATING` state.
:param str key_id: (required)
The OCID of the key.
:param UpdateKeyDetails update_key_details: (required)
UpdateKeyDetails
: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.Key`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/keys/{keyId}"
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_key got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {"keyId": key_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_key_details,
response_type="Key")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_key_details,
response_type="Key")
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/computeinstanceagent/cancel_instance_agent_command.py.html>`__ to see an example of how to use cancel_instance_agent_command API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/computeinstanceagent/create_instance_agent_command.py.html>`__ to see an example of how to use create_instance_agent_command API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/computeinstanceagent/get_instance_agent_command.py.html>`__ to see an example of how to use get_instance_agent_command API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/computeinstanceagent/get_instance_agent_command_execution.py.html>`__ to see an example of how to use get_instance_agent_command_execution API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/computeinstanceagent/list_instance_agent_command_executions.py.html>`__ to see an example of how to use list_instance_agent_command_executions API.
"""
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`
:example:
Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/computeinstanceagent/list_instance_agent_commands.py.html>`__ to see an example of how to use list_instance_agent_commands API.
"""
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]")
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')
class AuditClient(object):
"""
API for the Audit Service. Use this API for compliance monitoring in your tenancy.
For more information, see [Overview of Audit](/iaas/Content/Audit/Concepts/auditoverview.htm).
**Tip**: This API is good for queries, but not bulk-export 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://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': '/20190901',
'service_endpoint_template':
'https://audit.{region}.oraclecloud.com',
'skip_deserialization': kwargs.get('skip_deserialization', False)
}
self.base_client = BaseClient("audit", config, signer,
audit_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def get_configuration(self, compartment_id, **kwargs):
"""
Get the configuration
:param str compartment_id: (required)
ID of the root compartment (tenancy)
: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.audit.models.Configuration`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/configuration"
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_configuration 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"
}
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="Configuration")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="Configuration")
def list_events(self, compartment_id, start_time, end_time, **kwargs):
"""
Returns all the audit events processed for the specified compartment within the specified
time range.
:param str compartment_id: (required)
The `OCID`__ of the compartment.
__ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm
:param datetime start_time: (required)
Returns events that were processed at or after this start date and time, expressed in
`RFC 3339`__ timestamp format.
For example, a start value of `2017-01-15T11:30:00Z` will retrieve a list of all events processed
since 30 minutes after the 11th hour of January 15, 2017, in Coordinated Universal Time (UTC).
You can specify a value with granularity to the minute. Seconds (and milliseconds, if included) must
be set to `0`.
__ https://tools.ietf.org/html/rfc3339
:param datetime end_time: (required)
Returns events that were processed before this end date and time, expressed in
`RFC 3339`__ timestamp format.
For example, a start value of `2017-01-01T00:00:00Z` and an end value of `2017-01-02T00:00:00Z`
will retrieve a list of all events processed on January 1, 2017. Similarly, a start value of
`2017-01-01T00:00:00Z` and an end value of `2017-02-01T00:00:00Z` will result in a list of all
events processed between January 1, 2017 and January 31, 2017. You can specify a value with
granularity to the minute. Seconds (and milliseconds, if included) must be set to `0`.
__ https://tools.ietf.org/html/rfc3339
: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://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.audit.models.AuditEvent`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/auditEvents"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = ["retry_strategy", "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_events got unknown kwargs: {!r}".format(extra_kwargs))
query_params = {
"compartmentId": compartment_id,
"startTime": start_time,
"endTime": end_time,
"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[AuditEvent]")
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[AuditEvent]")
def update_configuration(self, compartment_id,
update_configuration_details, **kwargs):
"""
Update the configuration
:param str compartment_id: (required)
ID of the root compartment (tenancy)
:param UpdateConfigurationDetails update_configuration_details: (required)
The configuration properties
: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"
expected_kwargs = ["retry_strategy"]
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))
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"
}
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=update_configuration_details)
else:
return self.base_client.call_api(resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
body=update_configuration_details)
class ApplianceExportJobClient(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("appliance_export_job", config, signer,
dts_type_mapping,
**base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def change_appliance_export_job_compartment(
self, appliance_export_job_id,
change_appliance_export_job_compartment_details, **kwargs):
"""
Moves a ApplianceExportJob into a different compartment.
:param str appliance_export_job_id: (required)
ID of the Appliance Export Job
:param ChangeApplianceExportJobCompartmentDetails change_appliance_export_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://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 = "/applianceExportJobs/{applianceExportJobId}/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_appliance_export_job_compartment got unknown kwargs: {!r}"
.format(extra_kwargs))
path_params = {"applianceExportJobId": appliance_export_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_appliance_export_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_appliance_export_job_compartment_details)
def create_appliance_export_job(self, create_appliance_export_job_details,
**kwargs):
"""
Creates a new Appliance Export Job that corresponds with customer's logical dataset
:param CreateApplianceExportJobDetails create_appliance_export_job_details: (required)
Creates a new Appliance Export Job
: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.ApplianceExportJob`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/applianceExportJobs"
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_appliance_export_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_appliance_export_job_details,
response_type="ApplianceExportJob")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_appliance_export_job_details,
response_type="ApplianceExportJob")
def delete_appliance_export_job(self, appliance_export_job_id, **kwargs):
"""
deletes a Appliance Export Job
:param str appliance_export_job_id: (required)
ID of the Appliance Export Job
: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://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 = "/applianceExportJobs/{applianceExportJobId}"
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_appliance_export_job got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"applianceExportJobId": appliance_export_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)
}
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_appliance_export_job(self, appliance_export_job_id, **kwargs):
"""
Describes a Appliance Export Job in detail
:param str appliance_export_job_id: (required)
OCID of the Appliance Export 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://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.ApplianceExportJob`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/applianceExportJobs/{applianceExportJobId}"
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_appliance_export_job got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"applianceExportJobId": appliance_export_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",
"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="ApplianceExportJob")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="ApplianceExportJob")
def list_appliance_export_jobs(self, compartment_id, **kwargs):
"""
Lists Appliance Export Jobs in a given compartment
:param str compartment_id: (required)
compartment id
:param str lifecycle_state: (optional)
filtering by lifecycleState
Allowed values are: "CREATING", "ACTIVE", "INPROGRESS", "SUCCEEDED", "FAILED", "CANCELLED", "DELETED"
: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://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.ApplianceExportJobSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/applianceExportJobs"
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_appliance_export_jobs got unknown kwargs: {!r}".format(
extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = [
"CREATING", "ACTIVE", "INPROGRESS", "SUCCEEDED", "FAILED",
"CANCELLED", "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))
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[ApplianceExportJobSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[ApplianceExportJobSummary]")
def update_appliance_export_job(self, appliance_export_job_id,
update_appliance_export_job_details,
**kwargs):
"""
Updates a Appliance Export Job that corresponds with customer's logical dataset.
:param str appliance_export_job_id: (required)
ID of the Appliance Export Job
:param UpdateApplianceExportJobDetails update_appliance_export_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://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.ApplianceExportJob`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/applianceExportJobs/{applianceExportJobId}"
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_appliance_export_job got unknown kwargs: {!r}".format(
extra_kwargs))
path_params = {"applianceExportJobId": appliance_export_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)
}
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_appliance_export_job_details,
response_type="ApplianceExportJob")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
body=update_appliance_export_job_details,
response_type="ApplianceExportJob")
class EmailClient(object):
"""
API spec for managing OCI Email Delivery 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.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': '/20170907'
}
self.base_client = BaseClient("email", config, signer, email_type_mapping, **base_client_init_kwargs)
self.retry_strategy = kwargs.get('retry_strategy')
def create_sender(self, create_sender_details, **kwargs):
"""
Creates a sender for a tenancy in a given compartment.
Creates a sender for a tenancy in a given compartment.
:param CreateSenderDetails create_sender_details: (required)
Create a sender.
: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.email.models.Sender`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/senders"
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_sender got unknown kwargs: {!r}".format(extra_kwargs))
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,
header_params=header_params,
body=create_sender_details,
response_type="Sender")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_sender_details,
response_type="Sender")
def create_suppression(self, create_suppression_details, **kwargs):
"""
Creates an email suppression for a tenancy.
Adds recipient email addresses to the suppression list for a tenancy.
:param CreateSuppressionDetails create_suppression_details: (required)
Adds a single email address to the suppression list for a compartment's tenancy.
: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.email.models.Suppression`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/suppressions"
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_suppression got unknown kwargs: {!r}".format(extra_kwargs))
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,
header_params=header_params,
body=create_suppression_details,
response_type="Suppression")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
header_params=header_params,
body=create_suppression_details,
response_type="Suppression")
def delete_sender(self, sender_id, **kwargs):
"""
Deletes a sender for a tenancy in a given compartment.
Deletes an approved sender for a tenancy in a given compartment for a
provided `senderId`.
:param str sender_id: (required)
The unique OCID of the sender.
: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 = "/senders/{senderId}"
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_sender got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"senderId": sender_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"
}
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_suppression(self, suppression_id, **kwargs):
"""
Deletes a suppressed email address.
Removes a suppressed recipient email address from the suppression list
for a tenancy in a given compartment for a provided `suppressionId`.
:param str suppression_id: (required)
The unique OCID of the suppression.
: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 = "/suppressions/{suppressionId}"
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_suppression got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"suppressionId": suppression_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"
}
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_sender(self, sender_id, **kwargs):
"""
Gets an approved sender.
Gets an approved sender for a given `senderId`.
:param str sender_id: (required)
The unique OCID of the sender.
: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.email.models.Sender`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/senders/{senderId}"
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_sender got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"senderId": sender_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"
}
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="Sender")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Sender")
def get_suppression(self, suppression_id, **kwargs):
"""
Get a suppressed email address.
Gets the details of a suppressed recipient email address for a given
`suppressionId`. Each suppression is given a unique OCID.
:param str suppression_id: (required)
The unique OCID of the suppression.
: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.email.models.Suppression`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/suppressions/{suppressionId}"
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_suppression got unknown kwargs: {!r}".format(extra_kwargs))
path_params = {
"suppressionId": suppression_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"
}
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="Suppression")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
path_params=path_params,
header_params=header_params,
response_type="Suppression")
def list_senders(self, compartment_id, **kwargs):
"""
Get a list of approved sender summaries.
Gets a collection of approved sender email addresses and sender IDs.
:param str compartment_id: (required)
The OCID for the compartment.
:param str lifecycle_state: (optional)
The current state of a sender.
Allowed values are: "CREATING", "ACTIVE", "DELETING", "DELETED"
:param str email_address: (optional)
The email address of the approved sender.
:param str page: (optional)
The value of the `opc-next-page` response header from the previous
GET request.
:param int limit: (optional)
The maximum number of items to return in a paginated GET request.
:param str sort_by: (optional)
The field to sort by. The `TIMECREATED` value returns the list in in
descending order by default. The `EMAILADDRESS` value returns the list in
ascending order by default. Use the `SortOrderQueryParam` to change the
direction of the returned list of items.
Allowed values are: "TIMECREATED", "EMAILADDRESS"
:param str sort_order: (optional)
The sort order to use, either ascending or descending order.
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.email.models.SenderSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/senders"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"lifecycle_state",
"email_address",
"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_senders got unknown kwargs: {!r}".format(extra_kwargs))
if 'lifecycle_state' in kwargs:
lifecycle_state_allowed_values = ["CREATING", "ACTIVE", "DELETING", "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 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "EMAILADDRESS"]
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,
"lifecycleState": kwargs.get("lifecycle_state", missing),
"emailAddress": kwargs.get("email_address", missing),
"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}
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,
query_params=query_params,
header_params=header_params,
response_type="list[SenderSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SenderSummary]")
def list_suppressions(self, compartment_id, **kwargs):
"""
Get a summary of suppressed email addresses.
Gets a list of suppressed recipient email addresses for a user. The
`compartmentId` for suppressions must be a tenancy OCID. The returned list
is sorted by creation time in descending order.
:param str compartment_id: (required)
The OCID for the compartment.
:param str email_address: (optional)
The email address of the suppression.
:param datetime time_created_greater_than_or_equal_to: (optional)
Search for suppressions that were created within a specific date range,
using this parameter to specify the earliest creation date for the
returned list (inclusive). Specifying this parameter without the
corresponding `timeCreatedLessThan` parameter will retrieve suppressions created from the
given `timeCreatedGreaterThanOrEqualTo` to the current time, in \"YYYY-MM-ddThh:mmZ\" format with a
Z offset, as defined by RFC 3339.
**Example:** 2016-12-19T16:39:57.600Z
:param datetime time_created_less_than: (optional)
Search for suppressions that were created within a specific date range,
using this parameter to specify the latest creation date for the returned
list (exclusive). Specifying this parameter without the corresponding
`timeCreatedGreaterThanOrEqualTo` parameter will retrieve all suppressions created before the
specified end date, in \"YYYY-MM-ddThh:mmZ\" format with a Z offset, as
defined by RFC 3339.
**Example:** 2016-12-19T16:39:57.600Z
:param str page: (optional)
The value of the `opc-next-page` response header from the previous
GET request.
:param int limit: (optional)
The maximum number of items to return in a paginated GET request.
:param str sort_by: (optional)
The field to sort by. The `TIMECREATED` value returns the list in in
descending order by default. The `EMAILADDRESS` value returns the list in
ascending order by default. Use the `SortOrderQueryParam` to change the
direction of the returned list of items.
Allowed values are: "TIMECREATED", "EMAILADDRESS"
:param str sort_order: (optional)
The sort order to use, either ascending or descending order.
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.email.models.SuppressionSummary`
:rtype: :class:`~oci.response.Response`
"""
resource_path = "/suppressions"
method = "GET"
# Don't accept unknown kwargs
expected_kwargs = [
"retry_strategy",
"email_address",
"time_created_greater_than_or_equal_to",
"time_created_less_than",
"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_suppressions got unknown kwargs: {!r}".format(extra_kwargs))
if 'sort_by' in kwargs:
sort_by_allowed_values = ["TIMECREATED", "EMAILADDRESS"]
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,
"emailAddress": kwargs.get("email_address", missing),
"timeCreatedGreaterThanOrEqualTo": kwargs.get("time_created_greater_than_or_equal_to", missing),
"timeCreatedLessThan": kwargs.get("time_created_less_than", missing),
"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}
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,
query_params=query_params,
header_params=header_params,
response_type="list[SuppressionSummary]")
else:
return self.base_client.call_api(
resource_path=resource_path,
method=method,
query_params=query_params,
header_params=header_params,
response_type="list[SuppressionSummary]")
