def process_firebase_messages(lqueue, stop_event):
firebaseSession = AuthorizedSession(credentials)
baseUrl = FIREBASE_BASE_URL.format(args.firebaseAppName)
print("hi, this is before debug -----0")
while not stop_event.is_set():
try:
packet = lqueue.get(False)
print("hi, this is try debug -----1")
except Empty:
print("hi, this is except debug -----1")
time.sleep(NOTHING_TO_DO_DELAY)
pass
else:
if packet is None:
print("hi, this is none packet debug -----1")
continue
print("hi, this is debug -----0.01")
print("data from queue: " + format(packet)) #debug
firebasePath = packet['config']['firebasePath']
if packet['config']['topicAsChild']:
firebasePath = urllib.parse.urljoin(
packet['config']['firebasePath'] + '/', packet['topic'])
firebasePath = baseUrl + '/' + firebasePath + '.json'
print("Sending {0} to this URL {1}".format(packet['payload'],
firebasePath)) #debug
retry = 0
print("hi, this is debug -----1")
while True:
print("hi, this is debug -----2")
try:
if not args.dryRun: # https://obd-driving-data-default-rtdb.firebaseio.com/readings.json
r = firebaseSession.post(firebasePath,
json=packet['payload'],
timeout=FIREBASE_TIMEOUT
) #replace with firebase path
print("payload inserted : " + r.text) #debug
#except firebase_admin.exceptions.
except requests.exceptions.Timeout:
print("Firebase Timeout")
if retry < FIREBASE_MAX_RETRY:
retry += 1
debug("Retrying")
time.sleep(NOTHING_TO_DO_DELAY)
continue
except requests.exceptions.RequestException as e:
print("Firebase Exception" + str(e))
except Exception as e:
print(e)
print("Firebase Unknown Exception")
break
queue.task_done()
firebaseSession.close()
print("Stopping Firebase Thread ...")
def process_firebase_messages(lqueue, stop_event):
firebaseSession = AuthorizedSession(credentials)
baseUrl = FIREBASE_BASE_URL.format(args.firebaseAppName)
while not stop_event.is_set():
try:
packet = lqueue.get(False)
except Empty:
time.sleep(NOTHING_TO_DO_DELAY)
pass
else:
if packet is None:
continue
debug("data from queue: " + format(packet))
firebasePath = packet['config']['firebasePath']
if packet['config']['topicAsChild']:
firebasePath = urllib.parse.urljoin(packet['config']['firebasePath'] + '/', packet['topic'])
firebasePath = baseUrl + '/' + firebasePath + '.json'
debug ("Sending {0} to this URL {1}".format(packet['payload'], firebasePath))
retry = 0
while True:
try:
if not args.dryRun:
r = firebaseSession.post(firebasePath, json=packet['payload'], timeout=FIREBASE_TIMEOUT)
debug ("payload inserted : " + r.text)
except requests.exceptions.Timeout:
print ("Firebase Timeout")
if retry < FIREBASE_MAX_RETRY:
retry += 1
debug ("Retrying")
time.sleep(NOTHING_TO_DO_DELAY)
continue
except requests.exceptions.RequestException as e:
print ("Firebase Exception" + str(e))
except:
print ("Firebase Unknown Exception")
break
queue.task_done()
firebaseSession.close()
debug("Stopping Firebase Thread ...")
class ExternalVpnGatewaysRestTransport(ExternalVpnGatewaysTransport):
"""REST backend transport for ExternalVpnGateways.
The ExternalVpnGateways 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
"""
_STUBS: Dict[str, ExternalVpnGatewaysRestStub] = {}
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,
url_scheme: str = "https",
) -> 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 are developing
your own client library.
always_use_jwt_access (Optional[bool]): Whether self signed JWT should
be used for service account credentials.
url_scheme: the protocol scheme for the API endpoint. Normally
"https", but for testing or local servers,
"http" can be specified.
"""
# 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)
class _Delete(ExternalVpnGatewaysRestStub):
def __hash__(self):
return hash("Delete")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.DeleteExternalVpnGatewayRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete method over HTTP.
Args:
request (~.compute.DeleteExternalVpnGatewayRequest):
The request object. A request message for
ExternalVpnGateways.Delete. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "delete",
"uri": "/compute/v1/projects/{project}/global/externalVpnGateways/{external_vpn_gateway}",
},
]
request_kwargs = compute.DeleteExternalVpnGatewayRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.DeleteExternalVpnGatewayRequest.to_json(
compute.DeleteExternalVpnGatewayRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
)
class _Get(ExternalVpnGatewaysRestStub):
def __hash__(self):
return hash("Get")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.GetExternalVpnGatewayRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.ExternalVpnGateway:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetExternalVpnGatewayRequest):
The request object. A request message for
ExternalVpnGateways.Get. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.ExternalVpnGateway:
Represents an external VPN gateway.
External VPN gateway is the on-premises
VPN gateway(s) or another cloud
provider's VPN gateway that connects to
your Google Cloud VPN gateway. To create
a highly available VPN from Google Cloud
Platform to your VPN gateway or another
cloud provider's VPN gateway, you must
create a external VPN gateway resource
with information about the other
gateway. For more information about
using external VPN gateways, see
Creating an HA VPN gateway and tunnel
pair to a peer VPN.
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/global/externalVpnGateways/{external_vpn_gateway}",
},
]
request_kwargs = compute.GetExternalVpnGatewayRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.GetExternalVpnGatewayRequest.to_json(
compute.GetExternalVpnGatewayRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.ExternalVpnGateway.from_json(
response.content, ignore_unknown_fields=True
)
class _Insert(ExternalVpnGatewaysRestStub):
def __hash__(self):
return hash("Insert")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.InsertExternalVpnGatewayRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the insert method over HTTP.
Args:
request (~.compute.InsertExternalVpnGatewayRequest):
The request object. A request message for
ExternalVpnGateways.Insert. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "post",
"uri": "/compute/v1/projects/{project}/global/externalVpnGateways",
"body": "external_vpn_gateway_resource",
},
]
request_kwargs = compute.InsertExternalVpnGatewayRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
# Jsonify the request body
body = compute.ExternalVpnGateway.to_json(
compute.ExternalVpnGateway(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.InsertExternalVpnGatewayRequest.to_json(
compute.InsertExternalVpnGatewayRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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 _List(ExternalVpnGatewaysRestStub):
def __hash__(self):
return hash("List")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.ListExternalVpnGatewaysRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.ExternalVpnGatewayList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListExternalVpnGatewaysRequest):
The request object. A request message for
ExternalVpnGateways.List. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.ExternalVpnGatewayList:
Response to the list request, and
contains a list of externalVpnGateways.
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/global/externalVpnGateways",
},
]
request_kwargs = compute.ListExternalVpnGatewaysRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.ListExternalVpnGatewaysRequest.to_json(
compute.ListExternalVpnGatewaysRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.ExternalVpnGatewayList.from_json(
response.content, ignore_unknown_fields=True
)
class _SetLabels(ExternalVpnGatewaysRestStub):
def __hash__(self):
return hash("SetLabels")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.SetLabelsExternalVpnGatewayRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the set labels method over HTTP.
Args:
request (~.compute.SetLabelsExternalVpnGatewayRequest):
The request object. A request message for
ExternalVpnGateways.SetLabels. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "post",
"uri": "/compute/v1/projects/{project}/global/externalVpnGateways/{resource}/setLabels",
"body": "global_set_labels_request_resource",
},
]
request_kwargs = compute.SetLabelsExternalVpnGatewayRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
# Jsonify the request body
body = compute.GlobalSetLabelsRequest.to_json(
compute.GlobalSetLabelsRequest(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.SetLabelsExternalVpnGatewayRequest.to_json(
compute.SetLabelsExternalVpnGatewayRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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 _TestIamPermissions(ExternalVpnGatewaysRestStub):
def __hash__(self):
return hash("TestIamPermissions")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.TestIamPermissionsExternalVpnGatewayRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.TestPermissionsResponse:
r"""Call the test iam permissions method over HTTP.
Args:
request (~.compute.TestIamPermissionsExternalVpnGatewayRequest):
The request object. A request message for
ExternalVpnGateways.TestIamPermissions.
See the method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.TestPermissionsResponse:
"""
http_options = [
{
"method": "post",
"uri": "/compute/v1/projects/{project}/global/externalVpnGateways/{resource}/testIamPermissions",
"body": "test_permissions_request_resource",
},
]
request_kwargs = compute.TestIamPermissionsExternalVpnGatewayRequest.to_dict(
request
)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
# Jsonify the request body
body = compute.TestPermissionsRequest.to_json(
compute.TestPermissionsRequest(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.TestIamPermissionsExternalVpnGatewayRequest.to_json(
compute.TestIamPermissionsExternalVpnGatewayRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
)
@property
def delete(
self,
) -> Callable[[compute.DeleteExternalVpnGatewayRequest], compute.Operation]:
stub = self._STUBS.get("delete")
if not stub:
stub = self._STUBS["delete"] = self._Delete(self._session, self._host)
return stub
@property
def get(
self,
) -> Callable[[compute.GetExternalVpnGatewayRequest], compute.ExternalVpnGateway]:
stub = self._STUBS.get("get")
if not stub:
stub = self._STUBS["get"] = self._Get(self._session, self._host)
return stub
@property
def insert(
self,
) -> Callable[[compute.InsertExternalVpnGatewayRequest], compute.Operation]:
stub = self._STUBS.get("insert")
if not stub:
stub = self._STUBS["insert"] = self._Insert(self._session, self._host)
return stub
@property
def list(
self,
) -> Callable[
[compute.ListExternalVpnGatewaysRequest], compute.ExternalVpnGatewayList
]:
stub = self._STUBS.get("list")
if not stub:
stub = self._STUBS["list"] = self._List(self._session, self._host)
return stub
@property
def set_labels(
self,
) -> Callable[[compute.SetLabelsExternalVpnGatewayRequest], compute.Operation]:
stub = self._STUBS.get("set_labels")
if not stub:
stub = self._STUBS["set_labels"] = self._SetLabels(
self._session, self._host
)
return stub
@property
def test_iam_permissions(
self,
) -> Callable[
[compute.TestIamPermissionsExternalVpnGatewayRequest],
compute.TestPermissionsResponse,
]:
stub = self._STUBS.get("test_iam_permissions")
if not stub:
stub = self._STUBS["test_iam_permissions"] = self._TestIamPermissions(
self._session, self._host
)
return stub
def close(self):
self._session.close()
class ZonesRestTransport(ZonesTransport):
"""REST backend transport for Zones.
The Zones 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
"""
_STUBS: Dict[str, ZonesRestStub] = {}
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,
url_scheme: str = "https",
) -> 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 are developing
your own client library.
always_use_jwt_access (Optional[bool]): Whether self signed JWT should
be used for service account credentials.
url_scheme: the protocol scheme for the API endpoint. Normally
"https", but for testing or local servers,
"http" can be specified.
"""
# 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)
class _Get(ZonesRestStub):
def __hash__(self):
return hash("Get")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.GetZoneRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Zone:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetZoneRequest):
The request object. A request message for Zones.Get. See
the method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Zone:
Represents a Zone resource. A zone is
a deployment area. These deployment
areas are subsets of a region. For
example the zone us-east1-a is located
in the us-east1 region. For more
information, read Regions and Zones.
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/zones/{zone}",
},
]
request_kwargs = compute.GetZoneRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.GetZoneRequest.to_json(
compute.GetZoneRequest(transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.Zone.from_json(response.content,
ignore_unknown_fields=True)
class _List(ZonesRestStub):
def __hash__(self):
return hash("List")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.ListZonesRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.ZoneList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListZonesRequest):
The request object. A request message for Zones.List. See
the method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.ZoneList:
Contains a list of zone resources.
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/zones",
},
]
request_kwargs = compute.ListZonesRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.ListZonesRequest.to_json(
compute.ListZonesRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.ZoneList.from_json(response.content,
ignore_unknown_fields=True)
@property
def get(self) -> Callable[[compute.GetZoneRequest], compute.Zone]:
stub = self._STUBS.get("get")
if not stub:
stub = self._STUBS["get"] = self._Get(self._session, self._host)
return stub
@property
def list(self) -> Callable[[compute.ListZonesRequest], compute.ZoneList]:
stub = self._STUBS.get("list")
if not stub:
stub = self._STUBS["list"] = self._List(self._session, self._host)
return stub
def close(self):
self._session.close()
class ReservationsRestTransport(ReservationsTransport):
"""REST backend transport for Reservations.
The Reservations 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
"""
_STUBS: Dict[str, ReservationsRestStub] = {}
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,
url_scheme: str = "https",
) -> 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 are developing
your own client library.
always_use_jwt_access (Optional[bool]): Whether self signed JWT should
be used for service account credentials.
url_scheme: the protocol scheme for the API endpoint. Normally
"https", but for testing or local servers,
"http" can be specified.
"""
# 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)
class _AggregatedList(ReservationsRestStub):
def __hash__(self):
return hash("AggregatedList")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.AggregatedListReservationsRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.ReservationAggregatedList:
r"""Call the aggregated list method over HTTP.
Args:
request (~.compute.AggregatedListReservationsRequest):
The request object. A request message for
Reservations.AggregatedList. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.ReservationAggregatedList:
Contains a list of reservations.
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/aggregated/reservations",
},
]
request_kwargs = compute.AggregatedListReservationsRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.AggregatedListReservationsRequest.to_json(
compute.AggregatedListReservationsRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.ReservationAggregatedList.from_json(
response.content, ignore_unknown_fields=True
)
class _Delete(ReservationsRestStub):
def __hash__(self):
return hash("Delete")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.DeleteReservationRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete method over HTTP.
Args:
request (~.compute.DeleteReservationRequest):
The request object. A request message for
Reservations.Delete. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "delete",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations/{reservation}",
},
]
request_kwargs = compute.DeleteReservationRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.DeleteReservationRequest.to_json(
compute.DeleteReservationRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
)
class _Get(ReservationsRestStub):
def __hash__(self):
return hash("Get")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.GetReservationRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Reservation:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetReservationRequest):
The request object. A request message for
Reservations.Get. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.Reservation:
Represents a reservation resource. A
reservation ensures that capacity is
held in a specific zone even if the
reserved VMs are not running. For more
information, read Reserving zonal
resources.
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations/{reservation}",
},
]
request_kwargs = compute.GetReservationRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.GetReservationRequest.to_json(
compute.GetReservationRequest(transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.Reservation.from_json(
response.content, ignore_unknown_fields=True
)
class _GetIamPolicy(ReservationsRestStub):
def __hash__(self):
return hash("GetIamPolicy")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.GetIamPolicyReservationRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Policy:
r"""Call the get iam policy method over HTTP.
Args:
request (~.compute.GetIamPolicyReservationRequest):
The request object. A request message for
Reservations.GetIamPolicy. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/>`__.
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations/{resource}/getIamPolicy",
},
]
request_kwargs = compute.GetIamPolicyReservationRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.GetIamPolicyReservationRequest.to_json(
compute.GetIamPolicyReservationRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
)
class _Insert(ReservationsRestStub):
def __hash__(self):
return hash("Insert")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.InsertReservationRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the insert method over HTTP.
Args:
request (~.compute.InsertReservationRequest):
The request object. A request message for
Reservations.Insert. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "post",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations",
"body": "reservation_resource",
},
]
request_kwargs = compute.InsertReservationRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
# Jsonify the request body
body = compute.Reservation.to_json(
compute.Reservation(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.InsertReservationRequest.to_json(
compute.InsertReservationRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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 _List(ReservationsRestStub):
def __hash__(self):
return hash("List")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.ListReservationsRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.ReservationList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListReservationsRequest):
The request object. A request message for
Reservations.List. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.ReservationList:
"""
http_options = [
{
"method": "get",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations",
},
]
request_kwargs = compute.ListReservationsRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.ListReservationsRequest.to_json(
compute.ListReservationsRequest(transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.ReservationList.from_json(
response.content, ignore_unknown_fields=True
)
class _Resize(ReservationsRestStub):
def __hash__(self):
return hash("Resize")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.ResizeReservationRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the resize method over HTTP.
Args:
request (~.compute.ResizeReservationRequest):
The request object. A request message for
Reservations.Resize. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "post",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations/{reservation}/resize",
"body": "reservations_resize_request_resource",
},
]
request_kwargs = compute.ResizeReservationRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
# Jsonify the request body
body = compute.ReservationsResizeRequest.to_json(
compute.ReservationsResizeRequest(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.ResizeReservationRequest.to_json(
compute.ResizeReservationRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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 _SetIamPolicy(ReservationsRestStub):
def __hash__(self):
return hash("SetIamPolicy")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.SetIamPolicyReservationRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Policy:
r"""Call the set iam policy method over HTTP.
Args:
request (~.compute.SetIamPolicyReservationRequest):
The request object. A request message for
Reservations.SetIamPolicy. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/>`__.
"""
http_options = [
{
"method": "post",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations/{resource}/setIamPolicy",
"body": "zone_set_policy_request_resource",
},
]
request_kwargs = compute.SetIamPolicyReservationRequest.to_dict(request)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
# Jsonify the request body
body = compute.ZoneSetPolicyRequest.to_json(
compute.ZoneSetPolicyRequest(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.SetIamPolicyReservationRequest.to_json(
compute.SetIamPolicyReservationRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
)
class _TestIamPermissions(ReservationsRestStub):
def __hash__(self):
return hash("TestIamPermissions")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.TestIamPermissionsReservationRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.TestPermissionsResponse:
r"""Call the test iam permissions method over HTTP.
Args:
request (~.compute.TestIamPermissionsReservationRequest):
The request object. A request message for
Reservations.TestIamPermissions. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.TestPermissionsResponse:
"""
http_options = [
{
"method": "post",
"uri": "/compute/v1/projects/{project}/zones/{zone}/reservations/{resource}/testIamPermissions",
"body": "test_permissions_request_resource",
},
]
request_kwargs = compute.TestIamPermissionsReservationRequest.to_dict(
request
)
transcoded_request = path_template.transcode(http_options, **request_kwargs)
# Jsonify the request body
body = compute.TestPermissionsRequest.to_json(
compute.TestPermissionsRequest(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.TestIamPermissionsReservationRequest.to_json(
compute.TestIamPermissionsReservationRequest(
transcoded_request["query_params"]
),
including_default_value_fields=False,
use_integers_for_enums=False,
)
)
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
)
@property
def aggregated_list(
self,
) -> Callable[
[compute.AggregatedListReservationsRequest], compute.ReservationAggregatedList
]:
stub = self._STUBS.get("aggregated_list")
if not stub:
stub = self._STUBS["aggregated_list"] = self._AggregatedList(
self._session, self._host
)
return stub
@property
def delete(self) -> Callable[[compute.DeleteReservationRequest], compute.Operation]:
stub = self._STUBS.get("delete")
if not stub:
stub = self._STUBS["delete"] = self._Delete(self._session, self._host)
return stub
@property
def get(self) -> Callable[[compute.GetReservationRequest], compute.Reservation]:
stub = self._STUBS.get("get")
if not stub:
stub = self._STUBS["get"] = self._Get(self._session, self._host)
return stub
@property
def get_iam_policy(
self,
) -> Callable[[compute.GetIamPolicyReservationRequest], compute.Policy]:
stub = self._STUBS.get("get_iam_policy")
if not stub:
stub = self._STUBS["get_iam_policy"] = self._GetIamPolicy(
self._session, self._host
)
return stub
@property
def insert(self) -> Callable[[compute.InsertReservationRequest], compute.Operation]:
stub = self._STUBS.get("insert")
if not stub:
stub = self._STUBS["insert"] = self._Insert(self._session, self._host)
return stub
@property
def list(
self,
) -> Callable[[compute.ListReservationsRequest], compute.ReservationList]:
stub = self._STUBS.get("list")
if not stub:
stub = self._STUBS["list"] = self._List(self._session, self._host)
return stub
@property
def resize(self) -> Callable[[compute.ResizeReservationRequest], compute.Operation]:
stub = self._STUBS.get("resize")
if not stub:
stub = self._STUBS["resize"] = self._Resize(self._session, self._host)
return stub
@property
def set_iam_policy(
self,
) -> Callable[[compute.SetIamPolicyReservationRequest], compute.Policy]:
stub = self._STUBS.get("set_iam_policy")
if not stub:
stub = self._STUBS["set_iam_policy"] = self._SetIamPolicy(
self._session, self._host
)
return stub
@property
def test_iam_permissions(
self,
) -> Callable[
[compute.TestIamPermissionsReservationRequest], compute.TestPermissionsResponse
]:
stub = self._STUBS.get("test_iam_permissions")
if not stub:
stub = self._STUBS["test_iam_permissions"] = self._TestIamPermissions(
self._session, self._host
)
return stub
def close(self):
self._session.close()
class LoggingServiceV2RestTransport(LoggingServiceV2Transport):
"""REST backend transport for LoggingServiceV2.
Service for ingesting and querying logs.
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
"""
_STUBS: Dict[str, LoggingServiceV2RestStub] = {}
def __init__(
self,
*,
host: str = 'logging.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,
url_scheme: str = 'https',
interceptor: Optional[LoggingServiceV2RestInterceptor] = None,
) -> 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 are developing
your own client library.
always_use_jwt_access (Optional[bool]): Whether self signed JWT should
be used for service account credentials.
url_scheme: the protocol scheme for the API endpoint. Normally
"https", but for testing or local servers,
"http" can be specified.
"""
# 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
maybe_url_match = re.match("^(?P<scheme>http(?:s)?://)?(?P<host>.*)$",
host)
if maybe_url_match is None:
raise ValueError(
f"Unexpected hostname structure: {host}") # pragma: NO COVER
url_match_items = maybe_url_match.groupdict()
host = f"{url_scheme}://{host}" if not url_match_items[
"scheme"] else host
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._interceptor = interceptor or LoggingServiceV2RestInterceptor()
self._prep_wrapped_messages(client_info)
class _DeleteLog(LoggingServiceV2RestStub):
def __hash__(self):
return hash("DeleteLog")
__REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: logging.DeleteLogRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
):
r"""Call the delete log method over HTTP.
Args:
request (~.logging.DeleteLogRequest):
The request object. The parameters to DeleteLog.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
"""
http_options: List[Dict[str, str]] = [
{
'method': 'delete',
'uri': '/v2/{log_name=projects/*/logs/*}',
},
{
'method': 'delete',
'uri': '/v2/{log_name=*/*/logs/*}',
},
{
'method': 'delete',
'uri': '/v2/{log_name=organizations/*/logs/*}',
},
{
'method': 'delete',
'uri': '/v2/{log_name=folders/*/logs/*}',
},
{
'method': 'delete',
'uri': '/v2/{log_name=billingAccounts/*/logs/*}',
},
]
request, metadata = self._interceptor.pre_delete_log(
request, metadata)
request_kwargs = logging.DeleteLogRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request['uri']
method = transcoded_request['method']
# Jsonify the query params
query_params = json.loads(
logging.DeleteLogRequest.to_json(
logging.DeleteLogRequest(
transcoded_request['query_params']),
including_default_value_fields=False,
use_integers_for_enums=False))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers['Content-Type'] = 'application/json'
response = getattr(self._session, method)(
"{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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)
class _ListLogEntries(LoggingServiceV2RestStub):
def __hash__(self):
return hash("ListLogEntries")
__REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: logging.ListLogEntriesRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> logging.ListLogEntriesResponse:
r"""Call the list log entries method over HTTP.
Args:
request (~.logging.ListLogEntriesRequest):
The request object. The parameters to ``ListLogEntries``.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.logging.ListLogEntriesResponse:
Result returned from ``ListLogEntries``.
"""
http_options: List[Dict[str, str]] = [
{
'method': 'post',
'uri': '/v2beta1/entries:list',
'body': '*',
},
{
'method': 'post',
'uri': '/v2/entries:list',
'body': '*',
},
]
request, metadata = self._interceptor.pre_list_log_entries(
request, metadata)
request_kwargs = logging.ListLogEntriesRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
# Jsonify the request body
body = logging.ListLogEntriesRequest.to_json(
logging.ListLogEntriesRequest(transcoded_request['body']),
including_default_value_fields=False,
use_integers_for_enums=False)
uri = transcoded_request['uri']
method = transcoded_request['method']
# Jsonify the query params
query_params = json.loads(
logging.ListLogEntriesRequest.to_json(
logging.ListLogEntriesRequest(
transcoded_request['query_params']),
including_default_value_fields=False,
use_integers_for_enums=False))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers['Content-Type'] = 'application/json'
response = getattr(self._session, method)(
"{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
resp = logging.ListLogEntriesResponse.from_json(
response.content, ignore_unknown_fields=True)
resp = self._interceptor.post_list_log_entries(resp)
return resp
class _ListLogs(LoggingServiceV2RestStub):
def __hash__(self):
return hash("ListLogs")
__REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: logging.ListLogsRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> logging.ListLogsResponse:
r"""Call the list logs method over HTTP.
Args:
request (~.logging.ListLogsRequest):
The request object. The parameters to ListLogs.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.logging.ListLogsResponse:
Result returned from ListLogs.
"""
http_options: List[Dict[str, str]] = [
{
'method': 'get',
'uri': '/v2/{parent=*/*}/logs',
},
{
'method': 'get',
'uri': '/v2/{parent=projects/*}/logs',
},
{
'method': 'get',
'uri': '/v2/{parent=organizations/*}/logs',
},
{
'method': 'get',
'uri': '/v2/{parent=folders/*}/logs',
},
{
'method': 'get',
'uri': '/v2/{parent=billingAccounts/*}/logs',
},
{
'method':
'get',
'uri':
'/v2/{parent=projects/*/locations/*/buckets/*/views/*}/logs',
},
{
'method':
'get',
'uri':
'/v2/{parent=organizations/*/locations/*/buckets/*/views/*}/logs',
},
{
'method':
'get',
'uri':
'/v2/{parent=folders/*/locations/*/buckets/*/views/*}/logs',
},
{
'method':
'get',
'uri':
'/v2/{parent=billingAccounts/*/locations/*/buckets/*/views/*}/logs',
},
]
request, metadata = self._interceptor.pre_list_logs(
request, metadata)
request_kwargs = logging.ListLogsRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request['uri']
method = transcoded_request['method']
# Jsonify the query params
query_params = json.loads(
logging.ListLogsRequest.to_json(
logging.ListLogsRequest(
transcoded_request['query_params']),
including_default_value_fields=False,
use_integers_for_enums=False))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers['Content-Type'] = 'application/json'
response = getattr(self._session, method)(
"{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
resp = logging.ListLogsResponse.from_json(
response.content, ignore_unknown_fields=True)
resp = self._interceptor.post_list_logs(resp)
return resp
class _ListMonitoredResourceDescriptors(LoggingServiceV2RestStub):
def __hash__(self):
return hash("ListMonitoredResourceDescriptors")
def __call__(
self,
request: logging.ListMonitoredResourceDescriptorsRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> logging.ListMonitoredResourceDescriptorsResponse:
r"""Call the list monitored resource
descriptors method over HTTP.
Args:
request (~.logging.ListMonitoredResourceDescriptorsRequest):
The request object. The parameters to
ListMonitoredResourceDescriptors
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.logging.ListMonitoredResourceDescriptorsResponse:
Result returned from
ListMonitoredResourceDescriptors.
"""
http_options: List[Dict[str, str]] = [
{
'method': 'get',
'uri': '/v2/monitoredResourceDescriptors',
},
]
request, metadata = self._interceptor.pre_list_monitored_resource_descriptors(
request, metadata)
request_kwargs = logging.ListMonitoredResourceDescriptorsRequest.to_dict(
request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request['uri']
method = transcoded_request['method']
# Jsonify the query params
query_params = json.loads(
logging.ListMonitoredResourceDescriptorsRequest.to_json(
logging.ListMonitoredResourceDescriptorsRequest(
transcoded_request['query_params']),
including_default_value_fields=False,
use_integers_for_enums=False))
# Send the request
headers = dict(metadata)
headers['Content-Type'] = 'application/json'
response = getattr(self._session, method)(
"{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
resp = logging.ListMonitoredResourceDescriptorsResponse.from_json(
response.content, ignore_unknown_fields=True)
resp = self._interceptor.post_list_monitored_resource_descriptors(
resp)
return resp
class _TailLogEntries(LoggingServiceV2RestStub):
def __hash__(self):
return hash("TailLogEntries")
def __call__(
self,
request: logging.TailLogEntriesRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> rest_streaming.ResponseIterator:
raise NotImplementedError(
"Client streaming over REST is not yet defined for python client"
)
class _WriteLogEntries(LoggingServiceV2RestStub):
def __hash__(self):
return hash("WriteLogEntries")
__REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, str] = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: logging.WriteLogEntriesRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> logging.WriteLogEntriesResponse:
r"""Call the write log entries method over HTTP.
Args:
request (~.logging.WriteLogEntriesRequest):
The request object. The parameters to WriteLogEntries.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.logging.WriteLogEntriesResponse:
Result returned from WriteLogEntries.
"""
http_options: List[Dict[str, str]] = [
{
'method': 'post',
'uri': '/v2/entries:write',
'body': '*',
},
{
'method': 'post',
'uri': '/v2beta1/entries:write',
'body': '*',
},
]
request, metadata = self._interceptor.pre_write_log_entries(
request, metadata)
request_kwargs = logging.WriteLogEntriesRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
# Jsonify the request body
body = logging.WriteLogEntriesRequest.to_json(
logging.WriteLogEntriesRequest(transcoded_request['body']),
including_default_value_fields=False,
use_integers_for_enums=False)
uri = transcoded_request['uri']
method = transcoded_request['method']
# Jsonify the query params
query_params = json.loads(
logging.WriteLogEntriesRequest.to_json(
logging.WriteLogEntriesRequest(
transcoded_request['query_params']),
including_default_value_fields=False,
use_integers_for_enums=False))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers['Content-Type'] = 'application/json'
response = getattr(self._session, method)(
"{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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
resp = logging.WriteLogEntriesResponse.from_json(
response.content, ignore_unknown_fields=True)
resp = self._interceptor.post_write_log_entries(resp)
return resp
@property
def delete_log(
self) -> Callable[[logging.DeleteLogRequest], empty_pb2.Empty]:
stub = self._STUBS.get("delete_log")
if not stub:
stub = self._STUBS["delete_log"] = self._DeleteLog(
self._session, self._host, self._interceptor)
# The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
# In C++ this would require a dynamic_cast
return stub # type: ignore
@property
def list_log_entries(
self
) -> Callable[[logging.ListLogEntriesRequest],
logging.ListLogEntriesResponse]:
stub = self._STUBS.get("list_log_entries")
if not stub:
stub = self._STUBS["list_log_entries"] = self._ListLogEntries(
self._session, self._host, self._interceptor)
# The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
# In C++ this would require a dynamic_cast
return stub # type: ignore
@property
def list_logs(
self
) -> Callable[[logging.ListLogsRequest], logging.ListLogsResponse]:
stub = self._STUBS.get("list_logs")
if not stub:
stub = self._STUBS["list_logs"] = self._ListLogs(
self._session, self._host, self._interceptor)
# The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
# In C++ this would require a dynamic_cast
return stub # type: ignore
@property
def list_monitored_resource_descriptors(
self
) -> Callable[[logging.ListMonitoredResourceDescriptorsRequest],
logging.ListMonitoredResourceDescriptorsResponse]:
stub = self._STUBS.get("list_monitored_resource_descriptors")
if not stub:
stub = self._STUBS[
"list_monitored_resource_descriptors"] = self._ListMonitoredResourceDescriptors(
self._session, self._host, self._interceptor)
# The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
# In C++ this would require a dynamic_cast
return stub # type: ignore
@property
def tail_log_entries(
self
) -> Callable[[logging.TailLogEntriesRequest],
logging.TailLogEntriesResponse]:
stub = self._STUBS.get("tail_log_entries")
if not stub:
stub = self._STUBS["tail_log_entries"] = self._TailLogEntries(
self._session, self._host, self._interceptor)
# The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
# In C++ this would require a dynamic_cast
return stub # type: ignore
@property
def write_log_entries(
self
) -> Callable[[logging.WriteLogEntriesRequest],
logging.WriteLogEntriesResponse]:
stub = self._STUBS.get("write_log_entries")
if not stub:
stub = self._STUBS["write_log_entries"] = self._WriteLogEntries(
self._session, self._host, self._interceptor)
# The return type is fine, but mypy isn't sophisticated enough to determine what's going on here.
# In C++ this would require a dynamic_cast
return stub # type: ignore
def close(self):
self._session.close()
class HealthChecksRestTransport(HealthChecksTransport):
"""REST backend transport for HealthChecks.
The HealthChecks 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
"""
_STUBS: Dict[str, HealthChecksRestStub] = {}
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,
url_scheme: str = "https",
) -> 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 are developing
your own client library.
always_use_jwt_access (Optional[bool]): Whether self signed JWT should
be used for service account credentials.
url_scheme: the protocol scheme for the API endpoint. Normally
"https", but for testing or local servers,
"http" can be specified.
"""
# 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)
class _AggregatedList(HealthChecksRestStub):
def __hash__(self):
return hash("AggregatedList")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.AggregatedListHealthChecksRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.HealthChecksAggregatedList:
r"""Call the aggregated list method over HTTP.
Args:
request (~.compute.AggregatedListHealthChecksRequest):
The request object. A request message for
HealthChecks.AggregatedList. See the
method description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.HealthChecksAggregatedList:
"""
http_options = [
{
"method":
"get",
"uri":
"/compute/v1/projects/{project}/aggregated/healthChecks",
},
]
request_kwargs = compute.AggregatedListHealthChecksRequest.to_dict(
request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.AggregatedListHealthChecksRequest.to_json(
compute.AggregatedListHealthChecksRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.HealthChecksAggregatedList.from_json(
response.content, ignore_unknown_fields=True)
class _Delete(HealthChecksRestStub):
def __hash__(self):
return hash("Delete")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.DeleteHealthCheckRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the delete method over HTTP.
Args:
request (~.compute.DeleteHealthCheckRequest):
The request object. A request message for
HealthChecks.Delete. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method":
"delete",
"uri":
"/compute/v1/projects/{project}/global/healthChecks/{health_check}",
},
]
request_kwargs = compute.DeleteHealthCheckRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.DeleteHealthCheckRequest.to_json(
compute.DeleteHealthCheckRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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)
class _Get(HealthChecksRestStub):
def __hash__(self):
return hash("Get")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.GetHealthCheckRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.HealthCheck:
r"""Call the get method over HTTP.
Args:
request (~.compute.GetHealthCheckRequest):
The request object. A request message for
HealthChecks.Get. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.HealthCheck:
Represents a Health Check resource. Google Compute
Engine has two Health Check resources: \*
`Global </compute/docs/reference/rest/v1/healthChecks>`__
\*
`Regional </compute/docs/reference/rest/v1/regionHealthChecks>`__
Internal HTTP(S) load balancers must use regional health
checks (``compute.v1.regionHealthChecks``). Traffic
Director must use global health checks
(``compute.v1.HealthChecks``). Internal TCP/UDP load
balancers can use either regional or global health
checks (``compute.v1.regionHealthChecks`` or
``compute.v1.HealthChecks``). External HTTP(S), TCP
proxy, and SSL proxy load balancers as well as managed
instance group auto-healing must use global health
checks (``compute.v1.HealthChecks``). Backend
service-based network load balancers must use regional
health checks (``compute.v1.regionHealthChecks``).
Target pool-based network load balancers must use legacy
HTTP health checks (``compute.v1.httpHealthChecks``).
For more information, see Health checks overview.
"""
http_options = [
{
"method":
"get",
"uri":
"/compute/v1/projects/{project}/global/healthChecks/{health_check}",
},
]
request_kwargs = compute.GetHealthCheckRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.GetHealthCheckRequest.to_json(
compute.GetHealthCheckRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.HealthCheck.from_json(response.content,
ignore_unknown_fields=True)
class _Insert(HealthChecksRestStub):
def __hash__(self):
return hash("Insert")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.InsertHealthCheckRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the insert method over HTTP.
Args:
request (~.compute.InsertHealthCheckRequest):
The request object. A request message for
HealthChecks.Insert. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "post",
"uri":
"/compute/v1/projects/{project}/global/healthChecks",
"body": "health_check_resource",
},
]
request_kwargs = compute.InsertHealthCheckRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
# Jsonify the request body
body = compute.HealthCheck.to_json(
compute.HealthCheck(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.InsertHealthCheckRequest.to_json(
compute.InsertHealthCheckRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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 _List(HealthChecksRestStub):
def __hash__(self):
return hash("List")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.ListHealthChecksRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.HealthCheckList:
r"""Call the list method over HTTP.
Args:
request (~.compute.ListHealthChecksRequest):
The request object. A request message for
HealthChecks.List. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
metadata (Sequence[Tuple[str, str]]): Strings which should be
sent along with the request as metadata.
Returns:
~.compute.HealthCheckList:
Contains a list of HealthCheck
resources.
"""
http_options = [
{
"method": "get",
"uri":
"/compute/v1/projects/{project}/global/healthChecks",
},
]
request_kwargs = compute.ListHealthChecksRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.ListHealthChecksRequest.to_json(
compute.ListHealthChecksRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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.HealthCheckList.from_json(
response.content, ignore_unknown_fields=True)
class _Patch(HealthChecksRestStub):
def __hash__(self):
return hash("Patch")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.PatchHealthCheckRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the patch method over HTTP.
Args:
request (~.compute.PatchHealthCheckRequest):
The request object. A request message for
HealthChecks.Patch. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "patch",
"uri":
"/compute/v1/projects/{project}/global/healthChecks/{health_check}",
"body": "health_check_resource",
},
]
request_kwargs = compute.PatchHealthCheckRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
# Jsonify the request body
body = compute.HealthCheck.to_json(
compute.HealthCheck(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.PatchHealthCheckRequest.to_json(
compute.PatchHealthCheckRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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 _Update(HealthChecksRestStub):
def __hash__(self):
return hash("Update")
__REQUIRED_FIELDS_DEFAULT_VALUES = {}
@classmethod
def _get_unset_required_fields(cls, message_dict):
return {
k: v
for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items()
if k not in message_dict
}
def __call__(
self,
request: compute.UpdateHealthCheckRequest,
*,
retry: OptionalRetry = gapic_v1.method.DEFAULT,
timeout: float = None,
metadata: Sequence[Tuple[str, str]] = (),
) -> compute.Operation:
r"""Call the update method over HTTP.
Args:
request (~.compute.UpdateHealthCheckRequest):
The request object. A request message for
HealthChecks.Update. See the method
description for details.
retry (google.api_core.retry.Retry): Designation of what errors, if any,
should be retried.
timeout (float): The timeout for this request.
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/v1/globalOperations>`__
\*
`Regional </compute/docs/reference/rest/v1/regionOperations>`__
\*
`Zonal </compute/docs/reference/rest/v1/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.
"""
http_options = [
{
"method": "put",
"uri":
"/compute/v1/projects/{project}/global/healthChecks/{health_check}",
"body": "health_check_resource",
},
]
request_kwargs = compute.UpdateHealthCheckRequest.to_dict(request)
transcoded_request = path_template.transcode(
http_options, **request_kwargs)
# Jsonify the request body
body = compute.HealthCheck.to_json(
compute.HealthCheck(transcoded_request["body"]),
including_default_value_fields=False,
use_integers_for_enums=False,
)
uri = transcoded_request["uri"]
method = transcoded_request["method"]
# Jsonify the query params
query_params = json.loads(
compute.UpdateHealthCheckRequest.to_json(
compute.UpdateHealthCheckRequest(
transcoded_request["query_params"]),
including_default_value_fields=False,
use_integers_for_enums=False,
))
query_params.update(self._get_unset_required_fields(query_params))
# Send the request
headers = dict(metadata)
headers["Content-Type"] = "application/json"
response = getattr(self._session, method)(
# Replace with proper schema configuration (http/https) logic
"https://{host}{uri}".format(host=self._host, uri=uri),
timeout=timeout,
headers=headers,
params=rest_helpers.flatten_query_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)
@property
def aggregated_list(
self,
) -> Callable[[compute.AggregatedListHealthChecksRequest],
compute.HealthChecksAggregatedList]:
stub = self._STUBS.get("aggregated_list")
if not stub:
stub = self._STUBS["aggregated_list"] = self._AggregatedList(
self._session, self._host)
return stub
@property
def delete(
self
) -> Callable[[compute.DeleteHealthCheckRequest], compute.Operation]:
stub = self._STUBS.get("delete")
if not stub:
stub = self._STUBS["delete"] = self._Delete(
self._session, self._host)
return stub
@property
def get(
self
) -> Callable[[compute.GetHealthCheckRequest], compute.HealthCheck]:
stub = self._STUBS.get("get")
if not stub:
stub = self._STUBS["get"] = self._Get(self._session, self._host)
return stub
@property
def insert(
self
) -> Callable[[compute.InsertHealthCheckRequest], compute.Operation]:
stub = self._STUBS.get("insert")
if not stub:
stub = self._STUBS["insert"] = self._Insert(
self._session, self._host)
return stub
@property
def list(
self,
) -> Callable[[compute.ListHealthChecksRequest], compute.HealthCheckList]:
stub = self._STUBS.get("list")
if not stub:
stub = self._STUBS["list"] = self._List(self._session, self._host)
return stub
@property
def patch(
self
) -> Callable[[compute.PatchHealthCheckRequest], compute.Operation]:
stub = self._STUBS.get("patch")
if not stub:
stub = self._STUBS["patch"] = self._Patch(self._session,
self._host)
return stub
@property
def update(
self
) -> Callable[[compute.UpdateHealthCheckRequest], compute.Operation]:
stub = self._STUBS.get("update")
if not stub:
stub = self._STUBS["update"] = self._Update(
self._session, self._host)
return stub
def close(self):
self._session.close()
class GooglePlayService(InAppService):
scopes = ['https://www.googleapis.com/auth/androidpublisher']
base_uri = 'https://www.googleapis.com/androidpublisher/v3/applications'
products_uri = '/%packageName%/inappproducts'
product_purchase_uri = '/%packageName%/purchases/products/%productId%/tokens/%token%'
subscription_purchase_uri = '/%packageName%/purchases/subscriptions/%subscriptionId%/'+\
'tokens/%token%'
service_account_info = None
service_account_file = None
credentials = None
authed_session = None
package_name = None
def __init__(self,
service_account_info=None,
service_account_file=None,
package_name=None,
scopes=None,
base_uri=None,
products_uri=None,
product_purchase_uri=None,
subscription_purchase_uri=None):
if scopes is not None:
self.scopes = scopes
if base_uri is not None:
self.base_uri = base_uri
if products_uri is not None:
self.products_uri = products_uri
if product_purchase_uri is not None:
self.product_purchase_uri = product_purchase_uri
if subscription_purchase_uri is not None:
self.subscription_purchase_uri = subscription_purchase_uri
if service_account_info is not None:
self.service_account_info = service_account_info
if service_account_file is not None:
self.service_account_file = service_account_file
if package_name is not None:
self.package_name = package_name
if self.service_account_info is not None or self.service_account_file is not None:
self.authed_session = self.create_session()
def set_service_account_info(self, service_account_info):
self.service_account_info = service_account_info
return self
def set_service_account_file(self, service_account_file):
self.service_account_file = service_account_file
return self
def generate_credentials(self):
if self.service_account_info is not None:
self.credentials = service_account.Credentials.from_service_account_info(
self.service_account_info, scopes=self.scopes)
elif self.service_account_file is not None:
self.credentials = service_account.Credentials.from_service_account_file(
self.service_account_file, scopes=self.scopes)
return self.credentials
def create_session(self):
if self.credentials is None:
self.credentials = self.generate_credentials()
if self.credentials is not None:
self.authed_session = AuthorizedSession(self.credentials)
return self.authed_session
if not self.authed_session:
self.authed_session = None
return self.authed_session
def refresh_session(self):
self.authed_session = self.create_session()
def close_session(self):
return self.authed_session.close()
def get_products(self, package_name=None):
package_name = package_name if package_name is not None else self.package_name
response = self.request(
self.base_uri +
self.products_uri.replace('%packageName%', package_name))
return self.get_products_response(response)
def get_product_purchase(self, product_id, token, package_name=None):
package_name = package_name if package_name is not None else self.package_name
response = self.request(
self.base_uri +
self.product_purchase_uri.replace('%packageName%', package_name).
replace('%productId%', product_id).replace('%token%', token))
return self.get_product_response(response)
def get_subscription_purchase(self,
subscription_id,
token,
package_name=None):
package_name = package_name if package_name is not None else self.package_name
response = self.request(
self.base_uri + self.subscription_purchase_uri.
replace('%packageName%', package_name).replace(
'%subscriptionId%', subscription_id).replace('%token%', token))
return self.get_subscription_response(response,
additional_data={
'package_name':
package_name,
'subscription_id':
subscription_id
})
def request(self, query):
if self.authed_session is not None:
response = self.authed_session.get(query)
return response
else:
raise BaseException("authed_session is not defined")
def get_products_response(self, response, additional_data=None):
data = None
if response.ok:
data = response.json()['inappproduct']
return super(GooglePlayService,
self).get_products_response(response, data)
def get_product_response(self, response, additional_data=None):
data = None
if response.ok:
data = response.json()
return super(GooglePlayService,
self).get_product_response(response, data)
def get_subscription_response(self, response, additional_data=None):
data = None
try:
if response.ok:
response_data = response.json()
cancellation_date_ms = (
int(response_data['userCancellationTimeMillis'])
if 'userCancellationTimeMillis' in response_data else None)
cancellation_date = (int(cancellation_date_ms /
1000) if cancellation_date_ms
is not None else None)
expires_date_ms = (int(response_data['expiryTimeMillis'])
if 'expiryTimeMillis' in response_data else
None)
expires_date = (int(expires_date_ms / 1000)
if expires_date_ms is not None else None)
cancellation_reason = (response_data['cancelReason']
if 'cancelReason' in response_data else
None)
payment_state = (response_data['paymentState']
if 'paymentState' in response_data else None)
payment_state = (response_data['paymentState']
if 'paymentState' in response_data else None)
if cancellation_reason is None:
status = SubscriptionStatus.ACTIVE
elif cancellation_reason is not None:
status = SubscriptionStatus.CANCELLED
is_active = status == SubscriptionStatus.ACTIVE
data = {
'purchase_id':
response_data['orderId'],
'original_purchase_id':
response_data['orderId'],
'purchase_date_ms':
int(response_data['startTimeMillis']),
'purchase_date':
int(int(response_data['startTimeMillis']) / 1000),
'original_purchase_date_ms':
int(response_data['startTimeMillis']),
'original_purchase_date':
int(int(response_data['startTimeMillis']) / 1000),
'auto_renewing':
response_data['autoRenewing'],
'expires_date_ms':
expires_date_ms,
'expires_date':
expires_date,
'country_code':
response_data['countryCode'],
'price_currency_code':
response_data['priceCurrencyCode'],
'price_amount':
float(
int(int(response_data['priceAmountMicros']) / 1000) /
100),
'cancellation_date_ms':
cancellation_date_ms,
'cancellation_date':
cancellation_date,
'cancellation_reason':
cancellation_reason,
'payment_state':
payment_state,
'status':
status,
'is_active':
is_active,
'is_trial_period':
None,
'expiration_intent':
None
}
if additional_data is not None:
if 'package_name' in additional_data:
data.update(
{'bundle_id': additional_data['package_name']})
if 'subscription_id' in additional_data:
data.update({
'subscription_id':
additional_data['subscription_id']
})
return super(GooglePlayService,
self).get_subscription_response(response, data)
except Exception:
return super(GooglePlayService,
self).get_subscription_response(response)
