From 50aea4a577252be4f5ff62703619337d8958bca2 Mon Sep 17 00:00:00 2001 From: Luke Sneeringer Date: Fri, 22 Sep 2017 07:46:12 -0700 Subject: [PATCH 1/4] Add spanner_admin_database GAPIC. --- .../spanner_admin_database_v1/__init__.py | 30 + .../gapic/__init__.py | 0 .../gapic/database_admin_client.py | 663 +++++++++ .../gapic/database_admin_client_config.py | 68 + .../spanner_admin_database_v1/gapic/enums.py | 30 + .../proto/__init__.py | 0 .../proto/spanner_database_admin_pb2.py | 1223 +++++++++++++++++ .../proto/spanner_database_admin_pb2_grpc.py | 222 +++ .../cloud/spanner_admin_database_v1/types.py | 52 + 9 files changed, 2288 insertions(+) create mode 100644 spanner/google/cloud/spanner_admin_database_v1/__init__.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/gapic/__init__.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client_config.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/gapic/enums.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/proto/__init__.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2_grpc.py create mode 100644 spanner/google/cloud/spanner_admin_database_v1/types.py diff --git a/spanner/google/cloud/spanner_admin_database_v1/__init__.py b/spanner/google/cloud/spanner_admin_database_v1/__init__.py new file mode 100644 index 000000000000..b8f44082b9c5 --- /dev/null +++ b/spanner/google/cloud/spanner_admin_database_v1/__init__.py @@ -0,0 +1,30 @@ +# Copyright 2017, Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import + +from google.cloud.spanner_admin_database_v1 import types +from google.cloud.spanner_admin_database_v1.gapic import database_admin_client +from google.cloud.spanner_admin_database_v1.gapic import enums + + +class DatabaseAdminClient(database_admin_client.DatabaseAdminClient): + __doc__ = database_admin_client.DatabaseAdminClient.__doc__ + enums = enums + + +__all__ = ( + 'enums', + 'types', + 'DatabaseAdminClient', ) diff --git a/spanner/google/cloud/spanner_admin_database_v1/gapic/__init__.py b/spanner/google/cloud/spanner_admin_database_v1/gapic/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client.py b/spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client.py new file mode 100644 index 000000000000..37df1dc16090 --- /dev/null +++ b/spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client.py @@ -0,0 +1,663 @@ +# Copyright 2017, Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# EDITING INSTRUCTIONS +# This file was generated from the file +# https://github.com/google/googleapis/blob/master/google/spanner/admin/database/v1/spanner_database_admin.proto, +# and updates to that file get reflected here through a refresh process. +# For the short term, the refresh process will only be runnable by Google engineers. +# +# The only allowed edits are to method and file documentation. A 3-way +# merge preserves those additions if the generated source changes. +"""Accesses the google.spanner.admin.database.v1 DatabaseAdmin API.""" + +import collections +import json +import os +import pkg_resources +import platform + +from google.gapic.longrunning import operations_client +from google.gax import api_callable +from google.gax import config +from google.gax import path_template +import google.gax + +from google.cloud.spanner_admin_database_v1.gapic import database_admin_client_config +from google.cloud.spanner_admin_database_v1.gapic import enums +from google.cloud.spanner_admin_database_v1.proto import spanner_database_admin_pb2 +from google.iam.v1 import iam_policy_pb2 +from google.iam.v1 import policy_pb2 +from google.protobuf import empty_pb2 + +_PageDesc = google.gax.PageDescriptor + + +class DatabaseAdminClient(object): + """ + Cloud Spanner Database Admin API + + The Cloud Spanner Database Admin API can be used to create, drop, and + list databases. It also enables updating the schema of pre-existing + databases. + """ + + SERVICE_ADDRESS = 'spanner.googleapis.com' + """The default address of the service.""" + + DEFAULT_SERVICE_PORT = 443 + """The default port of the service.""" + + _PAGE_DESCRIPTORS = { + 'list_databases': _PageDesc('page_token', 'next_page_token', + 'databases') + } + + # The scopes needed to make gRPC calls to all of the methods defined in + # this service + _ALL_SCOPES = ( + 'https://www.googleapis.com/auth/cloud-platform', + 'https://www.googleapis.com/auth/spanner.admin', ) + + _INSTANCE_PATH_TEMPLATE = path_template.PathTemplate( + 'projects/{project}/instances/{instance}') + _DATABASE_PATH_TEMPLATE = path_template.PathTemplate( + 'projects/{project}/instances/{instance}/databases/{database}') + + @classmethod + def instance_path(cls, project, instance): + """Returns a fully-qualified instance resource name string.""" + return cls._INSTANCE_PATH_TEMPLATE.render({ + 'project': project, + 'instance': instance, + }) + + @classmethod + def database_path(cls, project, instance, database): + """Returns a fully-qualified database resource name string.""" + return cls._DATABASE_PATH_TEMPLATE.render({ + 'project': project, + 'instance': instance, + 'database': database, + }) + + @classmethod + def match_project_from_instance_name(cls, instance_name): + """Parses the project from a instance resource. + + Args: + instance_name (str): A fully-qualified path representing a instance + resource. + + Returns: + A string representing the project. + """ + return cls._INSTANCE_PATH_TEMPLATE.match(instance_name).get('project') + + @classmethod + def match_instance_from_instance_name(cls, instance_name): + """Parses the instance from a instance resource. + + Args: + instance_name (str): A fully-qualified path representing a instance + resource. + + Returns: + A string representing the instance. + """ + return cls._INSTANCE_PATH_TEMPLATE.match(instance_name).get('instance') + + @classmethod + def match_project_from_database_name(cls, database_name): + """Parses the project from a database resource. + + Args: + database_name (str): A fully-qualified path representing a database + resource. + + Returns: + A string representing the project. + """ + return cls._DATABASE_PATH_TEMPLATE.match(database_name).get('project') + + @classmethod + def match_instance_from_database_name(cls, database_name): + """Parses the instance from a database resource. + + Args: + database_name (str): A fully-qualified path representing a database + resource. + + Returns: + A string representing the instance. + """ + return cls._DATABASE_PATH_TEMPLATE.match(database_name).get('instance') + + @classmethod + def match_database_from_database_name(cls, database_name): + """Parses the database from a database resource. + + Args: + database_name (str): A fully-qualified path representing a database + resource. + + Returns: + A string representing the database. + """ + return cls._DATABASE_PATH_TEMPLATE.match(database_name).get('database') + + def __init__(self, + channel=None, + credentials=None, + ssl_credentials=None, + scopes=None, + client_config=None, + lib_name=None, + lib_version='', + metrics_headers=()): + """Constructor. + + Args: + channel (~grpc.Channel): A ``Channel`` instance through + which to make calls. + credentials (~google.auth.credentials.Credentials): The authorization + credentials to attach to requests. These credentials identify this + application to the service. + ssl_credentials (~grpc.ChannelCredentials): A + ``ChannelCredentials`` instance for use with an SSL-enabled + channel. + scopes (Sequence[str]): A list of OAuth2 scopes to attach to requests. + client_config (dict): + A dictionary for call options for each method. See + :func:`google.gax.construct_settings` for the structure of + this data. Falls back to the default config if not specified + or the specified config is missing data points. + lib_name (str): The API library software used for calling + the service. (Unless you are writing an API client itself, + leave this as default.) + lib_version (str): The API library software version used + for calling the service. (Unless you are writing an API client + itself, leave this as default.) + metrics_headers (dict): A dictionary of values for tracking + client library metrics. Ultimately serializes to a string + (e.g. 'foo/1.2.3 bar/3.14.1'). This argument should be + considered private. + """ + # Unless the calling application specifically requested + # OAuth scopes, request everything. + if scopes is None: + scopes = self._ALL_SCOPES + + # Initialize an empty client config, if none is set. + if client_config is None: + client_config = {} + + # Initialize metrics_headers as an ordered dictionary + # (cuts down on cardinality of the resulting string slightly). + metrics_headers = collections.OrderedDict(metrics_headers) + metrics_headers['gl-python'] = platform.python_version() + + # The library may or may not be set, depending on what is + # calling this client. Newer client libraries set the library name + # and version. + if lib_name: + metrics_headers[lib_name] = lib_version + + # Finally, track the GAPIC package version. + metrics_headers['gapic'] = pkg_resources.get_distribution( + 'google-cloud-spanner', ).version + + # Load the configuration defaults. + defaults = api_callable.construct_settings( + 'google.spanner.admin.database.v1.DatabaseAdmin', + database_admin_client_config.config, + client_config, + config.STATUS_CODE_NAMES, + metrics_headers=metrics_headers, + page_descriptors=self._PAGE_DESCRIPTORS, ) + self.database_admin_stub = config.create_stub( + spanner_database_admin_pb2.DatabaseAdminStub, + channel=channel, + service_path=self.SERVICE_ADDRESS, + service_port=self.DEFAULT_SERVICE_PORT, + credentials=credentials, + scopes=scopes, + ssl_credentials=ssl_credentials) + + self.operations_client = operations_client.OperationsClient( + service_path=self.SERVICE_ADDRESS, + channel=channel, + credentials=credentials, + ssl_credentials=ssl_credentials, + scopes=scopes, + client_config=client_config, + metrics_headers=metrics_headers, ) + + self._list_databases = api_callable.create_api_call( + self.database_admin_stub.ListDatabases, + settings=defaults['list_databases']) + self._create_database = api_callable.create_api_call( + self.database_admin_stub.CreateDatabase, + settings=defaults['create_database']) + self._get_database = api_callable.create_api_call( + self.database_admin_stub.GetDatabase, + settings=defaults['get_database']) + self._update_database_ddl = api_callable.create_api_call( + self.database_admin_stub.UpdateDatabaseDdl, + settings=defaults['update_database_ddl']) + self._drop_database = api_callable.create_api_call( + self.database_admin_stub.DropDatabase, + settings=defaults['drop_database']) + self._get_database_ddl = api_callable.create_api_call( + self.database_admin_stub.GetDatabaseDdl, + settings=defaults['get_database_ddl']) + self._set_iam_policy = api_callable.create_api_call( + self.database_admin_stub.SetIamPolicy, + settings=defaults['set_iam_policy']) + self._get_iam_policy = api_callable.create_api_call( + self.database_admin_stub.GetIamPolicy, + settings=defaults['get_iam_policy']) + self._test_iam_permissions = api_callable.create_api_call( + self.database_admin_stub.TestIamPermissions, + settings=defaults['test_iam_permissions']) + + # Service calls + def list_databases(self, parent, page_size=None, options=None): + """ + Lists Cloud Spanner databases. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> from google.gax import CallOptions, INITIAL_PAGE + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> parent = client.instance_path('[PROJECT]', '[INSTANCE]') + >>> + >>> + >>> # Iterate over all results + >>> for element in client.list_databases(parent): + ... # process element + ... pass + >>> + >>> # Or iterate over results one page at a time + >>> for page in client.list_databases(parent, options=CallOptions(page_token=INITIAL_PAGE)): + ... for element in page: + ... # process element + ... pass + + Args: + parent (str): Required. The instance whose databases should be listed. + Values are of the form ``projects//instances/``. + page_size (int): The maximum number of resources contained in the + underlying API response. If page streaming is performed per- + resource, this parameter does not affect the return value. If page + streaming is performed per-page, this determines the maximum number + of resources in a page. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.gax.PageIterator` instance. By default, this + is an iterable of :class:`~google.cloud.spanner_admin_database_v1.types.Database` instances. + This object can also be configured to iterate over the pages + of the response through the `options` parameter. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = spanner_database_admin_pb2.ListDatabasesRequest( + parent=parent, page_size=page_size) + return self._list_databases(request, options) + + def create_database(self, + parent, + create_statement, + extra_statements=None, + options=None): + """ + Creates a new Cloud Spanner database and starts to prepare it for serving. + The returned ``long-running operation`` will + have a name of the format ``/operations/`` and + can be used to track preparation of the database. The + ``metadata`` field type is + ``CreateDatabaseMetadata``. The + ``response`` field type is + ``Database``, if successful. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> parent = client.instance_path('[PROJECT]', '[INSTANCE]') + >>> create_statement = '' + >>> + >>> response = client.create_database(parent, create_statement) + >>> + >>> def callback(operation_future): + ... # Handle result. + ... result = operation_future.result() + >>> + >>> response.add_done_callback(callback) + >>> + >>> # Handle metadata. + >>> metadata = response.metadata() + + Args: + parent (str): Required. The name of the instance that will serve the new database. + Values are of the form ``projects//instances/``. + create_statement (str): Required. A ``CREATE DATABASE`` statement, which specifies the ID of the + new database. The database ID must conform to the regular expression + ``[a-z][a-z0-9_\-]*[a-z0-9]`` and be between 2 and 30 characters in length. + extra_statements (list[str]): An optional list of DDL statements to run inside the newly created + database. Statements can create tables, indexes, etc. These + statements execute atomically with the creation of the database: + if there is an error in any statement, the database is not created. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.cloud.spanner_admin_database_v1.types._OperationFuture` instance. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = spanner_database_admin_pb2.CreateDatabaseRequest( + parent=parent, + create_statement=create_statement, + extra_statements=extra_statements) + return google.gax._OperationFuture( + self._create_database(request, options), self.operations_client, + spanner_database_admin_pb2.Database, + spanner_database_admin_pb2.CreateDatabaseMetadata, options) + + def get_database(self, name, options=None): + """ + Gets the state of a Cloud Spanner database. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> name = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + >>> + >>> response = client.get_database(name) + + Args: + name (str): Required. The name of the requested database. Values are of the form + ``projects//instances//databases/``. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.cloud.spanner_admin_database_v1.types.Database` instance. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = spanner_database_admin_pb2.GetDatabaseRequest(name=name) + return self._get_database(request, options) + + def update_database_ddl(self, + database, + statements, + operation_id=None, + options=None): + """ + Updates the schema of a Cloud Spanner database by + creating/altering/dropping tables, columns, indexes, etc. The returned + ``long-running operation`` will have a name of + the format ``/operations/`` and can be used to + track execution of the schema change(s). The + ``metadata`` field type is + ``UpdateDatabaseDdlMetadata``. The operation has no response. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> database = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + >>> statements = [] + >>> + >>> response = client.update_database_ddl(database, statements) + >>> + >>> def callback(operation_future): + ... # Handle result. + ... result = operation_future.result() + >>> + >>> response.add_done_callback(callback) + >>> + >>> # Handle metadata. + >>> metadata = response.metadata() + + Args: + database (str): Required. The database to update. + statements (list[str]): DDL statements to be applied to the database. + operation_id (str): If empty, the new update request is assigned an + automatically-generated operation ID. Otherwise, ``operation_id`` + is used to construct the name of the resulting + ``Operation``. + + Specifying an explicit operation ID simplifies determining + whether the statements were executed in the event that the + ``UpdateDatabaseDdl`` call is replayed, + or the return value is otherwise lost: the ``database`` and + ``operation_id`` fields can be combined to form the + ``name`` of the resulting + ``longrunning.Operation``: ``/operations/``. + + ``operation_id`` should be unique within the database, and must be + a valid identifier: ``[a-z][a-z0-9_]*``. Note that + automatically-generated operation IDs always begin with an + underscore. If the named operation already exists, + ``UpdateDatabaseDdl`` returns + ``ALREADY_EXISTS``. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.cloud.spanner_admin_database_v1.types._OperationFuture` instance. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = spanner_database_admin_pb2.UpdateDatabaseDdlRequest( + database=database, + statements=statements, + operation_id=operation_id) + return google.gax._OperationFuture( + self._update_database_ddl(request, options), + self.operations_client, empty_pb2.Empty, + spanner_database_admin_pb2.UpdateDatabaseDdlMetadata, options) + + def drop_database(self, database, options=None): + """ + Drops (aka deletes) a Cloud Spanner database. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> database = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + >>> + >>> client.drop_database(database) + + Args: + database (str): Required. The database to be dropped. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = spanner_database_admin_pb2.DropDatabaseRequest( + database=database) + self._drop_database(request, options) + + def get_database_ddl(self, database, options=None): + """ + Returns the schema of a Cloud Spanner database as a list of formatted + DDL statements. This method does not show pending schema updates, those may + be queried using the ``Operations`` API. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> database = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + >>> + >>> response = client.get_database_ddl(database) + + Args: + database (str): Required. The database whose schema we wish to get. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.cloud.spanner_admin_database_v1.types.GetDatabaseDdlResponse` instance. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = spanner_database_admin_pb2.GetDatabaseDdlRequest( + database=database) + return self._get_database_ddl(request, options) + + def set_iam_policy(self, resource, policy, options=None): + """ + Sets the access control policy on a database resource. Replaces any + existing policy. + + Authorization requires ``spanner.databases.setIamPolicy`` permission on + ``resource``. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> resource = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + >>> policy = {} + >>> + >>> response = client.set_iam_policy(resource, policy) + + Args: + resource (str): REQUIRED: The resource for which the policy is being specified. + ``resource`` is usually specified as a path. For example, a Project + resource is specified as ``projects/{project}``. + policy (Union[dict, ~google.cloud.spanner_admin_database_v1.types.Policy]): REQUIRED: The complete policy to be applied to the ``resource``. The size of + the policy is limited to a few 10s of KB. An empty policy is a + valid policy but certain Cloud Platform services (such as Projects) + might reject them. + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.spanner_admin_database_v1.types.Policy` + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.cloud.spanner_admin_database_v1.types.Policy` instance. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = iam_policy_pb2.SetIamPolicyRequest( + resource=resource, policy=policy) + return self._set_iam_policy(request, options) + + def get_iam_policy(self, resource, options=None): + """ + Gets the access control policy for a database resource. Returns an empty + policy if a database exists but does not have a policy set. + + Authorization requires ``spanner.databases.getIamPolicy`` permission on + ``resource``. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> resource = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + >>> + >>> response = client.get_iam_policy(resource) + + Args: + resource (str): REQUIRED: The resource for which the policy is being requested. + ``resource`` is usually specified as a path. For example, a Project + resource is specified as ``projects/{project}``. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.cloud.spanner_admin_database_v1.types.Policy` instance. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = iam_policy_pb2.GetIamPolicyRequest(resource=resource) + return self._get_iam_policy(request, options) + + def test_iam_permissions(self, resource, permissions, options=None): + """ + Returns permissions that the caller has on the specified database resource. + + Attempting this RPC on a non-existent Cloud Spanner database will result in + a NOT_FOUND error if the user has ``spanner.databases.list`` permission on + the containing Cloud Spanner instance. Otherwise returns an empty set of + permissions. + + Example: + >>> from google.cloud import spanner_admin_database_v1 + >>> + >>> client = spanner_admin_database_v1.DatabaseAdminClient() + >>> + >>> resource = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + >>> permissions = [] + >>> + >>> response = client.test_iam_permissions(resource, permissions) + + Args: + resource (str): REQUIRED: The resource for which the policy detail is being requested. + ``resource`` is usually specified as a path. For example, a Project + resource is specified as ``projects/{project}``. + permissions (list[str]): The set of permissions to check for the ``resource``. Permissions with + wildcards (such as '*' or 'storage.*') are not allowed. For more + information see + `IAM Overview `_. + options (~google.gax.CallOptions): Overrides the default + settings for this call, e.g, timeout, retries etc. + + Returns: + A :class:`~google.cloud.spanner_admin_database_v1.types.TestIamPermissionsResponse` instance. + + Raises: + :exc:`google.gax.errors.GaxError` if the RPC is aborted. + :exc:`ValueError` if the parameters are invalid. + """ + request = iam_policy_pb2.TestIamPermissionsRequest( + resource=resource, permissions=permissions) + return self._test_iam_permissions(request, options) diff --git a/spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client_config.py b/spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client_config.py new file mode 100644 index 000000000000..b7ed930a9f1d --- /dev/null +++ b/spanner/google/cloud/spanner_admin_database_v1/gapic/database_admin_client_config.py @@ -0,0 +1,68 @@ +config = { + "interfaces": { + "google.spanner.admin.database.v1.DatabaseAdmin": { + "retry_codes": { + "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], + "non_idempotent": [] + }, + "retry_params": { + "default": { + "initial_retry_delay_millis": 1000, + "retry_delay_multiplier": 1.3, + "max_retry_delay_millis": 32000, + "initial_rpc_timeout_millis": 60000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 600000 + } + }, + "methods": { + "ListDatabases": { + "timeout_millis": 30000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "CreateDatabase": { + "timeout_millis": 30000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + }, + "GetDatabase": { + "timeout_millis": 30000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "UpdateDatabaseDdl": { + "timeout_millis": 30000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "DropDatabase": { + "timeout_millis": 30000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "GetDatabaseDdl": { + "timeout_millis": 30000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "SetIamPolicy": { + "timeout_millis": 30000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + }, + "GetIamPolicy": { + "timeout_millis": 30000, + "retry_codes_name": "idempotent", + "retry_params_name": "default" + }, + "TestIamPermissions": { + "timeout_millis": 30000, + "retry_codes_name": "non_idempotent", + "retry_params_name": "default" + } + } + } + } +} diff --git a/spanner/google/cloud/spanner_admin_database_v1/gapic/enums.py b/spanner/google/cloud/spanner_admin_database_v1/gapic/enums.py new file mode 100644 index 000000000000..4ce2fdcb556c --- /dev/null +++ b/spanner/google/cloud/spanner_admin_database_v1/gapic/enums.py @@ -0,0 +1,30 @@ +# Copyright 2017, Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Wrappers for protocol buffer enum types.""" + + +class Database(object): + class State(object): + """ + Indicates the current state of the database. + + Attributes: + STATE_UNSPECIFIED (int): Not specified. + CREATING (int): The database is still being created. Operations on the database may fail + with ``FAILED_PRECONDITION`` in this state. + READY (int): The database is fully created and ready for use. + """ + STATE_UNSPECIFIED = 0 + CREATING = 1 + READY = 2 diff --git a/spanner/google/cloud/spanner_admin_database_v1/proto/__init__.py b/spanner/google/cloud/spanner_admin_database_v1/proto/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2.py b/spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2.py new file mode 100644 index 000000000000..e0199e551cfd --- /dev/null +++ b/spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2.py @@ -0,0 +1,1223 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/cloud/spanner/admin/database_v1/proto/spanner_database_admin.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from google.api import auth_pb2 as google_dot_api_dot_auth__pb2 +from google.iam.v1 import iam_policy_pb2 as google_dot_iam_dot_v1_dot_iam__policy__pb2 +from google.iam.v1 import policy_pb2 as google_dot_iam_dot_v1_dot_policy__pb2 +from google.longrunning import operations_pb2 as google_dot_longrunning_dot_operations__pb2 +from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2 +from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/cloud/spanner/admin/database_v1/proto/spanner_database_admin.proto', + package='google.spanner.admin.database.v1', + syntax='proto3', + serialized_pb=_b('\nIgoogle/cloud/spanner/admin/database_v1/proto/spanner_database_admin.proto\x12 google.spanner.admin.database.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x15google/api/auth.proto\x1a\x1egoogle/iam/v1/iam_policy.proto\x1a\x1agoogle/iam/v1/policy.proto\x1a#google/longrunning/operations.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x92\x01\n\x08\x44\x61tabase\x12\x0c\n\x04name\x18\x01 \x01(\t\x12?\n\x05state\x18\x02 \x01(\x0e\x32\x30.google.spanner.admin.database.v1.Database.State\"7\n\x05State\x12\x15\n\x11STATE_UNSPECIFIED\x10\x00\x12\x0c\n\x08\x43REATING\x10\x01\x12\t\n\x05READY\x10\x02\"M\n\x14ListDatabasesRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x03 \x01(\x05\x12\x12\n\npage_token\x18\x04 \x01(\t\"o\n\x15ListDatabasesResponse\x12=\n\tdatabases\x18\x01 \x03(\x0b\x32*.google.spanner.admin.database.v1.Database\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t\"[\n\x15\x43reateDatabaseRequest\x12\x0e\n\x06parent\x18\x01 \x01(\t\x12\x18\n\x10\x63reate_statement\x18\x02 \x01(\t\x12\x18\n\x10\x65xtra_statements\x18\x03 \x03(\t\"*\n\x16\x43reateDatabaseMetadata\x12\x10\n\x08\x64\x61tabase\x18\x01 \x01(\t\"\"\n\x12GetDatabaseRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"V\n\x18UpdateDatabaseDdlRequest\x12\x10\n\x08\x64\x61tabase\x18\x01 \x01(\t\x12\x12\n\nstatements\x18\x02 \x03(\t\x12\x14\n\x0coperation_id\x18\x03 \x01(\t\"x\n\x19UpdateDatabaseDdlMetadata\x12\x10\n\x08\x64\x61tabase\x18\x01 \x01(\t\x12\x12\n\nstatements\x18\x02 \x03(\t\x12\x35\n\x11\x63ommit_timestamps\x18\x03 \x03(\x0b\x32\x1a.google.protobuf.Timestamp\"\'\n\x13\x44ropDatabaseRequest\x12\x10\n\x08\x64\x61tabase\x18\x01 \x01(\t\")\n\x15GetDatabaseDdlRequest\x12\x10\n\x08\x64\x61tabase\x18\x01 \x01(\t\",\n\x16GetDatabaseDdlResponse\x12\x12\n\nstatements\x18\x01 \x03(\t2\x95\x0c\n\rDatabaseAdmin\x12\xb7\x01\n\rListDatabases\x12\x36.google.spanner.admin.database.v1.ListDatabasesRequest\x1a\x37.google.spanner.admin.database.v1.ListDatabasesResponse\"5\x82\xd3\xe4\x93\x02/\x12-/v1/{parent=projects/*/instances/*}/databases\x12\xa2\x01\n\x0e\x43reateDatabase\x12\x37.google.spanner.admin.database.v1.CreateDatabaseRequest\x1a\x1d.google.longrunning.Operation\"8\x82\xd3\xe4\x93\x02\x32\"-/v1/{parent=projects/*/instances/*}/databases:\x01*\x12\xa6\x01\n\x0bGetDatabase\x12\x34.google.spanner.admin.database.v1.GetDatabaseRequest\x1a*.google.spanner.admin.database.v1.Database\"5\x82\xd3\xe4\x93\x02/\x12-/v1/{name=projects/*/instances/*/databases/*}\x12\xb0\x01\n\x11UpdateDatabaseDdl\x12:.google.spanner.admin.database.v1.UpdateDatabaseDdlRequest\x1a\x1d.google.longrunning.Operation\"@\x82\xd3\xe4\x93\x02:25/v1/{database=projects/*/instances/*/databases/*}/ddl:\x01*\x12\x98\x01\n\x0c\x44ropDatabase\x12\x35.google.spanner.admin.database.v1.DropDatabaseRequest\x1a\x16.google.protobuf.Empty\"9\x82\xd3\xe4\x93\x02\x33*1/v1/{database=projects/*/instances/*/databases/*}\x12\xc2\x01\n\x0eGetDatabaseDdl\x12\x37.google.spanner.admin.database.v1.GetDatabaseDdlRequest\x1a\x38.google.spanner.admin.database.v1.GetDatabaseDdlResponse\"=\x82\xd3\xe4\x93\x02\x37\x12\x35/v1/{database=projects/*/instances/*/databases/*}/ddl\x12\x94\x01\n\x0cSetIamPolicy\x12\".google.iam.v1.SetIamPolicyRequest\x1a\x15.google.iam.v1.Policy\"I\x82\xd3\xe4\x93\x02\x43\">/v1/{resource=projects/*/instances/*/databases/*}:setIamPolicy:\x01*\x12\x94\x01\n\x0cGetIamPolicy\x12\".google.iam.v1.GetIamPolicyRequest\x1a\x15.google.iam.v1.Policy\"I\x82\xd3\xe4\x93\x02\x43\">/v1/{resource=projects/*/instances/*/databases/*}:getIamPolicy:\x01*\x12\xba\x01\n\x12TestIamPermissions\x12(.google.iam.v1.TestIamPermissionsRequest\x1a).google.iam.v1.TestIamPermissionsResponse\"O\x82\xd3\xe4\x93\x02I\"D/v1/{resource=projects/*/instances/*/databases/*}:testIamPermissions:\x01*B\xb6\x01\n$com.google.spanner.admin.database.v1B\x19SpannerDatabaseAdminProtoP\x01ZHgoogle.golang.org/genproto/googleapis/spanner/admin/database/v1;database\xaa\x02&Google.Cloud.Spanner.Admin.Database.V1b\x06proto3') + , + dependencies=[google_dot_api_dot_annotations__pb2.DESCRIPTOR,google_dot_api_dot_auth__pb2.DESCRIPTOR,google_dot_iam_dot_v1_dot_iam__policy__pb2.DESCRIPTOR,google_dot_iam_dot_v1_dot_policy__pb2.DESCRIPTOR,google_dot_longrunning_dot_operations__pb2.DESCRIPTOR,google_dot_protobuf_dot_empty__pb2.DESCRIPTOR,google_dot_protobuf_dot_timestamp__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + +_DATABASE_STATE = _descriptor.EnumDescriptor( + name='State', + full_name='google.spanner.admin.database.v1.Database.State', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='STATE_UNSPECIFIED', index=0, number=0, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='CREATING', index=1, number=1, + options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='READY', index=2, number=2, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=415, + serialized_end=470, +) +_sym_db.RegisterEnumDescriptor(_DATABASE_STATE) + + +_DATABASE = _descriptor.Descriptor( + name='Database', + full_name='google.spanner.admin.database.v1.Database', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.spanner.admin.database.v1.Database.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='state', full_name='google.spanner.admin.database.v1.Database.state', index=1, + number=2, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _DATABASE_STATE, + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=324, + serialized_end=470, +) + + +_LISTDATABASESREQUEST = _descriptor.Descriptor( + name='ListDatabasesRequest', + full_name='google.spanner.admin.database.v1.ListDatabasesRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='parent', full_name='google.spanner.admin.database.v1.ListDatabasesRequest.parent', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='page_size', full_name='google.spanner.admin.database.v1.ListDatabasesRequest.page_size', index=1, + number=3, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='page_token', full_name='google.spanner.admin.database.v1.ListDatabasesRequest.page_token', index=2, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=472, + serialized_end=549, +) + + +_LISTDATABASESRESPONSE = _descriptor.Descriptor( + name='ListDatabasesResponse', + full_name='google.spanner.admin.database.v1.ListDatabasesResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='databases', full_name='google.spanner.admin.database.v1.ListDatabasesResponse.databases', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='next_page_token', full_name='google.spanner.admin.database.v1.ListDatabasesResponse.next_page_token', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=551, + serialized_end=662, +) + + +_CREATEDATABASEREQUEST = _descriptor.Descriptor( + name='CreateDatabaseRequest', + full_name='google.spanner.admin.database.v1.CreateDatabaseRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='parent', full_name='google.spanner.admin.database.v1.CreateDatabaseRequest.parent', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='create_statement', full_name='google.spanner.admin.database.v1.CreateDatabaseRequest.create_statement', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='extra_statements', full_name='google.spanner.admin.database.v1.CreateDatabaseRequest.extra_statements', index=2, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=664, + serialized_end=755, +) + + +_CREATEDATABASEMETADATA = _descriptor.Descriptor( + name='CreateDatabaseMetadata', + full_name='google.spanner.admin.database.v1.CreateDatabaseMetadata', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='database', full_name='google.spanner.admin.database.v1.CreateDatabaseMetadata.database', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=757, + serialized_end=799, +) + + +_GETDATABASEREQUEST = _descriptor.Descriptor( + name='GetDatabaseRequest', + full_name='google.spanner.admin.database.v1.GetDatabaseRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.spanner.admin.database.v1.GetDatabaseRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=801, + serialized_end=835, +) + + +_UPDATEDATABASEDDLREQUEST = _descriptor.Descriptor( + name='UpdateDatabaseDdlRequest', + full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='database', full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlRequest.database', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='statements', full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlRequest.statements', index=1, + number=2, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='operation_id', full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlRequest.operation_id', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=837, + serialized_end=923, +) + + +_UPDATEDATABASEDDLMETADATA = _descriptor.Descriptor( + name='UpdateDatabaseDdlMetadata', + full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='database', full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata.database', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='statements', full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata.statements', index=1, + number=2, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='commit_timestamps', full_name='google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata.commit_timestamps', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=925, + serialized_end=1045, +) + + +_DROPDATABASEREQUEST = _descriptor.Descriptor( + name='DropDatabaseRequest', + full_name='google.spanner.admin.database.v1.DropDatabaseRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='database', full_name='google.spanner.admin.database.v1.DropDatabaseRequest.database', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1047, + serialized_end=1086, +) + + +_GETDATABASEDDLREQUEST = _descriptor.Descriptor( + name='GetDatabaseDdlRequest', + full_name='google.spanner.admin.database.v1.GetDatabaseDdlRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='database', full_name='google.spanner.admin.database.v1.GetDatabaseDdlRequest.database', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1088, + serialized_end=1129, +) + + +_GETDATABASEDDLRESPONSE = _descriptor.Descriptor( + name='GetDatabaseDdlResponse', + full_name='google.spanner.admin.database.v1.GetDatabaseDdlResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='statements', full_name='google.spanner.admin.database.v1.GetDatabaseDdlResponse.statements', index=0, + number=1, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1131, + serialized_end=1175, +) + +_DATABASE.fields_by_name['state'].enum_type = _DATABASE_STATE +_DATABASE_STATE.containing_type = _DATABASE +_LISTDATABASESRESPONSE.fields_by_name['databases'].message_type = _DATABASE +_UPDATEDATABASEDDLMETADATA.fields_by_name['commit_timestamps'].message_type = google_dot_protobuf_dot_timestamp__pb2._TIMESTAMP +DESCRIPTOR.message_types_by_name['Database'] = _DATABASE +DESCRIPTOR.message_types_by_name['ListDatabasesRequest'] = _LISTDATABASESREQUEST +DESCRIPTOR.message_types_by_name['ListDatabasesResponse'] = _LISTDATABASESRESPONSE +DESCRIPTOR.message_types_by_name['CreateDatabaseRequest'] = _CREATEDATABASEREQUEST +DESCRIPTOR.message_types_by_name['CreateDatabaseMetadata'] = _CREATEDATABASEMETADATA +DESCRIPTOR.message_types_by_name['GetDatabaseRequest'] = _GETDATABASEREQUEST +DESCRIPTOR.message_types_by_name['UpdateDatabaseDdlRequest'] = _UPDATEDATABASEDDLREQUEST +DESCRIPTOR.message_types_by_name['UpdateDatabaseDdlMetadata'] = _UPDATEDATABASEDDLMETADATA +DESCRIPTOR.message_types_by_name['DropDatabaseRequest'] = _DROPDATABASEREQUEST +DESCRIPTOR.message_types_by_name['GetDatabaseDdlRequest'] = _GETDATABASEDDLREQUEST +DESCRIPTOR.message_types_by_name['GetDatabaseDdlResponse'] = _GETDATABASEDDLRESPONSE + +Database = _reflection.GeneratedProtocolMessageType('Database', (_message.Message,), dict( + DESCRIPTOR = _DATABASE, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """A Cloud Spanner database. + + + Attributes: + name: + Required. The name of the database. Values are of the form ``p + rojects//instances//databases/``, + where ```` is as specified in the ``CREATE + DATABASE`` statement. This name can be passed to other API + methods to identify the database. + state: + Output only. The current database state. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.Database) + )) +_sym_db.RegisterMessage(Database) + +ListDatabasesRequest = _reflection.GeneratedProtocolMessageType('ListDatabasesRequest', (_message.Message,), dict( + DESCRIPTOR = _LISTDATABASESREQUEST, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """The request for + [ListDatabases][google.spanner.admin.database.v1.DatabaseAdmin.ListDatabases]. + + + Attributes: + parent: + Required. The instance whose databases should be listed. + Values are of the form + ``projects//instances/``. + page_size: + Number of databases to be returned in the response. If 0 or + less, defaults to the server's maximum allowed page size. + page_token: + If non-empty, ``page_token`` should contain a [next\_page\_tok + en][google.spanner.admin.database.v1.ListDatabasesResponse.nex + t\_page\_token] from a previous [ListDatabasesResponse][google + .spanner.admin.database.v1.ListDatabasesResponse]. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.ListDatabasesRequest) + )) +_sym_db.RegisterMessage(ListDatabasesRequest) + +ListDatabasesResponse = _reflection.GeneratedProtocolMessageType('ListDatabasesResponse', (_message.Message,), dict( + DESCRIPTOR = _LISTDATABASESRESPONSE, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """The response for + [ListDatabases][google.spanner.admin.database.v1.DatabaseAdmin.ListDatabases]. + + + Attributes: + databases: + Databases that matched the request. + next_page_token: + ``next_page_token`` can be sent in a subsequent [ListDatabases + ][google.spanner.admin.database.v1.DatabaseAdmin.ListDatabases + ] call to fetch more of the matching databases. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.ListDatabasesResponse) + )) +_sym_db.RegisterMessage(ListDatabasesResponse) + +CreateDatabaseRequest = _reflection.GeneratedProtocolMessageType('CreateDatabaseRequest', (_message.Message,), dict( + DESCRIPTOR = _CREATEDATABASEREQUEST, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """The request for + [CreateDatabase][google.spanner.admin.database.v1.DatabaseAdmin.CreateDatabase]. + + + Attributes: + parent: + Required. The name of the instance that will serve the new + database. Values are of the form + ``projects//instances/``. + create_statement: + Required. A ``CREATE DATABASE`` statement, which specifies the + ID of the new database. The database ID must conform to the + regular expression ``[a-z][a-z0-9_\-]*[a-z0-9]`` and be + between 2 and 30 characters in length. + extra_statements: + An optional list of DDL statements to run inside the newly + created database. Statements can create tables, indexes, etc. + These statements execute atomically with the creation of the + database: if there is an error in any statement, the database + is not created. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.CreateDatabaseRequest) + )) +_sym_db.RegisterMessage(CreateDatabaseRequest) + +CreateDatabaseMetadata = _reflection.GeneratedProtocolMessageType('CreateDatabaseMetadata', (_message.Message,), dict( + DESCRIPTOR = _CREATEDATABASEMETADATA, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """Metadata type for the operation returned by + [CreateDatabase][google.spanner.admin.database.v1.DatabaseAdmin.CreateDatabase]. + + + Attributes: + database: + The database being created. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.CreateDatabaseMetadata) + )) +_sym_db.RegisterMessage(CreateDatabaseMetadata) + +GetDatabaseRequest = _reflection.GeneratedProtocolMessageType('GetDatabaseRequest', (_message.Message,), dict( + DESCRIPTOR = _GETDATABASEREQUEST, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """The request for + [GetDatabase][google.spanner.admin.database.v1.DatabaseAdmin.GetDatabase]. + + + Attributes: + name: + Required. The name of the requested database. Values are of + the form ``projects//instances//databases/< + database>``. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.GetDatabaseRequest) + )) +_sym_db.RegisterMessage(GetDatabaseRequest) + +UpdateDatabaseDdlRequest = _reflection.GeneratedProtocolMessageType('UpdateDatabaseDdlRequest', (_message.Message,), dict( + DESCRIPTOR = _UPDATEDATABASEDDLREQUEST, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """Enqueues the given DDL statements to be applied, in order but not + necessarily all at once, to the database schema at some point (or + points) in the future. The server checks that the statements are + executable (syntactically valid, name tables that exist, etc.) before + enqueueing them, but they may still fail upon later execution (e.g., if + a statement from another batch of statements is applied first and it + conflicts in some way, or if there is some data-related problem like a + ``NULL`` value in a column to which ``NOT NULL`` would be added). If a + statement fails, all subsequent statements in the batch are + automatically cancelled. + + Each batch of statements is assigned a name which can be used with the + [Operations][google.longrunning.Operations] API to monitor progress. See + the + [operation\_id][google.spanner.admin.database.v1.UpdateDatabaseDdlRequest.operation\_id] + field for more details. + + + Attributes: + database: + Required. The database to update. + statements: + DDL statements to be applied to the database. + operation_id: + If empty, the new update request is assigned an automatically- + generated operation ID. Otherwise, ``operation_id`` is used to + construct the name of the resulting + [Operation][google.longrunning.Operation]. Specifying an + explicit operation ID simplifies determining whether the + statements were executed in the event that the [UpdateDatabase + Ddl][google.spanner.admin.database.v1.DatabaseAdmin.UpdateData + baseDdl] call is replayed, or the return value is otherwise + lost: the [database][google.spanner.admin.database.v1.UpdateDa + tabaseDdlRequest.database] and ``operation_id`` fields can be + combined to form the [name][google.longrunning.Operation.name] + of the resulting + [longrunning.Operation][google.longrunning.Operation]: + ``/operations/``. ``operation_id`` + should be unique within the database, and must be a valid + identifier: ``[a-z][a-z0-9_]*``. Note that automatically- + generated operation IDs always begin with an underscore. If + the named operation already exists, [UpdateDatabaseDdl][google + .spanner.admin.database.v1.DatabaseAdmin.UpdateDatabaseDdl] + returns ``ALREADY_EXISTS``. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.UpdateDatabaseDdlRequest) + )) +_sym_db.RegisterMessage(UpdateDatabaseDdlRequest) + +UpdateDatabaseDdlMetadata = _reflection.GeneratedProtocolMessageType('UpdateDatabaseDdlMetadata', (_message.Message,), dict( + DESCRIPTOR = _UPDATEDATABASEDDLMETADATA, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """Metadata type for the operation returned by + [UpdateDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.UpdateDatabaseDdl]. + + + Attributes: + database: + The database being modified. + statements: + For an update this list contains all the statements. For an + individual statement, this list contains only that statement. + commit_timestamps: + Reports the commit timestamps of all statements that have + succeeded so far, where ``commit_timestamps[i]`` is the commit + timestamp for the statement ``statements[i]``. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata) + )) +_sym_db.RegisterMessage(UpdateDatabaseDdlMetadata) + +DropDatabaseRequest = _reflection.GeneratedProtocolMessageType('DropDatabaseRequest', (_message.Message,), dict( + DESCRIPTOR = _DROPDATABASEREQUEST, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """The request for + [DropDatabase][google.spanner.admin.database.v1.DatabaseAdmin.DropDatabase]. + + + Attributes: + database: + Required. The database to be dropped. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.DropDatabaseRequest) + )) +_sym_db.RegisterMessage(DropDatabaseRequest) + +GetDatabaseDdlRequest = _reflection.GeneratedProtocolMessageType('GetDatabaseDdlRequest', (_message.Message,), dict( + DESCRIPTOR = _GETDATABASEDDLREQUEST, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """The request for + [GetDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.GetDatabaseDdl]. + + + Attributes: + database: + Required. The database whose schema we wish to get. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.GetDatabaseDdlRequest) + )) +_sym_db.RegisterMessage(GetDatabaseDdlRequest) + +GetDatabaseDdlResponse = _reflection.GeneratedProtocolMessageType('GetDatabaseDdlResponse', (_message.Message,), dict( + DESCRIPTOR = _GETDATABASEDDLRESPONSE, + __module__ = 'google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2' + , + __doc__ = """The response for + [GetDatabaseDdl][google.spanner.admin.database.v1.DatabaseAdmin.GetDatabaseDdl]. + + + Attributes: + statements: + A list of formatted DDL statements defining the schema of the + database specified in the request. + """, + # @@protoc_insertion_point(class_scope:google.spanner.admin.database.v1.GetDatabaseDdlResponse) + )) +_sym_db.RegisterMessage(GetDatabaseDdlResponse) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n$com.google.spanner.admin.database.v1B\031SpannerDatabaseAdminProtoP\001ZHgoogle.golang.org/genproto/googleapis/spanner/admin/database/v1;database\252\002&Google.Cloud.Spanner.Admin.Database.V1')) +try: + # THESE ELEMENTS WILL BE DEPRECATED. + # Please use the generated *_pb2_grpc.py files instead. + import grpc + from grpc.beta import implementations as beta_implementations + from grpc.beta import interfaces as beta_interfaces + from grpc.framework.common import cardinality + from grpc.framework.interfaces.face import utilities as face_utilities + + + class DatabaseAdminStub(object): + """Cloud Spanner Database Admin API + + The Cloud Spanner Database Admin API can be used to create, drop, and + list databases. It also enables updating the schema of pre-existing + databases. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.ListDatabases = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/ListDatabases', + request_serializer=ListDatabasesRequest.SerializeToString, + response_deserializer=ListDatabasesResponse.FromString, + ) + self.CreateDatabase = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/CreateDatabase', + request_serializer=CreateDatabaseRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.GetDatabase = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabase', + request_serializer=GetDatabaseRequest.SerializeToString, + response_deserializer=Database.FromString, + ) + self.UpdateDatabaseDdl = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/UpdateDatabaseDdl', + request_serializer=UpdateDatabaseDdlRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.DropDatabase = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/DropDatabase', + request_serializer=DropDatabaseRequest.SerializeToString, + response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString, + ) + self.GetDatabaseDdl = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabaseDdl', + request_serializer=GetDatabaseDdlRequest.SerializeToString, + response_deserializer=GetDatabaseDdlResponse.FromString, + ) + self.SetIamPolicy = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/SetIamPolicy', + request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.SerializeToString, + response_deserializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + ) + self.GetIamPolicy = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/GetIamPolicy', + request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.SerializeToString, + response_deserializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + ) + self.TestIamPermissions = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/TestIamPermissions', + request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.SerializeToString, + response_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.FromString, + ) + + + class DatabaseAdminServicer(object): + """Cloud Spanner Database Admin API + + The Cloud Spanner Database Admin API can be used to create, drop, and + list databases. It also enables updating the schema of pre-existing + databases. + """ + + def ListDatabases(self, request, context): + """Lists Cloud Spanner databases. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateDatabase(self, request, context): + """Creates a new Cloud Spanner database and starts to prepare it for serving. + The returned [long-running operation][google.longrunning.Operation] will + have a name of the format `/operations/` and + can be used to track preparation of the database. The + [metadata][google.longrunning.Operation.metadata] field type is + [CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateDatabaseMetadata]. The + [response][google.longrunning.Operation.response] field type is + [Database][google.spanner.admin.database.v1.Database], if successful. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDatabase(self, request, context): + """Gets the state of a Cloud Spanner database. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateDatabaseDdl(self, request, context): + """Updates the schema of a Cloud Spanner database by + creating/altering/dropping tables, columns, indexes, etc. The returned + [long-running operation][google.longrunning.Operation] will have a name of + the format `/operations/` and can be used to + track execution of the schema change(s). The + [metadata][google.longrunning.Operation.metadata] field type is + [UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata]. The operation has no response. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropDatabase(self, request, context): + """Drops (aka deletes) a Cloud Spanner database. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDatabaseDdl(self, request, context): + """Returns the schema of a Cloud Spanner database as a list of formatted + DDL statements. This method does not show pending schema updates, those may + be queried using the [Operations][google.longrunning.Operations] API. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetIamPolicy(self, request, context): + """Sets the access control policy on a database resource. Replaces any + existing policy. + + Authorization requires `spanner.databases.setIamPolicy` permission on + [resource][google.iam.v1.SetIamPolicyRequest.resource]. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIamPolicy(self, request, context): + """Gets the access control policy for a database resource. Returns an empty + policy if a database exists but does not have a policy set. + + Authorization requires `spanner.databases.getIamPolicy` permission on + [resource][google.iam.v1.GetIamPolicyRequest.resource]. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TestIamPermissions(self, request, context): + """Returns permissions that the caller has on the specified database resource. + + Attempting this RPC on a non-existent Cloud Spanner database will result in + a NOT_FOUND error if the user has `spanner.databases.list` permission on + the containing Cloud Spanner instance. Otherwise returns an empty set of + permissions. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + + def add_DatabaseAdminServicer_to_server(servicer, server): + rpc_method_handlers = { + 'ListDatabases': grpc.unary_unary_rpc_method_handler( + servicer.ListDatabases, + request_deserializer=ListDatabasesRequest.FromString, + response_serializer=ListDatabasesResponse.SerializeToString, + ), + 'CreateDatabase': grpc.unary_unary_rpc_method_handler( + servicer.CreateDatabase, + request_deserializer=CreateDatabaseRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'GetDatabase': grpc.unary_unary_rpc_method_handler( + servicer.GetDatabase, + request_deserializer=GetDatabaseRequest.FromString, + response_serializer=Database.SerializeToString, + ), + 'UpdateDatabaseDdl': grpc.unary_unary_rpc_method_handler( + servicer.UpdateDatabaseDdl, + request_deserializer=UpdateDatabaseDdlRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'DropDatabase': grpc.unary_unary_rpc_method_handler( + servicer.DropDatabase, + request_deserializer=DropDatabaseRequest.FromString, + response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, + ), + 'GetDatabaseDdl': grpc.unary_unary_rpc_method_handler( + servicer.GetDatabaseDdl, + request_deserializer=GetDatabaseDdlRequest.FromString, + response_serializer=GetDatabaseDdlResponse.SerializeToString, + ), + 'SetIamPolicy': grpc.unary_unary_rpc_method_handler( + servicer.SetIamPolicy, + request_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.FromString, + response_serializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.SerializeToString, + ), + 'GetIamPolicy': grpc.unary_unary_rpc_method_handler( + servicer.GetIamPolicy, + request_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.FromString, + response_serializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.SerializeToString, + ), + 'TestIamPermissions': grpc.unary_unary_rpc_method_handler( + servicer.TestIamPermissions, + request_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.FromString, + response_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'google.spanner.admin.database.v1.DatabaseAdmin', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) + + + class BetaDatabaseAdminServicer(object): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This class was generated + only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0.""" + """Cloud Spanner Database Admin API + + The Cloud Spanner Database Admin API can be used to create, drop, and + list databases. It also enables updating the schema of pre-existing + databases. + """ + def ListDatabases(self, request, context): + """Lists Cloud Spanner databases. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def CreateDatabase(self, request, context): + """Creates a new Cloud Spanner database and starts to prepare it for serving. + The returned [long-running operation][google.longrunning.Operation] will + have a name of the format `/operations/` and + can be used to track preparation of the database. The + [metadata][google.longrunning.Operation.metadata] field type is + [CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateDatabaseMetadata]. The + [response][google.longrunning.Operation.response] field type is + [Database][google.spanner.admin.database.v1.Database], if successful. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def GetDatabase(self, request, context): + """Gets the state of a Cloud Spanner database. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def UpdateDatabaseDdl(self, request, context): + """Updates the schema of a Cloud Spanner database by + creating/altering/dropping tables, columns, indexes, etc. The returned + [long-running operation][google.longrunning.Operation] will have a name of + the format `/operations/` and can be used to + track execution of the schema change(s). The + [metadata][google.longrunning.Operation.metadata] field type is + [UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata]. The operation has no response. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def DropDatabase(self, request, context): + """Drops (aka deletes) a Cloud Spanner database. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def GetDatabaseDdl(self, request, context): + """Returns the schema of a Cloud Spanner database as a list of formatted + DDL statements. This method does not show pending schema updates, those may + be queried using the [Operations][google.longrunning.Operations] API. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def SetIamPolicy(self, request, context): + """Sets the access control policy on a database resource. Replaces any + existing policy. + + Authorization requires `spanner.databases.setIamPolicy` permission on + [resource][google.iam.v1.SetIamPolicyRequest.resource]. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def GetIamPolicy(self, request, context): + """Gets the access control policy for a database resource. Returns an empty + policy if a database exists but does not have a policy set. + + Authorization requires `spanner.databases.getIamPolicy` permission on + [resource][google.iam.v1.GetIamPolicyRequest.resource]. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + def TestIamPermissions(self, request, context): + """Returns permissions that the caller has on the specified database resource. + + Attempting this RPC on a non-existent Cloud Spanner database will result in + a NOT_FOUND error if the user has `spanner.databases.list` permission on + the containing Cloud Spanner instance. Otherwise returns an empty set of + permissions. + """ + context.code(beta_interfaces.StatusCode.UNIMPLEMENTED) + + + class BetaDatabaseAdminStub(object): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This class was generated + only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0.""" + """Cloud Spanner Database Admin API + + The Cloud Spanner Database Admin API can be used to create, drop, and + list databases. It also enables updating the schema of pre-existing + databases. + """ + def ListDatabases(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Lists Cloud Spanner databases. + """ + raise NotImplementedError() + ListDatabases.future = None + def CreateDatabase(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Creates a new Cloud Spanner database and starts to prepare it for serving. + The returned [long-running operation][google.longrunning.Operation] will + have a name of the format `/operations/` and + can be used to track preparation of the database. The + [metadata][google.longrunning.Operation.metadata] field type is + [CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateDatabaseMetadata]. The + [response][google.longrunning.Operation.response] field type is + [Database][google.spanner.admin.database.v1.Database], if successful. + """ + raise NotImplementedError() + CreateDatabase.future = None + def GetDatabase(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Gets the state of a Cloud Spanner database. + """ + raise NotImplementedError() + GetDatabase.future = None + def UpdateDatabaseDdl(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Updates the schema of a Cloud Spanner database by + creating/altering/dropping tables, columns, indexes, etc. The returned + [long-running operation][google.longrunning.Operation] will have a name of + the format `/operations/` and can be used to + track execution of the schema change(s). The + [metadata][google.longrunning.Operation.metadata] field type is + [UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata]. The operation has no response. + """ + raise NotImplementedError() + UpdateDatabaseDdl.future = None + def DropDatabase(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Drops (aka deletes) a Cloud Spanner database. + """ + raise NotImplementedError() + DropDatabase.future = None + def GetDatabaseDdl(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Returns the schema of a Cloud Spanner database as a list of formatted + DDL statements. This method does not show pending schema updates, those may + be queried using the [Operations][google.longrunning.Operations] API. + """ + raise NotImplementedError() + GetDatabaseDdl.future = None + def SetIamPolicy(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Sets the access control policy on a database resource. Replaces any + existing policy. + + Authorization requires `spanner.databases.setIamPolicy` permission on + [resource][google.iam.v1.SetIamPolicyRequest.resource]. + """ + raise NotImplementedError() + SetIamPolicy.future = None + def GetIamPolicy(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Gets the access control policy for a database resource. Returns an empty + policy if a database exists but does not have a policy set. + + Authorization requires `spanner.databases.getIamPolicy` permission on + [resource][google.iam.v1.GetIamPolicyRequest.resource]. + """ + raise NotImplementedError() + GetIamPolicy.future = None + def TestIamPermissions(self, request, timeout, metadata=None, with_call=False, protocol_options=None): + """Returns permissions that the caller has on the specified database resource. + + Attempting this RPC on a non-existent Cloud Spanner database will result in + a NOT_FOUND error if the user has `spanner.databases.list` permission on + the containing Cloud Spanner instance. Otherwise returns an empty set of + permissions. + """ + raise NotImplementedError() + TestIamPermissions.future = None + + + def beta_create_DatabaseAdmin_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This function was + generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" + request_deserializers = { + ('google.spanner.admin.database.v1.DatabaseAdmin', 'CreateDatabase'): CreateDatabaseRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'DropDatabase'): DropDatabaseRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabase'): GetDatabaseRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabaseDdl'): GetDatabaseDdlRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetIamPolicy'): google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'ListDatabases'): ListDatabasesRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'SetIamPolicy'): google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'TestIamPermissions'): google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'UpdateDatabaseDdl'): UpdateDatabaseDdlRequest.FromString, + } + response_serializers = { + ('google.spanner.admin.database.v1.DatabaseAdmin', 'CreateDatabase'): google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'DropDatabase'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabase'): Database.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabaseDdl'): GetDatabaseDdlResponse.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetIamPolicy'): google_dot_iam_dot_v1_dot_policy__pb2.Policy.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'ListDatabases'): ListDatabasesResponse.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'SetIamPolicy'): google_dot_iam_dot_v1_dot_policy__pb2.Policy.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'TestIamPermissions'): google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'UpdateDatabaseDdl'): google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + } + method_implementations = { + ('google.spanner.admin.database.v1.DatabaseAdmin', 'CreateDatabase'): face_utilities.unary_unary_inline(servicer.CreateDatabase), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'DropDatabase'): face_utilities.unary_unary_inline(servicer.DropDatabase), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabase'): face_utilities.unary_unary_inline(servicer.GetDatabase), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabaseDdl'): face_utilities.unary_unary_inline(servicer.GetDatabaseDdl), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetIamPolicy'): face_utilities.unary_unary_inline(servicer.GetIamPolicy), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'ListDatabases'): face_utilities.unary_unary_inline(servicer.ListDatabases), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'SetIamPolicy'): face_utilities.unary_unary_inline(servicer.SetIamPolicy), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'TestIamPermissions'): face_utilities.unary_unary_inline(servicer.TestIamPermissions), + ('google.spanner.admin.database.v1.DatabaseAdmin', 'UpdateDatabaseDdl'): face_utilities.unary_unary_inline(servicer.UpdateDatabaseDdl), + } + server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) + return beta_implementations.server(method_implementations, options=server_options) + + + def beta_create_DatabaseAdmin_stub(channel, host=None, metadata_transformer=None, pool=None, pool_size=None): + """The Beta API is deprecated for 0.15.0 and later. + + It is recommended to use the GA API (classes and functions in this + file not marked beta) for all further purposes. This function was + generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" + request_serializers = { + ('google.spanner.admin.database.v1.DatabaseAdmin', 'CreateDatabase'): CreateDatabaseRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'DropDatabase'): DropDatabaseRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabase'): GetDatabaseRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabaseDdl'): GetDatabaseDdlRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetIamPolicy'): google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'ListDatabases'): ListDatabasesRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'SetIamPolicy'): google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'TestIamPermissions'): google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.SerializeToString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'UpdateDatabaseDdl'): UpdateDatabaseDdlRequest.SerializeToString, + } + response_deserializers = { + ('google.spanner.admin.database.v1.DatabaseAdmin', 'CreateDatabase'): google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'DropDatabase'): google_dot_protobuf_dot_empty__pb2.Empty.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabase'): Database.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetDatabaseDdl'): GetDatabaseDdlResponse.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'GetIamPolicy'): google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'ListDatabases'): ListDatabasesResponse.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'SetIamPolicy'): google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'TestIamPermissions'): google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.FromString, + ('google.spanner.admin.database.v1.DatabaseAdmin', 'UpdateDatabaseDdl'): google_dot_longrunning_dot_operations__pb2.Operation.FromString, + } + cardinalities = { + 'CreateDatabase': cardinality.Cardinality.UNARY_UNARY, + 'DropDatabase': cardinality.Cardinality.UNARY_UNARY, + 'GetDatabase': cardinality.Cardinality.UNARY_UNARY, + 'GetDatabaseDdl': cardinality.Cardinality.UNARY_UNARY, + 'GetIamPolicy': cardinality.Cardinality.UNARY_UNARY, + 'ListDatabases': cardinality.Cardinality.UNARY_UNARY, + 'SetIamPolicy': cardinality.Cardinality.UNARY_UNARY, + 'TestIamPermissions': cardinality.Cardinality.UNARY_UNARY, + 'UpdateDatabaseDdl': cardinality.Cardinality.UNARY_UNARY, + } + stub_options = beta_implementations.stub_options(host=host, metadata_transformer=metadata_transformer, request_serializers=request_serializers, response_deserializers=response_deserializers, thread_pool=pool, thread_pool_size=pool_size) + return beta_implementations.dynamic_stub(channel, 'google.spanner.admin.database.v1.DatabaseAdmin', cardinalities, options=stub_options) +except ImportError: + pass +# @@protoc_insertion_point(module_scope) diff --git a/spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2_grpc.py b/spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2_grpc.py new file mode 100644 index 000000000000..5a88b9cb859f --- /dev/null +++ b/spanner/google/cloud/spanner_admin_database_v1/proto/spanner_database_admin_pb2_grpc.py @@ -0,0 +1,222 @@ +# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +import grpc + +import google.cloud.spanner.admin.database_v1.proto.spanner_database_admin_pb2 as google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2 +import google.iam.v1.iam_policy_pb2 as google_dot_iam_dot_v1_dot_iam__policy__pb2 +import google.iam.v1.policy_pb2 as google_dot_iam_dot_v1_dot_policy__pb2 +import google.longrunning.operations_pb2 as google_dot_longrunning_dot_operations__pb2 +import google.protobuf.empty_pb2 as google_dot_protobuf_dot_empty__pb2 + + +class DatabaseAdminStub(object): + """Cloud Spanner Database Admin API + + The Cloud Spanner Database Admin API can be used to create, drop, and + list databases. It also enables updating the schema of pre-existing + databases. + """ + + def __init__(self, channel): + """Constructor. + + Args: + channel: A grpc.Channel. + """ + self.ListDatabases = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/ListDatabases', + request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.ListDatabasesRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.ListDatabasesResponse.FromString, + ) + self.CreateDatabase = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/CreateDatabase', + request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.CreateDatabaseRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.GetDatabase = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabase', + request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.GetDatabaseRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.Database.FromString, + ) + self.UpdateDatabaseDdl = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/UpdateDatabaseDdl', + request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.UpdateDatabaseDdlRequest.SerializeToString, + response_deserializer=google_dot_longrunning_dot_operations__pb2.Operation.FromString, + ) + self.DropDatabase = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/DropDatabase', + request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.DropDatabaseRequest.SerializeToString, + response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString, + ) + self.GetDatabaseDdl = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/GetDatabaseDdl', + request_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.GetDatabaseDdlRequest.SerializeToString, + response_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.GetDatabaseDdlResponse.FromString, + ) + self.SetIamPolicy = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/SetIamPolicy', + request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.SerializeToString, + response_deserializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + ) + self.GetIamPolicy = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/GetIamPolicy', + request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.SerializeToString, + response_deserializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + ) + self.TestIamPermissions = channel.unary_unary( + '/google.spanner.admin.database.v1.DatabaseAdmin/TestIamPermissions', + request_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.SerializeToString, + response_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.FromString, + ) + + +class DatabaseAdminServicer(object): + """Cloud Spanner Database Admin API + + The Cloud Spanner Database Admin API can be used to create, drop, and + list databases. It also enables updating the schema of pre-existing + databases. + """ + + def ListDatabases(self, request, context): + """Lists Cloud Spanner databases. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def CreateDatabase(self, request, context): + """Creates a new Cloud Spanner database and starts to prepare it for serving. + The returned [long-running operation][google.longrunning.Operation] will + have a name of the format `/operations/` and + can be used to track preparation of the database. The + [metadata][google.longrunning.Operation.metadata] field type is + [CreateDatabaseMetadata][google.spanner.admin.database.v1.CreateDatabaseMetadata]. The + [response][google.longrunning.Operation.response] field type is + [Database][google.spanner.admin.database.v1.Database], if successful. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDatabase(self, request, context): + """Gets the state of a Cloud Spanner database. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def UpdateDatabaseDdl(self, request, context): + """Updates the schema of a Cloud Spanner database by + creating/altering/dropping tables, columns, indexes, etc. The returned + [long-running operation][google.longrunning.Operation] will have a name of + the format `/operations/` and can be used to + track execution of the schema change(s). The + [metadata][google.longrunning.Operation.metadata] field type is + [UpdateDatabaseDdlMetadata][google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata]. The operation has no response. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def DropDatabase(self, request, context): + """Drops (aka deletes) a Cloud Spanner database. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetDatabaseDdl(self, request, context): + """Returns the schema of a Cloud Spanner database as a list of formatted + DDL statements. This method does not show pending schema updates, those may + be queried using the [Operations][google.longrunning.Operations] API. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def SetIamPolicy(self, request, context): + """Sets the access control policy on a database resource. Replaces any + existing policy. + + Authorization requires `spanner.databases.setIamPolicy` permission on + [resource][google.iam.v1.SetIamPolicyRequest.resource]. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def GetIamPolicy(self, request, context): + """Gets the access control policy for a database resource. Returns an empty + policy if a database exists but does not have a policy set. + + Authorization requires `spanner.databases.getIamPolicy` permission on + [resource][google.iam.v1.GetIamPolicyRequest.resource]. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + def TestIamPermissions(self, request, context): + """Returns permissions that the caller has on the specified database resource. + + Attempting this RPC on a non-existent Cloud Spanner database will result in + a NOT_FOUND error if the user has `spanner.databases.list` permission on + the containing Cloud Spanner instance. Otherwise returns an empty set of + permissions. + """ + context.set_code(grpc.StatusCode.UNIMPLEMENTED) + context.set_details('Method not implemented!') + raise NotImplementedError('Method not implemented!') + + +def add_DatabaseAdminServicer_to_server(servicer, server): + rpc_method_handlers = { + 'ListDatabases': grpc.unary_unary_rpc_method_handler( + servicer.ListDatabases, + request_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.ListDatabasesRequest.FromString, + response_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.ListDatabasesResponse.SerializeToString, + ), + 'CreateDatabase': grpc.unary_unary_rpc_method_handler( + servicer.CreateDatabase, + request_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.CreateDatabaseRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'GetDatabase': grpc.unary_unary_rpc_method_handler( + servicer.GetDatabase, + request_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.GetDatabaseRequest.FromString, + response_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.Database.SerializeToString, + ), + 'UpdateDatabaseDdl': grpc.unary_unary_rpc_method_handler( + servicer.UpdateDatabaseDdl, + request_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.UpdateDatabaseDdlRequest.FromString, + response_serializer=google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, + ), + 'DropDatabase': grpc.unary_unary_rpc_method_handler( + servicer.DropDatabase, + request_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.DropDatabaseRequest.FromString, + response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, + ), + 'GetDatabaseDdl': grpc.unary_unary_rpc_method_handler( + servicer.GetDatabaseDdl, + request_deserializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.GetDatabaseDdlRequest.FromString, + response_serializer=google_dot_cloud_dot_spanner_dot_admin_dot_database__v1_dot_proto_dot_spanner__database__admin__pb2.GetDatabaseDdlResponse.SerializeToString, + ), + 'SetIamPolicy': grpc.unary_unary_rpc_method_handler( + servicer.SetIamPolicy, + request_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.FromString, + response_serializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.SerializeToString, + ), + 'GetIamPolicy': grpc.unary_unary_rpc_method_handler( + servicer.GetIamPolicy, + request_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.FromString, + response_serializer=google_dot_iam_dot_v1_dot_policy__pb2.Policy.SerializeToString, + ), + 'TestIamPermissions': grpc.unary_unary_rpc_method_handler( + servicer.TestIamPermissions, + request_deserializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.FromString, + response_serializer=google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.SerializeToString, + ), + } + generic_handler = grpc.method_handlers_generic_handler( + 'google.spanner.admin.database.v1.DatabaseAdmin', rpc_method_handlers) + server.add_generic_rpc_handlers((generic_handler,)) diff --git a/spanner/google/cloud/spanner_admin_database_v1/types.py b/spanner/google/cloud/spanner_admin_database_v1/types.py new file mode 100644 index 000000000000..eeb9c8bc799f --- /dev/null +++ b/spanner/google/cloud/spanner_admin_database_v1/types.py @@ -0,0 +1,52 @@ +# Copyright 2017, Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import absolute_import +import sys + +from google.gax.utils.messages import get_messages + +from google.api import auth_pb2 +from google.api import http_pb2 +from google.cloud.spanner_admin_database_v1.proto import spanner_database_admin_pb2 +from google.iam.v1 import iam_policy_pb2 +from google.iam.v1 import policy_pb2 +from google.iam.v1.logging import audit_data_pb2 +from google.longrunning import operations_pb2 +from google.protobuf import any_pb2 +from google.protobuf import descriptor_pb2 +from google.protobuf import empty_pb2 +from google.protobuf import timestamp_pb2 +from google.rpc import status_pb2 + +names = [] +for module in ( + auth_pb2, + http_pb2, + spanner_database_admin_pb2, + iam_policy_pb2, + policy_pb2, + audit_data_pb2, + operations_pb2, + any_pb2, + descriptor_pb2, + empty_pb2, + timestamp_pb2, + status_pb2, ): + for name, message in get_messages(module).items(): + message.__module__ = 'google.cloud.spanner_admin_database_v1.types' + setattr(sys.modules[__name__], name, message) + names.append(name) + +__all__ = tuple(sorted(names)) From 33d0ea7bc304fdaa8fdaf20885acc037935bf29f Mon Sep 17 00:00:00 2001 From: Luke Sneeringer Date: Fri, 22 Sep 2017 07:49:37 -0700 Subject: [PATCH 2/4] Update library to use admin_database autogen. * Remove dependency on gapic-google-cloud-spanner-admin-database-v1 * Update imports --- spanner/google/cloud/spanner/client.py | 2 +- spanner/setup.py | 10 ++++++---- spanner/tests/unit/test_client.py | 2 +- spanner/tests/unit/test_database.py | 14 +++++++------- 4 files changed, 15 insertions(+), 13 deletions(-) diff --git a/spanner/google/cloud/spanner/client.py b/spanner/google/cloud/spanner/client.py index 34e0a81c4fc4..384de839a9c8 100644 --- a/spanner/google/cloud/spanner/client.py +++ b/spanner/google/cloud/spanner/client.py @@ -27,7 +27,7 @@ from google.api.core import page_iterator from google.gax import INITIAL_PAGE # pylint: disable=line-too-long -from google.cloud.gapic.spanner_admin_database.v1.database_admin_client import ( # noqa +from google.cloud.spanner_admin_database_v1.gapic.database_admin_client import ( # noqa DatabaseAdminClient) from google.cloud.gapic.spanner_admin_instance.v1.instance_admin_client import ( # noqa InstanceAdminClient) diff --git a/spanner/setup.py b/spanner/setup.py index 2a69f7dfba9a..0ade9757eb9e 100644 --- a/spanner/setup.py +++ b/spanner/setup.py @@ -51,12 +51,14 @@ REQUIREMENTS = [ - 'google-cloud-core >= 0.27.0, < 0.28dev', - 'google-auth >= 1.1.0', - 'grpcio >= 1.2.0, < 2.0dev', 'gapic-google-cloud-spanner-v1 >= 0.15.0, < 0.16dev', - 'gapic-google-cloud-spanner-admin-database-v1 >= 0.15.0, < 0.16dev', 'gapic-google-cloud-spanner-admin-instance-v1 >= 0.15.0, < 0.16dev', + 'google-auth >= 1.1.0', + 'google-cloud-core >= 0.27.0, < 0.28dev', + 'google-gax>=0.15.15, <0.16dev', + 'googleapis-common-protos[grpc]>=1.5.2, <2.0dev', + 'grpc-google-iam-v1>=0.11.4, <0.12dev', + 'requests>=2.18.4, <3.0dev', ] setup( diff --git a/spanner/tests/unit/test_client.py b/spanner/tests/unit/test_client.py index 5fd79ab86ebb..7bb2efadc781 100644 --- a/spanner/tests/unit/test_client.py +++ b/spanner/tests/unit/test_client.py @@ -107,7 +107,7 @@ def test_constructor_credentials_wo_create_scoped(self): def test_admin_api_lib_name(self): from google.cloud.spanner import __version__ - from google.cloud.gapic.spanner_admin_database import v1 as db + from google.cloud.spanner_admin_database_v1 import gapic as db from google.cloud.gapic.spanner_admin_instance import v1 as inst # Get the actual admin client classes. diff --git a/spanner/tests/unit/test_database.py b/spanner/tests/unit/test_database.py index 851fec4a2175..0b154fd0f264 100644 --- a/spanner/tests/unit/test_database.py +++ b/spanner/tests/unit/test_database.py @@ -106,7 +106,7 @@ def test_ctor_w_ddl_statements_ok(self): self.assertEqual(list(database.ddl_statements), DDL_STATEMENTS) def test_from_pb_bad_database_name(self): - from google.cloud.proto.spanner.admin.database.v1 import ( + from google.cloud.spanner_admin_database_v1.proto import ( spanner_database_admin_pb2 as admin_v1_pb2) database_name = 'INCORRECT_FORMAT' @@ -117,7 +117,7 @@ def test_from_pb_bad_database_name(self): klass.from_pb(database_pb, None) def test_from_pb_project_mistmatch(self): - from google.cloud.proto.spanner.admin.database.v1 import ( + from google.cloud.spanner_admin_database_v1.proto import ( spanner_database_admin_pb2 as admin_v1_pb2) ALT_PROJECT = 'ALT_PROJECT' @@ -130,7 +130,7 @@ def test_from_pb_project_mistmatch(self): klass.from_pb(database_pb, instance) def test_from_pb_instance_mistmatch(self): - from google.cloud.proto.spanner.admin.database.v1 import ( + from google.cloud.spanner_admin_database_v1.proto import ( spanner_database_admin_pb2 as admin_v1_pb2) ALT_INSTANCE = '/projects/%s/instances/ALT-INSTANCE' % ( @@ -144,7 +144,7 @@ def test_from_pb_instance_mistmatch(self): klass.from_pb(database_pb, instance) def test_from_pb_success_w_explicit_pool(self): - from google.cloud.proto.spanner.admin.database.v1 import ( + from google.cloud.spanner_admin_database_v1.proto import ( spanner_database_admin_pb2 as admin_v1_pb2) client = _Client() @@ -161,7 +161,7 @@ def test_from_pb_success_w_explicit_pool(self): self.assertIs(database._pool, pool) def test_from_pb_success_w_hyphen_w_default_pool(self): - from google.cloud.proto.spanner.admin.database.v1 import ( + from google.cloud.spanner_admin_database_v1.proto import ( spanner_database_admin_pb2 as admin_v1_pb2) from google.cloud.spanner.pool import BurstyPool @@ -411,7 +411,7 @@ def test_exists_not_found(self): [('google-cloud-resource-prefix', database.name)]) def test_exists_success(self): - from google.cloud.proto.spanner.admin.database.v1 import ( + from google.cloud.spanner_admin_database_v1.proto import ( spanner_database_admin_pb2 as admin_v1_pb2) from tests._fixtures import DDL_STATEMENTS @@ -468,7 +468,7 @@ def test_reload_not_found(self): [('google-cloud-resource-prefix', database.name)]) def test_reload_success(self): - from google.cloud.proto.spanner.admin.database.v1 import ( + from google.cloud.spanner_admin_database_v1.proto import ( spanner_database_admin_pb2 as admin_v1_pb2) from tests._fixtures import DDL_STATEMENTS From 5d2510c44e0850f7c630e5972fe9e0843c91e015 Mon Sep 17 00:00:00 2001 From: Luke Sneeringer Date: Fri, 22 Sep 2017 08:48:07 -0700 Subject: [PATCH 3/4] Add documentation --- docs/spanner/gapic/v1/admin_database_api.rst | 6 ++++++ docs/spanner/gapic/v1/admin_database_types.rst | 5 +++++ docs/spanner/usage.rst | 3 +++ 3 files changed, 14 insertions(+) create mode 100644 docs/spanner/gapic/v1/admin_database_api.rst create mode 100644 docs/spanner/gapic/v1/admin_database_types.rst diff --git a/docs/spanner/gapic/v1/admin_database_api.rst b/docs/spanner/gapic/v1/admin_database_api.rst new file mode 100644 index 000000000000..c63f242e8557 --- /dev/null +++ b/docs/spanner/gapic/v1/admin_database_api.rst @@ -0,0 +1,6 @@ +Spanner Admin Database Client API +================================= + +.. automodule:: google.cloud.spanner_admin_database_v1 + :members: + :inherited-members: diff --git a/docs/spanner/gapic/v1/admin_database_types.rst b/docs/spanner/gapic/v1/admin_database_types.rst new file mode 100644 index 000000000000..de3d9585c715 --- /dev/null +++ b/docs/spanner/gapic/v1/admin_database_types.rst @@ -0,0 +1,5 @@ +Spanner Admin Database Client Types +=================================== + +.. automodule:: google.cloud.spanner_admin_database_v1.types + :members: diff --git a/docs/spanner/usage.rst b/docs/spanner/usage.rst index 762ec3894b03..4f0ef8d9f3e5 100644 --- a/docs/spanner/usage.rst +++ b/docs/spanner/usage.rst @@ -23,6 +23,9 @@ Spanner transaction-api streamed-api + gapic/v1/admin_database_api + gapic/v1/admin_database_types + API requests are sent to the `Cloud Spanner`_ API via RPC over HTTP/2. In order to support this, we'll rely on `gRPC`_. From e1bb60cb7045188780f8808fecffc5e6c1a157da Mon Sep 17 00:00:00 2001 From: Luke Sneeringer Date: Fri, 22 Sep 2017 08:59:47 -0700 Subject: [PATCH 4/4] Add auto-generated unit tests. --- .../gapic/v1/test_database_admin_client_v1.py | 506 ++++++++++++++++++ 1 file changed, 506 insertions(+) create mode 100644 spanner/tests/unit/gapic/v1/test_database_admin_client_v1.py diff --git a/spanner/tests/unit/gapic/v1/test_database_admin_client_v1.py b/spanner/tests/unit/gapic/v1/test_database_admin_client_v1.py new file mode 100644 index 000000000000..1f527dbca940 --- /dev/null +++ b/spanner/tests/unit/gapic/v1/test_database_admin_client_v1.py @@ -0,0 +1,506 @@ +# Copyright 2017, Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Unit tests.""" + +import mock +import unittest + +from google.gax import errors +from google.rpc import status_pb2 + +from google.cloud import spanner_admin_database_v1 +from google.cloud.spanner_admin_database_v1.proto import spanner_database_admin_pb2 +from google.iam.v1 import iam_policy_pb2 +from google.iam.v1 import policy_pb2 +from google.longrunning import operations_pb2 +from google.protobuf import empty_pb2 + + +class CustomException(Exception): + pass + + +class TestDatabaseAdminClient(unittest.TestCase): + @mock.patch('google.gax.config.create_stub', spec=True) + def test_list_databases(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + parent = client.instance_path('[PROJECT]', '[INSTANCE]') + + # Mock response + next_page_token = '' + databases_element = {} + databases = [databases_element] + expected_response = { + 'next_page_token': next_page_token, + 'databases': databases + } + expected_response = spanner_database_admin_pb2.ListDatabasesResponse( + **expected_response) + grpc_stub.ListDatabases.return_value = expected_response + + paged_list_response = client.list_databases(parent) + resources = list(paged_list_response) + self.assertEqual(1, len(resources)) + self.assertEqual(expected_response.databases[0], resources[0]) + + grpc_stub.ListDatabases.assert_called_once() + args, kwargs = grpc_stub.ListDatabases.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = spanner_database_admin_pb2.ListDatabasesRequest( + parent=parent) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.API_ERRORS', (CustomException, )) + @mock.patch('google.gax.config.create_stub', spec=True) + def test_list_databases_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + parent = client.instance_path('[PROJECT]', '[INSTANCE]') + + # Mock exception response + grpc_stub.ListDatabases.side_effect = CustomException() + + paged_list_response = client.list_databases(parent) + self.assertRaises(errors.GaxError, list, paged_list_response) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_create_database(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + parent = client.instance_path('[PROJECT]', '[INSTANCE]') + create_statement = 'createStatement552974828' + + # Mock response + name = 'name3373707' + expected_response = {'name': name} + expected_response = spanner_database_admin_pb2.Database( + **expected_response) + operation = operations_pb2.Operation( + name='operations/test_create_database', done=True) + operation.response.Pack(expected_response) + grpc_stub.CreateDatabase.return_value = operation + + response = client.create_database(parent, create_statement) + self.assertEqual(expected_response, response.result()) + + grpc_stub.CreateDatabase.assert_called_once() + args, kwargs = grpc_stub.CreateDatabase.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = spanner_database_admin_pb2.CreateDatabaseRequest( + parent=parent, create_statement=create_statement) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_create_database_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + parent = client.instance_path('[PROJECT]', '[INSTANCE]') + create_statement = 'createStatement552974828' + + # Mock exception response + error = status_pb2.Status() + operation = operations_pb2.Operation( + name='operations/test_create_database_exception', done=True) + operation.error.CopyFrom(error) + grpc_stub.CreateDatabase.return_value = operation + + response = client.create_database(parent, create_statement) + self.assertEqual(error, response.exception()) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_get_database(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + name = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + + # Mock response + name_2 = 'name2-1052831874' + expected_response = {'name': name_2} + expected_response = spanner_database_admin_pb2.Database( + **expected_response) + grpc_stub.GetDatabase.return_value = expected_response + + response = client.get_database(name) + self.assertEqual(expected_response, response) + + grpc_stub.GetDatabase.assert_called_once() + args, kwargs = grpc_stub.GetDatabase.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = spanner_database_admin_pb2.GetDatabaseRequest( + name=name) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.API_ERRORS', (CustomException, )) + @mock.patch('google.gax.config.create_stub', spec=True) + def test_get_database_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + name = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') + + # Mock exception response + grpc_stub.GetDatabase.side_effect = CustomException() + + self.assertRaises(errors.GaxError, client.get_database, name) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_update_database_ddl(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + database = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + statements = [] + + # Mock response + expected_response = {} + expected_response = empty_pb2.Empty(**expected_response) + operation = operations_pb2.Operation( + name='operations/test_update_database_ddl', done=True) + operation.response.Pack(expected_response) + grpc_stub.UpdateDatabaseDdl.return_value = operation + + response = client.update_database_ddl(database, statements) + self.assertEqual(expected_response, response.result()) + + grpc_stub.UpdateDatabaseDdl.assert_called_once() + args, kwargs = grpc_stub.UpdateDatabaseDdl.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = spanner_database_admin_pb2.UpdateDatabaseDdlRequest( + database=database, statements=statements) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_update_database_ddl_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + database = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + statements = [] + + # Mock exception response + error = status_pb2.Status() + operation = operations_pb2.Operation( + name='operations/test_update_database_ddl_exception', done=True) + operation.error.CopyFrom(error) + grpc_stub.UpdateDatabaseDdl.return_value = operation + + response = client.update_database_ddl(database, statements) + self.assertEqual(error, response.exception()) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_drop_database(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + database = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + + client.drop_database(database) + + grpc_stub.DropDatabase.assert_called_once() + args, kwargs = grpc_stub.DropDatabase.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = spanner_database_admin_pb2.DropDatabaseRequest( + database=database) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.API_ERRORS', (CustomException, )) + @mock.patch('google.gax.config.create_stub', spec=True) + def test_drop_database_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + database = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + + # Mock exception response + grpc_stub.DropDatabase.side_effect = CustomException() + + self.assertRaises(errors.GaxError, client.drop_database, database) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_get_database_ddl(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + database = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + + # Mock response + expected_response = {} + expected_response = spanner_database_admin_pb2.GetDatabaseDdlResponse( + **expected_response) + grpc_stub.GetDatabaseDdl.return_value = expected_response + + response = client.get_database_ddl(database) + self.assertEqual(expected_response, response) + + grpc_stub.GetDatabaseDdl.assert_called_once() + args, kwargs = grpc_stub.GetDatabaseDdl.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = spanner_database_admin_pb2.GetDatabaseDdlRequest( + database=database) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.API_ERRORS', (CustomException, )) + @mock.patch('google.gax.config.create_stub', spec=True) + def test_get_database_ddl_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + database = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + + # Mock exception response + grpc_stub.GetDatabaseDdl.side_effect = CustomException() + + self.assertRaises(errors.GaxError, client.get_database_ddl, database) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_set_iam_policy(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + resource = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + policy = {} + + # Mock response + version = 351608024 + etag = b'21' + expected_response = {'version': version, 'etag': etag} + expected_response = policy_pb2.Policy(**expected_response) + grpc_stub.SetIamPolicy.return_value = expected_response + + response = client.set_iam_policy(resource, policy) + self.assertEqual(expected_response, response) + + grpc_stub.SetIamPolicy.assert_called_once() + args, kwargs = grpc_stub.SetIamPolicy.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = iam_policy_pb2.SetIamPolicyRequest( + resource=resource, policy=policy) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.API_ERRORS', (CustomException, )) + @mock.patch('google.gax.config.create_stub', spec=True) + def test_set_iam_policy_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + resource = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + policy = {} + + # Mock exception response + grpc_stub.SetIamPolicy.side_effect = CustomException() + + self.assertRaises(errors.GaxError, client.set_iam_policy, resource, + policy) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_get_iam_policy(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + resource = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + + # Mock response + version = 351608024 + etag = b'21' + expected_response = {'version': version, 'etag': etag} + expected_response = policy_pb2.Policy(**expected_response) + grpc_stub.GetIamPolicy.return_value = expected_response + + response = client.get_iam_policy(resource) + self.assertEqual(expected_response, response) + + grpc_stub.GetIamPolicy.assert_called_once() + args, kwargs = grpc_stub.GetIamPolicy.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = iam_policy_pb2.GetIamPolicyRequest( + resource=resource) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.API_ERRORS', (CustomException, )) + @mock.patch('google.gax.config.create_stub', spec=True) + def test_get_iam_policy_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + resource = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + + # Mock exception response + grpc_stub.GetIamPolicy.side_effect = CustomException() + + self.assertRaises(errors.GaxError, client.get_iam_policy, resource) + + @mock.patch('google.gax.config.create_stub', spec=True) + def test_test_iam_permissions(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + resource = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + permissions = [] + + # Mock response + expected_response = {} + expected_response = iam_policy_pb2.TestIamPermissionsResponse( + **expected_response) + grpc_stub.TestIamPermissions.return_value = expected_response + + response = client.test_iam_permissions(resource, permissions) + self.assertEqual(expected_response, response) + + grpc_stub.TestIamPermissions.assert_called_once() + args, kwargs = grpc_stub.TestIamPermissions.call_args + self.assertEqual(len(args), 2) + self.assertEqual(len(kwargs), 1) + self.assertIn('metadata', kwargs) + actual_request = args[0] + + expected_request = iam_policy_pb2.TestIamPermissionsRequest( + resource=resource, permissions=permissions) + self.assertEqual(expected_request, actual_request) + + @mock.patch('google.gax.config.API_ERRORS', (CustomException, )) + @mock.patch('google.gax.config.create_stub', spec=True) + def test_test_iam_permissions_exception(self, mock_create_stub): + # Mock gRPC layer + grpc_stub = mock.Mock() + mock_create_stub.return_value = grpc_stub + + client = spanner_admin_database_v1.DatabaseAdminClient() + + # Mock request + resource = client.database_path('[PROJECT]', '[INSTANCE]', + '[DATABASE]') + permissions = [] + + # Mock exception response + grpc_stub.TestIamPermissions.side_effect = CustomException() + + self.assertRaises(errors.GaxError, client.test_iam_permissions, + resource, permissions)