# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. # # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is # regenerated. # -------------------------------------------------------------------------- from msrest.pipeline import ClientRawResponse import uuid from .. import models class PoolOperations(object): """PoolOperations operations. :param client: Client for service requests. :param config: Configuration of service client. :param serializer: An object model serializer. :param deserializer: An objec model deserializer. """ def __init__(self, client, config, serializer, deserializer): self._client = client self._serialize = serializer self._deserialize = deserializer self.config = config def list_pool_usage_metrics( self, pool_list_pool_usage_metrics_options=None, custom_headers=None, raw=False, **operation_config): """Lists the usage metrics, aggregated by pool across individual time intervals, for the specified account. :param pool_list_pool_usage_metrics_options: Additional parameters for the operation :type pool_list_pool_usage_metrics_options: :class:`PoolListPoolUsageMetricsOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: :class:`PoolUsageMetricsPaged ` """ start_time = None if pool_list_pool_usage_metrics_options is not None: start_time = pool_list_pool_usage_metrics_options.start_time end_time = None if pool_list_pool_usage_metrics_options is not None: end_time = pool_list_pool_usage_metrics_options.end_time filter = None if pool_list_pool_usage_metrics_options is not None: filter = pool_list_pool_usage_metrics_options.filter max_results = None if pool_list_pool_usage_metrics_options is not None: max_results = pool_list_pool_usage_metrics_options.max_results timeout = None if pool_list_pool_usage_metrics_options is not None: timeout = pool_list_pool_usage_metrics_options.timeout client_request_id = None if pool_list_pool_usage_metrics_options is not None: client_request_id = pool_list_pool_usage_metrics_options.client_request_id return_client_request_id = None if pool_list_pool_usage_metrics_options is not None: return_client_request_id = pool_list_pool_usage_metrics_options.return_client_request_id ocp_date = None if pool_list_pool_usage_metrics_options is not None: ocp_date = pool_list_pool_usage_metrics_options.ocp_date def internal_paging(next_link=None, raw=False): if not next_link: # Construct URL url = '/poolusagemetrics' # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if start_time is not None: query_parameters['starttime'] = self._serialize.query("start_time", start_time, 'iso-8601') if end_time is not None: query_parameters['endtime'] = self._serialize.query("end_time", end_time, 'iso-8601') if filter is not None: query_parameters['$filter'] = self._serialize.query("filter", filter, 'str') if max_results is not None: query_parameters['maxresults'] = self._serialize.query("max_results", max_results, 'int') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') else: url = next_link query_parameters = {} # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') # Construct and send request request = self._client.get(url, query_parameters) response = self._client.send( request, header_parameters, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) return response # Deserialize response deserialized = models.PoolUsageMetricsPaged(internal_paging, self._deserialize.dependencies) if raw: header_dict = {} client_raw_response = models.PoolUsageMetricsPaged(internal_paging, self._deserialize.dependencies, header_dict) return client_raw_response return deserialized def get_all_pools_lifetime_statistics( self, pool_get_all_pools_lifetime_statistics_options=None, custom_headers=None, raw=False, **operation_config): """Gets lifetime summary statistics for all of the pools in the specified account. Statistics are aggregated across all pools that have ever existed in the account, from account creation to the last update time of the statistics. :param pool_get_all_pools_lifetime_statistics_options: Additional parameters for the operation :type pool_get_all_pools_lifetime_statistics_options: :class:`PoolGetAllPoolsLifetimeStatisticsOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: :class:`PoolStatistics ` :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_get_all_pools_lifetime_statistics_options is not None: timeout = pool_get_all_pools_lifetime_statistics_options.timeout client_request_id = None if pool_get_all_pools_lifetime_statistics_options is not None: client_request_id = pool_get_all_pools_lifetime_statistics_options.client_request_id return_client_request_id = None if pool_get_all_pools_lifetime_statistics_options is not None: return_client_request_id = pool_get_all_pools_lifetime_statistics_options.return_client_request_id ocp_date = None if pool_get_all_pools_lifetime_statistics_options is not None: ocp_date = pool_get_all_pools_lifetime_statistics_options.ocp_date # Construct URL url = '/lifetimepoolstats' # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') # Construct and send request request = self._client.get(url, query_parameters) response = self._client.send(request, header_parameters, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) deserialized = None header_dict = {} if response.status_code == 200: deserialized = self._deserialize('PoolStatistics', response) header_dict = { 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', } if raw: client_raw_response = ClientRawResponse(deserialized, response) client_raw_response.add_headers(header_dict) return client_raw_response return deserialized def add( self, pool, pool_add_options=None, custom_headers=None, raw=False, **operation_config): """Adds a pool to the specified account. :param pool: The pool to be added. :type pool: :class:`PoolAddParameter ` :param pool_add_options: Additional parameters for the operation :type pool_add_options: :class:`PoolAddOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_add_options is not None: timeout = pool_add_options.timeout client_request_id = None if pool_add_options is not None: client_request_id = pool_add_options.client_request_id return_client_request_id = None if pool_add_options is not None: return_client_request_id = pool_add_options.return_client_request_id ocp_date = None if pool_add_options is not None: ocp_date = pool_add_options.ocp_date # Construct URL url = '/pools' # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') # Construct body body_content = self._serialize.body(pool, 'PoolAddParameter') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [201]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def list( self, pool_list_options=None, custom_headers=None, raw=False, **operation_config): """Lists all of the pools in the specified account. :param pool_list_options: Additional parameters for the operation :type pool_list_options: :class:`PoolListOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: :class:`CloudPoolPaged ` """ filter = None if pool_list_options is not None: filter = pool_list_options.filter select = None if pool_list_options is not None: select = pool_list_options.select expand = None if pool_list_options is not None: expand = pool_list_options.expand max_results = None if pool_list_options is not None: max_results = pool_list_options.max_results timeout = None if pool_list_options is not None: timeout = pool_list_options.timeout client_request_id = None if pool_list_options is not None: client_request_id = pool_list_options.client_request_id return_client_request_id = None if pool_list_options is not None: return_client_request_id = pool_list_options.return_client_request_id ocp_date = None if pool_list_options is not None: ocp_date = pool_list_options.ocp_date def internal_paging(next_link=None, raw=False): if not next_link: # Construct URL url = '/pools' # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if filter is not None: query_parameters['$filter'] = self._serialize.query("filter", filter, 'str') if select is not None: query_parameters['$select'] = self._serialize.query("select", select, 'str') if expand is not None: query_parameters['$expand'] = self._serialize.query("expand", expand, 'str') if max_results is not None: query_parameters['maxresults'] = self._serialize.query("max_results", max_results, 'int') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') else: url = next_link query_parameters = {} # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') # Construct and send request request = self._client.get(url, query_parameters) response = self._client.send( request, header_parameters, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) return response # Deserialize response deserialized = models.CloudPoolPaged(internal_paging, self._deserialize.dependencies) if raw: header_dict = {} client_raw_response = models.CloudPoolPaged(internal_paging, self._deserialize.dependencies, header_dict) return client_raw_response return deserialized def delete( self, pool_id, pool_delete_options=None, custom_headers=None, raw=False, **operation_config): """Deletes a pool from the specified account. :param pool_id: The id of the pool to delete. :type pool_id: str :param pool_delete_options: Additional parameters for the operation :type pool_delete_options: :class:`PoolDeleteOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_delete_options is not None: timeout = pool_delete_options.timeout client_request_id = None if pool_delete_options is not None: client_request_id = pool_delete_options.client_request_id return_client_request_id = None if pool_delete_options is not None: return_client_request_id = pool_delete_options.return_client_request_id ocp_date = None if pool_delete_options is not None: ocp_date = pool_delete_options.ocp_date if_match = None if pool_delete_options is not None: if_match = pool_delete_options.if_match if_none_match = None if pool_delete_options is not None: if_none_match = pool_delete_options.if_none_match if_modified_since = None if pool_delete_options is not None: if_modified_since = pool_delete_options.if_modified_since if_unmodified_since = None if pool_delete_options is not None: if_unmodified_since = pool_delete_options.if_unmodified_since # Construct URL url = '/pools/{poolId}' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct and send request request = self._client.delete(url, query_parameters) response = self._client.send(request, header_parameters, **operation_config) if response.status_code not in [202]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', }) return client_raw_response def exists( self, pool_id, pool_exists_options=None, custom_headers=None, raw=False, **operation_config): """Gets basic properties of a pool. :param pool_id: The id of the pool to get. :type pool_id: str :param pool_exists_options: Additional parameters for the operation :type pool_exists_options: :class:`PoolExistsOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: bool :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_exists_options is not None: timeout = pool_exists_options.timeout client_request_id = None if pool_exists_options is not None: client_request_id = pool_exists_options.client_request_id return_client_request_id = None if pool_exists_options is not None: return_client_request_id = pool_exists_options.return_client_request_id ocp_date = None if pool_exists_options is not None: ocp_date = pool_exists_options.ocp_date if_match = None if pool_exists_options is not None: if_match = pool_exists_options.if_match if_none_match = None if pool_exists_options is not None: if_none_match = pool_exists_options.if_none_match if_modified_since = None if pool_exists_options is not None: if_modified_since = pool_exists_options.if_modified_since if_unmodified_since = None if pool_exists_options is not None: if_unmodified_since = pool_exists_options.if_unmodified_since # Construct URL url = '/pools/{poolId}' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct and send request request = self._client.head(url, query_parameters) response = self._client.send(request, header_parameters, **operation_config) if response.status_code not in [200, 404]: raise models.BatchErrorException(self._deserialize, response) deserialized = (response.status_code == 200) if raw: client_raw_response = ClientRawResponse(deserialized, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', }) return client_raw_response return deserialized def get( self, pool_id, pool_get_options=None, custom_headers=None, raw=False, **operation_config): """Gets information about the specified pool. :param pool_id: The id of the pool to get. :type pool_id: str :param pool_get_options: Additional parameters for the operation :type pool_get_options: :class:`PoolGetOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: :class:`CloudPool ` :rtype: :class:`ClientRawResponse` if raw=true """ select = None if pool_get_options is not None: select = pool_get_options.select expand = None if pool_get_options is not None: expand = pool_get_options.expand timeout = None if pool_get_options is not None: timeout = pool_get_options.timeout client_request_id = None if pool_get_options is not None: client_request_id = pool_get_options.client_request_id return_client_request_id = None if pool_get_options is not None: return_client_request_id = pool_get_options.return_client_request_id ocp_date = None if pool_get_options is not None: ocp_date = pool_get_options.ocp_date if_match = None if pool_get_options is not None: if_match = pool_get_options.if_match if_none_match = None if pool_get_options is not None: if_none_match = pool_get_options.if_none_match if_modified_since = None if pool_get_options is not None: if_modified_since = pool_get_options.if_modified_since if_unmodified_since = None if pool_get_options is not None: if_unmodified_since = pool_get_options.if_unmodified_since # Construct URL url = '/pools/{poolId}' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if select is not None: query_parameters['$select'] = self._serialize.query("select", select, 'str') if expand is not None: query_parameters['$expand'] = self._serialize.query("expand", expand, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct and send request request = self._client.get(url, query_parameters) response = self._client.send(request, header_parameters, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) deserialized = None header_dict = {} if response.status_code == 200: deserialized = self._deserialize('CloudPool', response) header_dict = { 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', } if raw: client_raw_response = ClientRawResponse(deserialized, response) client_raw_response.add_headers(header_dict) return client_raw_response return deserialized def patch( self, pool_id, pool_patch_parameter, pool_patch_options=None, custom_headers=None, raw=False, **operation_config): """Updates the properties of a pool. :param pool_id: The id of the pool to update. :type pool_id: str :param pool_patch_parameter: The parameters for the request. :type pool_patch_parameter: :class:`PoolPatchParameter ` :param pool_patch_options: Additional parameters for the operation :type pool_patch_options: :class:`PoolPatchOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_patch_options is not None: timeout = pool_patch_options.timeout client_request_id = None if pool_patch_options is not None: client_request_id = pool_patch_options.client_request_id return_client_request_id = None if pool_patch_options is not None: return_client_request_id = pool_patch_options.return_client_request_id ocp_date = None if pool_patch_options is not None: ocp_date = pool_patch_options.ocp_date if_match = None if pool_patch_options is not None: if_match = pool_patch_options.if_match if_none_match = None if pool_patch_options is not None: if_none_match = pool_patch_options.if_none_match if_modified_since = None if pool_patch_options is not None: if_modified_since = pool_patch_options.if_modified_since if_unmodified_since = None if pool_patch_options is not None: if_unmodified_since = pool_patch_options.if_unmodified_since # Construct URL url = '/pools/{poolId}' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct body body_content = self._serialize.body(pool_patch_parameter, 'PoolPatchParameter') # Construct and send request request = self._client.patch(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def disable_auto_scale( self, pool_id, pool_disable_auto_scale_options=None, custom_headers=None, raw=False, **operation_config): """Disables automatic scaling for a pool. :param pool_id: The id of the pool on which to disable automatic scaling. :type pool_id: str :param pool_disable_auto_scale_options: Additional parameters for the operation :type pool_disable_auto_scale_options: :class:`PoolDisableAutoScaleOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_disable_auto_scale_options is not None: timeout = pool_disable_auto_scale_options.timeout client_request_id = None if pool_disable_auto_scale_options is not None: client_request_id = pool_disable_auto_scale_options.client_request_id return_client_request_id = None if pool_disable_auto_scale_options is not None: return_client_request_id = pool_disable_auto_scale_options.return_client_request_id ocp_date = None if pool_disable_auto_scale_options is not None: ocp_date = pool_disable_auto_scale_options.ocp_date # Construct URL url = '/pools/{poolId}/disableautoscale' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send(request, header_parameters, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def enable_auto_scale( self, pool_id, pool_enable_auto_scale_options=None, auto_scale_formula=None, auto_scale_evaluation_interval=None, custom_headers=None, raw=False, **operation_config): """Enables automatic scaling for a pool. :param pool_id: The id of the pool on which to enable automatic scaling. :type pool_id: str :param pool_enable_auto_scale_options: Additional parameters for the operation :type pool_enable_auto_scale_options: :class:`PoolEnableAutoScaleOptions ` :param auto_scale_formula: The formula for the desired number of compute nodes in the pool. :type auto_scale_formula: str :param auto_scale_evaluation_interval: A time interval for the desired autoscale evaluation period in the pool. :type auto_scale_evaluation_interval: timedelta :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_enable_auto_scale_options is not None: timeout = pool_enable_auto_scale_options.timeout client_request_id = None if pool_enable_auto_scale_options is not None: client_request_id = pool_enable_auto_scale_options.client_request_id return_client_request_id = None if pool_enable_auto_scale_options is not None: return_client_request_id = pool_enable_auto_scale_options.return_client_request_id ocp_date = None if pool_enable_auto_scale_options is not None: ocp_date = pool_enable_auto_scale_options.ocp_date if_match = None if pool_enable_auto_scale_options is not None: if_match = pool_enable_auto_scale_options.if_match if_none_match = None if pool_enable_auto_scale_options is not None: if_none_match = pool_enable_auto_scale_options.if_none_match if_modified_since = None if pool_enable_auto_scale_options is not None: if_modified_since = pool_enable_auto_scale_options.if_modified_since if_unmodified_since = None if pool_enable_auto_scale_options is not None: if_unmodified_since = pool_enable_auto_scale_options.if_unmodified_since pool_enable_auto_scale_parameter = models.PoolEnableAutoScaleParameter(auto_scale_formula=auto_scale_formula, auto_scale_evaluation_interval=auto_scale_evaluation_interval) # Construct URL url = '/pools/{poolId}/enableautoscale' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct body body_content = self._serialize.body(pool_enable_auto_scale_parameter, 'PoolEnableAutoScaleParameter') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def evaluate_auto_scale( self, pool_id, auto_scale_formula, pool_evaluate_auto_scale_options=None, custom_headers=None, raw=False, **operation_config): """Gets the result of evaluating an automatic scaling formula on the pool. :param pool_id: The id of the pool on which to evaluate the automatic scaling formula. :type pool_id: str :param auto_scale_formula: A formula for the desired number of compute nodes in the pool. :type auto_scale_formula: str :param pool_evaluate_auto_scale_options: Additional parameters for the operation :type pool_evaluate_auto_scale_options: :class:`PoolEvaluateAutoScaleOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: :class:`AutoScaleRun ` :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_evaluate_auto_scale_options is not None: timeout = pool_evaluate_auto_scale_options.timeout client_request_id = None if pool_evaluate_auto_scale_options is not None: client_request_id = pool_evaluate_auto_scale_options.client_request_id return_client_request_id = None if pool_evaluate_auto_scale_options is not None: return_client_request_id = pool_evaluate_auto_scale_options.return_client_request_id ocp_date = None if pool_evaluate_auto_scale_options is not None: ocp_date = pool_evaluate_auto_scale_options.ocp_date pool_evaluate_auto_scale_parameter = models.PoolEvaluateAutoScaleParameter(auto_scale_formula=auto_scale_formula) # Construct URL url = '/pools/{poolId}/evaluateautoscale' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') # Construct body body_content = self._serialize.body(pool_evaluate_auto_scale_parameter, 'PoolEvaluateAutoScaleParameter') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [200]: raise models.BatchErrorException(self._deserialize, response) deserialized = None header_dict = {} if response.status_code == 200: deserialized = self._deserialize('AutoScaleRun', response) header_dict = { 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', } if raw: client_raw_response = ClientRawResponse(deserialized, response) client_raw_response.add_headers(header_dict) return client_raw_response return deserialized def resize( self, pool_id, pool_resize_parameter, pool_resize_options=None, custom_headers=None, raw=False, **operation_config): """Changes the number of compute nodes that are assigned to a pool. :param pool_id: The id of the pool to resize. :type pool_id: str :param pool_resize_parameter: The parameters for the request. :type pool_resize_parameter: :class:`PoolResizeParameter ` :param pool_resize_options: Additional parameters for the operation :type pool_resize_options: :class:`PoolResizeOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_resize_options is not None: timeout = pool_resize_options.timeout client_request_id = None if pool_resize_options is not None: client_request_id = pool_resize_options.client_request_id return_client_request_id = None if pool_resize_options is not None: return_client_request_id = pool_resize_options.return_client_request_id ocp_date = None if pool_resize_options is not None: ocp_date = pool_resize_options.ocp_date if_match = None if pool_resize_options is not None: if_match = pool_resize_options.if_match if_none_match = None if pool_resize_options is not None: if_none_match = pool_resize_options.if_none_match if_modified_since = None if pool_resize_options is not None: if_modified_since = pool_resize_options.if_modified_since if_unmodified_since = None if pool_resize_options is not None: if_unmodified_since = pool_resize_options.if_unmodified_since # Construct URL url = '/pools/{poolId}/resize' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct body body_content = self._serialize.body(pool_resize_parameter, 'PoolResizeParameter') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [202]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def stop_resize( self, pool_id, pool_stop_resize_options=None, custom_headers=None, raw=False, **operation_config): """Stops an ongoing resize operation on the pool. This does not restore the pool to its previous state before the resize operation: it only stops any further changes being made, and the pool maintains its current state. :param pool_id: The id of the pool whose resizing you want to stop. :type pool_id: str :param pool_stop_resize_options: Additional parameters for the operation :type pool_stop_resize_options: :class:`PoolStopResizeOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_stop_resize_options is not None: timeout = pool_stop_resize_options.timeout client_request_id = None if pool_stop_resize_options is not None: client_request_id = pool_stop_resize_options.client_request_id return_client_request_id = None if pool_stop_resize_options is not None: return_client_request_id = pool_stop_resize_options.return_client_request_id ocp_date = None if pool_stop_resize_options is not None: ocp_date = pool_stop_resize_options.ocp_date if_match = None if pool_stop_resize_options is not None: if_match = pool_stop_resize_options.if_match if_none_match = None if pool_stop_resize_options is not None: if_none_match = pool_stop_resize_options.if_none_match if_modified_since = None if pool_stop_resize_options is not None: if_modified_since = pool_stop_resize_options.if_modified_since if_unmodified_since = None if pool_stop_resize_options is not None: if_unmodified_since = pool_stop_resize_options.if_unmodified_since # Construct URL url = '/pools/{poolId}/stopresize' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send(request, header_parameters, **operation_config) if response.status_code not in [202]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def update_properties( self, pool_id, pool_update_properties_parameter, pool_update_properties_options=None, custom_headers=None, raw=False, **operation_config): """Updates the properties of a pool. :param pool_id: The id of the pool to update. :type pool_id: str :param pool_update_properties_parameter: The parameters for the request. :type pool_update_properties_parameter: :class:`PoolUpdatePropertiesParameter ` :param pool_update_properties_options: Additional parameters for the operation :type pool_update_properties_options: :class:`PoolUpdatePropertiesOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_update_properties_options is not None: timeout = pool_update_properties_options.timeout client_request_id = None if pool_update_properties_options is not None: client_request_id = pool_update_properties_options.client_request_id return_client_request_id = None if pool_update_properties_options is not None: return_client_request_id = pool_update_properties_options.return_client_request_id ocp_date = None if pool_update_properties_options is not None: ocp_date = pool_update_properties_options.ocp_date # Construct URL url = '/pools/{poolId}/updateproperties' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') # Construct body body_content = self._serialize.body(pool_update_properties_parameter, 'PoolUpdatePropertiesParameter') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [204]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def upgrade_os( self, pool_id, target_os_version, pool_upgrade_os_options=None, custom_headers=None, raw=False, **operation_config): """Upgrades the operating system of the specified pool. :param pool_id: The id of the pool to upgrade. :type pool_id: str :param target_os_version: The Azure Guest OS version to be installed on the virtual machines in the pool. :type target_os_version: str :param pool_upgrade_os_options: Additional parameters for the operation :type pool_upgrade_os_options: :class:`PoolUpgradeOSOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_upgrade_os_options is not None: timeout = pool_upgrade_os_options.timeout client_request_id = None if pool_upgrade_os_options is not None: client_request_id = pool_upgrade_os_options.client_request_id return_client_request_id = None if pool_upgrade_os_options is not None: return_client_request_id = pool_upgrade_os_options.return_client_request_id ocp_date = None if pool_upgrade_os_options is not None: ocp_date = pool_upgrade_os_options.ocp_date if_match = None if pool_upgrade_os_options is not None: if_match = pool_upgrade_os_options.if_match if_none_match = None if pool_upgrade_os_options is not None: if_none_match = pool_upgrade_os_options.if_none_match if_modified_since = None if pool_upgrade_os_options is not None: if_modified_since = pool_upgrade_os_options.if_modified_since if_unmodified_since = None if pool_upgrade_os_options is not None: if_unmodified_since = pool_upgrade_os_options.if_unmodified_since pool_upgrade_os_parameter = models.PoolUpgradeOSParameter(target_os_version=target_os_version) # Construct URL url = '/pools/{poolId}/upgradeos' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct body body_content = self._serialize.body(pool_upgrade_os_parameter, 'PoolUpgradeOSParameter') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [202]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response def remove_nodes( self, pool_id, node_remove_parameter, pool_remove_nodes_options=None, custom_headers=None, raw=False, **operation_config): """Removes compute nodes from the specified pool. :param pool_id: The id of the pool from which you want to remove nodes. :type pool_id: str :param node_remove_parameter: The parameters for the request. :type node_remove_parameter: :class:`NodeRemoveParameter ` :param pool_remove_nodes_options: Additional parameters for the operation :type pool_remove_nodes_options: :class:`PoolRemoveNodesOptions ` :param dict custom_headers: headers that will be added to the request :param bool raw: returns the direct response alongside the deserialized response :param operation_config: :ref:`Operation configuration overrides`. :rtype: None :rtype: :class:`ClientRawResponse` if raw=true """ timeout = None if pool_remove_nodes_options is not None: timeout = pool_remove_nodes_options.timeout client_request_id = None if pool_remove_nodes_options is not None: client_request_id = pool_remove_nodes_options.client_request_id return_client_request_id = None if pool_remove_nodes_options is not None: return_client_request_id = pool_remove_nodes_options.return_client_request_id ocp_date = None if pool_remove_nodes_options is not None: ocp_date = pool_remove_nodes_options.ocp_date if_match = None if pool_remove_nodes_options is not None: if_match = pool_remove_nodes_options.if_match if_none_match = None if pool_remove_nodes_options is not None: if_none_match = pool_remove_nodes_options.if_none_match if_modified_since = None if pool_remove_nodes_options is not None: if_modified_since = pool_remove_nodes_options.if_modified_since if_unmodified_since = None if pool_remove_nodes_options is not None: if_unmodified_since = pool_remove_nodes_options.if_unmodified_since # Construct URL url = '/pools/{poolId}/removenodes' path_format_arguments = { 'poolId': self._serialize.url("pool_id", pool_id, 'str') } url = self._client.format_url(url, **path_format_arguments) # Construct parameters query_parameters = {} query_parameters['api-version'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str') if timeout is not None: query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int') # Construct headers header_parameters = {} header_parameters['Content-Type'] = 'application/json; odata=minimalmetadata; charset=utf-8' if self.config.generate_client_request_id: header_parameters['client-request-id'] = str(uuid.uuid1()) if custom_headers: header_parameters.update(custom_headers) if self.config.accept_language is not None: header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str') if client_request_id is not None: header_parameters['client-request-id'] = self._serialize.header("client_request_id", client_request_id, 'str') if return_client_request_id is not None: header_parameters['return-client-request-id'] = self._serialize.header("return_client_request_id", return_client_request_id, 'bool') if ocp_date is not None: header_parameters['ocp-date'] = self._serialize.header("ocp_date", ocp_date, 'rfc-1123') if if_match is not None: header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str') if if_none_match is not None: header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str') if if_modified_since is not None: header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123') if if_unmodified_since is not None: header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123') # Construct body body_content = self._serialize.body(node_remove_parameter, 'NodeRemoveParameter') # Construct and send request request = self._client.post(url, query_parameters) response = self._client.send( request, header_parameters, body_content, **operation_config) if response.status_code not in [202]: raise models.BatchErrorException(self._deserialize, response) if raw: client_raw_response = ClientRawResponse(None, response) client_raw_response.add_headers({ 'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str', }) return client_raw_response