| import os, re, sys |
| |
| from django.conf import settings |
| from django.core.management import call_command |
| from django.db import connection |
| from django.db.backends.creation import TEST_DATABASE_PREFIX |
| |
| def getstatusoutput(cmd): |
| "A simpler version of getstatusoutput that works on win32 platforms." |
| stdin, stdout, stderr = os.popen3(cmd) |
| output = stdout.read() |
| if output.endswith('\n'): output = output[:-1] |
| status = stdin.close() |
| return status, output |
| |
| def create_lang(db_name, verbosity=1): |
| "Sets up the pl/pgsql language on the given database." |
| |
| # Getting the command-line options for the shell command |
| options = get_cmd_options(db_name) |
| |
| # Constructing the 'createlang' command. |
| createlang_cmd = 'createlang %splpgsql' % options |
| if verbosity >= 1: print createlang_cmd |
| |
| # Must have database super-user privileges to execute createlang -- it must |
| # also be in your path. |
| status, output = getstatusoutput(createlang_cmd) |
| |
| # Checking the status of the command, 0 => execution successful |
| if status: |
| raise Exception("Error executing 'plpgsql' command: %s\n" % output) |
| |
| def _create_with_cursor(db_name, verbosity=1, autoclobber=False): |
| "Creates database with psycopg2 cursor." |
| |
| # Constructing the necessary SQL to create the database (the DATABASE_USER |
| # must possess the privileges to create a database) |
| create_sql = 'CREATE DATABASE %s' % connection.ops.quote_name(db_name) |
| if settings.DATABASE_USER: |
| create_sql += ' OWNER %s' % settings.DATABASE_USER |
| |
| cursor = connection.cursor() |
| connection.creation.set_autocommit() |
| |
| try: |
| # Trying to create the database first. |
| cursor.execute(create_sql) |
| #print create_sql |
| except Exception, e: |
| # Drop and recreate, if necessary. |
| if not autoclobber: |
| confirm = raw_input("\nIt appears the database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % db_name) |
| if autoclobber or confirm == 'yes': |
| if verbosity >= 1: print 'Destroying old spatial database...' |
| drop_db(db_name) |
| if verbosity >= 1: print 'Creating new spatial database...' |
| cursor.execute(create_sql) |
| else: |
| raise Exception('Spatial Database Creation canceled.') |
| |
| created_regex = re.compile(r'^createdb: database creation failed: ERROR: database ".+" already exists') |
| def _create_with_shell(db_name, verbosity=1, autoclobber=False): |
| """ |
| If no spatial database already exists, then using a cursor will not work. |
| Thus, a `createdb` command will be issued through the shell to bootstrap |
| creation of the spatial database. |
| """ |
| |
| # Getting the command-line options for the shell command |
| options = get_cmd_options(False) |
| create_cmd = 'createdb -O %s %s%s' % (settings.DATABASE_USER, options, db_name) |
| if verbosity >= 1: print create_cmd |
| |
| # Attempting to create the database. |
| status, output = getstatusoutput(create_cmd) |
| |
| if status: |
| if created_regex.match(output): |
| if not autoclobber: |
| confirm = raw_input("\nIt appears the database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % db_name) |
| if autoclobber or confirm == 'yes': |
| if verbosity >= 1: print 'Destroying old spatial database...' |
| drop_cmd = 'dropdb %s%s' % (options, db_name) |
| status, output = getstatusoutput(drop_cmd) |
| if status != 0: |
| raise Exception('Could not drop database %s: %s' % (db_name, output)) |
| if verbosity >= 1: print 'Creating new spatial database...' |
| status, output = getstatusoutput(create_cmd) |
| if status != 0: |
| raise Exception('Could not create database after dropping: %s' % output) |
| else: |
| raise Exception('Spatial Database Creation canceled.') |
| else: |
| raise Exception('Unknown error occurred in creating database: %s' % output) |
| |
| def create_spatial_db(test=False, verbosity=1, autoclobber=False, interactive=False): |
| "Creates a spatial database based on the settings." |
| |
| # Making sure we're using PostgreSQL and psycopg2 |
| if settings.DATABASE_ENGINE != 'postgresql_psycopg2': |
| raise Exception('Spatial database creation only supported postgresql_psycopg2 platform.') |
| |
| # Getting the spatial database name |
| if test: |
| db_name = get_spatial_db(test=True) |
| _create_with_cursor(db_name, verbosity=verbosity, autoclobber=autoclobber) |
| else: |
| db_name = get_spatial_db() |
| _create_with_shell(db_name, verbosity=verbosity, autoclobber=autoclobber) |
| |
| # Creating the db language, does not need to be done on NT platforms |
| # since the PostGIS installer enables this capability. |
| if os.name != 'nt': |
| create_lang(db_name, verbosity=verbosity) |
| |
| # Now adding in the PostGIS routines. |
| load_postgis_sql(db_name, verbosity=verbosity) |
| |
| if verbosity >= 1: print 'Creation of spatial database %s successful.' % db_name |
| |
| # Closing the connection |
| connection.close() |
| settings.DATABASE_NAME = db_name |
| |
| # Syncing the database |
| call_command('syncdb', verbosity=verbosity, interactive=interactive) |
| |
| def drop_db(db_name=False, test=False): |
| """ |
| Drops the given database (defaults to what is returned from |
| get_spatial_db()). All exceptions are propagated up to the caller. |
| """ |
| if not db_name: db_name = get_spatial_db(test=test) |
| cursor = connection.cursor() |
| cursor.execute('DROP DATABASE %s' % connection.ops.quote_name(db_name)) |
| |
| def get_cmd_options(db_name): |
| "Obtains the command-line PostgreSQL connection options for shell commands." |
| # The db_name parameter is optional |
| options = '' |
| if db_name: |
| options += '-d %s ' % db_name |
| if settings.DATABASE_USER: |
| options += '-U %s ' % settings.DATABASE_USER |
| if settings.DATABASE_HOST: |
| options += '-h %s ' % settings.DATABASE_HOST |
| if settings.DATABASE_PORT: |
| options += '-p %s ' % settings.DATABASE_PORT |
| return options |
| |
| def get_spatial_db(test=False): |
| """ |
| Returns the name of the spatial database. The 'test' keyword may be set |
| to return the test spatial database name. |
| """ |
| if test: |
| if settings.TEST_DATABASE_NAME: |
| test_db_name = settings.TEST_DATABASE_NAME |
| else: |
| test_db_name = TEST_DATABASE_PREFIX + settings.DATABASE_NAME |
| return test_db_name |
| else: |
| if not settings.DATABASE_NAME: |
| raise Exception('must configure DATABASE_NAME in settings.py') |
| return settings.DATABASE_NAME |
| |
| def load_postgis_sql(db_name, verbosity=1): |
| """ |
| This routine loads up the PostGIS SQL files lwpostgis.sql and |
| spatial_ref_sys.sql. |
| """ |
| |
| # Getting the path to the PostGIS SQL |
| try: |
| # POSTGIS_SQL_PATH may be placed in settings to tell GeoDjango where the |
| # PostGIS SQL files are located. This is especially useful on Win32 |
| # platforms since the output of pg_config looks like "C:/PROGRA~1/..". |
| sql_path = settings.POSTGIS_SQL_PATH |
| except AttributeError: |
| status, sql_path = getstatusoutput('pg_config --sharedir') |
| if status: |
| sql_path = '/usr/local/share' |
| |
| # The PostGIS SQL post-creation files. |
| lwpostgis_file = os.path.join(sql_path, 'lwpostgis.sql') |
| srefsys_file = os.path.join(sql_path, 'spatial_ref_sys.sql') |
| if not os.path.isfile(lwpostgis_file): |
| raise Exception('Could not find PostGIS function definitions in %s' % lwpostgis_file) |
| if not os.path.isfile(srefsys_file): |
| raise Exception('Could not find PostGIS spatial reference system definitions in %s' % srefsys_file) |
| |
| # Getting the psql command-line options, and command format. |
| options = get_cmd_options(db_name) |
| cmd_fmt = 'psql %s-f "%%s"' % options |
| |
| # Now trying to load up the PostGIS functions |
| cmd = cmd_fmt % lwpostgis_file |
| if verbosity >= 1: print cmd |
| status, output = getstatusoutput(cmd) |
| if status: |
| raise Exception('Error in loading PostGIS lwgeometry routines.') |
| |
| # Now trying to load up the Spatial Reference System table |
| cmd = cmd_fmt % srefsys_file |
| if verbosity >= 1: print cmd |
| status, output = getstatusoutput(cmd) |
| if status: |
| raise Exception('Error in loading PostGIS spatial_ref_sys table.') |
| |
| # Setting the permissions because on Windows platforms the owner |
| # of the spatial_ref_sys and geometry_columns tables is always |
| # the postgres user, regardless of how the db is created. |
| if os.name == 'nt': set_permissions(db_name) |
| |
| def set_permissions(db_name): |
| """ |
| Sets the permissions on the given database to that of the user specified |
| in the settings. Needed specifically for PostGIS on Win32 platforms. |
| """ |
| cursor = connection.cursor() |
| user = settings.DATABASE_USER |
| cursor.execute('ALTER TABLE geometry_columns OWNER TO %s' % user) |
| cursor.execute('ALTER TABLE spatial_ref_sys OWNER TO %s' % user) |
