def test_no_autosave_saves_atime_without_save(self): so = SessionObject({}, auto=False) so['foo'] = 'bar' so.persist() session = get_session(id=so.id) assert '_accessed_time' in session assert 'foo' not in session # because we didn't save()
def test_auto_save_saves_without_save(self): so = SessionObject({}, auto=True) so['foo'] = 'bar' # look ma, no save()! so.persist() session = get_session(id=so.id) assert 'foo' in session
def test_auto_save_saves_without_save(self): so = SessionObject({}, auto=True) so["foo"] = "bar" # look ma, no save()! so.persist() session = get_session(id=so.id) assert "foo" in session
def test_no_autosave_saves_atime_without_save(self): so = SessionObject({}, auto=False) so["foo"] = "bar" so.persist() session = get_session(id=so.id) assert "_accessed_time" in session assert "foo" not in session # because we didn't save()
def current_participant(request, dbsession, experiment, allow_create=True): """Get the current Participant or create a new one.""" session = SessionObject(request.environ, **coerce_session_params({'type': 'cookie', 'cookie_expires': 7776000, 'key': 'experiment.%s' % (experiment.external_id), 'encrypt_key': get_config_setting(request, 'beaker.session.encrypt_key'), 'validate_key': get_config_setting(request, 'beaker.session.validate_key'), 'auto': True})) if 'pid' in session: participant = dbsession.query(Participant).filter(and_(Participant.id == session['pid'], Participant.experiment_id == experiment.id)).first() else: participant = None if participant is None: if allow_create: participant = Participant(experiment_id=experiment.id, completed=False) participant['current'] = experiment.start.id participant['answered'] = [] dbsession.add(participant) dbsession.flush() else: return None session['pid'] = participant.id session.persist() request.response.headerlist.append(('Set-Cookie', session.__dict__['_headers']['cookie_out'])) return participant
def completed(request): dbsession = DBSession with transaction.manager: experiment = dbsession.query(Experiment).filter(Experiment.external_id == request.matchdict['ueid']).first() if experiment is None: raise HTTPNotFound() if experiment.status in ['paused', 'completed']: raise HTTPFound(request.route_url('experiment.unavailable', ueid=experiment.external_id)) participant = current_participant(request, dbsession, experiment, allow_create=False) if participant is None: if experiment.status == 'develop': raise HTTPFound(request.route_url('experiment.test', ueid=experiment.external_id)) else: raise HTTPFound(request.route_url('experiment.run', ueid=experiment.external_id)) participant.completed = True dbsession.add(experiment) dbsession.add(participant) if experiment.status == 'develop': session = SessionObject(request.environ, **coerce_session_params({'type': 'cookie', 'cookie_expires': 7776000, 'key': 'experiment.%s' % (experiment.external_id), 'encrypt_key': get_config_setting(request, 'beaker.session.encrypt_key'), 'validate_key': get_config_setting(request, 'beaker.session.validate_key'), 'auto': True})) session['pid'] = -1 session.persist() request.response.headerlist.append(('Set-Cookie', session.__dict__['_headers']['cookie_out'])) return {'experiment': experiment, 'participant': participant}
def test_no_autosave_saves_with_save(self): so = SessionObject({}, auto=False) so['foo'] = 'bar' so.save() so.persist() session = get_session(id=so.id) assert '_accessed_time' in session assert 'foo' in session
def test_accessed_time_off_saves_atime_when_saving(self): so = SessionObject({}, save_accessed_time=False) atime = so['_accessed_time'] so['foo'] = 'bar' so.save() so.persist() session = get_session(id=so.id, save_accessed_time=False) assert 'foo' in session assert '_accessed_time' in session self.assertEqual(session.last_accessed, atime)
def __init__(self, request): SessionObject.__init__(self, request.environ, **self._options) def session_callback(request, response): exception = getattr(request, 'exception', None) if (exception is None or self._cookie_on_exception and self.accessed()): self.persist() headers = self.__dict__['_headers'] if headers['set_cookie'] and headers['cookie_out']: response.headerlist.append( ('Set-Cookie', headers['cookie_out'])) request.add_response_callback(session_callback)
def __init__(self, request): SessionObject.__init__(self, request.environ, **self._options) def session_callback(request, response): exception = getattr(request, "exception", None) if exception is None or self._cookie_on_exception and self.accessed(): self.persist() headers = self.__dict__["_headers"] if headers["set_cookie"] and headers["cookie_out"]: response.headerlist.append(("Set-Cookie", headers["cookie_out"])) request.add_response_callback(session_callback)
def test_no_autosave_saves_with_delete(self): req = {'cookie': {'beaker.session.id': 123}} so = SessionObject(req, auto=False) so['foo'] = 'bar' so.save() so.persist() session = get_session(id=so.id) assert 'foo' in session so2 = SessionObject(req, auto=False) so2.delete() so2.persist() session = get_session(id=so2.id) assert 'foo' not in session
def __call__(self, environ, start_response): """ This function's implementation is taken directly from Beaker, with HTTPS detection added. When accessed over HTTPS, force setting cookie's secure flag. The only difference from that original code is that we switch the secure option on and off depending on the URL scheme (first two lines). To avoid concurrency issues, we use a local options variable. """ options = dict(self.options) options["secure"] = environ['wsgi.url_scheme'] == 'https' session = SessionObject(environ, **options) if environ.get('paste.registry'): if environ['paste.registry'].reglist: environ['paste.registry'].register(self.session, session) environ[self.environ_key] = session environ['beaker.get_session'] = self._get_session if 'paste.testing_variables' in environ and 'webtest_varname' in options: environ['paste.testing_variables'][ options['webtest_varname']] = session def session_start_response(status, headers, exc_info=None): if session.accessed(): session.persist() if session.__dict__['_headers']['set_cookie']: cookie = session.__dict__['_headers']['cookie_out'] if cookie: headers.append(('Set-cookie', cookie)) return start_response(status, headers, exc_info) return self.wrap_app(environ, session_start_response)
def session(self): """Create and return the session object This also adds a response callback, which ensures that the session is written out, and the appropriate cookie's are set if necessary on the response object. """ exception_abort = self.registry.session_exception sess_opts = self.registry.session_options if not sess_opts: raise Exception("Can't use the session without configuring sessions") session = SessionObject(self.environ, **sess_opts) def session_callback(request, response): exception = getattr(request, 'exception', None) if exception is not None and exception_abort: return None if session.accessed(): session.persist() if session.__dict__['_headers']['set_cookie']: cookie = session.__dict__['_headers']['cookie_out'] if cookie: response.headerlist.append(('Set-cookie', cookie)) self._sess_callback = session_callback self.add_response_callback(session_callback) return session
def create_fake_env(): registry = Registry() registry.prepare() registry.register(session, SessionObject({})) registry.register(request, Request.blank('/bootstrap')) request.identity = {} return session, request
def restore_session(self, environ): '''Given a wsgi environment it reconstruct a session object :param environ: wsgi environment :return: session object ''' session = SessionObject(environ, **self.options) environ[self.environ_key] = session environ['beaker.get_session'] = self._get_session return Session({}, use_cookies=True, **self.options)
def test_accessed_time_off_doesnt_save_without_save(self): req = {'cookie': {'beaker.session.id': 123}} so = SessionObject(req, save_accessed_time=False) so.persist() # so we can do a set on a non-new session so2 = SessionObject(req, save_accessed_time=False) so2['foo'] = 'bar' # no save() so2.persist() session = get_session(id=so.id, save_accessed_time=False) assert 'foo' not in session
def test_accessed_time_off_doesnt_save_without_save(self): req = {"cookie": {"beaker.session.id": 123}} so = SessionObject(req, save_accessed_time=False) so.persist() # so we can do a set on a non-new session so2 = SessionObject(req, save_accessed_time=False) so2["foo"] = "bar" # no save() so2.persist() session = get_session(id=so.id, save_accessed_time=False) assert "foo" not in session
def _respond(cls, request): try: path_response = cls.__routes.match(request.path_info) if path_response[0] is None: raise exc.HTTPNotFound() endpoint = path_response[0] session = SessionObject( request.environ, **cls.__get_session_config()) try: method = endpoint(request.method) result = method( _Request( session=session, route_params=path_response[1], path_for=cls.__routes.path_for, raw=request ) ) except Exception as e: raise exc.HTTPServerError() response = webob.Response() if session.accessed(): if not session.dirty(): session.save() session.persist() cookie = session.__dict__['_headers']['cookie_out'] if \ session.__dict__['_headers']['set_cookie'] else None if cookie: response.headers.add('Set-Cookie', cookie) if cls.__config['show_x_powered_by']: response.headers.add( 'X-Powered-By', 'Lulu version %s' % _VERSION) if isinstance(result, basestring): response.text = result response.charset = 'utf8' elif type(result) is dict: response.content_type = result['content_type'] if \ 'content_type' in result.keys() else 'text/html' response.body = result['body'] return response except exc.HTTPError as e: return e
def test_no_autosave_saves_with_save(self): so = SessionObject({}, auto=False) so["foo"] = "bar" so.save() so.persist() session = get_session(id=so.id) assert "_accessed_time" in session assert "foo" in session
def _init_stack(config=None, environ=None): if not config: config = pylons.test.pylonsapp.config if not environ: environ = {} pylons.url._push_object(URLGenerator(config['routes.map'], environ or {})) pylons.app_globals._push_object(config['pylons.app_globals']) pylons.config._push_object(config) pylons.tmpl_context._push_object(ContextObj()) # Initialize a translator for tests that utilize i18n translator = _get_translator(pylons.config.get('lang')) pylons.translator._push_object(translator) pylons.session._push_object(SessionObject(environ or {})) pylons.request._push_object(webob.Request.blank('', environ=environ))
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 test_accessed_time_off_saves_atime_when_saving(self): so = SessionObject({}, save_accessed_time=False) atime = so["_accessed_time"] so["foo"] = "bar" so.save() so.persist() session = get_session(id=so.id, save_accessed_time=False) assert "foo" in session assert "_accessed_time" in session self.assertEqual(session.last_accessed, atime)
def __call__(self, environ, start_response): session = SessionObject(environ, **self.options) if environ.get('paste.registry'): if environ['paste.registry'].reglist: environ['paste.registry'].register(self.session, session) environ[self.environ_key] = session environ['beaker.get_session'] = self._get_session def session_start_response(status, headers, exc_info=None): if session.__dict__['_sess'] is not None: if session.__dict__['_headers']['set_cookie']: cookie = session.__dict__['_headers']['cookie_out'] if cookie: headers.append(('Set-cookie', cookie)) return start_response(status, headers, exc_info) return self.wrap_app(environ, session_start_response)
def __call__(self, environ, start_response): session = SessionObject(environ, **self.session_options) environ['beaker.session'] = session environ['beaker.get_session'] = self._get_session def session_start_response(status, headers, exc_info=None): if session.accessed(): session.persist() if session.__dict__['_headers']['set_cookie']: cookie = session.__dict__['_headers']['cookie_out'] if cookie: headers.append(('Set-cookie', cookie)) return start_response(status, headers, exc_info) return super(BottleExt, self).__call__(environ, session_start_response)
def __call__(self, controller, environ, context): context.session = session = SessionObject(environ, **self.options) environ['beaker.session'] = session environ['beaker.get_session'] = self._get_session if 'paste.testing_variables' in environ: environ['paste.testing_variables']['session'] = session response = self.next_handler(controller, environ, context) if session.accessed(): session.persist() session_headers = session.__dict__['_headers'] if session_headers['set_cookie']: cookie = session_headers['cookie_out'] if cookie: response.headers.extend((('Set-cookie', cookie), )) return response
def __call__(self, environ, start_response): session = SessionObject(environ, **self.options) if environ.get('paste.registry'): if environ['paste.registry'].reglist: environ['paste.registry'].register(self.session, session) environ[self.environ_key] = session environ['beaker.get_session'] = self._get_session if 'paste.testing_variables' in environ and 'webtest_varname' in self.options: environ['paste.testing_variables'][self.options['webtest_varname']] = session def session_start_response(status, headers, exc_info = None): if session.accessed(): session.persist() if session.__dict__['_headers']['set_cookie']: cookie = session.__dict__['_headers']['cookie_out'] if cookie: headers.append(('Set-cookie', cookie)) return start_response(status, headers, exc_info) return self.wrap_app(environ, session_start_response)
def __call__(self, environ, start_response): session = SessionObject(environ, **self.options) if environ.get("paste.registry"): if environ["paste.registry"].reglist: environ["paste.registry"].register(self.session, session) environ[self.environ_key] = session environ["beaker.get_session"] = self._get_session if "paste.testing_variables" in environ and "webtest_varname" in self.options: environ["paste.testing_variables"][ self.options["webtest_varname"]] = session def session_start_response(status, headers, exc_info=None): if session.accessed(): session.persist() if session.__dict__["_headers"]["set_cookie"]: cookie = session.__dict__["_headers"]["cookie_out"] if cookie: headers.append(("Set-cookie", cookie)) return start_response(status, headers, exc_info) return self.wrap_app(environ, session_start_response)
def process_request(self, request, *args): session_id = request.headers.get(FallbackSessionMiddleware.HEADER_NAME, None) session = SessionObject(request.env, id=session_id, **self.options) request.env[self.environ_key] = session
def __init__(self, environ, **params): SessionObject.__init__(self, environ, **params)
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')