def __init__(self, filename):
self.filename = filename
self.mtime = os.stat(filename).st_mtime
self.load(self.filename)
self._lock = threading.Lock()
for section, default_options in config.defaults().iteritems():
for name, value in default_options.iteritems():
config.set(section, name, value)
try:
config.save()
self.log.info(
"Wrote sample configuration file with the new "
"settings and their default values: %s", filename)
except IOError, e:
self.log.warn("Couldn't write sample configuration file (%s)",
e,
exc_info=True)
env_cache = {}
env_cache_lock = threading.Lock()
def open_environment(env_path=None, use_cache=False):
"""Open an existing environment object, and verify that the database is up
to date.
:param env_path: absolute path to the environment directory; if
ommitted, the value of the `TRAC_ENV` environment
variable is used
:param use_cache: whether the environment should be cached for
subsequent invocations of this function
:return: the `Environment` object
"""
if not env_path:
env_path = os.getenv('TRAC_ENV')
from trac.config import ListOption, ChoiceOption
from trac.core import *
from trac.env import ISystemInfoProvider
from trac.versioncontrol import Changeset, Node, Repository, \
IRepositoryConnector, \
NoSuchChangeset, NoSuchNode
from trac.versioncontrol.cache import CachedRepository
from trac.util import embedded_numbers
from trac.util.concurrency import threading
from trac.util.text import exception_to_unicode, to_unicode
from trac.util.translation import _
from trac.util.datefmt import from_utimestamp, to_datetime, utc
application_pool = None
application_pool_lock = threading.Lock()
def _import_svn():
global fs, repos, core, delta, _kindmap, _svn_uri_canonicalize
from svn import fs, repos, core, delta
_kindmap = {core.svn_node_dir: Node.DIRECTORY,
core.svn_node_file: Node.FILE}
try:
_svn_uri_canonicalize = core.svn_uri_canonicalize # Subversion 1.7+
except AttributeError:
_svn_uri_canonicalize = lambda v: v
# Protect svn.core methods from GC
Pool.apr_pool_clear = staticmethod(core.apr_pool_clear)
Pool.apr_pool_destroy = staticmethod(core.apr_pool_destroy)
def __init__(self):
self._cache = {}
self._lock = threading.Lock()
self._connectors = None
self._all_repositories = None
hook_name = os.path.basename(hook_path[:-3])
plugins_dir = _get_plugins_dir(env_path)
load_path = os.path.join(plugins_dir, hook_path)
module = imp.load_source(hook_name, load_path)
return module
def _get_hook_class(env_path, hook_path, class_type):
module = _hook_load(env_path, hook_path)
for (name, cls) in inspect.getmembers(module, inspect.isclass):
if issubclass(cls, class_type) and \
not cls is class_type:
return cls
return None
_global_hooks_installed = False
_global_hooks_lock = threading.Lock()
def install_global_hooks():
global _global_hooks_installed, _global_hooks_lock
if _global_hooks_installed:
return
_global_hooks_lock.acquire()
try:
if not _global_hooks_installed:
try:
# TODO: this is currently hardcoded, maybe it could be made configurable in the future
import multiproduct.hooks
except:
pass
_global_hooks_installed = True
finally:
