| 1 |
import sys |
| 2 |
|
| 3 |
from django.conf import settings |
| 4 |
from django.db import DatabaseError |
| 5 |
from django.db.backends.base.creation import BaseDatabaseCreation |
| 6 |
from django.utils.crypto import get_random_string |
| 7 |
from django.utils.functional import cached_property |
| 8 |
|
| 9 |
TEST_DATABASE_PREFIX = "test_" |
| 10 |
|
| 11 |
|
| 12 |
class DatabaseCreation(BaseDatabaseCreation): |
| 13 |
@cached_property |
| 14 |
def _maindb_connection(self): |
| 15 |
""" |
| 16 |
This is analogous to other backends' `_nodb_connection` property, |
| 17 |
which allows access to an "administrative" connection which can |
| 18 |
be used to manage the test databases. |
| 19 |
For Oracle, the only connection that can be used for that purpose |
| 20 |
is the main (non-test) connection. |
| 21 |
""" |
| 22 |
settings_dict = settings.DATABASES[self.connection.alias] |
| 23 |
user = settings_dict.get("SAVED_USER") or settings_dict["USER"] |
| 24 |
password = settings_dict.get("SAVED_PASSWORD") or settings_dict["PASSWORD"] |
| 25 |
settings_dict = {**settings_dict, "USER": user, "PASSWORD": password} |
| 26 |
DatabaseWrapper = type(self.connection) |
| 27 |
return DatabaseWrapper(settings_dict, alias=self.connection.alias) |
| 28 |
|
| 29 |
def _create_test_db(self, verbosity=1, autoclobber=False, keepdb=False): |
| 30 |
parameters = self._get_test_db_params() |
| 31 |
with self._maindb_connection.cursor() as cursor: |
| 32 |
if self._test_database_create(): |
| 33 |
try: |
| 34 |
self._execute_test_db_creation( |
| 35 |
cursor, parameters, verbosity, keepdb |
| 36 |
) |
| 37 |
except Exception as e: |
| 38 |
if "ORA-01543" not in str(e): |
| 39 |
# All errors except "tablespace already exists" cancel tests |
| 40 |
self.log("Got an error creating the test database: %s" % e) |
| 41 |
sys.exit(2) |
| 42 |
if not autoclobber: |
| 43 |
confirm = input( |
| 44 |
"It appears the test database, %s, already exists. " |
| 45 |
"Type 'yes' to delete it, or 'no' to cancel: " |
| 46 |
% parameters["user"] |
| 47 |
) |
| 48 |
if autoclobber or confirm == "yes": |
| 49 |
if verbosity >= 1: |
| 50 |
self.log( |
| 51 |
"Destroying old test database for alias '%s'..." |
| 52 |
% self.connection.alias |
| 53 |
) |
| 54 |
try: |
| 55 |
self._execute_test_db_destruction( |
| 56 |
cursor, parameters, verbosity |
| 57 |
) |
| 58 |
except DatabaseError as e: |
| 59 |
if "ORA-29857" in str(e): |
| 60 |
self._handle_objects_preventing_db_destruction( |
| 61 |
cursor, parameters, verbosity, autoclobber |
| 62 |
) |
| 63 |
else: |
| 64 |
# Ran into a database error that isn't about |
| 65 |
# leftover objects in the tablespace. |
| 66 |
self.log( |
| 67 |
"Got an error destroying the old test database: %s" |
| 68 |
% e |
| 69 |
) |
| 70 |
sys.exit(2) |
| 71 |
except Exception as e: |
| 72 |
self.log( |
| 73 |
"Got an error destroying the old test database: %s" % e |
| 74 |
) |
| 75 |
sys.exit(2) |
| 76 |
try: |
| 77 |
self._execute_test_db_creation( |
| 78 |
cursor, parameters, verbosity, keepdb |
| 79 |
) |
| 80 |
except Exception as e: |
| 81 |
self.log( |
| 82 |
"Got an error recreating the test database: %s" % e |
| 83 |
) |
| 84 |
sys.exit(2) |
| 85 |
else: |
| 86 |
self.log("Tests cancelled.") |
| 87 |
sys.exit(1) |
| 88 |
|
| 89 |
if self._test_user_create(): |
| 90 |
if verbosity >= 1: |
| 91 |
self.log("Creating test user...") |
| 92 |
try: |
| 93 |
self._create_test_user(cursor, parameters, verbosity, keepdb) |
| 94 |
except Exception as e: |
| 95 |
if "ORA-01920" not in str(e): |
| 96 |
# All errors except "user already exists" cancel tests |
| 97 |
self.log("Got an error creating the test user: %s" % e) |
| 98 |
sys.exit(2) |
| 99 |
if not autoclobber: |
| 100 |
confirm = input( |
| 101 |
"It appears the test user, %s, already exists. Type " |
| 102 |
"'yes' to delete it, or 'no' to cancel: " |
| 103 |
% parameters["user"] |
| 104 |
) |
| 105 |
if autoclobber or confirm == "yes": |
| 106 |
try: |
| 107 |
if verbosity >= 1: |
| 108 |
self.log("Destroying old test user...") |
| 109 |
self._destroy_test_user(cursor, parameters, verbosity) |
| 110 |
if verbosity >= 1: |
| 111 |
self.log("Creating test user...") |
| 112 |
self._create_test_user( |
| 113 |
cursor, parameters, verbosity, keepdb |
| 114 |
) |
| 115 |
except Exception as e: |
| 116 |
self.log("Got an error recreating the test user: %s" % e) |
| 117 |
sys.exit(2) |
| 118 |
else: |
| 119 |
self.log("Tests cancelled.") |
| 120 |
sys.exit(1) |
| 121 |
# Done with main user -- test user and tablespaces created. |
| 122 |
self._maindb_connection.close() |
| 123 |
self._switch_to_test_user(parameters) |
| 124 |
return self.connection.settings_dict["NAME"] |
| 125 |
|
| 126 |
def _switch_to_test_user(self, parameters): |
| 127 |
""" |
| 128 |
Switch to the user that's used for creating the test database. |
| 129 |
|
| 130 |
Oracle doesn't have the concept of separate databases under the same |
| 131 |
user, so a separate user is used; see _create_test_db(). The main user |
| 132 |
is also needed for cleanup when testing is completed, so save its |
| 133 |
credentials in the SAVED_USER/SAVED_PASSWORD key in the settings dict. |
| 134 |
""" |
| 135 |
real_settings = settings.DATABASES[self.connection.alias] |
| 136 |
real_settings["SAVED_USER"] = self.connection.settings_dict["SAVED_USER"] = ( |
| 137 |
self.connection.settings_dict["USER"] |
| 138 |
) |
| 139 |
real_settings["SAVED_PASSWORD"] = self.connection.settings_dict[ |
| 140 |
"SAVED_PASSWORD" |
| 141 |
] = self.connection.settings_dict["PASSWORD"] |
| 142 |
real_test_settings = real_settings["TEST"] |
| 143 |
test_settings = self.connection.settings_dict["TEST"] |
| 144 |
real_test_settings["USER"] = real_settings["USER"] = test_settings["USER"] = ( |
| 145 |
self.connection.settings_dict["USER"] |
| 146 |
) = parameters["user"] |
| 147 |
real_settings["PASSWORD"] = self.connection.settings_dict["PASSWORD"] = ( |
| 148 |
parameters["password"] |
| 149 |
) |
| 150 |
|
| 151 |
def set_as_test_mirror(self, primary_settings_dict): |
| 152 |
""" |
| 153 |
Set this database up to be used in testing as a mirror of a primary |
| 154 |
database whose settings are given. |
| 155 |
""" |
| 156 |
self.connection.settings_dict["USER"] = primary_settings_dict["USER"] |
| 157 |
self.connection.settings_dict["PASSWORD"] = primary_settings_dict["PASSWORD"] |
| 158 |
|
| 159 |
def _handle_objects_preventing_db_destruction( |
| 160 |
self, cursor, parameters, verbosity, autoclobber |
| 161 |
): |
| 162 |
# There are objects in the test tablespace which prevent dropping it |
| 163 |
# The easy fix is to drop the test user -- but are we allowed to do so? |
| 164 |
self.log( |
| 165 |
"There are objects in the old test database which prevent its destruction." |
| 166 |
"\nIf they belong to the test user, deleting the user will allow the test " |
| 167 |
"database to be recreated.\n" |
| 168 |
"Otherwise, you will need to find and remove each of these objects, " |
| 169 |
"or use a different tablespace.\n" |
| 170 |
) |
| 171 |
if self._test_user_create(): |
| 172 |
if not autoclobber: |
| 173 |
confirm = input("Type 'yes' to delete user %s: " % parameters["user"]) |
| 174 |
if autoclobber or confirm == "yes": |
| 175 |
try: |
| 176 |
if verbosity >= 1: |
| 177 |
self.log("Destroying old test user...") |
| 178 |
self._destroy_test_user(cursor, parameters, verbosity) |
| 179 |
except Exception as e: |
| 180 |
self.log("Got an error destroying the test user: %s" % e) |
| 181 |
sys.exit(2) |
| 182 |
try: |
| 183 |
if verbosity >= 1: |
| 184 |
self.log( |
| 185 |
"Destroying old test database for alias '%s'..." |
| 186 |
% self.connection.alias |
| 187 |
) |
| 188 |
self._execute_test_db_destruction(cursor, parameters, verbosity) |
| 189 |
except Exception as e: |
| 190 |
self.log("Got an error destroying the test database: %s" % e) |
| 191 |
sys.exit(2) |
| 192 |
else: |
| 193 |
self.log("Tests cancelled -- test database cannot be recreated.") |
| 194 |
sys.exit(1) |
| 195 |
else: |
| 196 |
self.log( |
| 197 |
"Django is configured to use pre-existing test user '%s'," |
| 198 |
" and will not attempt to delete it." % parameters["user"] |
| 199 |
) |
| 200 |
self.log("Tests cancelled -- test database cannot be recreated.") |
| 201 |
sys.exit(1) |
| 202 |
|
| 203 |
def _destroy_test_db(self, test_database_name, verbosity=1): |
| 204 |
""" |
| 205 |
Destroy a test database, prompting the user for confirmation if the |
| 206 |
database already exists. Return the name of the test database created. |
| 207 |
""" |
| 208 |
if not self.connection.is_pool: |
| 209 |
self.connection.settings_dict["USER"] = self.connection.settings_dict[ |
| 210 |
"SAVED_USER" |
| 211 |
] |
| 212 |
self.connection.settings_dict["PASSWORD"] = self.connection.settings_dict[ |
| 213 |
"SAVED_PASSWORD" |
| 214 |
] |
| 215 |
self.connection.close() |
| 216 |
self.connection.close_pool() |
| 217 |
parameters = self._get_test_db_params() |
| 218 |
with self._maindb_connection.cursor() as cursor: |
| 219 |
if self._test_user_create(): |
| 220 |
if verbosity >= 1: |
| 221 |
self.log("Destroying test user...") |
| 222 |
self._destroy_test_user(cursor, parameters, verbosity) |
| 223 |
if self._test_database_create(): |
| 224 |
if verbosity >= 1: |
| 225 |
self.log("Destroying test database tables...") |
| 226 |
self._execute_test_db_destruction(cursor, parameters, verbosity) |
| 227 |
self._maindb_connection.close() |
| 228 |
self._maindb_connection.close_pool() |
| 229 |
|
| 230 |
def _execute_test_db_creation(self, cursor, parameters, verbosity, keepdb=False): |
| 231 |
if verbosity >= 2: |
| 232 |
self.log("_create_test_db(): dbname = %s" % parameters["user"]) |
| 233 |
if self._test_database_oracle_managed_files(): |
| 234 |
statements = [ |
| 235 |
""" |
| 236 |
CREATE TABLESPACE %(tblspace)s |
| 237 |
DATAFILE SIZE %(size)s |
| 238 |
AUTOEXTEND ON NEXT %(extsize)s MAXSIZE %(maxsize)s |
| 239 |
""", |
| 240 |
""" |
| 241 |
CREATE TEMPORARY TABLESPACE %(tblspace_temp)s |
| 242 |
TEMPFILE SIZE %(size_tmp)s |
| 243 |
AUTOEXTEND ON NEXT %(extsize_tmp)s MAXSIZE %(maxsize_tmp)s |
| 244 |
""", |
| 245 |
] |
| 246 |
else: |
| 247 |
statements = [ |
| 248 |
""" |
| 249 |
CREATE TABLESPACE %(tblspace)s |
| 250 |
DATAFILE '%(datafile)s' SIZE %(size)s REUSE |
| 251 |
AUTOEXTEND ON NEXT %(extsize)s MAXSIZE %(maxsize)s |
| 252 |
""", |
| 253 |
""" |
| 254 |
CREATE TEMPORARY TABLESPACE %(tblspace_temp)s |
| 255 |
TEMPFILE '%(datafile_tmp)s' SIZE %(size_tmp)s REUSE |
| 256 |
AUTOEXTEND ON NEXT %(extsize_tmp)s MAXSIZE %(maxsize_tmp)s |
| 257 |
""", |
| 258 |
] |
| 259 |
# Ignore "tablespace already exists" error when keepdb is on. |
| 260 |
acceptable_ora_err = "ORA-01543" if keepdb else None |
| 261 |
self._execute_allow_fail_statements( |
| 262 |
cursor, statements, parameters, verbosity, acceptable_ora_err |
| 263 |
) |
| 264 |
|
| 265 |
def _create_test_user(self, cursor, parameters, verbosity, keepdb=False): |
| 266 |
if verbosity >= 2: |
| 267 |
self.log("_create_test_user(): username = %s" % parameters["user"]) |
| 268 |
statements = [ |
| 269 |
"""CREATE USER %(user)s |
| 270 |
IDENTIFIED BY "%(password)s" |
| 271 |
DEFAULT TABLESPACE %(tblspace)s |
| 272 |
TEMPORARY TABLESPACE %(tblspace_temp)s |
| 273 |
QUOTA UNLIMITED ON %(tblspace)s |
| 274 |
""", |
| 275 |
"""GRANT CREATE SESSION, |
| 276 |
CREATE TABLE, |
| 277 |
CREATE SEQUENCE, |
| 278 |
CREATE PROCEDURE, |
| 279 |
CREATE TRIGGER |
| 280 |
TO %(user)s""", |
| 281 |
] |
| 282 |
# Ignore "user already exists" error when keepdb is on |
| 283 |
acceptable_ora_err = "ORA-01920" if keepdb else None |
| 284 |
success = self._execute_allow_fail_statements( |
| 285 |
cursor, statements, parameters, verbosity, acceptable_ora_err |
| 286 |
) |
| 287 |
# If the password was randomly generated, change the user accordingly. |
| 288 |
if not success and self._test_settings_get("PASSWORD") is None: |
| 289 |
set_password = 'ALTER USER %(user)s IDENTIFIED BY "%(password)s"' |
| 290 |
self._execute_statements(cursor, [set_password], parameters, verbosity) |
| 291 |
# Most test suites can be run without "create view" and |
| 292 |
# "create materialized view" privileges. But some need it. |
| 293 |
for object_type in ("VIEW", "MATERIALIZED VIEW"): |
| 294 |
extra = "GRANT CREATE %(object_type)s TO %(user)s" |
| 295 |
parameters["object_type"] = object_type |
| 296 |
success = self._execute_allow_fail_statements( |
| 297 |
cursor, [extra], parameters, verbosity, "ORA-01031" |
| 298 |
) |
| 299 |
if not success and verbosity >= 2: |
| 300 |
self.log( |
| 301 |
"Failed to grant CREATE %s permission to test user. This may be ok." |
| 302 |
% object_type |
| 303 |
) |
| 304 |
|
| 305 |
def _execute_test_db_destruction(self, cursor, parameters, verbosity): |
| 306 |
if verbosity >= 2: |
| 307 |
self.log("_execute_test_db_destruction(): dbname=%s" % parameters["user"]) |
| 308 |
statements = [ |
| 309 |
"DROP TABLESPACE %(tblspace)s " |
| 310 |
"INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS", |
| 311 |
"DROP TABLESPACE %(tblspace_temp)s " |
| 312 |
"INCLUDING CONTENTS AND DATAFILES CASCADE CONSTRAINTS", |
| 313 |
] |
| 314 |
self._execute_statements(cursor, statements, parameters, verbosity) |
| 315 |
|
| 316 |
def _destroy_test_user(self, cursor, parameters, verbosity): |
| 317 |
if verbosity >= 2: |
| 318 |
self.log("_destroy_test_user(): user=%s" % parameters["user"]) |
| 319 |
self.log("Be patient. This can take some time...") |
| 320 |
statements = [ |
| 321 |
"DROP USER %(user)s CASCADE", |
| 322 |
] |
| 323 |
self._execute_statements(cursor, statements, parameters, verbosity) |
| 324 |
|
| 325 |
def _execute_statements( |
| 326 |
self, cursor, statements, parameters, verbosity, allow_quiet_fail=False |
| 327 |
): |
| 328 |
for template in statements: |
| 329 |
stmt = template % parameters |
| 330 |
if verbosity >= 2: |
| 331 |
print(stmt) |
| 332 |
try: |
| 333 |
cursor.execute(stmt) |
| 334 |
except Exception as err: |
| 335 |
if (not allow_quiet_fail) or verbosity >= 2: |
| 336 |
self.log("Failed (%s)" % (err)) |
| 337 |
raise |
| 338 |
|
| 339 |
def _execute_allow_fail_statements( |
| 340 |
self, cursor, statements, parameters, verbosity, acceptable_ora_err |
| 341 |
): |
| 342 |
""" |
| 343 |
Execute statements which are allowed to fail silently if the Oracle |
| 344 |
error code given by `acceptable_ora_err` is raised. Return True if the |
| 345 |
statements execute without an exception, or False otherwise. |
| 346 |
""" |
| 347 |
try: |
| 348 |
# Statement can fail when acceptable_ora_err is not None |
| 349 |
allow_quiet_fail = ( |
| 350 |
acceptable_ora_err is not None and len(acceptable_ora_err) > 0 |
| 351 |
) |
| 352 |
self._execute_statements( |
| 353 |
cursor, |
| 354 |
statements, |
| 355 |
parameters, |
| 356 |
verbosity, |
| 357 |
allow_quiet_fail=allow_quiet_fail, |
| 358 |
) |
| 359 |
return True |
| 360 |
except DatabaseError as err: |
| 361 |
description = str(err) |
| 362 |
if acceptable_ora_err is None or acceptable_ora_err not in description: |
| 363 |
raise |
| 364 |
return False |
| 365 |
|
| 366 |
def _get_test_db_params(self): |
| 367 |
return { |
| 368 |
"dbname": self._test_database_name(), |
| 369 |
"user": self._test_database_user(), |
| 370 |
"password": self._test_database_passwd(), |
| 371 |
"tblspace": self._test_database_tblspace(), |
| 372 |
"tblspace_temp": self._test_database_tblspace_tmp(), |
| 373 |
"datafile": self._test_database_tblspace_datafile(), |
| 374 |
"datafile_tmp": self._test_database_tblspace_tmp_datafile(), |
| 375 |
"maxsize": self._test_database_tblspace_maxsize(), |
| 376 |
"maxsize_tmp": self._test_database_tblspace_tmp_maxsize(), |
| 377 |
"size": self._test_database_tblspace_size(), |
| 378 |
"size_tmp": self._test_database_tblspace_tmp_size(), |
| 379 |
"extsize": self._test_database_tblspace_extsize(), |
| 380 |
"extsize_tmp": self._test_database_tblspace_tmp_extsize(), |
| 381 |
} |
| 382 |
|
| 383 |
def _test_settings_get(self, key, default=None, prefixed=None): |
| 384 |
""" |
| 385 |
Return a value from the test settings dict, or a given default, or a |
| 386 |
prefixed entry from the main settings dict. |
| 387 |
""" |
| 388 |
settings_dict = self.connection.settings_dict |
| 389 |
val = settings_dict["TEST"].get(key, default) |
| 390 |
if val is None and prefixed: |
| 391 |
val = TEST_DATABASE_PREFIX + settings_dict[prefixed] |
| 392 |
return val |
| 393 |
|
| 394 |
def _test_database_name(self): |
| 395 |
return self._test_settings_get("NAME", prefixed="NAME") |
| 396 |
|
| 397 |
def _test_database_create(self): |
| 398 |
return self._test_settings_get("CREATE_DB", default=True) |
| 399 |
|
| 400 |
def _test_user_create(self): |
| 401 |
return self._test_settings_get("CREATE_USER", default=True) |
| 402 |
|
| 403 |
def _test_database_user(self): |
| 404 |
return self._test_settings_get("USER", prefixed="USER") |
| 405 |
|
| 406 |
def _test_database_passwd(self): |
| 407 |
password = self._test_settings_get("PASSWORD") |
| 408 |
if password is None and self._test_user_create(): |
| 409 |
# Oracle passwords are limited to 30 chars and can't contain symbols. |
| 410 |
password = get_random_string(30) |
| 411 |
return password |
| 412 |
|
| 413 |
def _test_database_tblspace(self): |
| 414 |
return self._test_settings_get("TBLSPACE", prefixed="USER") |
| 415 |
|
| 416 |
def _test_database_tblspace_tmp(self): |
| 417 |
settings_dict = self.connection.settings_dict |
| 418 |
return settings_dict["TEST"].get( |
| 419 |
"TBLSPACE_TMP", TEST_DATABASE_PREFIX + settings_dict["USER"] + "_temp" |
| 420 |
) |
| 421 |
|
| 422 |
def _test_database_tblspace_datafile(self): |
| 423 |
tblspace = "%s.dbf" % self._test_database_tblspace() |
| 424 |
return self._test_settings_get("DATAFILE", default=tblspace) |
| 425 |
|
| 426 |
def _test_database_tblspace_tmp_datafile(self): |
| 427 |
tblspace = "%s.dbf" % self._test_database_tblspace_tmp() |
| 428 |
return self._test_settings_get("DATAFILE_TMP", default=tblspace) |
| 429 |
|
| 430 |
def _test_database_tblspace_maxsize(self): |
| 431 |
return self._test_settings_get("DATAFILE_MAXSIZE", default="500M") |
| 432 |
|
| 433 |
def _test_database_tblspace_tmp_maxsize(self): |
| 434 |
return self._test_settings_get("DATAFILE_TMP_MAXSIZE", default="500M") |
| 435 |
|
| 436 |
def _test_database_tblspace_size(self): |
| 437 |
return self._test_settings_get("DATAFILE_SIZE", default="50M") |
| 438 |
|
| 439 |
def _test_database_tblspace_tmp_size(self): |
| 440 |
return self._test_settings_get("DATAFILE_TMP_SIZE", default="50M") |
| 441 |
|
| 442 |
def _test_database_tblspace_extsize(self): |
| 443 |
return self._test_settings_get("DATAFILE_EXTSIZE", default="25M") |
| 444 |
|
| 445 |
def _test_database_tblspace_tmp_extsize(self): |
| 446 |
return self._test_settings_get("DATAFILE_TMP_EXTSIZE", default="25M") |
| 447 |
|
| 448 |
def _test_database_oracle_managed_files(self): |
| 449 |
return self._test_settings_get("ORACLE_MANAGED_FILES", default=False) |
| 450 |
|
| 451 |
def _get_test_db_name(self): |
| 452 |
""" |
| 453 |
Return the 'production' DB name to get the test DB creation machinery |
| 454 |
to work. This isn't a great deal in this case because DB names as |
| 455 |
handled by Django don't have real counterparts in Oracle. |
| 456 |
""" |
| 457 |
return self.connection.settings_dict["NAME"] |
| 458 |
|
| 459 |
def test_db_signature(self): |
| 460 |
settings_dict = self.connection.settings_dict |
| 461 |
return ( |
| 462 |
settings_dict["HOST"], |
| 463 |
settings_dict["PORT"], |
| 464 |
settings_dict["ENGINE"], |
| 465 |
settings_dict["NAME"], |
| 466 |
self._test_database_user(), |
| 467 |
) |