def __init__(self, tracker_home, optimize=0):
"""New-style tracker instance constructor
Parameters:
tracker_home:
tracker home directory
optimize:
if set, precompile html templates
"""
self.tracker_home = tracker_home
self.optimize = optimize
self.config = configuration.CoreConfig(tracker_home)
self.ajax_actions = {}
self.load_interfaces()
self.backend = backends.get_backend(self.get_backend_name())
if self.optimize:
# initialize tracker extensions
for extension in self.get_extensions('extensions'):
extension(self)
# load database schema
schemafilename = os.path.join(self.tracker_home, 'schema.py')
# Note: can't use built-in open()
# because of the global function with the same name
schemafile = file(schemafilename, 'rt')
self.schema = compile(schemafile.read(), schemafilename, 'exec')
schemafile.close()
# load database detectors
self.detectors = self.get_extensions('detectors')
# db_open is set to True after first open()
self.db_open = 0
def setUp(self):
backend = backends.get_backend('anydbm')
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = backend.Database(config, 'admin')
setupSchema(self.db, 1, backend)
def setUp(self):
backend = backends.get_backend('anydbm')
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = backend.Database(config, 'admin')
setupSchema(self.db, 1, backend)
class mysqlOpener:
if have_backend('mysql'):
module = get_backend('mysql')
def setUp(self):
self.module.db_nuke(config)
def tearDown(self):
self.db.close()
self.nuke_database()
def nuke_database(self):
self.module.db_nuke(config)
class tsearch2Opener:
if have_backend('tsearch2'):
module = get_backend('tsearch2')
def setUp(self):
pass
def tearDown(self):
self.nuke_database()
def nuke_database(self):
# clear out the database - easiest way is to nuke and re-create it
self.module.db_nuke(config)
def __init__(self, tracker_home, optimize=0):
"""New-style tracker instance constructor
Parameters:
tracker_home:
tracker home directory
optimize:
if set, precompile html templates
"""
self.tracker_home = tracker_home
self.optimize = optimize
# if set, call schema_hook after executing schema.py will get
# same variables (in particular db) as schema.py main purpose is
# for regression tests
self.schema_hook = None
self.config = configuration.CoreConfig(tracker_home)
self.actions = {}
self.cgi_actions = {}
self.templating_utils = {}
self.load_interfaces()
self.templates = templating.Templates(self.config["TEMPLATES"])
self.backend = backends.get_backend(self.get_backend_name())
if self.optimize:
libdir = os.path.join(self.tracker_home, 'lib')
if os.path.isdir(libdir):
sys.path.insert(1, libdir)
self.templates.precompileTemplates()
# initialize tracker extensions
for extension in self.get_extensions('extensions'):
extension(self)
# load database schema
schemafilename = os.path.join(self.tracker_home, 'schema.py')
# Note: can't use built-in open()
# because of the global function with the same name
schemafile = file(schemafilename, 'rt')
self.schema = compile(schemafile.read(), schemafilename, 'exec')
schemafile.close()
# load database detectors
self.detectors = self.get_extensions('detectors')
# db_open is set to True after first open()
self.db_open = 0
if libdir in sys.path:
sys.path.remove(libdir)
def __init__(self, tracker_home, optimize=0):
"""New-style tracker instance constructor
Parameters:
tracker_home:
tracker home directory
optimize:
if set, precompile html templates
"""
self.tracker_home = tracker_home
self.optimize = optimize
# if set, call schema_hook after executing schema.py will get
# same variables (in particular db) as schema.py main purpose is
# for regression tests
self.schema_hook = None
self.config = configuration.CoreConfig(tracker_home)
self.actions = {}
self.cgi_actions = {}
self.templating_utils = {}
libdir = os.path.join(self.tracker_home, 'lib')
self.libdir = os.path.isdir(libdir) and libdir or ''
self.load_interfaces()
self.templates = templating.get_loader(self.config["TEMPLATES"],
self.config["TEMPLATE_ENGINE"])
rdbms_backend = self.config.RDBMS_BACKEND
self.backend = backends.get_backend(rdbms_backend)
if self.optimize:
self.templates.precompile()
# initialize tracker extensions
for extension in self.get_extensions('extensions'):
extension(self)
# load database schema
self.schema = self._compile('schema.py')
# load database detectors
self.detectors = self.get_extensions('detectors')
# db_open is set to True after first open()
self.db_open = 0
def __init__(self, tracker_home, optimize=0):
"""New-style tracker instance constructor
Parameters:
tracker_home:
tracker home directory
optimize:
if set, precompile html templates
"""
self.tracker_home = tracker_home
self.optimize = optimize
# if set, call schema_hook after executing schema.py will get
# same variables (in particular db) as schema.py main purpose is
# for regression tests
self.schema_hook = None
self.config = configuration.CoreConfig(tracker_home)
self.actions = {}
self.cgi_actions = {}
self.templating_utils = {}
libdir = os.path.join(self.tracker_home, 'lib')
self.libdir = os.path.isdir(libdir) and libdir or ''
self.load_interfaces()
self.templates = templating.get_templates(self.config["TEMPLATES"],
self.config["TEMPLATE_ENGINE"])
self.backend = backends.get_backend(self.get_backend_name())
if self.optimize:
self.templates.precompileTemplates()
# initialize tracker extensions
for extension in self.get_extensions('extensions'):
extension(self)
# load database schema
self.schema = self._compile('schema.py')
# load database detectors
self.detectors = self.get_extensions('detectors')
# db_open is set to True after first open()
self.db_open = 0
def install_demo(home, backend, template):
"""Install a demo tracker
Parameters:
home:
tracker home directory path
backend:
database backend name
template:
full path to the tracker template directory
"""
from roundup import init, instance, password, backends
# set up the config for this tracker
config = configuration.CoreConfig()
config['TRACKER_HOME'] = home
config['MAIL_DOMAIN'] = 'localhost'
config['DATABASE'] = 'db'
config['WEB_DEBUG'] = True
if backend in ('mysql', 'postgresql'):
config['RDBMS_HOST'] = 'localhost'
config['RDBMS_USER'] = '******'
config['RDBMS_PASSWORD'] = '******'
config['RDBMS_NAME'] = 'rounduptest'
# see if we have further db nuking to perform
module = backends.get_backend(backend)
if module.db_exists(config):
module.db_nuke(config)
init.install(home, template)
# don't have email flying around
os.remove(os.path.join(home, 'detectors', 'nosyreaction.py'))
try:
os.remove(os.path.join(home, 'detectors', 'nosyreaction.pyc'))
except os.error, error:
if error.errno != errno.ENOENT:
raise
def install_demo(home, backend, template):
"""Install a demo tracker
Parameters:
home:
tracker home directory path
backend:
database backend name
template:
full path to the tracker template directory
"""
from roundup import init, instance, password, backends
# set up the config for this tracker
config = configuration.CoreConfig()
config['TRACKER_HOME'] = home
config['MAIL_DOMAIN'] = 'localhost'
config['DATABASE'] = 'db'
config['WEB_DEBUG'] = True
if backend in ('mysql', 'postgresql'):
config['RDBMS_HOST'] = 'localhost'
config['RDBMS_USER'] = '******'
config['RDBMS_PASSWORD'] = '******'
config['RDBMS_NAME'] = 'rounduptest'
# see if we have further db nuking to perform
module = backends.get_backend(backend)
if module.db_exists(config):
module.db_nuke(config)
init.install(home, template)
# don't have email flying around
os.remove(os.path.join(home, 'detectors', 'nosyreaction.py'))
try:
os.remove(os.path.join(home, 'detectors', 'nosyreaction.pyc'))
except os.error, error:
if error.errno != errno.ENOENT:
raise
def __init__(self, tracker_home, optimize=0):
"""New-style tracker instance constructor
Parameters:
tracker_home:
tracker home directory
optimize:
if set, precompile html templates
"""
self.tracker_home = tracker_home
self.optimize = optimize
self.config = configuration.CoreConfig(tracker_home)
self.cgi_actions = {}
self.templating_utils = {}
self.load_interfaces()
self.templates = templating.Templates(self.config["TEMPLATES"])
self.backend = backends.get_backend(self.get_backend_name())
if self.optimize:
libdir = os.path.join(self.tracker_home, 'lib')
if os.path.isdir(libdir):
sys.path.insert(1, libdir)
self.templates.precompileTemplates()
# initialize tracker extensions
for extension in self.get_extensions('extensions'):
extension(self)
# load database schema
schemafilename = os.path.join(self.tracker_home, 'schema.py')
# Note: can't use built-in open()
# because of the global function with the same name
schemafile = file(schemafilename, 'rt')
self.schema = compile(schemafile.read(), schemafilename, 'exec')
schemafile.close()
# load database detectors
self.detectors = self.get_extensions('detectors')
# db_open is set to True after first open()
self.db_open = 0
if libdir in sys.path:
sys.path.remove(libdir)
class postgresqlOpener:
if have_backend('postgresql'):
module = get_backend('postgresql')
def setup_class(cls):
# nuke the db once for the class. Handles the case
# where an aborted test run (^C during setUp for example)
# leaves the database in an unusable, partly configured state.
try:
cls.nuke_database(cls)
except:
# ignore failure to nuke the database.
pass
def setUp(self):
pass
def tearDown(self):
self.nuke_database()
def nuke_database(self):
# clear out the database - easiest way is to nuke and re-create it
self.module.db_nuke(config)
class sqliteOpener:
if have_backend('sqlite'):
module = get_backend('sqlite')
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class anydbmOpener:
module = get_backend('anydbm')
def nuke_database(self):
shutil.rmtree(config.DATABASE)
def __init__(self, tracker_home, optimize=0):
"""New-style tracker instance constructor
Parameters:
tracker_home:
tracker home directory
optimize:
if set, precompile html templates
"""
self.tracker_home = tracker_home
self.optimize = optimize
# if set, call schema_hook after executing schema.py will get
# same variables (in particular db) as schema.py main purpose is
# for regression tests
self.schema_hook = None
self.config = configuration.CoreConfig(tracker_home)
self.actions = {}
self.cgi_actions = {}
self.templating_utils = {}
libdir = os.path.join(self.tracker_home, 'lib')
self.libdir = os.path.isdir(libdir) and libdir or ''
self.load_interfaces()
self.templates = templating.get_loader(self.config["TEMPLATES"],
self.config["TEMPLATE_ENGINE"])
rdbms_backend = self.config.RDBMS_BACKEND
# TODO: Remove in v1.7
# Provide some backwards compatability for existing Roundup instances
# that still define the backend type in 'db/backend_name' and warn the
# users they need to update their config.ini
if rdbms_backend == '':
filename = os.path.join(self.config.DATABASE, 'backend_name')
msg = """\n
The 'backend_name' file is no longer used to configure the database backend
used for the tracker. Please read 'doc/upgrading.txt' to find out how to
update your config.ini
"""
try:
with open(filename) as backend_file:
rdbms_backend = backend_file.readline().strip()
with warnings.catch_warnings():
warnings.simplefilter("once", DeprecationWarning)
warnings.warn(msg, DeprecationWarning, stacklevel=2)
except IOError:
pass
self.backend = backends.get_backend(rdbms_backend)
if self.optimize:
self.templates.precompile()
# initialize tracker extensions
for extension in self.get_extensions('extensions'):
extension(self)
# load database schema
self.schema = self._compile('schema.py')
# load database detectors
self.detectors = self.get_extensions('detectors')
# db_open is set to True after first open()
self.db_open = 0
def __init__(self, tracker_home, optimize=0):
"""New-style tracker instance constructor
Parameters:
tracker_home:
tracker home directory
optimize:
if set, precompile html templates
"""
self.tracker_home = tracker_home
self.optimize = optimize
# if set, call schema_hook after executing schema.py will get
# same variables (in particular db) as schema.py main purpose is
# for regression tests
self.schema_hook = None
self.config = configuration.CoreConfig(tracker_home)
self.actions = {}
self.cgi_actions = {}
self.templating_utils = {}
libdir = os.path.join(self.tracker_home, 'lib')
self.libdir = os.path.isdir(libdir) and libdir or ''
self.load_interfaces()
self.templates = templating.get_loader(self.config["TEMPLATES"],
self.config["TEMPLATE_ENGINE"])
rdbms_backend = self.config.RDBMS_BACKEND
# TODO: Remove in v1.7
# Provide some backwards compatability for existing Roundup instances
# that still define the backend type in 'db/backend_name' and warn the
# users they need to update their config.ini
if rdbms_backend == '':
filename = os.path.join(self.config.DATABASE, 'backend_name')
msg = """\n
The 'backend_name' file is no longer used to configure the database backend
used for the tracker. Please read 'doc/upgrading.txt' to find out how to
update your config.ini
"""
try:
with file(filename) as backend_file:
rdbms_backend = backend_file.readline().strip()
with warnings.catch_warnings():
warnings.simplefilter("once", DeprecationWarning)
warnings.warn(msg, DeprecationWarning, stacklevel=2)
except IOError:
pass
self.backend = backends.get_backend(rdbms_backend)
if self.optimize:
self.templates.precompile()
# initialize tracker extensions
for extension in self.get_extensions('extensions'):
extension(self)
# load database schema
self.schema = self._compile('schema.py')
# load database detectors
self.detectors = self.get_extensions('detectors')
# db_open is set to True after first open()
self.db_open = 0
def install_demo(home, backend, template):
"""Install a demo tracker
Parameters:
home:
tracker home directory path
backend:
database backend name
template:
tracker template
"""
from roundup import init, instance, password, backends
# set up the config for this tracker
config = configuration.CoreConfig()
config['TRACKER_HOME'] = home
config['MAIL_DOMAIN'] = 'localhost'
config['DATABASE'] = 'db'
config['WEB_DEBUG'] = True
if backend in ('mysql', 'postgresql'):
config['RDBMS_HOST'] = 'localhost'
config['RDBMS_USER'] = '******'
config['RDBMS_PASSWORD'] = '******'
config['RDBMS_NAME'] = 'rounduptest'
# see if we have further db nuking to perform
module = backends.get_backend(backend)
if module.db_exists(config):
module.db_nuke(config)
template_dir = os.path.join('share', 'roundup', 'templates', template)
init.install(home, template_dir)
# don't have email flying around
nosyreaction = os.path.join(home, 'detectors', 'nosyreaction.py')
if os.path.exists(nosyreaction):
os.remove(nosyreaction)
nosyreaction += 'c'
if os.path.exists(nosyreaction):
os.remove(nosyreaction)
init.write_select_db(home, backend)
# figure basic params for server
hostname = 'localhost'
# pick a fairly odd, random port
port = 8917
while 1:
print 'Trying to set up web server on port %d ...'%port,
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
s.connect((hostname, port))
except socket.error, e:
if not hasattr(e, 'args') or e.args[0] != errno.ECONNREFUSED:
raise
print 'should be ok.'
break
else:
s.close()
print 'already in use.'
port += 100
