def restore(self, source):
"""Restore from a backup to this database.
:type source: :class:`~google.cloud.spanner_v1.backup.Backup`
:param source: the path of the source being restored from.
:rtype: :class:`~google.api_core.operation.Operation`
:returns: a future used to poll the status of the create request
:raises Conflict: if the database already exists
:raises NotFound:
if the instance owning the database does not exist, or
if the backup being restored from does not exist
:raises ValueError: if backup is not set
"""
if source is None:
raise ValueError("Restore source not specified")
if type(self._encryption_config) == dict:
self._encryption_config = RestoreDatabaseEncryptionConfig(
**self._encryption_config)
if (self.encryption_config and self.encryption_config.kms_key_name
and self.encryption_config.encryption_type !=
RestoreDatabaseEncryptionConfig.EncryptionType.
CUSTOMER_MANAGED_ENCRYPTION):
raise ValueError(
"kms_key_name only used with CUSTOMER_MANAGED_ENCRYPTION")
api = self._instance._client.database_admin_api
metadata = _metadata_with_prefix(self.name)
request = RestoreDatabaseRequest(
parent=self._instance.name,
database_id=self.database_id,
backup=source.name,
encryption_config=self._encryption_config or None,
)
future = api.restore_database(
request=request,
metadata=metadata,
)
return future
def test_backup_workflow(
shared_instance,
shared_database,
database_version_time,
backups_to_delete,
databases_to_delete,
):
from google.cloud.spanner_admin_database_v1 import (
CreateBackupEncryptionConfig,
EncryptionConfig,
EncryptionInfo,
RestoreDatabaseEncryptionConfig,
)
backup_id = _helpers.unique_id("backup_id", separator="_")
expire_time = datetime.datetime.now(
datetime.timezone.utc) + datetime.timedelta(days=3)
encryption_enum = CreateBackupEncryptionConfig.EncryptionType
encryption_config = CreateBackupEncryptionConfig(
encryption_type=encryption_enum.GOOGLE_DEFAULT_ENCRYPTION, )
# Create backup.
backup = shared_instance.backup(
backup_id,
database=shared_database,
expire_time=expire_time,
version_time=database_version_time,
encryption_config=encryption_config,
)
operation = backup.create()
backups_to_delete.append(backup)
# Check metadata.
metadata = operation.metadata
assert backup.name == metadata.name
assert shared_database.name == metadata.database
operation.result() # blocks indefinitely
# Check backup object.
backup.reload()
assert shared_database.name == backup._database
assert expire_time == backup.expire_time
assert backup.create_time is not None
assert database_version_time == backup.version_time
assert backup.size_bytes is not None
assert backup.state is not None
assert (EncryptionInfo.Type.GOOGLE_DEFAULT_ENCRYPTION ==
backup.encryption_info.encryption_type)
# Update with valid argument.
valid_expire_time = datetime.datetime.now(
datetime.timezone.utc) + datetime.timedelta(days=7)
backup.update_expire_time(valid_expire_time)
assert valid_expire_time == backup.expire_time
# Restore database to same instance.
restored_id = _helpers.unique_id("restored_db", separator="_")
encryption_config = RestoreDatabaseEncryptionConfig(
encryption_type=RestoreDatabaseEncryptionConfig.EncryptionType.
GOOGLE_DEFAULT_ENCRYPTION, )
database = shared_instance.database(
restored_id,
encryption_config=encryption_config,
)
databases_to_delete.append(database)
operation = database.restore(source=backup)
restored_db = operation.result() # blocks indefinitely
assert database_version_time == restored_db.restore_info.backup_info.version_time
metadata = operation.metadata
assert database_version_time == metadata.backup_info.version_time
database.reload()
expected_encryption_config = EncryptionConfig()
assert expected_encryption_config == database.encryption_config
database.drop()
backup.delete()
assert not backup.exists()