def createService(self, serviceFactory):
"""
Create a L{PostgresService} to use for building a store.
"""
dbRoot = FilePath(self.sharedDBPath)
if DB_TYPE[0] == POSTGRES_DIALECT:
return PostgresService(dbRoot,
serviceFactory,
current_sql_schema,
resetSchema=True,
databaseName="caldav",
options=[
"-c log_lock_waits=TRUE",
"-c log_statement=all",
"-c log_line_prefix='%p.%x '",
"-c fsync=FALSE",
"-c synchronous_commit=off",
"-c full_page_writes=FALSE",
"-c client-min-messages=warning",
],
testMode=True)
elif DB_TYPE[0] == ORACLE_DIALECT:
return OracleService(
dbRoot,
serviceFactory,
testMode=True,
dsnUser=self.options.get("dsnUser"),
)
def test_startService_withDumpFile(self):
"""
Assuming a properly configured environment ($PATH points at an 'initdb'
and 'postgres', $PYTHONPATH includes pgdb), starting a
L{PostgresService} will start the service passed to it, after importing
an existing dump file.
"""
test = self
class SimpleService1(Service):
instances = []
ready = Deferred()
def __init__(self, connectionFactory, storageService):
self.connection = connectionFactory()
test.addCleanup(self.connection.close)
self.instances.append(self)
def startService(self):
cursor = self.connection.cursor()
try:
cursor.execute(
"insert into import_test_table values ('value2')"
)
except:
self.ready.errback()
else:
self.ready.callback(None)
finally:
cursor.close()
# The SQL in importFile.sql will get executed, including the insertion of "value1"
importFileName = CachingFilePath(__file__).parent().child("importFile.sql").path
svc = PostgresService(
CachingFilePath("postgres_3.pgdb"),
SimpleService1,
"",
databaseName="dummy_db",
testMode=True,
importFileName=importFileName
)
svc.startService()
self.addCleanup(svc.stopService)
yield SimpleService1.ready
connection = SimpleService1.instances[0].connection
cursor = connection.cursor()
cursor.execute("select * from import_test_table")
values = cursor.fetchall()
self.assertEquals(values, [["value1"], ["value2"]])
def test_startService_Socket(self):
"""
Assuming a properly configured environment ($PATH points at an 'initdb'
and 'postgres', $PYTHONPATH includes pgdb), starting a
L{PostgresService} will start the service passed to it, after executing
the schema.
"""
test = self
class SimpleService2(Service):
instances = []
ready = Deferred()
def __init__(self, connectionFactory, storageService):
self.connection = connectionFactory()
test.addCleanup(self.connection.close)
self.instances.append(self)
def startService(self):
cursor = self.connection.cursor()
try:
cursor.execute(
"insert into test_dummy_table values ('dummy')"
)
except:
self.ready.errback()
else:
self.ready.callback(None)
finally:
cursor.close()
svc = PostgresService(
CachingFilePath("postgres_2.pgdb"),
SimpleService2,
"create table TEST_DUMMY_TABLE (stub varchar)",
databaseName="dummy_db",
listenAddresses=['127.0.0.1', ],
testMode=True
)
svc.startService()
self.addCleanup(svc.stopService)
yield SimpleService2.ready
connection = SimpleService2.instances[0].connection
cursor = connection.cursor()
cursor.execute("select * from test_dummy_table")
values = cursor.fetchall()
self.assertEquals(map(list, values), [["dummy"]])
def createService(self, serviceFactory):
"""
Create a L{PostgresService} to use for building a store.
"""
dbRoot = FilePath(self.sharedDBPath)
return PostgresService(dbRoot,
serviceFactory,
current_sql_schema,
resetSchema=True,
databaseName="caldav",
options=[
"-c log_lock_waits=TRUE",
"-c log_statement=all",
"-c log_line_prefix='%p.%x '",
"-c fsync=FALSE",
"-c synchronous_commit=off",
"-c full_page_writes=FALSE",
],
testMode=True)
def pgServiceFromConfig(config, subServiceFactory, uid=None, gid=None):
"""
Construct a L{PostgresService} from a given configuration and subservice.
@param config: the configuration to derive postgres configuration
parameters from.
@param subServiceFactory: A factory for the service to start once the
L{PostgresService} has been initialized.
@param uid: The user-ID to run the PostgreSQL server as.
@param gid: The group-ID to run the PostgreSQL server as.
@return: a service which can start postgres.
@rtype: L{PostgresService}
"""
dbRoot = CachingFilePath(config.DatabaseRoot)
# Construct a PostgresService exactly as the parent would, so that we
# can establish connection information.
return PostgresService(
dbRoot, subServiceFactory, current_sql_schema,
databaseName=config.Postgres.DatabaseName,
clusterName=config.Postgres.ClusterName,
logFile=config.Postgres.LogFile,
logDirectory=config.LogRoot if config.Postgres.LogRotation else "",
socketDir=config.Postgres.SocketDirectory,
listenAddresses=config.Postgres.ListenAddresses,
sharedBuffers=config.Postgres.SharedBuffers,
maxConnections=config.Postgres.MaxConnections,
options=config.Postgres.Options,
uid=uid, gid=gid,
spawnedDBUser=config.SpawnedDBUser,
importFileName=config.DBImportFile,
pgCtl=config.Postgres.Ctl,
initDB=config.Postgres.Init,
)
