Debian Codegraph @

django/db/backends/oracle/creation.py

raw
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 )