« prev ^ index » next coverage.py v7.3.2, created at 2023-12-08 06:45 +0000
1# -*- coding: utf-8 -*-
2# Copyright 2023 Google LLC
3#
4# Licensed under the Apache License, Version 2.0 (the "License");
5# you may not use this file except in compliance with the License.
6# You may obtain a copy of the License at
7#
8# http://www.apache.org/licenses/LICENSE-2.0
9#
10# Unless required by applicable law or agreed to in writing, software
11# distributed under the License is distributed on an "AS IS" BASIS,
12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13# See the License for the specific language governing permissions and
14# limitations under the License.
15#
16import warnings
17from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
19from google.api_core import gapic_v1
20from google.api_core import grpc_helpers_async
21from google.api_core import operations_v1
22from google.auth import credentials as ga_credentials # type: ignore
23from google.auth.transport.grpc import SslCredentials # type: ignore
25import grpc # type: ignore
26from grpc.experimental import aio # type: ignore
28from google.cloud.logging_v2.types import logging_config
29from google.longrunning import operations_pb2 # type: ignore
30from google.protobuf import empty_pb2 # type: ignore
31from .base import ConfigServiceV2Transport, DEFAULT_CLIENT_INFO
32from .grpc import ConfigServiceV2GrpcTransport
35class ConfigServiceV2GrpcAsyncIOTransport(ConfigServiceV2Transport):
36 """gRPC AsyncIO backend transport for ConfigServiceV2.
38 Service for configuring sinks used to route log entries.
40 This class defines the same methods as the primary client, so the
41 primary client can load the underlying transport implementation
42 and call it.
44 It sends protocol buffers over the wire using gRPC (which is built on
45 top of HTTP/2); the ``grpcio`` package must be installed.
46 """
48 _grpc_channel: aio.Channel
49 _stubs: Dict[str, Callable] = {}
51 @classmethod
52 def create_channel(
53 cls,
54 host: str = "logging.googleapis.com",
55 credentials: Optional[ga_credentials.Credentials] = None,
56 credentials_file: Optional[str] = None,
57 scopes: Optional[Sequence[str]] = None,
58 quota_project_id: Optional[str] = None,
59 **kwargs,
60 ) -> aio.Channel:
61 """Create and return a gRPC AsyncIO channel object.
62 Args:
63 host (Optional[str]): The host for the channel to use.
64 credentials (Optional[~.Credentials]): The
65 authorization credentials to attach to requests. These
66 credentials identify this application to the service. If
67 none are specified, the client will attempt to ascertain
68 the credentials from the environment.
69 credentials_file (Optional[str]): A file with credentials that can
70 be loaded with :func:`google.auth.load_credentials_from_file`.
71 This argument is ignored if ``channel`` is provided.
72 scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
73 service. These are only used when credentials are not specified and
74 are passed to :func:`google.auth.default`.
75 quota_project_id (Optional[str]): An optional project to use for billing
76 and quota.
77 kwargs (Optional[dict]): Keyword arguments, which are passed to the
78 channel creation.
79 Returns:
80 aio.Channel: A gRPC AsyncIO channel object.
81 """
83 return grpc_helpers_async.create_channel(
84 host,
85 credentials=credentials,
86 credentials_file=credentials_file,
87 quota_project_id=quota_project_id,
88 default_scopes=cls.AUTH_SCOPES,
89 scopes=scopes,
90 default_host=cls.DEFAULT_HOST,
91 **kwargs,
92 )
94 def __init__(
95 self,
96 *,
97 host: str = "logging.googleapis.com",
98 credentials: Optional[ga_credentials.Credentials] = None,
99 credentials_file: Optional[str] = None,
100 scopes: Optional[Sequence[str]] = None,
101 channel: Optional[aio.Channel] = None,
102 api_mtls_endpoint: Optional[str] = None,
103 client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
104 ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None,
105 client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None,
106 quota_project_id: Optional[str] = None,
107 client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
108 always_use_jwt_access: Optional[bool] = False,
109 api_audience: Optional[str] = None,
110 ) -> None:
111 """Instantiate the transport.
113 Args:
114 host (Optional[str]):
115 The hostname to connect to.
116 credentials (Optional[google.auth.credentials.Credentials]): The
117 authorization credentials to attach to requests. These
118 credentials identify the application to the service; if none
119 are specified, the client will attempt to ascertain the
120 credentials from the environment.
121 This argument is ignored if ``channel`` is provided.
122 credentials_file (Optional[str]): A file with credentials that can
123 be loaded with :func:`google.auth.load_credentials_from_file`.
124 This argument is ignored if ``channel`` is provided.
125 scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
126 service. These are only used when credentials are not specified and
127 are passed to :func:`google.auth.default`.
128 channel (Optional[aio.Channel]): A ``Channel`` instance through
129 which to make calls.
130 api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
131 If provided, it overrides the ``host`` argument and tries to create
132 a mutual TLS channel with client SSL credentials from
133 ``client_cert_source`` or application default SSL credentials.
134 client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
135 Deprecated. A callback to provide client SSL certificate bytes and
136 private key bytes, both in PEM format. It is ignored if
137 ``api_mtls_endpoint`` is None.
138 ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
139 for the grpc channel. It is ignored if ``channel`` is provided.
140 client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
141 A callback to provide client certificate bytes and private key bytes,
142 both in PEM format. It is used to configure a mutual TLS channel. It is
143 ignored if ``channel`` or ``ssl_channel_credentials`` is provided.
144 quota_project_id (Optional[str]): An optional project to use for billing
145 and quota.
146 client_info (google.api_core.gapic_v1.client_info.ClientInfo):
147 The client info used to send a user-agent string along with
148 API requests. If ``None``, then default info will be used.
149 Generally, you only need to set this if you're developing
150 your own client library.
151 always_use_jwt_access (Optional[bool]): Whether self signed JWT should
152 be used for service account credentials.
154 Raises:
155 google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
156 creation failed for any reason.
157 google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
158 and ``credentials_file`` are passed.
159 """
160 self._grpc_channel = None
161 self._ssl_channel_credentials = ssl_channel_credentials
162 self._stubs: Dict[str, Callable] = {}
163 self._operations_client: Optional[operations_v1.OperationsAsyncClient] = None
165 if api_mtls_endpoint:
166 warnings.warn("api_mtls_endpoint is deprecated", DeprecationWarning)
167 if client_cert_source:
168 warnings.warn("client_cert_source is deprecated", DeprecationWarning)
170 if channel:
171 # Ignore credentials if a channel was passed.
172 credentials = False
173 # If a channel was explicitly provided, set it.
174 self._grpc_channel = channel
175 self._ssl_channel_credentials = None
176 else:
177 if api_mtls_endpoint:
178 host = api_mtls_endpoint
180 # Create SSL credentials with client_cert_source or application
181 # default SSL credentials.
182 if client_cert_source:
183 cert, key = client_cert_source()
184 self._ssl_channel_credentials = grpc.ssl_channel_credentials(
185 certificate_chain=cert, private_key=key
186 )
187 else:
188 self._ssl_channel_credentials = SslCredentials().ssl_credentials
190 else:
191 if client_cert_source_for_mtls and not ssl_channel_credentials:
192 cert, key = client_cert_source_for_mtls()
193 self._ssl_channel_credentials = grpc.ssl_channel_credentials(
194 certificate_chain=cert, private_key=key
195 )
197 # The base transport sets the host, credentials and scopes
198 super().__init__(
199 host=host,
200 credentials=credentials,
201 credentials_file=credentials_file,
202 scopes=scopes,
203 quota_project_id=quota_project_id,
204 client_info=client_info,
205 always_use_jwt_access=always_use_jwt_access,
206 api_audience=api_audience,
207 )
209 if not self._grpc_channel:
210 self._grpc_channel = type(self).create_channel(
211 self._host,
212 # use the credentials which are saved
213 credentials=self._credentials,
214 # Set ``credentials_file`` to ``None`` here as
215 # the credentials that we saved earlier should be used.
216 credentials_file=None,
217 scopes=self._scopes,
218 ssl_credentials=self._ssl_channel_credentials,
219 quota_project_id=quota_project_id,
220 options=[
221 ("grpc.max_send_message_length", -1),
222 ("grpc.max_receive_message_length", -1),
223 ],
224 )
226 # Wrap messages. This must be done after self._grpc_channel exists
227 self._prep_wrapped_messages(client_info)
229 @property
230 def grpc_channel(self) -> aio.Channel:
231 """Create the channel designed to connect to this service.
233 This property caches on the instance; repeated calls return
234 the same channel.
235 """
236 # Return the channel from cache.
237 return self._grpc_channel
239 @property
240 def operations_client(self) -> operations_v1.OperationsAsyncClient:
241 """Create the client designed to process long-running operations.
243 This property caches on the instance; repeated calls return the same
244 client.
245 """
246 # Quick check: Only create a new client if we do not already have one.
247 if self._operations_client is None:
248 self._operations_client = operations_v1.OperationsAsyncClient(
249 self.grpc_channel
250 )
252 # Return the client from cache.
253 return self._operations_client
255 @property
256 def list_buckets(
257 self,
258 ) -> Callable[
259 [logging_config.ListBucketsRequest],
260 Awaitable[logging_config.ListBucketsResponse],
261 ]:
262 r"""Return a callable for the list buckets method over gRPC.
264 Lists log buckets.
266 Returns:
267 Callable[[~.ListBucketsRequest],
268 Awaitable[~.ListBucketsResponse]]:
269 A function that, when called, will call the underlying RPC
270 on the server.
271 """
272 # Generate a "stub function" on-the-fly which will actually make
273 # the request.
274 # gRPC handles serialization and deserialization, so we just need
275 # to pass in the functions for each.
276 if "list_buckets" not in self._stubs:
277 self._stubs["list_buckets"] = self.grpc_channel.unary_unary(
278 "/google.logging.v2.ConfigServiceV2/ListBuckets",
279 request_serializer=logging_config.ListBucketsRequest.serialize,
280 response_deserializer=logging_config.ListBucketsResponse.deserialize,
281 )
282 return self._stubs["list_buckets"]
284 @property
285 def get_bucket(
286 self,
287 ) -> Callable[
288 [logging_config.GetBucketRequest], Awaitable[logging_config.LogBucket]
289 ]:
290 r"""Return a callable for the get bucket method over gRPC.
292 Gets a log bucket.
294 Returns:
295 Callable[[~.GetBucketRequest],
296 Awaitable[~.LogBucket]]:
297 A function that, when called, will call the underlying RPC
298 on the server.
299 """
300 # Generate a "stub function" on-the-fly which will actually make
301 # the request.
302 # gRPC handles serialization and deserialization, so we just need
303 # to pass in the functions for each.
304 if "get_bucket" not in self._stubs:
305 self._stubs["get_bucket"] = self.grpc_channel.unary_unary(
306 "/google.logging.v2.ConfigServiceV2/GetBucket",
307 request_serializer=logging_config.GetBucketRequest.serialize,
308 response_deserializer=logging_config.LogBucket.deserialize,
309 )
310 return self._stubs["get_bucket"]
312 @property
313 def create_bucket_async(
314 self,
315 ) -> Callable[
316 [logging_config.CreateBucketRequest], Awaitable[operations_pb2.Operation]
317 ]:
318 r"""Return a callable for the create bucket async method over gRPC.
320 Creates a log bucket asynchronously that can be used
321 to store log entries.
322 After a bucket has been created, the bucket's location
323 cannot be changed.
325 Returns:
326 Callable[[~.CreateBucketRequest],
327 Awaitable[~.Operation]]:
328 A function that, when called, will call the underlying RPC
329 on the server.
330 """
331 # Generate a "stub function" on-the-fly which will actually make
332 # the request.
333 # gRPC handles serialization and deserialization, so we just need
334 # to pass in the functions for each.
335 if "create_bucket_async" not in self._stubs:
336 self._stubs["create_bucket_async"] = self.grpc_channel.unary_unary(
337 "/google.logging.v2.ConfigServiceV2/CreateBucketAsync",
338 request_serializer=logging_config.CreateBucketRequest.serialize,
339 response_deserializer=operations_pb2.Operation.FromString,
340 )
341 return self._stubs["create_bucket_async"]
343 @property
344 def update_bucket_async(
345 self,
346 ) -> Callable[
347 [logging_config.UpdateBucketRequest], Awaitable[operations_pb2.Operation]
348 ]:
349 r"""Return a callable for the update bucket async method over gRPC.
351 Updates a log bucket asynchronously.
353 If the bucket has a ``lifecycle_state`` of ``DELETE_REQUESTED``,
354 then ``FAILED_PRECONDITION`` will be returned.
356 After a bucket has been created, the bucket's location cannot be
357 changed.
359 Returns:
360 Callable[[~.UpdateBucketRequest],
361 Awaitable[~.Operation]]:
362 A function that, when called, will call the underlying RPC
363 on the server.
364 """
365 # Generate a "stub function" on-the-fly which will actually make
366 # the request.
367 # gRPC handles serialization and deserialization, so we just need
368 # to pass in the functions for each.
369 if "update_bucket_async" not in self._stubs:
370 self._stubs["update_bucket_async"] = self.grpc_channel.unary_unary(
371 "/google.logging.v2.ConfigServiceV2/UpdateBucketAsync",
372 request_serializer=logging_config.UpdateBucketRequest.serialize,
373 response_deserializer=operations_pb2.Operation.FromString,
374 )
375 return self._stubs["update_bucket_async"]
377 @property
378 def create_bucket(
379 self,
380 ) -> Callable[
381 [logging_config.CreateBucketRequest], Awaitable[logging_config.LogBucket]
382 ]:
383 r"""Return a callable for the create bucket method over gRPC.
385 Creates a log bucket that can be used to store log
386 entries. After a bucket has been created, the bucket's
387 location cannot be changed.
389 Returns:
390 Callable[[~.CreateBucketRequest],
391 Awaitable[~.LogBucket]]:
392 A function that, when called, will call the underlying RPC
393 on the server.
394 """
395 # Generate a "stub function" on-the-fly which will actually make
396 # the request.
397 # gRPC handles serialization and deserialization, so we just need
398 # to pass in the functions for each.
399 if "create_bucket" not in self._stubs:
400 self._stubs["create_bucket"] = self.grpc_channel.unary_unary(
401 "/google.logging.v2.ConfigServiceV2/CreateBucket",
402 request_serializer=logging_config.CreateBucketRequest.serialize,
403 response_deserializer=logging_config.LogBucket.deserialize,
404 )
405 return self._stubs["create_bucket"]
407 @property
408 def update_bucket(
409 self,
410 ) -> Callable[
411 [logging_config.UpdateBucketRequest], Awaitable[logging_config.LogBucket]
412 ]:
413 r"""Return a callable for the update bucket method over gRPC.
415 Updates a log bucket.
417 If the bucket has a ``lifecycle_state`` of ``DELETE_REQUESTED``,
418 then ``FAILED_PRECONDITION`` will be returned.
420 After a bucket has been created, the bucket's location cannot be
421 changed.
423 Returns:
424 Callable[[~.UpdateBucketRequest],
425 Awaitable[~.LogBucket]]:
426 A function that, when called, will call the underlying RPC
427 on the server.
428 """
429 # Generate a "stub function" on-the-fly which will actually make
430 # the request.
431 # gRPC handles serialization and deserialization, so we just need
432 # to pass in the functions for each.
433 if "update_bucket" not in self._stubs:
434 self._stubs["update_bucket"] = self.grpc_channel.unary_unary(
435 "/google.logging.v2.ConfigServiceV2/UpdateBucket",
436 request_serializer=logging_config.UpdateBucketRequest.serialize,
437 response_deserializer=logging_config.LogBucket.deserialize,
438 )
439 return self._stubs["update_bucket"]
441 @property
442 def delete_bucket(
443 self,
444 ) -> Callable[[logging_config.DeleteBucketRequest], Awaitable[empty_pb2.Empty]]:
445 r"""Return a callable for the delete bucket method over gRPC.
447 Deletes a log bucket.
449 Changes the bucket's ``lifecycle_state`` to the
450 ``DELETE_REQUESTED`` state. After 7 days, the bucket will be
451 purged and all log entries in the bucket will be permanently
452 deleted.
454 Returns:
455 Callable[[~.DeleteBucketRequest],
456 Awaitable[~.Empty]]:
457 A function that, when called, will call the underlying RPC
458 on the server.
459 """
460 # Generate a "stub function" on-the-fly which will actually make
461 # the request.
462 # gRPC handles serialization and deserialization, so we just need
463 # to pass in the functions for each.
464 if "delete_bucket" not in self._stubs:
465 self._stubs["delete_bucket"] = self.grpc_channel.unary_unary(
466 "/google.logging.v2.ConfigServiceV2/DeleteBucket",
467 request_serializer=logging_config.DeleteBucketRequest.serialize,
468 response_deserializer=empty_pb2.Empty.FromString,
469 )
470 return self._stubs["delete_bucket"]
472 @property
473 def undelete_bucket(
474 self,
475 ) -> Callable[[logging_config.UndeleteBucketRequest], Awaitable[empty_pb2.Empty]]:
476 r"""Return a callable for the undelete bucket method over gRPC.
478 Undeletes a log bucket. A bucket that has been
479 deleted can be undeleted within the grace period of 7
480 days.
482 Returns:
483 Callable[[~.UndeleteBucketRequest],
484 Awaitable[~.Empty]]:
485 A function that, when called, will call the underlying RPC
486 on the server.
487 """
488 # Generate a "stub function" on-the-fly which will actually make
489 # the request.
490 # gRPC handles serialization and deserialization, so we just need
491 # to pass in the functions for each.
492 if "undelete_bucket" not in self._stubs:
493 self._stubs["undelete_bucket"] = self.grpc_channel.unary_unary(
494 "/google.logging.v2.ConfigServiceV2/UndeleteBucket",
495 request_serializer=logging_config.UndeleteBucketRequest.serialize,
496 response_deserializer=empty_pb2.Empty.FromString,
497 )
498 return self._stubs["undelete_bucket"]
500 @property
501 def list_views(
502 self,
503 ) -> Callable[
504 [logging_config.ListViewsRequest], Awaitable[logging_config.ListViewsResponse]
505 ]:
506 r"""Return a callable for the list views method over gRPC.
508 Lists views on a log bucket.
510 Returns:
511 Callable[[~.ListViewsRequest],
512 Awaitable[~.ListViewsResponse]]:
513 A function that, when called, will call the underlying RPC
514 on the server.
515 """
516 # Generate a "stub function" on-the-fly which will actually make
517 # the request.
518 # gRPC handles serialization and deserialization, so we just need
519 # to pass in the functions for each.
520 if "list_views" not in self._stubs:
521 self._stubs["list_views"] = self.grpc_channel.unary_unary(
522 "/google.logging.v2.ConfigServiceV2/ListViews",
523 request_serializer=logging_config.ListViewsRequest.serialize,
524 response_deserializer=logging_config.ListViewsResponse.deserialize,
525 )
526 return self._stubs["list_views"]
528 @property
529 def get_view(
530 self,
531 ) -> Callable[[logging_config.GetViewRequest], Awaitable[logging_config.LogView]]:
532 r"""Return a callable for the get view method over gRPC.
534 Gets a view on a log bucket..
536 Returns:
537 Callable[[~.GetViewRequest],
538 Awaitable[~.LogView]]:
539 A function that, when called, will call the underlying RPC
540 on the server.
541 """
542 # Generate a "stub function" on-the-fly which will actually make
543 # the request.
544 # gRPC handles serialization and deserialization, so we just need
545 # to pass in the functions for each.
546 if "get_view" not in self._stubs:
547 self._stubs["get_view"] = self.grpc_channel.unary_unary(
548 "/google.logging.v2.ConfigServiceV2/GetView",
549 request_serializer=logging_config.GetViewRequest.serialize,
550 response_deserializer=logging_config.LogView.deserialize,
551 )
552 return self._stubs["get_view"]
554 @property
555 def create_view(
556 self,
557 ) -> Callable[
558 [logging_config.CreateViewRequest], Awaitable[logging_config.LogView]
559 ]:
560 r"""Return a callable for the create view method over gRPC.
562 Creates a view over log entries in a log bucket. A
563 bucket may contain a maximum of 30 views.
565 Returns:
566 Callable[[~.CreateViewRequest],
567 Awaitable[~.LogView]]:
568 A function that, when called, will call the underlying RPC
569 on the server.
570 """
571 # Generate a "stub function" on-the-fly which will actually make
572 # the request.
573 # gRPC handles serialization and deserialization, so we just need
574 # to pass in the functions for each.
575 if "create_view" not in self._stubs:
576 self._stubs["create_view"] = self.grpc_channel.unary_unary(
577 "/google.logging.v2.ConfigServiceV2/CreateView",
578 request_serializer=logging_config.CreateViewRequest.serialize,
579 response_deserializer=logging_config.LogView.deserialize,
580 )
581 return self._stubs["create_view"]
583 @property
584 def update_view(
585 self,
586 ) -> Callable[
587 [logging_config.UpdateViewRequest], Awaitable[logging_config.LogView]
588 ]:
589 r"""Return a callable for the update view method over gRPC.
591 Updates a view on a log bucket. This method replaces the
592 following fields in the existing view with values from the new
593 view: ``filter``. If an ``UNAVAILABLE`` error is returned, this
594 indicates that system is not in a state where it can update the
595 view. If this occurs, please try again in a few minutes.
597 Returns:
598 Callable[[~.UpdateViewRequest],
599 Awaitable[~.LogView]]:
600 A function that, when called, will call the underlying RPC
601 on the server.
602 """
603 # Generate a "stub function" on-the-fly which will actually make
604 # the request.
605 # gRPC handles serialization and deserialization, so we just need
606 # to pass in the functions for each.
607 if "update_view" not in self._stubs:
608 self._stubs["update_view"] = self.grpc_channel.unary_unary(
609 "/google.logging.v2.ConfigServiceV2/UpdateView",
610 request_serializer=logging_config.UpdateViewRequest.serialize,
611 response_deserializer=logging_config.LogView.deserialize,
612 )
613 return self._stubs["update_view"]
615 @property
616 def delete_view(
617 self,
618 ) -> Callable[[logging_config.DeleteViewRequest], Awaitable[empty_pb2.Empty]]:
619 r"""Return a callable for the delete view method over gRPC.
621 Deletes a view on a log bucket. If an ``UNAVAILABLE`` error is
622 returned, this indicates that system is not in a state where it
623 can delete the view. If this occurs, please try again in a few
624 minutes.
626 Returns:
627 Callable[[~.DeleteViewRequest],
628 Awaitable[~.Empty]]:
629 A function that, when called, will call the underlying RPC
630 on the server.
631 """
632 # Generate a "stub function" on-the-fly which will actually make
633 # the request.
634 # gRPC handles serialization and deserialization, so we just need
635 # to pass in the functions for each.
636 if "delete_view" not in self._stubs:
637 self._stubs["delete_view"] = self.grpc_channel.unary_unary(
638 "/google.logging.v2.ConfigServiceV2/DeleteView",
639 request_serializer=logging_config.DeleteViewRequest.serialize,
640 response_deserializer=empty_pb2.Empty.FromString,
641 )
642 return self._stubs["delete_view"]
644 @property
645 def list_sinks(
646 self,
647 ) -> Callable[
648 [logging_config.ListSinksRequest], Awaitable[logging_config.ListSinksResponse]
649 ]:
650 r"""Return a callable for the list sinks method over gRPC.
652 Lists sinks.
654 Returns:
655 Callable[[~.ListSinksRequest],
656 Awaitable[~.ListSinksResponse]]:
657 A function that, when called, will call the underlying RPC
658 on the server.
659 """
660 # Generate a "stub function" on-the-fly which will actually make
661 # the request.
662 # gRPC handles serialization and deserialization, so we just need
663 # to pass in the functions for each.
664 if "list_sinks" not in self._stubs:
665 self._stubs["list_sinks"] = self.grpc_channel.unary_unary(
666 "/google.logging.v2.ConfigServiceV2/ListSinks",
667 request_serializer=logging_config.ListSinksRequest.serialize,
668 response_deserializer=logging_config.ListSinksResponse.deserialize,
669 )
670 return self._stubs["list_sinks"]
672 @property
673 def get_sink(
674 self,
675 ) -> Callable[[logging_config.GetSinkRequest], Awaitable[logging_config.LogSink]]:
676 r"""Return a callable for the get sink method over gRPC.
678 Gets a sink.
680 Returns:
681 Callable[[~.GetSinkRequest],
682 Awaitable[~.LogSink]]:
683 A function that, when called, will call the underlying RPC
684 on the server.
685 """
686 # Generate a "stub function" on-the-fly which will actually make
687 # the request.
688 # gRPC handles serialization and deserialization, so we just need
689 # to pass in the functions for each.
690 if "get_sink" not in self._stubs:
691 self._stubs["get_sink"] = self.grpc_channel.unary_unary(
692 "/google.logging.v2.ConfigServiceV2/GetSink",
693 request_serializer=logging_config.GetSinkRequest.serialize,
694 response_deserializer=logging_config.LogSink.deserialize,
695 )
696 return self._stubs["get_sink"]
698 @property
699 def create_sink(
700 self,
701 ) -> Callable[
702 [logging_config.CreateSinkRequest], Awaitable[logging_config.LogSink]
703 ]:
704 r"""Return a callable for the create sink method over gRPC.
706 Creates a sink that exports specified log entries to a
707 destination. The export of newly-ingested log entries begins
708 immediately, unless the sink's ``writer_identity`` is not
709 permitted to write to the destination. A sink can export log
710 entries only from the resource owning the sink.
712 Returns:
713 Callable[[~.CreateSinkRequest],
714 Awaitable[~.LogSink]]:
715 A function that, when called, will call the underlying RPC
716 on the server.
717 """
718 # Generate a "stub function" on-the-fly which will actually make
719 # the request.
720 # gRPC handles serialization and deserialization, so we just need
721 # to pass in the functions for each.
722 if "create_sink" not in self._stubs:
723 self._stubs["create_sink"] = self.grpc_channel.unary_unary(
724 "/google.logging.v2.ConfigServiceV2/CreateSink",
725 request_serializer=logging_config.CreateSinkRequest.serialize,
726 response_deserializer=logging_config.LogSink.deserialize,
727 )
728 return self._stubs["create_sink"]
730 @property
731 def update_sink(
732 self,
733 ) -> Callable[
734 [logging_config.UpdateSinkRequest], Awaitable[logging_config.LogSink]
735 ]:
736 r"""Return a callable for the update sink method over gRPC.
738 Updates a sink. This method replaces the following fields in the
739 existing sink with values from the new sink: ``destination``,
740 and ``filter``.
742 The updated sink might also have a new ``writer_identity``; see
743 the ``unique_writer_identity`` field.
745 Returns:
746 Callable[[~.UpdateSinkRequest],
747 Awaitable[~.LogSink]]:
748 A function that, when called, will call the underlying RPC
749 on the server.
750 """
751 # Generate a "stub function" on-the-fly which will actually make
752 # the request.
753 # gRPC handles serialization and deserialization, so we just need
754 # to pass in the functions for each.
755 if "update_sink" not in self._stubs:
756 self._stubs["update_sink"] = self.grpc_channel.unary_unary(
757 "/google.logging.v2.ConfigServiceV2/UpdateSink",
758 request_serializer=logging_config.UpdateSinkRequest.serialize,
759 response_deserializer=logging_config.LogSink.deserialize,
760 )
761 return self._stubs["update_sink"]
763 @property
764 def delete_sink(
765 self,
766 ) -> Callable[[logging_config.DeleteSinkRequest], Awaitable[empty_pb2.Empty]]:
767 r"""Return a callable for the delete sink method over gRPC.
769 Deletes a sink. If the sink has a unique ``writer_identity``,
770 then that service account is also deleted.
772 Returns:
773 Callable[[~.DeleteSinkRequest],
774 Awaitable[~.Empty]]:
775 A function that, when called, will call the underlying RPC
776 on the server.
777 """
778 # Generate a "stub function" on-the-fly which will actually make
779 # the request.
780 # gRPC handles serialization and deserialization, so we just need
781 # to pass in the functions for each.
782 if "delete_sink" not in self._stubs:
783 self._stubs["delete_sink"] = self.grpc_channel.unary_unary(
784 "/google.logging.v2.ConfigServiceV2/DeleteSink",
785 request_serializer=logging_config.DeleteSinkRequest.serialize,
786 response_deserializer=empty_pb2.Empty.FromString,
787 )
788 return self._stubs["delete_sink"]
790 @property
791 def create_link(
792 self,
793 ) -> Callable[
794 [logging_config.CreateLinkRequest], Awaitable[operations_pb2.Operation]
795 ]:
796 r"""Return a callable for the create link method over gRPC.
798 Asynchronously creates a linked dataset in BigQuery
799 which makes it possible to use BigQuery to read the logs
800 stored in the log bucket. A log bucket may currently
801 only contain one link.
803 Returns:
804 Callable[[~.CreateLinkRequest],
805 Awaitable[~.Operation]]:
806 A function that, when called, will call the underlying RPC
807 on the server.
808 """
809 # Generate a "stub function" on-the-fly which will actually make
810 # the request.
811 # gRPC handles serialization and deserialization, so we just need
812 # to pass in the functions for each.
813 if "create_link" not in self._stubs:
814 self._stubs["create_link"] = self.grpc_channel.unary_unary(
815 "/google.logging.v2.ConfigServiceV2/CreateLink",
816 request_serializer=logging_config.CreateLinkRequest.serialize,
817 response_deserializer=operations_pb2.Operation.FromString,
818 )
819 return self._stubs["create_link"]
821 @property
822 def delete_link(
823 self,
824 ) -> Callable[
825 [logging_config.DeleteLinkRequest], Awaitable[operations_pb2.Operation]
826 ]:
827 r"""Return a callable for the delete link method over gRPC.
829 Deletes a link. This will also delete the
830 corresponding BigQuery linked dataset.
832 Returns:
833 Callable[[~.DeleteLinkRequest],
834 Awaitable[~.Operation]]:
835 A function that, when called, will call the underlying RPC
836 on the server.
837 """
838 # Generate a "stub function" on-the-fly which will actually make
839 # the request.
840 # gRPC handles serialization and deserialization, so we just need
841 # to pass in the functions for each.
842 if "delete_link" not in self._stubs:
843 self._stubs["delete_link"] = self.grpc_channel.unary_unary(
844 "/google.logging.v2.ConfigServiceV2/DeleteLink",
845 request_serializer=logging_config.DeleteLinkRequest.serialize,
846 response_deserializer=operations_pb2.Operation.FromString,
847 )
848 return self._stubs["delete_link"]
850 @property
851 def list_links(
852 self,
853 ) -> Callable[
854 [logging_config.ListLinksRequest], Awaitable[logging_config.ListLinksResponse]
855 ]:
856 r"""Return a callable for the list links method over gRPC.
858 Lists links.
860 Returns:
861 Callable[[~.ListLinksRequest],
862 Awaitable[~.ListLinksResponse]]:
863 A function that, when called, will call the underlying RPC
864 on the server.
865 """
866 # Generate a "stub function" on-the-fly which will actually make
867 # the request.
868 # gRPC handles serialization and deserialization, so we just need
869 # to pass in the functions for each.
870 if "list_links" not in self._stubs:
871 self._stubs["list_links"] = self.grpc_channel.unary_unary(
872 "/google.logging.v2.ConfigServiceV2/ListLinks",
873 request_serializer=logging_config.ListLinksRequest.serialize,
874 response_deserializer=logging_config.ListLinksResponse.deserialize,
875 )
876 return self._stubs["list_links"]
878 @property
879 def get_link(
880 self,
881 ) -> Callable[[logging_config.GetLinkRequest], Awaitable[logging_config.Link]]:
882 r"""Return a callable for the get link method over gRPC.
884 Gets a link.
886 Returns:
887 Callable[[~.GetLinkRequest],
888 Awaitable[~.Link]]:
889 A function that, when called, will call the underlying RPC
890 on the server.
891 """
892 # Generate a "stub function" on-the-fly which will actually make
893 # the request.
894 # gRPC handles serialization and deserialization, so we just need
895 # to pass in the functions for each.
896 if "get_link" not in self._stubs:
897 self._stubs["get_link"] = self.grpc_channel.unary_unary(
898 "/google.logging.v2.ConfigServiceV2/GetLink",
899 request_serializer=logging_config.GetLinkRequest.serialize,
900 response_deserializer=logging_config.Link.deserialize,
901 )
902 return self._stubs["get_link"]
904 @property
905 def list_exclusions(
906 self,
907 ) -> Callable[
908 [logging_config.ListExclusionsRequest],
909 Awaitable[logging_config.ListExclusionsResponse],
910 ]:
911 r"""Return a callable for the list exclusions method over gRPC.
913 Lists all the exclusions on the \_Default sink in a parent
914 resource.
916 Returns:
917 Callable[[~.ListExclusionsRequest],
918 Awaitable[~.ListExclusionsResponse]]:
919 A function that, when called, will call the underlying RPC
920 on the server.
921 """
922 # Generate a "stub function" on-the-fly which will actually make
923 # the request.
924 # gRPC handles serialization and deserialization, so we just need
925 # to pass in the functions for each.
926 if "list_exclusions" not in self._stubs:
927 self._stubs["list_exclusions"] = self.grpc_channel.unary_unary(
928 "/google.logging.v2.ConfigServiceV2/ListExclusions",
929 request_serializer=logging_config.ListExclusionsRequest.serialize,
930 response_deserializer=logging_config.ListExclusionsResponse.deserialize,
931 )
932 return self._stubs["list_exclusions"]
934 @property
935 def get_exclusion(
936 self,
937 ) -> Callable[
938 [logging_config.GetExclusionRequest], Awaitable[logging_config.LogExclusion]
939 ]:
940 r"""Return a callable for the get exclusion method over gRPC.
942 Gets the description of an exclusion in the \_Default sink.
944 Returns:
945 Callable[[~.GetExclusionRequest],
946 Awaitable[~.LogExclusion]]:
947 A function that, when called, will call the underlying RPC
948 on the server.
949 """
950 # Generate a "stub function" on-the-fly which will actually make
951 # the request.
952 # gRPC handles serialization and deserialization, so we just need
953 # to pass in the functions for each.
954 if "get_exclusion" not in self._stubs:
955 self._stubs["get_exclusion"] = self.grpc_channel.unary_unary(
956 "/google.logging.v2.ConfigServiceV2/GetExclusion",
957 request_serializer=logging_config.GetExclusionRequest.serialize,
958 response_deserializer=logging_config.LogExclusion.deserialize,
959 )
960 return self._stubs["get_exclusion"]
962 @property
963 def create_exclusion(
964 self,
965 ) -> Callable[
966 [logging_config.CreateExclusionRequest], Awaitable[logging_config.LogExclusion]
967 ]:
968 r"""Return a callable for the create exclusion method over gRPC.
970 Creates a new exclusion in the \_Default sink in a specified
971 parent resource. Only log entries belonging to that resource can
972 be excluded. You can have up to 10 exclusions in a resource.
974 Returns:
975 Callable[[~.CreateExclusionRequest],
976 Awaitable[~.LogExclusion]]:
977 A function that, when called, will call the underlying RPC
978 on the server.
979 """
980 # Generate a "stub function" on-the-fly which will actually make
981 # the request.
982 # gRPC handles serialization and deserialization, so we just need
983 # to pass in the functions for each.
984 if "create_exclusion" not in self._stubs:
985 self._stubs["create_exclusion"] = self.grpc_channel.unary_unary(
986 "/google.logging.v2.ConfigServiceV2/CreateExclusion",
987 request_serializer=logging_config.CreateExclusionRequest.serialize,
988 response_deserializer=logging_config.LogExclusion.deserialize,
989 )
990 return self._stubs["create_exclusion"]
992 @property
993 def update_exclusion(
994 self,
995 ) -> Callable[
996 [logging_config.UpdateExclusionRequest], Awaitable[logging_config.LogExclusion]
997 ]:
998 r"""Return a callable for the update exclusion method over gRPC.
1000 Changes one or more properties of an existing exclusion in the
1001 \_Default sink.
1003 Returns:
1004 Callable[[~.UpdateExclusionRequest],
1005 Awaitable[~.LogExclusion]]:
1006 A function that, when called, will call the underlying RPC
1007 on the server.
1008 """
1009 # Generate a "stub function" on-the-fly which will actually make
1010 # the request.
1011 # gRPC handles serialization and deserialization, so we just need
1012 # to pass in the functions for each.
1013 if "update_exclusion" not in self._stubs:
1014 self._stubs["update_exclusion"] = self.grpc_channel.unary_unary(
1015 "/google.logging.v2.ConfigServiceV2/UpdateExclusion",
1016 request_serializer=logging_config.UpdateExclusionRequest.serialize,
1017 response_deserializer=logging_config.LogExclusion.deserialize,
1018 )
1019 return self._stubs["update_exclusion"]
1021 @property
1022 def delete_exclusion(
1023 self,
1024 ) -> Callable[[logging_config.DeleteExclusionRequest], Awaitable[empty_pb2.Empty]]:
1025 r"""Return a callable for the delete exclusion method over gRPC.
1027 Deletes an exclusion in the \_Default sink.
1029 Returns:
1030 Callable[[~.DeleteExclusionRequest],
1031 Awaitable[~.Empty]]:
1032 A function that, when called, will call the underlying RPC
1033 on the server.
1034 """
1035 # Generate a "stub function" on-the-fly which will actually make
1036 # the request.
1037 # gRPC handles serialization and deserialization, so we just need
1038 # to pass in the functions for each.
1039 if "delete_exclusion" not in self._stubs:
1040 self._stubs["delete_exclusion"] = self.grpc_channel.unary_unary(
1041 "/google.logging.v2.ConfigServiceV2/DeleteExclusion",
1042 request_serializer=logging_config.DeleteExclusionRequest.serialize,
1043 response_deserializer=empty_pb2.Empty.FromString,
1044 )
1045 return self._stubs["delete_exclusion"]
1047 @property
1048 def get_cmek_settings(
1049 self,
1050 ) -> Callable[
1051 [logging_config.GetCmekSettingsRequest], Awaitable[logging_config.CmekSettings]
1052 ]:
1053 r"""Return a callable for the get cmek settings method over gRPC.
1055 Gets the Logging CMEK settings for the given resource.
1057 Note: CMEK for the Log Router can be configured for Google Cloud
1058 projects, folders, organizations and billing accounts. Once
1059 configured for an organization, it applies to all projects and
1060 folders in the Google Cloud organization.
1062 See `Enabling CMEK for Log
1063 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
1064 for more information.
1066 Returns:
1067 Callable[[~.GetCmekSettingsRequest],
1068 Awaitable[~.CmekSettings]]:
1069 A function that, when called, will call the underlying RPC
1070 on the server.
1071 """
1072 # Generate a "stub function" on-the-fly which will actually make
1073 # the request.
1074 # gRPC handles serialization and deserialization, so we just need
1075 # to pass in the functions for each.
1076 if "get_cmek_settings" not in self._stubs:
1077 self._stubs["get_cmek_settings"] = self.grpc_channel.unary_unary(
1078 "/google.logging.v2.ConfigServiceV2/GetCmekSettings",
1079 request_serializer=logging_config.GetCmekSettingsRequest.serialize,
1080 response_deserializer=logging_config.CmekSettings.deserialize,
1081 )
1082 return self._stubs["get_cmek_settings"]
1084 @property
1085 def update_cmek_settings(
1086 self,
1087 ) -> Callable[
1088 [logging_config.UpdateCmekSettingsRequest],
1089 Awaitable[logging_config.CmekSettings],
1090 ]:
1091 r"""Return a callable for the update cmek settings method over gRPC.
1093 Updates the Log Router CMEK settings for the given resource.
1095 Note: CMEK for the Log Router can currently only be configured
1096 for Google Cloud organizations. Once configured, it applies to
1097 all projects and folders in the Google Cloud organization.
1099 [UpdateCmekSettings][google.logging.v2.ConfigServiceV2.UpdateCmekSettings]
1100 will fail if 1) ``kms_key_name`` is invalid, or 2) the
1101 associated service account does not have the required
1102 ``roles/cloudkms.cryptoKeyEncrypterDecrypter`` role assigned for
1103 the key, or 3) access to the key is disabled.
1105 See `Enabling CMEK for Log
1106 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
1107 for more information.
1109 Returns:
1110 Callable[[~.UpdateCmekSettingsRequest],
1111 Awaitable[~.CmekSettings]]:
1112 A function that, when called, will call the underlying RPC
1113 on the server.
1114 """
1115 # Generate a "stub function" on-the-fly which will actually make
1116 # the request.
1117 # gRPC handles serialization and deserialization, so we just need
1118 # to pass in the functions for each.
1119 if "update_cmek_settings" not in self._stubs:
1120 self._stubs["update_cmek_settings"] = self.grpc_channel.unary_unary(
1121 "/google.logging.v2.ConfigServiceV2/UpdateCmekSettings",
1122 request_serializer=logging_config.UpdateCmekSettingsRequest.serialize,
1123 response_deserializer=logging_config.CmekSettings.deserialize,
1124 )
1125 return self._stubs["update_cmek_settings"]
1127 @property
1128 def get_settings(
1129 self,
1130 ) -> Callable[
1131 [logging_config.GetSettingsRequest], Awaitable[logging_config.Settings]
1132 ]:
1133 r"""Return a callable for the get settings method over gRPC.
1135 Gets the Log Router settings for the given resource.
1137 Note: Settings for the Log Router can be get for Google Cloud
1138 projects, folders, organizations and billing accounts. Currently
1139 it can only be configured for organizations. Once configured for
1140 an organization, it applies to all projects and folders in the
1141 Google Cloud organization.
1143 See `Enabling CMEK for Log
1144 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
1145 for more information.
1147 Returns:
1148 Callable[[~.GetSettingsRequest],
1149 Awaitable[~.Settings]]:
1150 A function that, when called, will call the underlying RPC
1151 on the server.
1152 """
1153 # Generate a "stub function" on-the-fly which will actually make
1154 # the request.
1155 # gRPC handles serialization and deserialization, so we just need
1156 # to pass in the functions for each.
1157 if "get_settings" not in self._stubs:
1158 self._stubs["get_settings"] = self.grpc_channel.unary_unary(
1159 "/google.logging.v2.ConfigServiceV2/GetSettings",
1160 request_serializer=logging_config.GetSettingsRequest.serialize,
1161 response_deserializer=logging_config.Settings.deserialize,
1162 )
1163 return self._stubs["get_settings"]
1165 @property
1166 def update_settings(
1167 self,
1168 ) -> Callable[
1169 [logging_config.UpdateSettingsRequest], Awaitable[logging_config.Settings]
1170 ]:
1171 r"""Return a callable for the update settings method over gRPC.
1173 Updates the Log Router settings for the given resource.
1175 Note: Settings for the Log Router can currently only be
1176 configured for Google Cloud organizations. Once configured, it
1177 applies to all projects and folders in the Google Cloud
1178 organization.
1180 [UpdateSettings][google.logging.v2.ConfigServiceV2.UpdateSettings]
1181 will fail if 1) ``kms_key_name`` is invalid, or 2) the
1182 associated service account does not have the required
1183 ``roles/cloudkms.cryptoKeyEncrypterDecrypter`` role assigned for
1184 the key, or 3) access to the key is disabled. 4) ``location_id``
1185 is not supported by Logging. 5) ``location_id`` violate
1186 OrgPolicy.
1188 See `Enabling CMEK for Log
1189 Router <https://cloud.google.com/logging/docs/routing/managed-encryption>`__
1190 for more information.
1192 Returns:
1193 Callable[[~.UpdateSettingsRequest],
1194 Awaitable[~.Settings]]:
1195 A function that, when called, will call the underlying RPC
1196 on the server.
1197 """
1198 # Generate a "stub function" on-the-fly which will actually make
1199 # the request.
1200 # gRPC handles serialization and deserialization, so we just need
1201 # to pass in the functions for each.
1202 if "update_settings" not in self._stubs:
1203 self._stubs["update_settings"] = self.grpc_channel.unary_unary(
1204 "/google.logging.v2.ConfigServiceV2/UpdateSettings",
1205 request_serializer=logging_config.UpdateSettingsRequest.serialize,
1206 response_deserializer=logging_config.Settings.deserialize,
1207 )
1208 return self._stubs["update_settings"]
1210 @property
1211 def copy_log_entries(
1212 self,
1213 ) -> Callable[
1214 [logging_config.CopyLogEntriesRequest], Awaitable[operations_pb2.Operation]
1215 ]:
1216 r"""Return a callable for the copy log entries method over gRPC.
1218 Copies a set of log entries from a log bucket to a
1219 Cloud Storage bucket.
1221 Returns:
1222 Callable[[~.CopyLogEntriesRequest],
1223 Awaitable[~.Operation]]:
1224 A function that, when called, will call the underlying RPC
1225 on the server.
1226 """
1227 # Generate a "stub function" on-the-fly which will actually make
1228 # the request.
1229 # gRPC handles serialization and deserialization, so we just need
1230 # to pass in the functions for each.
1231 if "copy_log_entries" not in self._stubs:
1232 self._stubs["copy_log_entries"] = self.grpc_channel.unary_unary(
1233 "/google.logging.v2.ConfigServiceV2/CopyLogEntries",
1234 request_serializer=logging_config.CopyLogEntriesRequest.serialize,
1235 response_deserializer=operations_pb2.Operation.FromString,
1236 )
1237 return self._stubs["copy_log_entries"]
1239 def close(self):
1240 return self.grpc_channel.close()
1242 @property
1243 def cancel_operation(
1244 self,
1245 ) -> Callable[[operations_pb2.CancelOperationRequest], None]:
1246 r"""Return a callable for the cancel_operation method over gRPC."""
1247 # Generate a "stub function" on-the-fly which will actually make
1248 # the request.
1249 # gRPC handles serialization and deserialization, so we just need
1250 # to pass in the functions for each.
1251 if "cancel_operation" not in self._stubs:
1252 self._stubs["cancel_operation"] = self.grpc_channel.unary_unary(
1253 "/google.longrunning.Operations/CancelOperation",
1254 request_serializer=operations_pb2.CancelOperationRequest.SerializeToString,
1255 response_deserializer=None,
1256 )
1257 return self._stubs["cancel_operation"]
1259 @property
1260 def get_operation(
1261 self,
1262 ) -> Callable[[operations_pb2.GetOperationRequest], operations_pb2.Operation]:
1263 r"""Return a callable for the get_operation method over gRPC."""
1264 # Generate a "stub function" on-the-fly which will actually make
1265 # the request.
1266 # gRPC handles serialization and deserialization, so we just need
1267 # to pass in the functions for each.
1268 if "get_operation" not in self._stubs:
1269 self._stubs["get_operation"] = self.grpc_channel.unary_unary(
1270 "/google.longrunning.Operations/GetOperation",
1271 request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
1272 response_deserializer=operations_pb2.Operation.FromString,
1273 )
1274 return self._stubs["get_operation"]
1276 @property
1277 def list_operations(
1278 self,
1279 ) -> Callable[
1280 [operations_pb2.ListOperationsRequest], operations_pb2.ListOperationsResponse
1281 ]:
1282 r"""Return a callable for the list_operations method over gRPC."""
1283 # Generate a "stub function" on-the-fly which will actually make
1284 # the request.
1285 # gRPC handles serialization and deserialization, so we just need
1286 # to pass in the functions for each.
1287 if "list_operations" not in self._stubs:
1288 self._stubs["list_operations"] = self.grpc_channel.unary_unary(
1289 "/google.longrunning.Operations/ListOperations",
1290 request_serializer=operations_pb2.ListOperationsRequest.SerializeToString,
1291 response_deserializer=operations_pb2.ListOperationsResponse.FromString,
1292 )
1293 return self._stubs["list_operations"]
1296__all__ = ("ConfigServiceV2GrpcAsyncIOTransport",)