class PacketMirroringsRestTransport(PacketMirroringsTransport):
"""REST backend transport for PacketMirrorings.
The PacketMirrorings API.
This class defines the same methods as the primary client, so the
primary client can load the underlying transport implementation
and call it.
It sends JSON representations of protocol buffers over HTTP/1.1
"""
def __init__(
self,
*,
host: str = "compute.googleapis.com",
credentials: ga_credentials.Credentials = None,
credentials_file: str = None,
scopes: Sequence[str] = None,
client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
quota_project_id: Optional[str] = None,
client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
) -> None:
"""Instantiate the transport.
Args:
host (Optional[str]):
The hostname to connect to.
credentials (Optional[google.auth.credentials.Credentials]): The
authorization credentials to attach to requests. These
credentials identify the application to the service; if none
are specified, the client will attempt to ascertain the
credentials from the environment.
credentials_file (Optional[str]): A file with credentials that can
be loaded with :func:`google.auth.load_credentials_from_file`.
This argument is ignored if ``channel`` is provided.
scopes (Optional(Sequence[str])): A list of scopes. This argument is
ignored if ``channel`` is provided.
client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
certificate to configure mutual TLS HTTP channel. It is ignored
if ``channel`` is provided.
quota_project_id (Optional[str]): An optional project to use for billing
and quota.
client_info (google.api_core.gapic_v1.client_info.ClientInfo):
The client info used to send a user-agent string along with
API requests. If ``None``, then default info will be used.
Generally, you only need to set this if you're developing
your own client library.
"""
# Run the base constructor
# TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
# TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
# credentials object
super().__init__(
host=host,
credentials=credentials,
client_info=client_info,
)
self._session = AuthorizedSession(self._credentials,
default_host=self.DEFAULT_HOST)
if client_cert_source_for_mtls:
self._session.configure_mtls_channel(client_cert_source_for_mtls)
self._prep_wrapped_messages(client_info)
def aggregated_list(
self,
request: compute.AggregatedListPacketMirroringsRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.PacketMirroringAggregatedList:
r"""Call the aggregated list method over HTTP.
Args:
request (~.compute.AggregatedListPacketMirroringsRequest):
The request object. A request message for
PacketMirrorings.AggregatedList. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.PacketMirroringAggregatedList:
Contains a list of packetMirrorings.
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/aggregated/packetMirrorings".format(
host=self._host,
project=request.project,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.AggregatedListPacketMirroringsRequest.filter in request:
query_params["filter"] = request.filter
if compute.AggregatedListPacketMirroringsRequest.include_all_scopes in request:
query_params["includeAllScopes"] = request.include_all_scopes
if compute.AggregatedListPacketMirroringsRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.AggregatedListPacketMirroringsRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.AggregatedListPacketMirroringsRequest.page_token in request:
query_params["pageToken"] = request.page_token
if (compute.AggregatedListPacketMirroringsRequest.
return_partial_success in request):
query_params[
"returnPartialSuccess"] = request.return_partial_success
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
response = self._session.get(url, )
# Raise requests.exceptions.HTTPError if the status code is >= 400
response.raise_for_status()
# Return the response
return compute.PacketMirroringAggregatedList.from_json(
response.content, ignore_unknown_fields=True)
def delete(
self,
request: compute.DeletePacketMirroringRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete method over HTTP.
Args:
request (~.compute.DeletePacketMirroringRequest):
The request object. A request message for
PacketMirrorings.Delete. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/packetMirrorings/{packet_mirroring}".format(
host=self._host,
project=request.project,
region=request.region,
packet_mirroring=request.packet_mirroring,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.DeletePacketMirroringRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
response = self._session.delete(url, )
# Raise requests.exceptions.HTTPError if the status code is >= 400
response.raise_for_status()
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def get(
self,
request: compute.GetPacketMirroringRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.PacketMirroring:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetPacketMirroringRequest):
The request object. A request message for
PacketMirrorings.Get. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.PacketMirroring:
Represents a Packet Mirroring resource.
Packet Mirroring clones the traffic of specified
instances in your Virtual Private Cloud (VPC) network
and forwards it to a collector destination, such as an
instance group of an internal TCP/UDP load balancer, for
analysis or examination. For more information about
setting up Packet Mirroring, see Using Packet Mirroring.
(== resource_for {$api_version}.packetMirrorings ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/packetMirrorings/{packet_mirroring}".format(
host=self._host,
project=request.project,
region=request.region,
packet_mirroring=request.packet_mirroring,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
response = self._session.get(url, )
# Raise requests.exceptions.HTTPError if the status code is >= 400
response.raise_for_status()
# Return the response
return compute.PacketMirroring.from_json(response.content,
ignore_unknown_fields=True)
def insert(
self,
request: compute.InsertPacketMirroringRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the insert method over HTTP.
Args:
request (~.compute.InsertPacketMirroringRequest):
The request object. A request message for
PacketMirrorings.Insert. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.PacketMirroring.to_json(
request.packet_mirroring_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/packetMirrorings".format(
host=self._host,
project=request.project,
region=request.region,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.InsertPacketMirroringRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
response = self._session.post(
url,
data=body,
)
# Raise requests.exceptions.HTTPError if the status code is >= 400
response.raise_for_status()
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def list(
self,
request: compute.ListPacketMirroringsRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.PacketMirroringList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListPacketMirroringsRequest):
The request object. A request message for
PacketMirrorings.List. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.PacketMirroringList:
Contains a list of PacketMirroring
resources.
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/packetMirrorings".format(
host=self._host,
project=request.project,
region=request.region,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.ListPacketMirroringsRequest.filter in request:
query_params["filter"] = request.filter
if compute.ListPacketMirroringsRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.ListPacketMirroringsRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.ListPacketMirroringsRequest.page_token in request:
query_params["pageToken"] = request.page_token
if compute.ListPacketMirroringsRequest.return_partial_success in request:
query_params[
"returnPartialSuccess"] = request.return_partial_success
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
response = self._session.get(url, )
# Raise requests.exceptions.HTTPError if the status code is >= 400
response.raise_for_status()
# Return the response
return compute.PacketMirroringList.from_json(
response.content, ignore_unknown_fields=True)
def patch(
self,
request: compute.PatchPacketMirroringRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the patch method over HTTP.
Args:
request (~.compute.PatchPacketMirroringRequest):
The request object. A request message for
PacketMirrorings.Patch. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.PacketMirroring.to_json(
request.packet_mirroring_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/packetMirrorings/{packet_mirroring}".format(
host=self._host,
project=request.project,
region=request.region,
packet_mirroring=request.packet_mirroring,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.PatchPacketMirroringRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
response = self._session.patch(
url,
data=body,
)
# Raise requests.exceptions.HTTPError if the status code is >= 400
response.raise_for_status()
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def test_iam_permissions(
self,
request: compute.TestIamPermissionsPacketMirroringRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.TestPermissionsResponse:
r"""Call the test iam permissions method over HTTP.
Args:
request (~.compute.TestIamPermissionsPacketMirroringRequest):
The request object. A request message for
PacketMirrorings.TestIamPermissions. See
the method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.TestPermissionsResponse:
"""
# Jsonify the request body
body = compute.TestPermissionsRequest.to_json(
request.test_permissions_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/packetMirrorings/{resource}/testIamPermissions".format(
host=self._host,
project=request.project,
region=request.region,
resource=request.resource,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
response = self._session.post(
url,
data=body,
)
# Raise requests.exceptions.HTTPError if the status code is >= 400
response.raise_for_status()
# Return the response
return compute.TestPermissionsResponse.from_json(
response.content, ignore_unknown_fields=True)
class NodeGroupsRestTransport(NodeGroupsTransport):
"""REST backend transport for NodeGroups.
The NodeGroups API.
This class defines the same methods as the primary client, so the
primary client can load the underlying transport implementation
and call it.
It sends JSON representations of protocol buffers over HTTP/1.1
"""
def __init__(
self,
*,
host: str = "compute.googleapis.com",
credentials: ga_credentials.Credentials = None,
credentials_file: str = None,
scopes: Sequence[str] = None,
client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
quota_project_id: Optional[str] = None,
client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
always_use_jwt_access: Optional[bool] = False,
) -> None:
"""Instantiate the transport.
Args:
host (Optional[str]):
The hostname to connect to.
credentials (Optional[google.auth.credentials.Credentials]): The
authorization credentials to attach to requests. These
credentials identify the application to the service; if none
are specified, the client will attempt to ascertain the
credentials from the environment.
credentials_file (Optional[str]): A file with credentials that can
be loaded with :func:`google.auth.load_credentials_from_file`.
This argument is ignored if ``channel`` is provided.
scopes (Optional(Sequence[str])): A list of scopes. This argument is
ignored if ``channel`` is provided.
client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
certificate to configure mutual TLS HTTP channel. It is ignored
if ``channel`` is provided.
quota_project_id (Optional[str]): An optional project to use for billing
and quota.
client_info (google.api_core.gapic_v1.client_info.ClientInfo):
The client info used to send a user-agent string along with
API requests. If ``None``, then default info will be used.
Generally, you only need to set this if you're developing
your own client library.
"""
# Run the base constructor
# TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
# TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
# credentials object
super().__init__(
host=host,
credentials=credentials,
client_info=client_info,
always_use_jwt_access=always_use_jwt_access,
)
self._session = AuthorizedSession(
self._credentials, default_host=self.DEFAULT_HOST
)
if client_cert_source_for_mtls:
self._session.configure_mtls_channel(client_cert_source_for_mtls)
self._prep_wrapped_messages(client_info)
def add_nodes(
self,
request: compute.AddNodesNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the add nodes method over HTTP.
Args:
request (~.compute.AddNodesNodeGroupRequest):
The request object. A request message for
NodeGroups.AddNodes. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.NodeGroupsAddNodesRequest.to_json(
request.node_groups_add_nodes_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{node_group}/addNodes".format(
host=self._host,
project=request.project,
zone=request.zone,
node_group=request.node_group,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.AddNodesNodeGroupRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url, headers=headers, params=query_params, data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content, ignore_unknown_fields=True)
def aggregated_list(
self,
request: compute.AggregatedListNodeGroupsRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.NodeGroupAggregatedList:
r"""Call the aggregated list method over HTTP.
Args:
request (~.compute.AggregatedListNodeGroupsRequest):
The request object. A request message for
NodeGroups.AggregatedList. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.NodeGroupAggregatedList:
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/aggregated/nodeGroups".format(
host=self._host, project=request.project,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.AggregatedListNodeGroupsRequest.filter in request:
query_params["filter"] = request.filter
if compute.AggregatedListNodeGroupsRequest.include_all_scopes in request:
query_params["includeAllScopes"] = request.include_all_scopes
if compute.AggregatedListNodeGroupsRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.AggregatedListNodeGroupsRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.AggregatedListNodeGroupsRequest.page_token in request:
query_params["pageToken"] = request.page_token
if compute.AggregatedListNodeGroupsRequest.return_partial_success in request:
query_params["returnPartialSuccess"] = request.return_partial_success
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(url, headers=headers, params=query_params,)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.NodeGroupAggregatedList.from_json(
response.content, ignore_unknown_fields=True
)
def delete(
self,
request: compute.DeleteNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete method over HTTP.
Args:
request (~.compute.DeleteNodeGroupRequest):
The request object. A request message for
NodeGroups.Delete. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{node_group}".format(
host=self._host,
project=request.project,
zone=request.zone,
node_group=request.node_group,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.DeleteNodeGroupRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.delete(url, headers=headers, params=query_params,)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content, ignore_unknown_fields=True)
def delete_nodes(
self,
request: compute.DeleteNodesNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete nodes method over HTTP.
Args:
request (~.compute.DeleteNodesNodeGroupRequest):
The request object. A request message for
NodeGroups.DeleteNodes. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.NodeGroupsDeleteNodesRequest.to_json(
request.node_groups_delete_nodes_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{node_group}/deleteNodes".format(
host=self._host,
project=request.project,
zone=request.zone,
node_group=request.node_group,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.DeleteNodesNodeGroupRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url, headers=headers, params=query_params, data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content, ignore_unknown_fields=True)
def get(
self,
request: compute.GetNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.NodeGroup:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetNodeGroupRequest):
The request object. A request message for NodeGroups.Get.
See the method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.NodeGroup:
Represent a sole-tenant Node Group resource.
A sole-tenant node is a physical server that is
dedicated to hosting VM instances only for your specific
project. Use sole-tenant nodes to keep your instances
physically separated from instances in other projects,
or to group your instances together on the same host
hardware. For more information, read Sole-tenant nodes.
(== resource_for {$api_version}.nodeGroups ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{node_group}".format(
host=self._host,
project=request.project,
zone=request.zone,
node_group=request.node_group,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(url, headers=headers, params=query_params,)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.NodeGroup.from_json(response.content, ignore_unknown_fields=True)
def get_iam_policy(
self,
request: compute.GetIamPolicyNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Policy:
r"""Call the get iam policy method over HTTP.
Args:
request (~.compute.GetIamPolicyNodeGroupRequest):
The request object. A request message for
NodeGroups.GetIamPolicy. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Policy:
An Identity and Access Management (IAM) policy, which
specifies access controls for Google Cloud resources.
A ``Policy`` is a collection of ``bindings``. A
``binding`` binds one or more ``members`` to a single
``role``. Members can be user accounts, service
accounts, Google groups, and domains (such as G Suite).
A ``role`` is a named list of permissions; each ``role``
can be an IAM predefined role or a user-created custom
role.
For some types of Google Cloud resources, a ``binding``
can also specify a ``condition``, which is a logical
expression that allows access to a resource only if the
expression evaluates to ``true``. A condition can add
constraints based on attributes of the request, the
resource, or both. To learn which resources support
conditions in their IAM policies, see the `IAM
documentation <https://cloud.google.com/iam/help/conditions/resource-policies>`__.
**JSON example:**
{ "bindings": [ { "role":
"roles/resourcemanager.organizationAdmin", "members": [
"user:[email protected]", "group:[email protected]",
"domain:google.com",
"serviceAccount:[email protected]"
] }, { "role":
"roles/resourcemanager.organizationViewer", "members": [
"user:[email protected]" ], "condition": { "title":
"expirable access", "description": "Does not grant
access after Sep 2020", "expression": "request.time <
timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag":
"BwWWja0YfJA=", "version": 3 }
**YAML example:**
bindings: - members: - user:[email protected] -
group:[email protected] - domain:google.com -
serviceAccount:[email protected]
role: roles/resourcemanager.organizationAdmin - members:
- user:[email protected] role:
roles/resourcemanager.organizationViewer condition:
title: expirable access description: Does not grant
access after Sep 2020 expression: request.time <
timestamp('2020-10-01T00:00:00.000Z') - etag:
BwWWja0YfJA= - version: 3
For a description of IAM and its features, see the `IAM
documentation <https://cloud.google.com/iam/docs/>`__.
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{resource}/getIamPolicy".format(
host=self._host,
project=request.project,
zone=request.zone,
resource=request.resource,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if (
compute.GetIamPolicyNodeGroupRequest.options_requested_policy_version
in request
):
query_params[
"optionsRequestedPolicyVersion"
] = request.options_requested_policy_version
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(url, headers=headers, params=query_params,)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Policy.from_json(response.content, ignore_unknown_fields=True)
def insert(
self,
request: compute.InsertNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the insert method over HTTP.
Args:
request (~.compute.InsertNodeGroupRequest):
The request object. A request message for
NodeGroups.Insert. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.NodeGroup.to_json(
request.node_group_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups".format(
host=self._host, project=request.project, zone=request.zone,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
query_params["initialNodeCount"] = request.initial_node_count
if compute.InsertNodeGroupRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url, headers=headers, params=query_params, data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content, ignore_unknown_fields=True)
def list(
self,
request: compute.ListNodeGroupsRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.NodeGroupList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListNodeGroupsRequest):
The request object. A request message for
NodeGroups.List. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.NodeGroupList:
Contains a list of nodeGroups.
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups".format(
host=self._host, project=request.project, zone=request.zone,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.ListNodeGroupsRequest.filter in request:
query_params["filter"] = request.filter
if compute.ListNodeGroupsRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.ListNodeGroupsRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.ListNodeGroupsRequest.page_token in request:
query_params["pageToken"] = request.page_token
if compute.ListNodeGroupsRequest.return_partial_success in request:
query_params["returnPartialSuccess"] = request.return_partial_success
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(url, headers=headers, params=query_params,)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.NodeGroupList.from_json(
response.content, ignore_unknown_fields=True
)
def list_nodes(
self,
request: compute.ListNodesNodeGroupsRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.NodeGroupsListNodes:
r"""Call the list nodes method over HTTP.
Args:
request (~.compute.ListNodesNodeGroupsRequest):
The request object. A request message for
NodeGroups.ListNodes. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.NodeGroupsListNodes:
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{node_group}/listNodes".format(
host=self._host,
project=request.project,
zone=request.zone,
node_group=request.node_group,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.ListNodesNodeGroupsRequest.filter in request:
query_params["filter"] = request.filter
if compute.ListNodesNodeGroupsRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.ListNodesNodeGroupsRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.ListNodesNodeGroupsRequest.page_token in request:
query_params["pageToken"] = request.page_token
if compute.ListNodesNodeGroupsRequest.return_partial_success in request:
query_params["returnPartialSuccess"] = request.return_partial_success
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(url, headers=headers, params=query_params,)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.NodeGroupsListNodes.from_json(
response.content, ignore_unknown_fields=True
)
def patch(
self,
request: compute.PatchNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the patch method over HTTP.
Args:
request (~.compute.PatchNodeGroupRequest):
The request object. A request message for
NodeGroups.Patch. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.NodeGroup.to_json(
request.node_group_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{node_group}".format(
host=self._host,
project=request.project,
zone=request.zone,
node_group=request.node_group,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.PatchNodeGroupRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.patch(
url, headers=headers, params=query_params, data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content, ignore_unknown_fields=True)
def set_iam_policy(
self,
request: compute.SetIamPolicyNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Policy:
r"""Call the set iam policy method over HTTP.
Args:
request (~.compute.SetIamPolicyNodeGroupRequest):
The request object. A request message for
NodeGroups.SetIamPolicy. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Policy:
An Identity and Access Management (IAM) policy, which
specifies access controls for Google Cloud resources.
A ``Policy`` is a collection of ``bindings``. A
``binding`` binds one or more ``members`` to a single
``role``. Members can be user accounts, service
accounts, Google groups, and domains (such as G Suite).
A ``role`` is a named list of permissions; each ``role``
can be an IAM predefined role or a user-created custom
role.
For some types of Google Cloud resources, a ``binding``
can also specify a ``condition``, which is a logical
expression that allows access to a resource only if the
expression evaluates to ``true``. A condition can add
constraints based on attributes of the request, the
resource, or both. To learn which resources support
conditions in their IAM policies, see the `IAM
documentation <https://cloud.google.com/iam/help/conditions/resource-policies>`__.
**JSON example:**
{ "bindings": [ { "role":
"roles/resourcemanager.organizationAdmin", "members": [
"user:[email protected]", "group:[email protected]",
"domain:google.com",
"serviceAccount:[email protected]"
] }, { "role":
"roles/resourcemanager.organizationViewer", "members": [
"user:[email protected]" ], "condition": { "title":
"expirable access", "description": "Does not grant
access after Sep 2020", "expression": "request.time <
timestamp('2020-10-01T00:00:00.000Z')", } } ], "etag":
"BwWWja0YfJA=", "version": 3 }
**YAML example:**
bindings: - members: - user:[email protected] -
group:[email protected] - domain:google.com -
serviceAccount:[email protected]
role: roles/resourcemanager.organizationAdmin - members:
- user:[email protected] role:
roles/resourcemanager.organizationViewer condition:
title: expirable access description: Does not grant
access after Sep 2020 expression: request.time <
timestamp('2020-10-01T00:00:00.000Z') - etag:
BwWWja0YfJA= - version: 3
For a description of IAM and its features, see the `IAM
documentation <https://cloud.google.com/iam/docs/>`__.
"""
# Jsonify the request body
body = compute.ZoneSetPolicyRequest.to_json(
request.zone_set_policy_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{resource}/setIamPolicy".format(
host=self._host,
project=request.project,
zone=request.zone,
resource=request.resource,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url, headers=headers, params=query_params, data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Policy.from_json(response.content, ignore_unknown_fields=True)
def set_node_template(
self,
request: compute.SetNodeTemplateNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the set node template method over HTTP.
Args:
request (~.compute.SetNodeTemplateNodeGroupRequest):
The request object. A request message for
NodeGroups.SetNodeTemplate. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.NodeGroupsSetNodeTemplateRequest.to_json(
request.node_groups_set_node_template_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{node_group}/setNodeTemplate".format(
host=self._host,
project=request.project,
zone=request.zone,
node_group=request.node_group,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.SetNodeTemplateNodeGroupRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url, headers=headers, params=query_params, data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content, ignore_unknown_fields=True)
def test_iam_permissions(
self,
request: compute.TestIamPermissionsNodeGroupRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.TestPermissionsResponse:
r"""Call the test iam permissions method over HTTP.
Args:
request (~.compute.TestIamPermissionsNodeGroupRequest):
The request object. A request message for
NodeGroups.TestIamPermissions. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.TestPermissionsResponse:
"""
# Jsonify the request body
body = compute.TestPermissionsRequest.to_json(
request.test_permissions_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/zones/{zone}/nodeGroups/{resource}/testIamPermissions".format(
host=self._host,
project=request.project,
zone=request.zone,
resource=request.resource,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url, headers=headers, params=query_params, data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.TestPermissionsResponse.from_json(
response.content, ignore_unknown_fields=True
)
class RegionBackendServicesRestTransport(RegionBackendServicesTransport):
"""REST backend transport for RegionBackendServices.
The RegionBackendServices API.
This class defines the same methods as the primary client, so the
primary client can load the underlying transport implementation
and call it.
It sends JSON representations of protocol buffers over HTTP/1.1
"""
def __init__(
self,
*,
host: str = "compute.googleapis.com",
credentials: ga_credentials.Credentials = None,
credentials_file: str = None,
scopes: Sequence[str] = None,
client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
quota_project_id: Optional[str] = None,
client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
always_use_jwt_access: Optional[bool] = False,
) -> None:
"""Instantiate the transport.
Args:
host (Optional[str]):
The hostname to connect to.
credentials (Optional[google.auth.credentials.Credentials]): The
authorization credentials to attach to requests. These
credentials identify the application to the service; if none
are specified, the client will attempt to ascertain the
credentials from the environment.
credentials_file (Optional[str]): A file with credentials that can
be loaded with :func:`google.auth.load_credentials_from_file`.
This argument is ignored if ``channel`` is provided.
scopes (Optional(Sequence[str])): A list of scopes. This argument is
ignored if ``channel`` is provided.
client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
certificate to configure mutual TLS HTTP channel. It is ignored
if ``channel`` is provided.
quota_project_id (Optional[str]): An optional project to use for billing
and quota.
client_info (google.api_core.gapic_v1.client_info.ClientInfo):
The client info used to send a user-agent string along with
API requests. If ``None``, then default info will be used.
Generally, you only need to set this if you're developing
your own client library.
"""
# Run the base constructor
# TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
# TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
# credentials object
super().__init__(
host=host,
credentials=credentials,
client_info=client_info,
always_use_jwt_access=always_use_jwt_access,
)
self._session = AuthorizedSession(self._credentials,
default_host=self.DEFAULT_HOST)
if client_cert_source_for_mtls:
self._session.configure_mtls_channel(client_cert_source_for_mtls)
self._prep_wrapped_messages(client_info)
def delete(
self,
request: compute.DeleteRegionBackendServiceRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete method over HTTP.
Args:
request (~.compute.DeleteRegionBackendServiceRequest):
The request object. A request message for
RegionBackendServices.Delete. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}".format(
host=self._host,
project=request.project,
region=request.region,
backend_service=request.backend_service,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.DeleteRegionBackendServiceRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.delete(
url,
headers=headers,
params=query_params,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def get(
self,
request: compute.GetRegionBackendServiceRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.BackendService:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetRegionBackendServiceRequest):
The request object. A request message for
RegionBackendServices.Get. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.BackendService:
Represents a Backend Service resource.
A backend service defines how Google Cloud load
balancers distribute traffic. The backend service
configuration contains a set of values, such as the
protocol used to connect to backends, various
distribution and session settings, health checks, and
timeouts. These settings provide fine-grained control
over how your load balancer behaves. Most of the
settings have default values that allow for easy
configuration if you need to get started quickly.
Backend services in Google Compute Engine can be either
regionally or globally scoped.
- `Global </compute/docs/reference/rest/{$api_version}/backendServices>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionBackendServices>`__
For more information, see Backend Services.
(== resource_for {$api_version}.backendService ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}".format(
host=self._host,
project=request.project,
region=request.region,
backend_service=request.backend_service,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(
url,
headers=headers,
params=query_params,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.BackendService.from_json(response.content,
ignore_unknown_fields=True)
def get_health(
self,
request: compute.GetHealthRegionBackendServiceRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.BackendServiceGroupHealth:
r"""Call the get health method over HTTP.
Args:
request (~.compute.GetHealthRegionBackendServiceRequest):
The request object. A request message for
RegionBackendServices.GetHealth. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.BackendServiceGroupHealth:
"""
# Jsonify the request body
body = compute.ResourceGroupReference.to_json(
request.resource_group_reference_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}/getHealth".format(
host=self._host,
project=request.project,
region=request.region,
backend_service=request.backend_service,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url,
headers=headers,
params=query_params,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.BackendServiceGroupHealth.from_json(
response.content, ignore_unknown_fields=True)
def insert(
self,
request: compute.InsertRegionBackendServiceRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the insert method over HTTP.
Args:
request (~.compute.InsertRegionBackendServiceRequest):
The request object. A request message for
RegionBackendServices.Insert. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.BackendService.to_json(
request.backend_service_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/backendServices".format(
host=self._host,
project=request.project,
region=request.region,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.InsertRegionBackendServiceRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url,
headers=headers,
params=query_params,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def list(
self,
request: compute.ListRegionBackendServicesRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.BackendServiceList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListRegionBackendServicesRequest):
The request object. A request message for
RegionBackendServices.List. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.BackendServiceList:
Contains a list of BackendService
resources.
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/backendServices".format(
host=self._host,
project=request.project,
region=request.region,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.ListRegionBackendServicesRequest.filter in request:
query_params["filter"] = request.filter
if compute.ListRegionBackendServicesRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.ListRegionBackendServicesRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.ListRegionBackendServicesRequest.page_token in request:
query_params["pageToken"] = request.page_token
if compute.ListRegionBackendServicesRequest.return_partial_success in request:
query_params[
"returnPartialSuccess"] = request.return_partial_success
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(
url,
headers=headers,
params=query_params,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.BackendServiceList.from_json(response.content,
ignore_unknown_fields=True)
def patch(
self,
request: compute.PatchRegionBackendServiceRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the patch method over HTTP.
Args:
request (~.compute.PatchRegionBackendServiceRequest):
The request object. A request message for
RegionBackendServices.Patch. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.BackendService.to_json(
request.backend_service_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}".format(
host=self._host,
project=request.project,
region=request.region,
backend_service=request.backend_service,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.PatchRegionBackendServiceRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.patch(
url,
headers=headers,
params=query_params,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def update(
self,
request: compute.UpdateRegionBackendServiceRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the update method over HTTP.
Args:
request (~.compute.UpdateRegionBackendServiceRequest):
The request object. A request message for
RegionBackendServices.Update. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.BackendService.to_json(
request.backend_service_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/regions/{region}/backendServices/{backend_service}".format(
host=self._host,
project=request.project,
region=request.region,
backend_service=request.backend_service,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.UpdateRegionBackendServiceRequest.request_id in request:
query_params["requestId"] = request.request_id
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.put(
url,
headers=headers,
params=query_params,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
class TargetHttpsProxiesRestTransport(TargetHttpsProxiesTransport):
"""REST backend transport for TargetHttpsProxies.
The TargetHttpsProxies API.
This class defines the same methods as the primary client, so the
primary client can load the underlying transport implementation
and call it.
It sends JSON representations of protocol buffers over HTTP/1.1
"""
def __init__(
self,
*,
host: str = "compute.googleapis.com",
credentials: ga_credentials.Credentials = None,
credentials_file: str = None,
scopes: Sequence[str] = None,
client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
quota_project_id: Optional[str] = None,
client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
) -> None:
"""Instantiate the transport.
Args:
host (Optional[str]):
The hostname to connect to.
credentials (Optional[google.auth.credentials.Credentials]): The
authorization credentials to attach to requests. These
credentials identify the application to the service; if none
are specified, the client will attempt to ascertain the
credentials from the environment.
credentials_file (Optional[str]): A file with credentials that can
be loaded with :func:`google.auth.load_credentials_from_file`.
This argument is ignored if ``channel`` is provided.
scopes (Optional(Sequence[str])): A list of scopes. This argument is
ignored if ``channel`` is provided.
client_cert_source_for_mtls (Callable[[], Tuple[bytes, bytes]]): Client
certificate to configure mutual TLS HTTP channel. It is ignored
if ``channel`` is provided.
quota_project_id (Optional[str]): An optional project to use for billing
and quota.
client_info (google.api_core.gapic_v1.client_info.ClientInfo):
The client info used to send a user-agent string along with
API requests. If ``None``, then default info will be used.
Generally, you only need to set this if you're developing
your own client library.
"""
# Run the base constructor
# TODO(yon-mg): resolve other ctor params i.e. scopes, quota, etc.
# TODO: When custom host (api_endpoint) is set, `scopes` must *also* be set on the
# credentials object
super().__init__(
host=host,
credentials=credentials,
client_info=client_info,
)
self._session = AuthorizedSession(self._credentials,
default_host=self.DEFAULT_HOST)
if client_cert_source_for_mtls:
self._session.configure_mtls_channel(client_cert_source_for_mtls)
self._prep_wrapped_messages(client_info)
def aggregated_list(
self,
request: compute.AggregatedListTargetHttpsProxiesRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.TargetHttpsProxyAggregatedList:
r"""Call the aggregated list method over HTTP.
Args:
request (~.compute.AggregatedListTargetHttpsProxiesRequest):
The request object. A request message for
TargetHttpsProxies.AggregatedList. See
the method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.TargetHttpsProxyAggregatedList:
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/aggregated/targetHttpsProxies".format(
host=self._host,
project=request.project,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.AggregatedListTargetHttpsProxiesRequest.filter in request:
query_params["filter"] = request.filter
if (compute.AggregatedListTargetHttpsProxiesRequest.include_all_scopes
in request):
query_params["includeAllScopes"] = request.include_all_scopes
if compute.AggregatedListTargetHttpsProxiesRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.AggregatedListTargetHttpsProxiesRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.AggregatedListTargetHttpsProxiesRequest.page_token in request:
query_params["pageToken"] = request.page_token
if (compute.AggregatedListTargetHttpsProxiesRequest.
return_partial_success in request):
query_params[
"returnPartialSuccess"] = request.return_partial_success
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(
url,
headers=headers,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.TargetHttpsProxyAggregatedList.from_json(
response.content, ignore_unknown_fields=True)
def delete(
self,
request: compute.DeleteTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete method over HTTP.
Args:
request (~.compute.DeleteTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.Delete. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/global/targetHttpsProxies/{target_https_proxy}".format(
host=self._host,
project=request.project,
target_https_proxy=request.target_https_proxy,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.DeleteTargetHttpsProxyRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.delete(
url,
headers=headers,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def get(
self,
request: compute.GetTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.TargetHttpsProxy:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.Get. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.TargetHttpsProxy:
Represents a Target HTTPS Proxy resource.
Google Compute Engine has two Target HTTPS Proxy
resources:
- `Global </compute/docs/reference/rest/{$api_version}/targetHttpsProxies>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionTargetHttpsProxies>`__
A target HTTPS proxy is a component of GCP HTTPS load
balancers.
- targetHttpsProxies are used by external HTTPS load
balancers. \* regionTargetHttpsProxies are used by
internal HTTPS load balancers.
Forwarding rules reference a target HTTPS proxy, and the
target proxy then references a URL map. For more
information, read Using Target Proxies and Forwarding
rule concepts. (== resource_for
{$api_version}.targetHttpsProxies ==) (== resource_for
{$api_version}.regionTargetHttpsProxies ==)
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/global/targetHttpsProxies/{target_https_proxy}".format(
host=self._host,
project=request.project,
target_https_proxy=request.target_https_proxy,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(
url,
headers=headers,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.TargetHttpsProxy.from_json(response.content,
ignore_unknown_fields=True)
def insert(
self,
request: compute.InsertTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the insert method over HTTP.
Args:
request (~.compute.InsertTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.Insert. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.TargetHttpsProxy.to_json(
request.target_https_proxy_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/global/targetHttpsProxies".format(
host=self._host,
project=request.project,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.InsertTargetHttpsProxyRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url,
headers=headers,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def list(
self,
request: compute.ListTargetHttpsProxiesRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.TargetHttpsProxyList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListTargetHttpsProxiesRequest):
The request object. A request message for
TargetHttpsProxies.List. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.TargetHttpsProxyList:
Contains a list of TargetHttpsProxy
resources.
"""
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/global/targetHttpsProxies".format(
host=self._host,
project=request.project,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.ListTargetHttpsProxiesRequest.filter in request:
query_params["filter"] = request.filter
if compute.ListTargetHttpsProxiesRequest.max_results in request:
query_params["maxResults"] = request.max_results
if compute.ListTargetHttpsProxiesRequest.order_by in request:
query_params["orderBy"] = request.order_by
if compute.ListTargetHttpsProxiesRequest.page_token in request:
query_params["pageToken"] = request.page_token
if compute.ListTargetHttpsProxiesRequest.return_partial_success in request:
query_params[
"returnPartialSuccess"] = request.return_partial_success
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.get(
url,
headers=headers,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.TargetHttpsProxyList.from_json(
response.content, ignore_unknown_fields=True)
def patch(
self,
request: compute.PatchTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the patch method over HTTP.
Args:
request (~.compute.PatchTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.Patch. See the method
description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.TargetHttpsProxy.to_json(
request.target_https_proxy_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/global/targetHttpsProxies/{target_https_proxy}".format(
host=self._host,
project=request.project,
target_https_proxy=request.target_https_proxy,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.PatchTargetHttpsProxyRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.patch(
url,
headers=headers,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def set_quic_override(
self,
request: compute.SetQuicOverrideTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the set quic override method over HTTP.
Args:
request (~.compute.SetQuicOverrideTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.SetQuicOverride. See
the method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.TargetHttpsProxiesSetQuicOverrideRequest.to_json(
request.target_https_proxies_set_quic_override_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/global/targetHttpsProxies/{target_https_proxy}/setQuicOverride".format(
host=self._host,
project=request.project,
target_https_proxy=request.target_https_proxy,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.SetQuicOverrideTargetHttpsProxyRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url,
headers=headers,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def set_ssl_certificates(
self,
request: compute.SetSslCertificatesTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the set ssl certificates method over HTTP.
Args:
request (~.compute.SetSslCertificatesTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.SetSslCertificates.
See the method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.TargetHttpsProxiesSetSslCertificatesRequest.to_json(
request.target_https_proxies_set_ssl_certificates_request_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/targetHttpsProxies/{target_https_proxy}/setSslCertificates".format(
host=self._host,
project=request.project,
target_https_proxy=request.target_https_proxy,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.SetSslCertificatesTargetHttpsProxyRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url,
headers=headers,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def set_ssl_policy(
self,
request: compute.SetSslPolicyTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the set ssl policy method over HTTP.
Args:
request (~.compute.SetSslPolicyTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.SetSslPolicy. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.SslPolicyReference.to_json(
request.ssl_policy_reference_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/global/targetHttpsProxies/{target_https_proxy}/setSslPolicy".format(
host=self._host,
project=request.project,
target_https_proxy=request.target_https_proxy,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.SetSslPolicyTargetHttpsProxyRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url,
headers=headers,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
def set_url_map(
self,
request: compute.SetUrlMapTargetHttpsProxyRequest,
*,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the set url map method over HTTP.
Args:
request (~.compute.SetUrlMapTargetHttpsProxyRequest):
The request object. A request message for
TargetHttpsProxies.SetUrlMap. See the
method description for details.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Operation:
Represents an Operation resource.
Google Compute Engine has three Operation resources:
- `Global </compute/docs/reference/rest/{$api_version}/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/{$api_version}/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/{$api_version}/zoneOperations>`__
You can use an operation resource to manage asynchronous
API requests. For more information, read Handling API
responses.
Operations can be global, regional or zonal.
- For global operations, use the ``globalOperations``
resource.
- For regional operations, use the ``regionOperations``
resource.
- For zonal operations, use the ``zonalOperations``
resource.
For more information, read Global, Regional, and Zonal
Resources. (== resource_for
{$api_version}.globalOperations ==) (== resource_for
{$api_version}.regionOperations ==) (== resource_for
{$api_version}.zoneOperations ==)
"""
# Jsonify the request body
body = compute.UrlMapReference.to_json(
request.url_map_reference_resource,
including_default_value_fields=False,
use_integers_for_enums=False,
)
# TODO(yon-mg): need to handle grpc transcoding and parse url correctly
# current impl assumes basic case of grpc transcoding
url = "https://{host}/compute/v1/projects/{project}/targetHttpsProxies/{target_https_proxy}/setUrlMap".format(
host=self._host,
project=request.project,
target_https_proxy=request.target_https_proxy,
)
# TODO(yon-mg): handle nested fields corerctly rather than using only top level fields
# not required for GCE
query_params = {}
if compute.SetUrlMapTargetHttpsProxyRequest.request_id in request:
query_params["requestId"] = request.request_id
# TODO(yon-mg): further discussion needed whether 'python truthiness' is appropriate here
# discards default values
# TODO(yon-mg): add test for proper url encoded strings
query_params = [
"{k}={v}".format(k=k, v=v) for k, v in query_params.items()
]
url += "?{}".format("&".join(query_params)).replace(" ", "+")
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = self._session.post(
url,
headers=headers,
data=body,
)
# In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception
# subclass.
if response.status_code >= 400:
raise core_exceptions.from_http_response(response)
# Return the response
return compute.Operation.from_json(response.content,
ignore_unknown_fields=True)
