def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __build_image(self, build_image_request_content, **kwargs):
"""build_image # noqa: E501
Create a custom ParallelCluster image in a given region. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.build_image(build_image_request_content, async_req=True)
>>> result = thread.get()
Args:
build_image_request_content (BuildImageRequestContent):
Keyword Args:
suppress_validators ([str]): Identifies one or more config validators to suppress. Format: (ALL|type:[A-Za-z0-9]+). [optional]
validation_failure_level (ValidationLevel): Min validation level that will cause the creation to fail. (Defaults to 'ERROR'.). [optional]
dryrun (bool, none_type): Only perform request validation without creating any resource. It can be used to validate the image configuration. (Defaults to 'false'.). [optional]
rollback_on_failure (bool, none_type): When set, will automatically initiate an image stack rollback on failure. (Defaults to 'false'.). [optional]
region (str): AWS Region that the operation corresponds to.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
BuildImageResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['build_image_request_content'] = \
build_image_request_content
return self.call_with_http_info(**kwargs)
self.build_image = _Endpoint(
settings={
'response_type': (BuildImageResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/images/custom',
'operation_id': 'build_image',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'build_image_request_content',
'suppress_validators',
'validation_failure_level',
'dryrun',
'rollback_on_failure',
'region',
],
'required': [
'build_image_request_content',
],
'nullable': [
'dryrun',
'rollback_on_failure',
],
'enum': [],
'validation': [
'suppress_validators',
]
},
root_map={
'validations': {
('suppress_validators', ): {},
},
'allowed_values': {},
'openapi_types': {
'build_image_request_content':
(BuildImageRequestContent, ),
'suppress_validators': ([str], ),
'validation_failure_level': (ValidationLevel, ),
'dryrun': (
bool,
none_type,
),
'rollback_on_failure': (
bool,
none_type,
),
'region': (str, ),
},
'attribute_map': {
'suppress_validators': 'suppressValidators',
'validation_failure_level': 'validationFailureLevel',
'dryrun': 'dryrun',
'rollback_on_failure': 'rollbackOnFailure',
'region': 'region',
},
'location_map': {
'build_image_request_content': 'body',
'suppress_validators': 'query',
'validation_failure_level': 'query',
'dryrun': 'query',
'rollback_on_failure': 'query',
'region': 'query',
},
'collection_format_map': {
'suppress_validators': 'multi',
}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__build_image)
def __delete_image(self, image_id, **kwargs):
"""delete_image # noqa: E501
Initiate the deletion of the custom ParallelCluster image. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_image(image_id, async_req=True)
>>> result = thread.get()
Args:
image_id (str): Id of the image.
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
force (bool, none_type): Force deletion in case there are instances using the AMI or in case the AMI is shared. (Defaults to 'false'.). [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
DeleteImageResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['image_id'] = \
image_id
return self.call_with_http_info(**kwargs)
self.delete_image = _Endpoint(
settings={
'response_type': (DeleteImageResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/images/custom/{imageId}',
'operation_id': 'delete_image',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'image_id',
'region',
'force',
],
'required': [
'image_id',
],
'nullable': [
'force',
],
'enum': [],
'validation': [
'image_id',
]
},
root_map={
'validations': {
('image_id', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'image_id': (str, ),
'region': (str, ),
'force': (
bool,
none_type,
),
},
'attribute_map': {
'image_id': 'imageId',
'region': 'region',
'force': 'force',
},
'location_map': {
'image_id': 'path',
'region': 'query',
'force': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__delete_image)
def __describe_image(self, image_id, **kwargs):
"""describe_image # noqa: E501
Get detailed information about an existing image. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.describe_image(image_id, async_req=True)
>>> result = thread.get()
Args:
image_id (str): Id of the image.
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
DescribeImageResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['image_id'] = \
image_id
return self.call_with_http_info(**kwargs)
self.describe_image = _Endpoint(
settings={
'response_type': (DescribeImageResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/images/custom/{imageId}',
'operation_id': 'describe_image',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'image_id',
'region',
],
'required': [
'image_id',
],
'nullable': [],
'enum': [],
'validation': [
'image_id',
]
},
root_map={
'validations': {
('image_id', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'image_id': (str, ),
'region': (str, ),
},
'attribute_map': {
'image_id': 'imageId',
'region': 'region',
},
'location_map': {
'image_id': 'path',
'region': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__describe_image)
def __list_images(self, image_status, **kwargs):
"""list_images # noqa: E501
Retrieve the list of existing custom images. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_images(image_status, async_req=True)
>>> result = thread.get()
Args:
image_status (ImageStatusFilteringOption): Filter images by the status provided.
Keyword Args:
region (str): List images built in a given AWS Region.. [optional]
next_token (str): Token to use for paginated requests.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
ListImagesResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['image_status'] = \
image_status
return self.call_with_http_info(**kwargs)
self.list_images = _Endpoint(settings={
'response_type': (ListImagesResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path':
'/v3/images/custom',
'operation_id':
'list_images',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'image_status',
'region',
'next_token',
],
'required': [
'image_status',
],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'image_status':
(ImageStatusFilteringOption, ),
'region': (str, ),
'next_token': (str, ),
},
'attribute_map': {
'image_status': 'imageStatus',
'region': 'region',
'next_token': 'nextToken',
},
'location_map': {
'image_status': 'query',
'region': 'query',
'next_token': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__list_images)
def __list_official_images(self, **kwargs):
"""list_official_images # noqa: E501
List Official ParallelCluster AMIs. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_official_images(async_req=True)
>>> result = thread.get()
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
os (str): Filter by OS distribution (Default is to not filter.). [optional]
architecture (str): Filter by architecture (Default is to not filter.). [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
ListOfficialImagesResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.list_official_images = _Endpoint(settings={
'response_type': (ListOfficialImagesResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path':
'/v3/images/official',
'operation_id':
'list_official_images',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'region',
'os',
'architecture',
],
'required': [],
'nullable': [],
'enum': [],
'validation': []
},
root_map={
'validations': {},
'allowed_values': {},
'openapi_types': {
'region': (str, ),
'os': (str, ),
'architecture': (str, ),
},
'attribute_map': {
'region':
'region',
'os':
'os',
'architecture':
'architecture',
},
'location_map': {
'region': 'query',
'os': 'query',
'architecture': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept':
['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__list_official_images)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __get_image_log_events(self, image_id, log_stream_name, **kwargs):
"""get_image_log_events # noqa: E501
Retrieve the events associated with an image build. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_image_log_events(image_id, log_stream_name, async_req=True)
>>> result = thread.get()
Args:
image_id (str): Id of the image.
log_stream_name (str): Name of the log stream.
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
next_token (str): Token to use for paginated requests.. [optional]
start_from_head (bool, none_type): If the value is true, the earliest log events are returned first. If the value is false, the latest log events are returned first. (Defaults to 'false'.). [optional]
limit (float, none_type): The maximum number of log events returned. If you don't specify a value, the maximum is as many log events as can fit in a response size of 1 MB, up to 10,000 log events.. [optional]
start_time (datetime): The start of the time range, expressed in ISO 8601 format (e.g. '2021-01-01T20:00:00Z'). Events with a timestamp equal to this time or later than this time are included.. [optional]
end_time (datetime): The end of the time range, expressed in ISO 8601 format (e.g. '2021-01-01T20:00:00Z'). Events with a timestamp equal to or later than this time are not included.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
GetImageLogEventsResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['image_id'] = \
image_id
kwargs['log_stream_name'] = \
log_stream_name
return self.call_with_http_info(**kwargs)
self.get_image_log_events = _Endpoint(
settings={
'response_type': (GetImageLogEventsResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path':
'/v3/images/custom/{imageId}/logstreams/{logStreamName}',
'operation_id': 'get_image_log_events',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'image_id',
'log_stream_name',
'region',
'next_token',
'start_from_head',
'limit',
'start_time',
'end_time',
],
'required': [
'image_id',
'log_stream_name',
],
'nullable': [
'start_from_head',
'limit',
],
'enum': [],
'validation': [
'image_id',
]
},
root_map={
'validations': {
('image_id', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'image_id': (str, ),
'log_stream_name': (str, ),
'region': (str, ),
'next_token': (str, ),
'start_from_head': (
bool,
none_type,
),
'limit': (
float,
none_type,
),
'start_time': (datetime, ),
'end_time': (datetime, ),
},
'attribute_map': {
'image_id': 'imageId',
'log_stream_name': 'logStreamName',
'region': 'region',
'next_token': 'nextToken',
'start_from_head': 'startFromHead',
'limit': 'limit',
'start_time': 'startTime',
'end_time': 'endTime',
},
'location_map': {
'image_id': 'path',
'log_stream_name': 'path',
'region': 'query',
'next_token': 'query',
'start_from_head': 'query',
'limit': 'query',
'start_time': 'query',
'end_time': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_image_log_events)
def __get_image_stack_events(self, image_id, **kwargs):
"""get_image_stack_events # noqa: E501
Retrieve the events associated with the stack for a given image build. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_image_stack_events(image_id, async_req=True)
>>> result = thread.get()
Args:
image_id (str): Id of the image.
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
next_token (str): Token to use for paginated requests.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
GetImageStackEventsResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['image_id'] = \
image_id
return self.call_with_http_info(**kwargs)
self.get_image_stack_events = _Endpoint(
settings={
'response_type': (GetImageStackEventsResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/images/custom/{imageId}/stackevents',
'operation_id': 'get_image_stack_events',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'image_id',
'region',
'next_token',
],
'required': [
'image_id',
],
'nullable': [],
'enum': [],
'validation': [
'image_id',
]
},
root_map={
'validations': {
('image_id', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'image_id': (str, ),
'region': (str, ),
'next_token': (str, ),
},
'attribute_map': {
'image_id': 'imageId',
'region': 'region',
'next_token': 'nextToken',
},
'location_map': {
'image_id': 'path',
'region': 'query',
'next_token': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__get_image_stack_events)
def __list_image_log_streams(self, image_id, **kwargs):
"""list_image_log_streams # noqa: E501
Retrieve the list of log streams associated with an image. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_image_log_streams(image_id, async_req=True)
>>> result = thread.get()
Args:
image_id (str): Id of the image.
Keyword Args:
region (str): Region that the given image belongs to.. [optional]
next_token (str): Token to use for paginated requests.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
ListImageLogStreamsResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['image_id'] = \
image_id
return self.call_with_http_info(**kwargs)
self.list_image_log_streams = _Endpoint(
settings={
'response_type': (ListImageLogStreamsResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/images/custom/{imageId}/logstreams',
'operation_id': 'list_image_log_streams',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'image_id',
'region',
'next_token',
],
'required': [
'image_id',
],
'nullable': [],
'enum': [],
'validation': [
'image_id',
]
},
root_map={
'validations': {
('image_id', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'image_id': (str, ),
'region': (str, ),
'next_token': (str, ),
},
'attribute_map': {
'image_id': 'imageId',
'region': 'region',
'next_token': 'nextToken',
},
'location_map': {
'image_id': 'path',
'region': 'query',
'next_token': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__list_image_log_streams)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __describe_compute_fleet(self, cluster_name, **kwargs):
"""describe_compute_fleet # noqa: E501
Describe the status of the compute fleet. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.describe_compute_fleet(cluster_name, async_req=True)
>>> result = thread.get()
Args:
cluster_name (str): Name of the cluster
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
DescribeComputeFleetResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cluster_name'] = \
cluster_name
return self.call_with_http_info(**kwargs)
self.describe_compute_fleet = _Endpoint(
settings={
'response_type': (DescribeComputeFleetResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters/{clusterName}/computefleet',
'operation_id': 'describe_compute_fleet',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'cluster_name',
'region',
],
'required': [
'cluster_name',
],
'nullable': [],
'enum': [],
'validation': [
'cluster_name',
]
},
root_map={
'validations': {
('cluster_name', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'cluster_name': (str, ),
'region': (str, ),
},
'attribute_map': {
'cluster_name': 'clusterName',
'region': 'region',
},
'location_map': {
'cluster_name': 'path',
'region': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__describe_compute_fleet)
def __update_compute_fleet(self, cluster_name,
update_compute_fleet_request_content,
**kwargs):
"""update_compute_fleet # noqa: E501
Update the status of the cluster compute fleet. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_compute_fleet(cluster_name, update_compute_fleet_request_content, async_req=True)
>>> result = thread.get()
Args:
cluster_name (str): Name of the cluster
update_compute_fleet_request_content (UpdateComputeFleetRequestContent):
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
UpdateComputeFleetResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cluster_name'] = \
cluster_name
kwargs['update_compute_fleet_request_content'] = \
update_compute_fleet_request_content
return self.call_with_http_info(**kwargs)
self.update_compute_fleet = _Endpoint(
settings={
'response_type': (UpdateComputeFleetResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters/{clusterName}/computefleet',
'operation_id': 'update_compute_fleet',
'http_method': 'PATCH',
'servers': None,
},
params_map={
'all': [
'cluster_name',
'update_compute_fleet_request_content',
'region',
],
'required': [
'cluster_name',
'update_compute_fleet_request_content',
],
'nullable': [],
'enum': [],
'validation': [
'cluster_name',
]
},
root_map={
'validations': {
('cluster_name', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'cluster_name': (str, ),
'update_compute_fleet_request_content':
(UpdateComputeFleetRequestContent, ),
'region': (str, ),
},
'attribute_map': {
'cluster_name': 'clusterName',
'region': 'region',
},
'location_map': {
'cluster_name': 'path',
'update_compute_fleet_request_content': 'body',
'region': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__update_compute_fleet)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __delete_cluster_instances(self, cluster_name, **kwargs):
"""delete_cluster_instances # noqa: E501
Initiate the forced termination of all cluster compute nodes. Does not work with AWS Batch clusters. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_cluster_instances(cluster_name, async_req=True)
>>> result = thread.get()
Args:
cluster_name (str): Name of the cluster
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
force (bool, none_type): Force the deletion also when the cluster with the given name is not found. (Defaults to 'false'.). [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
None
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cluster_name'] = \
cluster_name
return self.call_with_http_info(**kwargs)
self.delete_cluster_instances = _Endpoint(
settings={
'response_type': None,
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters/{clusterName}/instances',
'operation_id': 'delete_cluster_instances',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'cluster_name',
'region',
'force',
],
'required': [
'cluster_name',
],
'nullable': [
'force',
],
'enum': [],
'validation': [
'cluster_name',
]
},
root_map={
'validations': {
('cluster_name', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'cluster_name': (str, ),
'region': (str, ),
'force': (
bool,
none_type,
),
},
'attribute_map': {
'cluster_name': 'clusterName',
'region': 'region',
'force': 'force',
},
'location_map': {
'cluster_name': 'path',
'region': 'query',
'force': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__delete_cluster_instances)
def __describe_cluster_instances(self, cluster_name, **kwargs):
"""describe_cluster_instances # noqa: E501
Describe the instances belonging to a given cluster. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.describe_cluster_instances(cluster_name, async_req=True)
>>> result = thread.get()
Args:
cluster_name (str): Name of the cluster
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
next_token (str): Token to use for paginated requests.. [optional]
node_type (NodeType): Filter the instances by node type.. [optional]
queue_name (str): Filter the instances by queue name.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
DescribeClusterInstancesResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cluster_name'] = \
cluster_name
return self.call_with_http_info(**kwargs)
self.describe_cluster_instances = _Endpoint(
settings={
'response_type': (DescribeClusterInstancesResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters/{clusterName}/instances',
'operation_id': 'describe_cluster_instances',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'cluster_name',
'region',
'next_token',
'node_type',
'queue_name',
],
'required': [
'cluster_name',
],
'nullable': [],
'enum': [],
'validation': [
'cluster_name',
]
},
root_map={
'validations': {
('cluster_name', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'cluster_name': (str, ),
'region': (str, ),
'next_token': (str, ),
'node_type': (NodeType, ),
'queue_name': (str, ),
},
'attribute_map': {
'cluster_name': 'clusterName',
'region': 'region',
'next_token': 'nextToken',
'node_type': 'nodeType',
'queue_name': 'queueName',
},
'location_map': {
'cluster_name': 'path',
'region': 'query',
'next_token': 'query',
'node_type': 'query',
'queue_name': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__describe_cluster_instances)
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def __create_cluster(self, create_cluster_request_content, **kwargs):
"""create_cluster # noqa: E501
Create a managed cluster in a given region. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_cluster(create_cluster_request_content, async_req=True)
>>> result = thread.get()
Args:
create_cluster_request_content (CreateClusterRequestContent):
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
suppress_validators ([str]): Identifies one or more config validators to suppress. Format: (ALL|type:[A-Za-z0-9]+). [optional]
validation_failure_level (ValidationLevel): Min validation level that will cause the creation to fail. (Defaults to 'ERROR'.). [optional]
dryrun (bool, none_type): Only perform request validation without creating any resource. May be used to validate the cluster configuration. (Defaults to 'false'.). [optional]
rollback_on_failure (bool, none_type): When set it automatically initiates a cluster stack rollback on failures. (Defaults to 'true'.). [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
CreateClusterResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['create_cluster_request_content'] = \
create_cluster_request_content
return self.call_with_http_info(**kwargs)
self.create_cluster = _Endpoint(
settings={
'response_type': (CreateClusterResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters',
'operation_id': 'create_cluster',
'http_method': 'POST',
'servers': None,
},
params_map={
'all': [
'create_cluster_request_content',
'region',
'suppress_validators',
'validation_failure_level',
'dryrun',
'rollback_on_failure',
],
'required': [
'create_cluster_request_content',
],
'nullable': [
'dryrun',
'rollback_on_failure',
],
'enum': [],
'validation': [
'suppress_validators',
]
},
root_map={
'validations': {
('suppress_validators', ): {},
},
'allowed_values': {},
'openapi_types': {
'create_cluster_request_content':
(CreateClusterRequestContent, ),
'region': (str, ),
'suppress_validators': ([str], ),
'validation_failure_level': (ValidationLevel, ),
'dryrun': (
bool,
none_type,
),
'rollback_on_failure': (
bool,
none_type,
),
},
'attribute_map': {
'region': 'region',
'suppress_validators': 'suppressValidators',
'validation_failure_level': 'validationFailureLevel',
'dryrun': 'dryrun',
'rollback_on_failure': 'rollbackOnFailure',
},
'location_map': {
'create_cluster_request_content': 'body',
'region': 'query',
'suppress_validators': 'query',
'validation_failure_level': 'query',
'dryrun': 'query',
'rollback_on_failure': 'query',
},
'collection_format_map': {
'suppress_validators': 'multi',
}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__create_cluster)
def __delete_cluster(self, cluster_name, **kwargs):
"""delete_cluster # noqa: E501
Initiate the deletion of a cluster. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_cluster(cluster_name, async_req=True)
>>> result = thread.get()
Args:
cluster_name (str): Name of the cluster
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
DeleteClusterResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cluster_name'] = \
cluster_name
return self.call_with_http_info(**kwargs)
self.delete_cluster = _Endpoint(
settings={
'response_type': (DeleteClusterResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters/{clusterName}',
'operation_id': 'delete_cluster',
'http_method': 'DELETE',
'servers': None,
},
params_map={
'all': [
'cluster_name',
'region',
],
'required': [
'cluster_name',
],
'nullable': [],
'enum': [],
'validation': [
'cluster_name',
]
},
root_map={
'validations': {
('cluster_name', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'cluster_name': (str, ),
'region': (str, ),
},
'attribute_map': {
'cluster_name': 'clusterName',
'region': 'region',
},
'location_map': {
'cluster_name': 'path',
'region': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__delete_cluster)
def __describe_cluster(self, cluster_name, **kwargs):
"""describe_cluster # noqa: E501
Get detailed information about an existing cluster. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.describe_cluster(cluster_name, async_req=True)
>>> result = thread.get()
Args:
cluster_name (str): Name of the cluster
Keyword Args:
region (str): AWS Region that the operation corresponds to.. [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
DescribeClusterResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cluster_name'] = \
cluster_name
return self.call_with_http_info(**kwargs)
self.describe_cluster = _Endpoint(
settings={
'response_type': (DescribeClusterResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters/{clusterName}',
'operation_id': 'describe_cluster',
'http_method': 'GET',
'servers': None,
},
params_map={
'all': [
'cluster_name',
'region',
],
'required': [
'cluster_name',
],
'nullable': [],
'enum': [],
'validation': [
'cluster_name',
]
},
root_map={
'validations': {
('cluster_name', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
},
'allowed_values': {},
'openapi_types': {
'cluster_name': (str, ),
'region': (str, ),
},
'attribute_map': {
'cluster_name': 'clusterName',
'region': 'region',
},
'location_map': {
'cluster_name': 'path',
'region': 'query',
},
'collection_format_map': {}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__describe_cluster)
def __list_clusters(self, **kwargs):
"""list_clusters # noqa: E501
Retrieve the list of existing clusters. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.list_clusters(async_req=True)
>>> result = thread.get()
Keyword Args:
region (str): List clusters deployed to a given AWS Region.. [optional]
next_token (str): Token to use for paginated requests.. [optional]
cluster_status ([ClusterStatusFilteringOption]): Filter by cluster status. (Defaults to all clusters.). [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
ListClustersResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
return self.call_with_http_info(**kwargs)
self.list_clusters = _Endpoint(settings={
'response_type': (ListClustersResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path':
'/v3/clusters',
'operation_id':
'list_clusters',
'http_method':
'GET',
'servers':
None,
},
params_map={
'all': [
'region',
'next_token',
'cluster_status',
],
'required': [],
'nullable': [],
'enum': [],
'validation': [
'cluster_status',
]
},
root_map={
'validations': {
('cluster_status', ): {},
},
'allowed_values': {},
'openapi_types': {
'region': (str, ),
'next_token': (str, ),
'cluster_status':
([ClusterStatusFilteringOption
], ),
},
'attribute_map': {
'region': 'region',
'next_token': 'nextToken',
'cluster_status':
'clusterStatus',
},
'location_map': {
'region': 'query',
'next_token': 'query',
'cluster_status': 'query',
},
'collection_format_map': {
'cluster_status': 'multi',
}
},
headers_map={
'accept': ['application/json'],
'content_type': [],
},
api_client=api_client,
callable=__list_clusters)
def __update_cluster(self, cluster_name,
update_cluster_request_content, **kwargs):
"""update_cluster # noqa: E501
Update a cluster managed in a given region. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_cluster(cluster_name, update_cluster_request_content, async_req=True)
>>> result = thread.get()
Args:
cluster_name (str): Name of the cluster
update_cluster_request_content (UpdateClusterRequestContent):
Keyword Args:
suppress_validators ([str]): Identifies one or more config validators to suppress. Format: (ALL|type:[A-Za-z0-9]+). [optional]
validation_failure_level (ValidationLevel): Min validation level that will cause the update to fail. (Defaults to 'ERROR'.). [optional]
region (str): AWS Region that the operation corresponds to.. [optional]
dryrun (bool, none_type): Only perform request validation without creating any resource. May be used to validate the cluster configuration and update requirements. (Defaults to 'false'.). [optional]
force_update (bool, none_type): Force update by ignoring the update validation errors. (Defaults to 'false'.). [optional]
_return_http_data_only (bool): response data without head status
code and headers. Default is True.
_preload_content (bool): if False, the urllib3.HTTPResponse object
will be returned without reading/decoding response data.
Default is True.
_request_timeout (float/tuple): timeout setting for this request. If one
number provided, it will be total request timeout. It can also
be a pair (tuple) of (connection, read) timeouts.
Default is None.
_check_input_type (bool): specifies if type checking
should be done one the data sent to the server.
Default is True.
_check_return_type (bool): specifies if type checking
should be done one the data received from the server.
Default is True.
_host_index (int/None): specifies the index of the server
that we want to use.
Default is read from the configuration.
async_req (bool): execute request asynchronously
Returns:
UpdateClusterResponseContent
If the method is called asynchronously, returns the request
thread.
"""
kwargs['async_req'] = kwargs.get('async_req', False)
kwargs['_return_http_data_only'] = kwargs.get(
'_return_http_data_only', True)
kwargs['_preload_content'] = kwargs.get('_preload_content', True)
kwargs['_request_timeout'] = kwargs.get('_request_timeout', None)
kwargs['_check_input_type'] = kwargs.get('_check_input_type', True)
kwargs['_check_return_type'] = kwargs.get('_check_return_type',
True)
kwargs['_host_index'] = kwargs.get('_host_index')
kwargs['cluster_name'] = \
cluster_name
kwargs['update_cluster_request_content'] = \
update_cluster_request_content
return self.call_with_http_info(**kwargs)
self.update_cluster = _Endpoint(
settings={
'response_type': (UpdateClusterResponseContent, ),
'auth': ['aws.auth.sigv4'],
'endpoint_path': '/v3/clusters/{clusterName}',
'operation_id': 'update_cluster',
'http_method': 'PUT',
'servers': None,
},
params_map={
'all': [
'cluster_name',
'update_cluster_request_content',
'suppress_validators',
'validation_failure_level',
'region',
'dryrun',
'force_update',
],
'required': [
'cluster_name',
'update_cluster_request_content',
],
'nullable': [
'dryrun',
'force_update',
],
'enum': [],
'validation': [
'cluster_name',
'suppress_validators',
]
},
root_map={
'validations': {
('cluster_name', ): {
'regex': {
'pattern':
r'^[a-zA-Z][a-zA-Z0-9-]+$', # noqa: E501
},
},
('suppress_validators', ): {},
},
'allowed_values': {},
'openapi_types': {
'cluster_name': (str, ),
'update_cluster_request_content':
(UpdateClusterRequestContent, ),
'suppress_validators': ([str], ),
'validation_failure_level': (ValidationLevel, ),
'region': (str, ),
'dryrun': (
bool,
none_type,
),
'force_update': (
bool,
none_type,
),
},
'attribute_map': {
'cluster_name': 'clusterName',
'suppress_validators': 'suppressValidators',
'validation_failure_level': 'validationFailureLevel',
'region': 'region',
'dryrun': 'dryrun',
'force_update': 'forceUpdate',
},
'location_map': {
'cluster_name': 'path',
'update_cluster_request_content': 'body',
'suppress_validators': 'query',
'validation_failure_level': 'query',
'region': 'query',
'dryrun': 'query',
'force_update': 'query',
},
'collection_format_map': {
'suppress_validators': 'multi',
}
},
headers_map={
'accept': ['application/json'],
'content_type': ['application/json']
},
api_client=api_client,
callable=__update_cluster)