| 17 |
import popen2 |
import popen2 |
| 18 |
import shutil |
import shutil |
| 19 |
import traceback |
import traceback |
| 20 |
|
import re |
| 21 |
|
|
| 22 |
import support |
import support |
| 23 |
|
|
| 185 |
raise RuntimeError("postmaster didn't start") |
raise RuntimeError("postmaster didn't start") |
| 186 |
|
|
| 187 |
def is_running(self): |
def is_running(self): |
| 188 |
"""Return true a postmaster process is running on self.dbdir |
"""Return whether a postmaster process is running on self.dbdir |
| 189 |
|
|
| 190 |
This method runs pg_ctl status on the dbdir so even if the |
This method runs pg_ctl status on the dbdir and returns True if |
| 191 |
object has just been created it is possible that this method |
that command succeeds and False otherwise. |
| 192 |
returns true if there's still a postmaster process running for |
|
| 193 |
self.dbdir. |
Note that it is possible that this method returns true even if |
| 194 |
|
the PostgreSQLServer instance has just been created and |
| 195 |
|
createdb() has not been called yet. This can happen, for |
| 196 |
|
instance, if the server has been started manually for debugging |
| 197 |
|
purposes after a test suite run. |
| 198 |
""" |
""" |
| 199 |
return run_boolean_command(["pg_ctl", "-D", self.dbdir, "status"]) |
return run_boolean_command(["pg_ctl", "-D", self.dbdir, "status"]) |
| 200 |
|
|
| 203 |
run_command(["pg_ctl", "-m", "fast", "-D", self.dbdir, "stop"], |
run_command(["pg_ctl", "-m", "fast", "-D", self.dbdir, "stop"], |
| 204 |
os.path.join(self.dbdir, "pg_ctl-stop.log")) |
os.path.join(self.dbdir, "pg_ctl-stop.log")) |
| 205 |
|
|
| 206 |
def new_postgis_db(self, dbname, tables = None, reference_systems = None): |
def new_postgis_db(self, dbname, tables = None, reference_systems = None, |
| 207 |
|
views = None): |
| 208 |
"""Create and return a new PostGISDatabase object using self as server |
"""Create and return a new PostGISDatabase object using self as server |
| 209 |
""" |
""" |
| 210 |
db = PostGISDatabase(self, self.postgis_sql, dbname, tables = tables, |
db = PostGISDatabase(self, self.postgis_sql, dbname, tables = tables, |
| 211 |
reference_systems = reference_systems) |
reference_systems = reference_systems, |
| 212 |
|
views = views) |
| 213 |
db.initdb() |
db.initdb() |
| 214 |
self.known_dbs[dbname] = db |
self.known_dbs[dbname] = db |
| 215 |
return db |
return db |
| 216 |
|
|
| 217 |
def get_static_data_db(self, dbname, tables, reference_systems): |
def get_static_data_db(self, dbname, tables, reference_systems, views): |
| 218 |
"""Return a PostGISDatabase for a database with the given static data |
"""Return a PostGISDatabase for a database with the given static data |
| 219 |
|
|
| 220 |
If no databasse of the name dbname exists, create a new one via |
If no databasse of the name dbname exists, create a new one via |
| 232 |
""" |
""" |
| 233 |
db = self.known_dbs.get(dbname) |
db = self.known_dbs.get(dbname) |
| 234 |
if db is not None: |
if db is not None: |
| 235 |
if db.has_data(tables, reference_systems): |
if db.has_data(tables, reference_systems, views): |
| 236 |
return db |
return db |
| 237 |
raise ValueError("PostGISDatabase named %r doesn't have tables %r" |
raise ValueError("PostGISDatabase named %r doesn't have tables %r" |
| 238 |
% (dbname, tables)) |
% (dbname, tables)) |
| 239 |
return self.new_postgis_db(dbname, tables, reference_systems) |
return self.new_postgis_db(dbname, tables, reference_systems, views) |
| 240 |
|
|
| 241 |
def get_default_static_data_db(self): |
def get_default_static_data_db(self): |
| 242 |
dbname = "PostGISStaticTests" |
dbname = "PostGISStaticTests" |
| 273 |
("srid", 1), |
("srid", 1), |
| 274 |
("gid_column", "point_id")]), |
("gid_column", "point_id")]), |
| 275 |
] |
] |
| 276 |
return self.get_static_data_db(dbname, tables, srids) |
views = [("v_landmarks", "SELECT * FROM landmarks_point_id")] |
| 277 |
|
return self.get_static_data_db(dbname, tables, srids, views) |
| 278 |
|
|
| 279 |
def connection_params(self, user): |
def connection_params(self, user): |
| 280 |
"""Return the connection parameters for the given user |
"""Return the connection parameters for the given user |
| 304 |
return " ".join(params) |
return " ".join(params) |
| 305 |
|
|
| 306 |
def execute_sql(self, dbname, user, sql): |
def execute_sql(self, dbname, user, sql): |
| 307 |
"""Execute the sql statament |
"""Execute the sql statament and return a result for SELECT statements |
| 308 |
|
|
| 309 |
The user parameter us used as in connection_params. The dbname |
The user parameter us used as in connection_params. The dbname |
| 310 |
parameter must be the name of a database in the cluster. |
parameter must be the name of a database in the cluster. The |
| 311 |
|
sql parameter is the SQL statement to execute as a string. If |
| 312 |
|
the string starts with 'select' (matched case insensitively) the |
| 313 |
|
first row of the result will be returned. Otherwise the return |
| 314 |
|
value is None. |
| 315 |
""" |
""" |
| 316 |
conn = psycopg.connect("dbname=%s " % dbname |
conn = psycopg.connect("dbname=%s " % dbname |
| 317 |
+ self.connection_string(user)) |
+ self.connection_string(user)) |
| 318 |
cursor = conn.cursor() |
cursor = conn.cursor() |
| 319 |
cursor.execute(sql) |
cursor.execute(sql) |
| 320 |
|
if sql.lower().startswith("select"): |
| 321 |
|
row = cursor.fetchone() |
| 322 |
|
else: |
| 323 |
|
row = None |
| 324 |
conn.commit() |
conn.commit() |
| 325 |
conn.close() |
conn.close() |
| 326 |
|
return row |
| 327 |
|
|
| 328 |
|
def server_version(self): |
| 329 |
|
"""Return the server version as a tuple (major, minor, patch) |
| 330 |
|
|
| 331 |
|
Each item in the tuple is an int. |
| 332 |
|
""" |
| 333 |
|
result = self.execute_sql("template1", "admin", "SELECT version();")[0] |
| 334 |
|
match = re.match(r"PostgreSQL (\d+\.\d+\.\d+)", result) |
| 335 |
|
if match: |
| 336 |
|
return tuple(map(int, match.group(1).split("."))) |
| 337 |
|
else: |
| 338 |
|
raise RutimeError("Cannot determine PostgreSQL server version" |
| 339 |
|
" from %r" % result) |
| 340 |
|
|
| 341 |
def require_authentication(self, required): |
def require_authentication(self, required): |
| 342 |
"""Switch authentication requirements on or off |
"""Switch authentication requirements on or off |
| 348 |
corresponding call to switch it off again in the test case' |
corresponding call to switch it off again in the test case' |
| 349 |
tearDown method or in a finally: block. |
tearDown method or in a finally: block. |
| 350 |
""" |
""" |
| 351 |
|
# Starting with PostgreSQL 7.3 the pg_hba.conf file has an |
| 352 |
|
# additional column with a username. Query the server version |
| 353 |
|
# and generate a file in the correct format. |
| 354 |
|
if self.server_version() >= (7, 3): |
| 355 |
|
user = "all" |
| 356 |
|
else: |
| 357 |
|
user = "" |
| 358 |
if required: |
if required: |
| 359 |
contents = "local all password\n" |
contents = "local all %s password\n" % user |
| 360 |
else: |
else: |
| 361 |
contents = "local all trust\n" |
contents = "local all %s trust\n" % user |
| 362 |
f = open(os.path.join(self.dbdir, "pg_hba.conf"), "w") |
f = open(os.path.join(self.dbdir, "pg_hba.conf"), "w") |
| 363 |
f.write(contents) |
f.write(contents) |
| 364 |
f.close() |
f.close() |
| 382 |
"""A PostGIS database in a PostgreSQLServer""" |
"""A PostGIS database in a PostgreSQLServer""" |
| 383 |
|
|
| 384 |
def __init__(self, server, postgis_sql, dbname, tables = None, |
def __init__(self, server, postgis_sql, dbname, tables = None, |
| 385 |
reference_systems = ()): |
reference_systems = (), views = None): |
| 386 |
"""Initialize the PostGISDatabase |
"""Initialize the PostGISDatabase |
| 387 |
|
|
| 388 |
Parameters: |
Parameters: |
| 408 |
(srid, params) pairs where srid is the srid defined by |
(srid, params) pairs where srid is the srid defined by |
| 409 |
the proj4 paramter string params. The srid can be given |
the proj4 paramter string params. The srid can be given |
| 410 |
as an extra parameter in the tables list. |
as an extra parameter in the tables list. |
| 411 |
|
|
| 412 |
|
views -- Optional description of views. If given it should |
| 413 |
|
be a list of (viewname, select_stmt) pairs where |
| 414 |
|
viewname is the name of the view to be created and |
| 415 |
|
select_stmt is the select statement to use as the basis. |
| 416 |
|
The views will be created after the tables and may refer |
| 417 |
|
to them in the select_stmt. |
| 418 |
""" |
""" |
| 419 |
self.server = server |
self.server = server |
| 420 |
self.postgis_sql = postgis_sql |
self.postgis_sql = postgis_sql |
| 421 |
self.dbname = dbname |
self.dbname = dbname |
| 422 |
self.tables = tables |
self.tables = tables |
| 423 |
|
self.views = views |
| 424 |
if reference_systems: |
if reference_systems: |
| 425 |
self.reference_systems = reference_systems |
self.reference_systems = reference_systems |
| 426 |
else: |
else: |
| 476 |
tablename, shapefile, kw = unpack(info) |
tablename, shapefile, kw = unpack(info) |
| 477 |
upload_shapefile(shapefile, self, tablename, **kw) |
upload_shapefile(shapefile, self, tablename, **kw) |
| 478 |
|
|
| 479 |
def has_data(self, tables, reference_systems): |
if self.views is not None: |
| 480 |
|
for viewname, select_stmt in self.views: |
| 481 |
|
self.server.execute_sql(self.dbname, "admin", |
| 482 |
|
"CREATE VIEW %s AS %s" % (viewname, |
| 483 |
|
select_stmt)) |
| 484 |
|
self.server.execute_sql(self.dbname, "admin", |
| 485 |
|
"GRANT SELECT ON %s TO PUBLIC;" |
| 486 |
|
% viewname) |
| 487 |
|
|
| 488 |
|
def has_data(self, tables, reference_systems, views): |
| 489 |
return (self.tables == tables |
return (self.tables == tables |
| 490 |
and self.reference_systems == reference_systems) |
and self.reference_systems == reference_systems |
| 491 |
|
and self.views == views) |
| 492 |
|
|
| 493 |
|
|
| 494 |
def find_postgis_sql(): |
def find_postgis_sql(): |
Parent Directory
| 
Revision Log
| 
Patch