def setup_app_env(self, environ, start_response):
"""Setup and register all the Pylons objects with the registry
After creating all the global objects for use in the request,
:meth:`~PylonsApp.register_globals` is called to register them
in the environment.
"""
if self.log_debug:
log.debug("Setting up Pylons stacked object globals")
# Setup the basic pylons global objects
req_options = self.request_options
req = Request(environ, charset=req_options['charset'],
unicode_errors=req_options['errors'],
decode_param_names=req_options['decode_param_names'])
req.language = req_options['language']
req.config = self.config
req.link, req.route_dict = environ['wsgiorg.routing_args']
response = Response(
content_type=self.response_options['content_type'],
charset=self.response_options['charset'])
response.headers.update(self.response_options['headers'])
# Store a copy of the request/response in environ for faster access
pylons_obj = PylonsContext()
pylons_obj.config = self.config
pylons_obj.request = req
pylons_obj.response = response
pylons_obj.app_globals = self.globals
pylons_obj.h = self.helpers
if 'routes.url' in environ:
pylons_obj.url = environ['routes.url']
environ['pylons.pylons'] = pylons_obj
environ['pylons.environ_config'] = self.environ_config
# Setup the translator object
lang = self.config['lang']
pylons_obj.translator = _get_translator(lang, pylons_config=self.config)
if self.config['pylons.strict_tmpl_context']:
tmpl_context = ContextObj()
else:
tmpl_context = AttribSafeContextObj()
pylons_obj.tmpl_context = req.tmpl_context = tmpl_context
if self._session_key in environ:
pylons_obj.session = req.session = environ[self._session_key]
if self._cache_key in environ:
pylons_obj.cache = environ[self._cache_key]
# Load the globals with the registry if around
if 'paste.registry' in environ:
self.register_globals(environ)
def setup_app_env(self, environ, start_response):
"""Setup and register all the Pylons objects with the registry
After creating all the global objects for use in the request,
:meth:`~PylonsApp.register_globals` is called to register them
in the environment.
"""
if self.log_debug:
log.debug("Setting up Pylons stacked object globals")
# Setup the basic pylons global objects
req_options = self.request_options
req = Request(environ,
charset=req_options['charset'],
unicode_errors=req_options['errors'],
decode_param_names=req_options['decode_param_names'])
req.language = req_options['language']
req.config = self.config
req.link, req.route_dict = environ['wsgiorg.routing_args']
response = Response(content_type=self.response_options['content_type'],
charset=self.response_options['charset'])
response.headers.update(self.response_options['headers'])
# Store a copy of the request/response in environ for faster access
pylons_obj = PylonsContext()
pylons_obj.config = self.config
pylons_obj.request = req
pylons_obj.response = response
pylons_obj.app_globals = self.globals
pylons_obj.h = self.helpers
if 'routes.url' in environ:
pylons_obj.url = environ['routes.url']
environ['pylons.pylons'] = pylons_obj
environ['pylons.environ_config'] = self.environ_config
# Setup the translator object
lang = self.config['lang']
pylons_obj.translator = _get_translator(lang,
pylons_config=self.config)
if self.config['pylons.strict_tmpl_context']:
tmpl_context = ContextObj()
else:
tmpl_context = AttribSafeContextObj()
pylons_obj.tmpl_context = req.tmpl_context = tmpl_context
if self._session_key in environ:
pylons_obj.session = req.session = environ[self._session_key]
if self._cache_key in environ:
pylons_obj.cache = environ[self._cache_key]
# Load the globals with the registry if around
if 'paste.registry' in environ:
self.register_globals(environ)
def setup_app_env(self, environ, start_response):
"""Setup and register all the Pylons objects with the registry
After creating all the global objects for use in the request,
:meth:`~PylonsApp.register_globals` is called to register them
in the environment.
"""
if self.log_debug:
log.debug("Setting up Pylons stacked object globals")
# Setup the basic pylons global objects
req = Request(environ)
req.language = self.request_options['language']
response = Response(
content_type=self.response_options['content_type'],
charset=self.response_options['charset'])
response.headers.update(self.response_options['headers'])
# Store a copy of the request/response in environ for faster access
pylons_obj = PylonsContext()
pylons_obj.config = self.config
pylons_obj.request = req
pylons_obj.response = response
pylons_obj.g = pylons_obj.app_globals = self.globals
pylons_obj.h = self.helpers
if hasattr(self, 'buffet'):
pylons_obj.buffet = self.buffet
environ['pylons.pylons'] = pylons_obj
environ['pylons.environ_config'] = self.environ_config
# Setup the translator object
pylons_obj.translator = _get_translator(self.config.get('lang'))
if self.config['pylons.strict_c']:
c = ContextObj()
else:
c = AttribSafeContextObj()
pylons_obj.c = c
econf = self.config['pylons.environ_config']
if econf.get('session') and econf['session'] in environ:
pylons_obj.session = environ[econf['session']]
elif 'beaker.session' in environ:
pylons_obj.session = environ['beaker.session']
if econf.get('cache') and econf['cache'] in environ:
pylons_obj.cache = environ[econf['cache']]
elif 'beaker.cache' in environ:
pylons_obj.cache = environ['beaker.cache']
# Load the globals with the registry if around
if 'paste.registry' in environ:
self.register_globals(environ)
def fake_request(pylons_config,
server_name='mediadrop.example',
language='en',
method='GET',
request_uri='/',
post_vars=None,
registry=None):
paste_registry = registry or _paste_registry(pylons.request)
app_globals = pylons_config['pylons.app_globals']
if post_vars and method.upper() != 'POST':
raise ValueError(
'You must not specify post_vars for request method %r' % method)
wsgi_environ = create_wsgi_environ('http://%s%s' %
(server_name, request_uri),
method.upper(),
request_body=post_vars)
wsgi_environ['paste.registry'] = paste_registry
request = Request(wsgi_environ, charset='utf-8')
request.language = language
request.settings = app_globals.settings
register_instance(paste_registry, 'request', request)
response = Response(content_type='application/xml', charset='utf-8')
register_instance(paste_registry, 'response', response)
setup_session(paste_registry, if_not_registered=True)
routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
register_instance(paste_registry, 'url', routes_url)
# Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
# mediadrop.lib.environment
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
register_instance(paste_registry, 'tmpl_context', tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
register_instance(paste_registry, 'c', tmpl_context)
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
setup_translator(language=language,
registry=paste_registry,
locale_dirs=pylons_config.get('locale_dirs'))
wsgi_environ.update({
'pylons.pylons': pylons,
'paste.registry': paste_registry,
'routes.url': routes_url,
})
return request
def fake_request(pylons_config,
server_name='mediacore.example',
language='en',
method='GET',
request_uri='/',
post_vars=None):
app_globals = pylons_config['pylons.app_globals']
pylons.app_globals._push_object(app_globals)
if post_vars and method.upper() != 'POST':
raise ValueError(
'You must not specify post_vars for request method %r' % method)
wsgi_environ = create_wsgi_environ('http://%s%s' %
(server_name, request_uri),
method.upper(),
request_body=post_vars)
request = Request(wsgi_environ, charset='utf-8')
request.language = language
request.settings = app_globals.settings
pylons.request._push_object(request)
response = Response(content_type='application/xml', charset='utf-8')
pylons.response._push_object(response)
session = SessionObject(wsgi_environ)
pylons.session._push_object(session)
routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
pylons.url._push_object(routes_url)
# Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
# mediacore.lib.environment
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
pylons.tmpl_context._push_object(tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
paste_registry = Registry()
paste_registry.prepare()
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
setup_translator(language=language, registry=paste_registry)
wsgi_environ.update({
'pylons.pylons': pylons,
'paste.registry': paste_registry,
})
return request
def fake_request(pylons_config, server_name='mediadrop.example', language='en',
method='GET', request_uri='/', post_vars=None):
app_globals = pylons_config['pylons.app_globals']
pylons.app_globals._push_object(app_globals)
if post_vars and method.upper() != 'POST':
raise ValueError('You must not specify post_vars for request method %r' % method)
wsgi_environ = create_wsgi_environ('http://%s%s' % (server_name, request_uri),
method.upper(), request_body=post_vars)
request = Request(wsgi_environ, charset='utf-8')
request.language = language
request.settings = app_globals.settings
pylons.request._push_object(request)
response = Response(content_type='application/xml', charset='utf-8')
pylons.response._push_object(response)
session = SessionObject(wsgi_environ)
pylons.session._push_object(session)
routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
pylons.url._push_object(routes_url)
# TODO: Use ContextObj() for Pylons 0.10
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
pylons.tmpl_context._push_object(tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
paste_registry = Registry()
paste_registry.prepare()
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
mediacore_i18n_path = os.path.join(os.path.dirname(mediacore.__file__), 'i18n')
translator = Translator(language, dict(mediacore=mediacore_i18n_path))
# not sure why but sometimes pylons.translator is not a StackedObjectProxy
# but just a regular Translator.
if not hasattr(pylons.translator, '_push_object'):
pylons.translator = StackedObjectProxy()
paste_registry.replace(pylons.translator, translator)
wsgi_environ.update({
'pylons.pylons': pylons,
'paste.registry': paste_registry,
})
return request
def mock_pylons():
from paste.registry import Registry
import pylons
from pylons.util import AttribSafeContextObj
import ckan.lib.app_globals as app_globals
from ckan.lib.cli import MockTranslator
from ckan.config.routing import make_map
from pylons.controllers.util import Request, Response
from routes.util import URLGenerator
class TestPylonsSession(dict):
last_accessed = None
def save(self):
pass
registry = Registry()
registry.prepare()
context_obj = AttribSafeContextObj()
registry.register(pylons.c, context_obj)
app_globals_obj = app_globals.app_globals
registry.register(pylons.g, app_globals_obj)
request_obj = Request(dict(HTTP_HOST="nohost", REQUEST_METHOD="GET"))
registry.register(pylons.request, request_obj)
translator_obj = MockTranslator()
registry.register(pylons.translator, translator_obj)
registry.register(pylons.response, Response())
mapper = make_map()
registry.register(pylons.url, URLGenerator(mapper, {}))
registry.register(pylons.session, TestPylonsSession())
def setup_class(cls):
cls.registry = Registry()
cls.registry.prepare()
cls.context_obj = AttribSafeContextObj()
cls.registry.register(pylons.c, cls.context_obj)
cls.app_globals_obj = app_globals.Globals()
cls.registry.register(pylons.g, cls.app_globals_obj)
cls.request_obj = Request(dict(HTTP_HOST="nohost"))
cls.registry.register(pylons.request, cls.request_obj)
cls.translator_obj = MockTranslator()
cls.registry.register(pylons.translator, cls.translator_obj)
cls.buffet = pylons.templating.Buffet('genshi',
template_root='ckan.templates')
cls.registry.register(pylons.buffet, cls.buffet)
cls.registry.register(pylons.response, Response())
mapper = make_map()
cls.registry.register(pylons.url, URLGenerator(mapper, {}))
cls.registry.register(pylons.session, TestSession())
# Templates often want to find out the request's routes info, so put
# some dummy values into the routes_dict, so the templates that do
# this don't cause an exception.
pylons.request.environ.update({
'pylons.routes_dict': {
'action': 'test-action',
'controller': 'test-package::',
}
})
def create_request(path, environ=None):
"""Helper used in test cases to quickly setup a request obj.
``path``
The path will become PATH_INFO
``environ``
Additional environment
Returns an instance of the `webob.Request` object.
"""
# setup the environ
if environ is None:
environ = {}
environ.update(default_environ)
# create a "blank" WebOb Request object
# using Pylon's Request which is a webob Request plus
# some compatibility methods
req = Request.blank(path, environ)
# setup a Registry
reg = environ.setdefault('paste.registry', Registry())
reg.prepare()
# setup pylons.request to point to our Registry
reg.register(pylons.request, req)
# setup tmpl context
tmpl_context._push_object(ContextObj())
url._push_object(URLGenerator(default_map, environ))
return req
def create_request(path, environ=None):
"""Helper used in test cases to quickly setup a request obj.
``path``
The path will become PATH_INFO
``environ``
Additional environment
Returns an instance of the `webob.Request` object.
"""
# setup the environ
if environ is None:
environ = {}
environ.update(default_environ)
# create a "blank" WebOb Request object
# using Pylon's Request which is a webob Request plus
# some compatibility methods
req = Request.blank(path, environ)
# setup a Registry
reg = environ.setdefault('paste.registry', Registry())
reg.prepare()
# setup pylons.request to point to our Registry
reg.register(pylons.request, req)
# setup tmpl context
tmpl_context._push_object(ContextObj())
url._push_object(URLGenerator(default_map, environ))
return req
def create_fake_env():
registry = Registry()
registry.prepare()
registry.register(session, SessionObject({}))
registry.register(request, Request.blank('/bootstrap'))
request.identity = {}
return session, request
def fake_request(pylons_config, server_name='mediacore.example', language='en',
method='GET', request_uri='/', post_vars=None):
app_globals = pylons_config['pylons.app_globals']
pylons.app_globals._push_object(app_globals)
if post_vars and method.upper() != 'POST':
raise ValueError('You must not specify post_vars for request method %r' % method)
wsgi_environ = create_wsgi_environ('http://%s%s' % (server_name, request_uri),
method.upper(), request_body=post_vars)
request = Request(wsgi_environ, charset='utf-8')
request.language = language
request.settings = app_globals.settings
pylons.request._push_object(request)
response = Response(content_type='application/xml', charset='utf-8')
pylons.response._push_object(response)
session = SessionObject(wsgi_environ)
pylons.session._push_object(session)
routes_url = URLGenerator(pylons_config['routes.map'], wsgi_environ)
pylons.url._push_object(routes_url)
# Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
# mediacore.lib.environment
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
pylons.tmpl_context._push_object(tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
paste_registry = Registry()
paste_registry.prepare()
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
setup_translator(language=language, registry=paste_registry,
locale_dirs=pylons_config.get('locale_dirs'))
wsgi_environ.update({
'pylons.pylons': pylons,
'paste.registry': paste_registry,
})
return request
def __call__(self, environ, start_response):
registry = environ['paste.registry']
py_obj = PylonsContext()
environ_config = environ.setdefault('pylons.environ_config', {})
if self.setup_cache:
py_obj.cache = environ['beaker.cache']
registry.register(pylons.cache, environ['beaker.cache'])
environ_config['cache'] = 'beaker.cache'
if self.setup_session:
py_obj.session = environ['beaker.session']
registry.register(pylons.session, environ['beaker.session'])
environ_config['session'] = 'beaker.session'
if self.setup_g:
py_obj.g = py_obj.app_globals = self.g
registry.register(pylons.g, self.g)
registry.register(pylons.app_globals, self.g)
translator = gettext.NullTranslations()
py_obj.translator = translator
registry.register(pylons.translator, translator)
# Update the environ
req = Request(
environ,
charset=request_defaults['charset'],
unicode_errors=request_defaults['errors'],
decode_param_names=request_defaults['decode_param_names'])
req.language = request_defaults['language']
response = Response(content_type=response_defaults['content_type'],
charset=response_defaults['charset'])
response.headers.update(response_defaults['headers'])
environ.update(self.environ)
py_obj.config = pylons.config._current_obj()
py_obj.request = req
py_obj.response = response
py_obj.c = ContextObj()
environ['pylons.pylons'] = py_obj
registry.register(pylons.request, req)
registry.register(pylons.response, response)
if 'routes.url' in environ:
registry.register(pylons.url, environ['routes.url'])
return self.app(environ, start_response)
def fake_request(
pylons_config, server_name="mediadrop.example", language="en", method="GET", request_uri="/", post_vars=None
):
app_globals = pylons_config["pylons.app_globals"]
pylons.app_globals._push_object(app_globals)
if post_vars and method.upper() != "POST":
raise ValueError("You must not specify post_vars for request method %r" % method)
wsgi_environ = create_wsgi_environ(
"http://%s%s" % (server_name, request_uri), method.upper(), request_body=post_vars
)
request = Request(wsgi_environ, charset="utf-8")
request.language = language
request.settings = app_globals.settings
pylons.request._push_object(request)
response = Response(content_type="application/xml", charset="utf-8")
pylons.response._push_object(response)
session = SessionObject(wsgi_environ)
pylons.session._push_object(session)
routes_url = URLGenerator(pylons_config["routes.map"], wsgi_environ)
pylons.url._push_object(routes_url)
# Use ContextObj() when we get rid of 'pylons.strict_tmpl_context=False' in
# mediadrop.lib.environment
tmpl_context = AttribSafeContextObj()
tmpl_context.paginators = Bunch()
pylons.tmpl_context._push_object(tmpl_context)
# some parts of Pylons (e.g. Pylons.controllers.core.WSGIController)
# use the '.c' alias instead.
pylons.c = pylons.tmpl_context
paste_registry = Registry()
paste_registry.prepare()
engines = create_tw_engine_manager(app_globals)
host_framework = PylonsHostFramework(engines=engines)
paste_registry.register(tw.framework, host_framework)
setup_translator(language=language, registry=paste_registry, locale_dirs=pylons_config.get("locale_dirs"))
wsgi_environ.update({"pylons.pylons": pylons, "paste.registry": paste_registry})
return request
def __call__(self, environ, start_response):
registry = environ['paste.registry']
py_obj = PylonsContext()
environ_config = environ.setdefault('pylons.environ_config', {})
if self.setup_cache:
py_obj.cache = environ['beaker.cache']
registry.register(pylons.cache, environ['beaker.cache'])
environ_config['cache'] = 'beaker.cache'
if self.setup_session:
py_obj.session = environ['beaker.session']
registry.register(pylons.session, environ['beaker.session'])
environ_config['session'] = 'beaker.session'
if self.setup_g:
py_obj.g = py_obj.app_globals = self.g
registry.register(pylons.g, self.g)
registry.register(pylons.app_globals, self.g)
translator = gettext.NullTranslations()
py_obj.translator = translator
registry.register(pylons.translator, translator)
# Update the environ
req = Request(environ, charset=request_defaults['charset'],
unicode_errors=request_defaults['errors'],
decode_param_names=request_defaults['decode_param_names'])
req.language = request_defaults['language']
response = Response(
content_type=response_defaults['content_type'],
charset=response_defaults['charset'])
response.headers.update(response_defaults['headers'])
environ.update(self.environ)
py_obj.config = pylons.config._current_obj()
py_obj.request = req
py_obj.response = response
py_obj.c = ContextObj()
environ['pylons.pylons'] = py_obj
registry.register(pylons.request, req)
registry.register(pylons.response, response)
if 'routes.url' in environ:
registry.register(pylons.url, environ['routes.url'])
return self.app(environ, start_response)
def test_can_return_correct_url_even_for_whoopsidasy_page(self):
user_url = 'http://server.example:8080/media/view?id=123'
user_environ = create_wsgi_environ(user_url, 'GET')
user_request = Request(user_environ, charset='utf-8')
self._inject_url_generator_for_request(user_request)
error_request = self.init_fake_request(request_uri='/error/document')
self._inject_url_generator_for_request(error_request)
error_request.environ['pylons.original_request'] = user_request
assert_equals(user_url, current_url())
def init_fake_request(self, server_name='mediacore.example', language='en'):
app_globals = self.pylons_config['pylons.app_globals']
translator = Translator(language, app_globals.plugin_mgr.locale_dirs())
pylons.translator._push_object(translator)
pylons.app_globals._push_object(app_globals)
request = Request({}, charset='utf-8')
request.language = language
request.settings = app_globals.settings
pylons.request._push_object(request)
response = Response(content_type='application/xml', charset='utf-8')
pylons.response._push_object(response)
wsgi_environ = {'HTTP_HOST': server_name}
session = SessionObject(wsgi_environ)
pylons.session._push_object(session)
routes_url = URLGenerator(self.pylons_config['routes.map'], wsgi_environ)
pylons.url._push_object(routes_url)
pylons.tmpl_context._push_object(ContextObj())
def __call__(self, environ, start_response):
status, headers, app_iter, exc_info = call_wsgi_application(
self.app, environ, catch_exc_info=True)
if status[:3] in self.errors and \
'pylons.status_code_redirect' not in environ and self.error_path:
# Create a response object
environ['pylons.original_response'] = Response(status=status,
headerlist=headers,
app_iter=app_iter)
environ['pylons.original_request'] = Request(environ)
# Create a new environ to avoid touching the original request data
new_environ = environ.copy()
new_environ['PATH_INFO'] = self.error_path
newstatus, headers, app_iter, exc_info = call_wsgi_application(
self.app, new_environ, catch_exc_info=True)
start_response(status, headers, exc_info)
return app_iter
def setup_class(cls):
cls.registry = Registry()
cls.registry.prepare()
cls.context_obj = AttribSafeContextObj()
cls.registry.register(pylons.c, cls.context_obj)
cls.app_globals_obj = app_globals.Globals()
cls.registry.register(pylons.g, cls.app_globals_obj)
cls.request_obj = Request(dict(HTTP_HOST="nohost"))
cls.registry.register(pylons.request, cls.request_obj)
cls.translator_obj = MockTranslator()
cls.registry.register(pylons.translator, cls.translator_obj)
cls.buffet = pylons.templating.Buffet('genshi',
template_root='ckan.templates')
cls.registry.register(pylons.buffet, cls.buffet)
cls.registry.register(pylons.response, Response())
mapper = make_map()
cls.registry.register(pylons.url, URLGenerator(mapper, {}))
cls.registry.register(pylons.session, TestSession())
def bootstrap(command, conf, vars):
"""Place any commands to setup bq here"""
# <websetup.bootstrap.before.auth
from sqlalchemy.exc import IntegrityError
from bq.data_service.model import Taggable, Tag, BQUser, ModuleExecution
registry = Registry()
registry.prepare()
registry.register(session, SessionObject({}))
registry.register(request, Request.blank('/bootstrap'))
request.identity = {}
log.info('BEGIN boostrap')
try:
initial_mex = ModuleExecution(mex_id = False, owner_id = False)
initial_mex.mex = initial_mex
initial_mex.name = "initialization"
initial_mex.type = "initialization"
initial_mex.hidden = True
model.DBSession.add(initial_mex)
model.DBSession.flush()
admin = model.User(
user_name = u"admin",
display_name = config.get('bisque.admin_display_name', u'Bisque admin'))
admin._email_address = config.get('bisque.admin_email', u'*****@*****.**')
admin.password = u'admin'
# password = u'admin')
#admin.password = u'admin'
model.DBSession.add(admin)
for g in [ u'admins', u'managers' ] :
group = model.Group()
group.group_name = g
group.display_name = u'Administrators Group'
group.users.append(admin)
model.DBSession.add(group)
permission = model.Permission()
permission.permission_name = u'root'
permission.description = u'This permission give an administrative right to the bearer'
permission.groups.append(group)
model.DBSession.add(permission)
#model.DBSession.flush()
# This commit will setup the BQUser also
transaction.commit()
except IntegrityError:
print 'Warning, there was a problem adding your auth data, it may have already been added:'
#import traceback
#print traceback.format_exc()
transaction.abort()
print 'Continuing with bootstrapping...'
try:
######
#
#from bq.data_service.model import UniqueName
initial_mex = model.DBSession.query(ModuleExecution).first()
session['mex_id'] = initial_mex.id
#request.identity['bisque.mex_id'] = initial_mex.id
admin = model.DBSession.query(BQUser).filter_by(resource_name = 'admin').first()
admin.mex_id = initial_mex.id
initial_mex.owner = admin
session['user'] = admin
system = model.DBSession.query(Taggable).filter_by (resource_type='system').first()
if system is None:
system_prefs = defaults_path('preferences.xml.default')
if os.path.exists(system_prefs):
with open (system_prefs) as f:
system = bisquik2db (f)
system.permission = 'published'
else:
print( "Couldn't find %s: using minimal default preferences" % system_prefs)
system = Taggable(resource_type = 'system')
version = Tag(parent = system)
version.name ='version'
version.value = __VERSION__
prefs = Tag(parent = system)
prefs.name = 'Preferences'
model.DBSession.add(system)
transaction.commit()
except IntegrityError:
log.exception ( 'Warning, there was a problem adding your system object, it may have already been added:')
#import traceback
#print traceback.format_exc()
transaction.abort()
log.warning ( 'Continuing with bootstrapping...' )
log.info('END boostrap')
