class BackendServicesRestTransport(BackendServicesTransport): """REST backend transport for BackendServices. The BackendServices 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 add_signed_url_key( self, request: compute.AddSignedUrlKeyBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the add signed url key method over HTTP. Args: request (~.compute.AddSignedUrlKeyBackendServiceRequest): The request object. A request message for BackendServices.AddSignedUrlKey. 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.SignedUrlKey.to_json( request.signed_url_key_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/backendServices/{backend_service}/addSignedUrlKey".format( host=self._host, project=request.project, 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.AddSignedUrlKeyBackendServiceRequest.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 aggregated_list( self, request: compute.AggregatedListBackendServicesRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.BackendServiceAggregatedList: r"""Call the aggregated list method over HTTP. Args: request (~.compute.AggregatedListBackendServicesRequest): The request object. A request message for BackendServices.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.BackendServiceAggregatedList: Contains a list of BackendServicesScopedList. """ # 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/backendServices".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.AggregatedListBackendServicesRequest.filter in request: query_params["filter"] = request.filter if compute.AggregatedListBackendServicesRequest.include_all_scopes in request: query_params["includeAllScopes"] = request.include_all_scopes if compute.AggregatedListBackendServicesRequest.max_results in request: query_params["maxResults"] = request.max_results if compute.AggregatedListBackendServicesRequest.order_by in request: query_params["orderBy"] = request.order_by if compute.AggregatedListBackendServicesRequest.page_token in request: query_params["pageToken"] = request.page_token if (compute.AggregatedListBackendServicesRequest.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.BackendServiceAggregatedList.from_json( response.content, ignore_unknown_fields=True) def delete( self, request: compute.DeleteBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the delete method over HTTP. Args: request (~.compute.DeleteBackendServiceRequest): The request object. A request message for BackendServices.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/backendServices/{backend_service}".format( host=self._host, project=request.project, 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.DeleteBackendServiceRequest.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 delete_signed_url_key( self, request: compute.DeleteSignedUrlKeyBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the delete signed url key method over HTTP. Args: request (~.compute.DeleteSignedUrlKeyBackendServiceRequest): The request object. A request message for BackendServices.DeleteSignedUrlKey. 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/backendServices/{backend_service}/deleteSignedUrlKey".format( host=self._host, project=request.project, 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 request.key_name: query_params["keyName"] = request.key_name if compute.DeleteSignedUrlKeyBackendServiceRequest.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, ) # 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.GetBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.BackendService: r"""Call the get method over HTTP. Args: request (~.compute.GetBackendServiceRequest): The request object. A request message for BackendServices.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}/global/backendServices/{backend_service}".format( host=self._host, project=request.project, 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 = {} # 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.BackendService.from_json(response.content, ignore_unknown_fields=True) def get_health( self, request: compute.GetHealthBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.BackendServiceGroupHealth: r"""Call the get health method over HTTP. Args: request (~.compute.GetHealthBackendServiceRequest): The request object. A request message for BackendServices.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}/global/backendServices/{backend_service}/getHealth".format( host=self._host, project=request.project, 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 = {} # 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.BackendServiceGroupHealth.from_json( response.content, ignore_unknown_fields=True) def insert( self, request: compute.InsertBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the insert method over HTTP. Args: request (~.compute.InsertBackendServiceRequest): The request object. A request message for BackendServices.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}/global/backendServices".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.InsertBackendServiceRequest.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.ListBackendServicesRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.BackendServiceList: r"""Call the list method over HTTP. Args: request (~.compute.ListBackendServicesRequest): The request object. A request message for BackendServices.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}/global/backendServices".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.ListBackendServicesRequest.filter in request: query_params["filter"] = request.filter if compute.ListBackendServicesRequest.max_results in request: query_params["maxResults"] = request.max_results if compute.ListBackendServicesRequest.order_by in request: query_params["orderBy"] = request.order_by if compute.ListBackendServicesRequest.page_token in request: query_params["pageToken"] = request.page_token if compute.ListBackendServicesRequest.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.BackendServiceList.from_json(response.content, ignore_unknown_fields=True) def patch( self, request: compute.PatchBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the patch method over HTTP. Args: request (~.compute.PatchBackendServiceRequest): The request object. A request message for BackendServices.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}/global/backendServices/{backend_service}".format( host=self._host, project=request.project, 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.PatchBackendServiceRequest.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 set_security_policy( self, request: compute.SetSecurityPolicyBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the set security policy method over HTTP. Args: request (~.compute.SetSecurityPolicyBackendServiceRequest): The request object. A request message for BackendServices.SetSecurityPolicy. 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.SecurityPolicyReference.to_json( request.security_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/backendServices/{backend_service}/setSecurityPolicy".format( host=self._host, project=request.project, 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.SetSecurityPolicyBackendServiceRequest.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 update( self, request: compute.UpdateBackendServiceRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the update method over HTTP. Args: request (~.compute.UpdateBackendServiceRequest): The request object. A request message for BackendServices.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}/global/backendServices/{backend_service}".format( host=self._host, project=request.project, 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.UpdateBackendServiceRequest.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.put( 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)
class FirewallsRestTransport(FirewallsTransport): """REST backend transport for Firewalls. The Firewalls 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 delete( self, request: compute.DeleteFirewallRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the delete method over HTTP. Args: request (~.compute.DeleteFirewallRequest): The request object. A request message for Firewalls.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/firewalls/{firewall}".format( host=self._host, project=request.project, firewall=request.firewall, ) # TODO(yon-mg): handle nested fields corerctly rather than using only top level fields # not required for GCE query_params = {} if compute.DeleteFirewallRequest.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.GetFirewallRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Firewall: r"""Call the get method over HTTP. Args: request (~.compute.GetFirewallRequest): The request object. A request message for Firewalls.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.Firewall: Represents a Firewall Rule resource. Firewall rules allow or deny ingress traffic to, and egress traffic from your instances. For more information, read Firewall rules. """ # 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/firewalls/{firewall}".format( host=self._host, project=request.project, firewall=request.firewall, ) # 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.Firewall.from_json(response.content, ignore_unknown_fields=True) def insert( self, request: compute.InsertFirewallRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the insert method over HTTP. Args: request (~.compute.InsertFirewallRequest): The request object. A request message for Firewalls.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.Firewall.to_json( request.firewall_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/firewalls".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.InsertFirewallRequest.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.ListFirewallsRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.FirewallList: r"""Call the list method over HTTP. Args: request (~.compute.ListFirewallsRequest): The request object. A request message for Firewalls.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.FirewallList: Contains a list of firewalls. """ # 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/firewalls".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.ListFirewallsRequest.filter in request: query_params["filter"] = request.filter if compute.ListFirewallsRequest.max_results in request: query_params["maxResults"] = request.max_results if compute.ListFirewallsRequest.order_by in request: query_params["orderBy"] = request.order_by if compute.ListFirewallsRequest.page_token in request: query_params["pageToken"] = request.page_token if compute.ListFirewallsRequest.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.FirewallList.from_json(response.content, ignore_unknown_fields=True) def patch( self, request: compute.PatchFirewallRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the patch method over HTTP. Args: request (~.compute.PatchFirewallRequest): The request object. A request message for Firewalls.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.Firewall.to_json( request.firewall_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/firewalls/{firewall}".format( host=self._host, project=request.project, firewall=request.firewall, ) # TODO(yon-mg): handle nested fields corerctly rather than using only top level fields # not required for GCE query_params = {} if compute.PatchFirewallRequest.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 update( self, request: compute.UpdateFirewallRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the update method over HTTP. Args: request (~.compute.UpdateFirewallRequest): The request object. A request message for Firewalls.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.Firewall.to_json( request.firewall_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/firewalls/{firewall}".format( host=self._host, project=request.project, firewall=request.firewall, ) # TODO(yon-mg): handle nested fields corerctly rather than using only top level fields # not required for GCE query_params = {} if compute.UpdateFirewallRequest.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.put( 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)
class LicensesRestTransport(LicensesTransport): """REST backend transport for Licenses. The Licenses 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.DeleteLicenseRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the delete method over HTTP. Args: request (~.compute.DeleteLicenseRequest): The request object. A request message for Licenses.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/licenses/{license}".format( host=self._host, project=request.project, license=request.license_, ) # TODO(yon-mg): handle nested fields corerctly rather than using only top level fields # not required for GCE query_params = {} query_params["license"] = request.license_ if compute.DeleteLicenseRequest.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.GetLicenseRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.License: r"""Call the get method over HTTP. Args: request (~.compute.GetLicenseRequest): The request object. A request message for Licenses.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.License: Represents a License resource. A License represents billing and aggregate usage data for public and marketplace images. Caution This resource is intended for use only by third-party partners who are creating Cloud Marketplace images. (== resource_for {$api_version}.licenses ==) """ # 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/licenses/{license}".format( host=self._host, project=request.project, license=request.license_, ) # TODO(yon-mg): handle nested fields corerctly rather than using only top level fields # not required for GCE query_params = {} query_params["license"] = request.license_ # 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.License.from_json(response.content, ignore_unknown_fields=True) def get_iam_policy( self, request: compute.GetIamPolicyLicenseRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Policy: r"""Call the get iam policy method over HTTP. Args: request (~.compute.GetIamPolicyLicenseRequest): The request object. A request message for Licenses.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}/global/licenses/{resource}/getIamPolicy".format( host=self._host, project=request.project, 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.GetIamPolicyLicenseRequest.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.InsertLicenseRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Operation: r"""Call the insert method over HTTP. Args: request (~.compute.InsertLicenseRequest): The request object. A request message for Licenses.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.License.to_json( request.license_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/licenses".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.InsertLicenseRequest.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.ListLicensesRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.LicensesListResponse: r"""Call the list method over HTTP. Args: request (~.compute.ListLicensesRequest): The request object. A request message for Licenses.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.LicensesListResponse: """ # 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/licenses".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.ListLicensesRequest.filter in request: query_params["filter"] = request.filter if compute.ListLicensesRequest.max_results in request: query_params["maxResults"] = request.max_results if compute.ListLicensesRequest.order_by in request: query_params["orderBy"] = request.order_by if compute.ListLicensesRequest.page_token in request: query_params["pageToken"] = request.page_token if compute.ListLicensesRequest.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.LicensesListResponse.from_json( response.content, ignore_unknown_fields=True) def set_iam_policy( self, request: compute.SetIamPolicyLicenseRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.Policy: r"""Call the set iam policy method over HTTP. Args: request (~.compute.SetIamPolicyLicenseRequest): The request object. A request message for Licenses.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.GlobalSetPolicyRequest.to_json( request.global_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}/global/licenses/{resource}/setIamPolicy".format( host=self._host, project=request.project, 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 test_iam_permissions( self, request: compute.TestIamPermissionsLicenseRequest, *, metadata: Sequence[Tuple[str, str]] = (), ) -> compute.TestPermissionsResponse: r"""Call the test iam permissions method over HTTP. Args: request (~.compute.TestIamPermissionsLicenseRequest): The request object. A request message for Licenses.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}/global/licenses/{resource}/testIamPermissions".format( host=self._host, project=request.project, 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 Google: auth_session = None credentials = None record = None def __init__(self): google_code = AccessToken.objects.filter(active=True, integration=2) print(google_code) if google_code.exists(): self.record = google_code.first() self.credentials = google.oauth2.credentials.Credentials( token=self.record.token, refresh_token=self.record.refresh_token, token_uri='https://www.googleapis.com/oauth2/v4/token', client_id=self.record.client_id, client_secret=self.record.client_secret) self.auth_session = AuthorizedSession(self.credentials) # if datetime.now() > self.record.expiring: # self.refresh() def exists(self): return self.record is not None def refresh(self): self.credentials.refresh(Request) self.record.token_encrypt = self.credentials.token self.record.expiring = self.credentials.expiry self.record.save() def find_by_email(self, email): response = self.auth_session.get( 'https://www.googleapis.com/admin/directory/v1/users?customer=my_customer&query=email%3D' + email.lower()) print(response.json()) if 'users' in response.json(): return True return False def get_all_users(self): response = self.auth_session.get( 'https://www.googleapis.com/admin/directory/v1/users?customer=my_customer' ) if 'users' in response.json(): return response.json()['users'] return False def add_user(self, payload): headers = { 'Content-Type': 'application/json', 'Accept': 'application/json', 'charset': 'UTF-8' } response = self.auth_session.post( 'https://www.googleapis.com/admin/directory/v1/users', data=json.dumps(payload), headers=headers) if response.status_code == 400: if response.json()['error']['errors'][0]['reason'] == 'invalid': raise EmailAddressNotValidError if response.status_code == 403 or response.status_code == 404: raise EmailAddressNotValidError if response.status_code == 401: raise UnauthorizedError if response.status_code == 200: return def delete_user(self, email): response = self.auth_session.delete( 'https://www.googleapis.com/admin/directory/v1/users/' + email.lower()) if response.status_code == 404 or response.status_code == 204: return True return False