def test_session_in_db(self): request.app_name = "myapp" db = DAL("sqlite:memory") session = Session(secret="a", expiration=10, storage=DBStore(db)) request.cookies.clear() session.on_request() session["key"] = "value" cookie_name = session.local.session_cookie_name session.on_success(200) a, b = str( response._cookies)[len("Set-Cookie: "):].split(";")[0].split( "=", 1) request.cookies[a] = b session.finalize() self.assertIsNone(session.local) session = Session(expiration=10, storage=DBStore(db)) request.cookies[a] = b session.on_request() self.assertEqual(session.get("key"), "value") session = Session(expiration=10, storage=DBStore(db)) request.cookies[a] = "wrong_cookie" session.on_request() self.assertEqual(session.get("key"), None)
def test_session_in_db(self): request.app_name = 'myapp' db = DAL('sqlite:memory') session = Session(secret="a", expiration=10, storage=DBStore(db)) request.cookies.clear() session.on_request() session['key'] = 'value' session.on_success() cookie_name = session.local.session_cookie_name a, b = str( response._cookies)[len('Set-Cookie: '):].split(';')[0].split( '=', 1) request.cookies[a] = b request.cookies = response._cookies session.local.data.clear() session = Session(expiration=10, storage=DBStore(db)) session.on_request() self.assertEqual(session.get('key'), 'value') request.cookies[a] = 'wrong_cookie' session = Session(expiration=10, storage=DBStore(db)) session.on_request() self.assertEqual(session.get('key'), None)
def test_session_in_db(self): request.app_name = "myapp" db = DAL("sqlite:memory") session = Session(secret="a", expiration=10, storage=DBStore(db)) request.cookies.clear() session.on_request() session["key"] = "value" cookie_name = session.local.session_cookie_name session.on_success(200) a, b = str( response._cookies)[len("Set-Cookie: "):].split(";")[0].split( "=", 1) request.cookies[a] = b _before_request() with pytest.raises(RuntimeError) as err: session.local self.assertTrue('py4web hint' in str(err.value)) session = Session(expiration=10, storage=DBStore(db)) request.cookies[a] = b session.on_request() self.assertEqual(session.get("key"), "value") session = Session(expiration=10, storage=DBStore(db)) request.cookies[a] = "wrong_cookie" session.on_request() self.assertEqual(session.get("key"), None)
"%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s") for item in settings.LOGGERS: level, filename = item.split(":", 1) if filename in ("stdout", "stderr"): handler = logging.StreamHandler(getattr(sys, filename)) else: handler = logging.FileHandler(filename) handler.setFormatter(formatter) logger.setLevel(getattr(logging, level.upper(), "DEBUG")) logger.addHandler(handler) # connect to db db = DAL( settings.DB_URI, folder=settings.DB_FOLDER, pool_size=settings.DB_POOL_SIZE, migrate=settings.DB_MIGRATE, fake_migrate=settings.DB_FAKE_MIGRATE, ) # define global objects that may or may not be used by th actions cache = Cache(size=1000) T = Translator(settings.T_FOLDER) flash = Flash() # pick the session type that suits you best if settings.SESSION_TYPE == "cookies": session = Session(secret=settings.SESSION_SECRET_KEY) elif settings.SESSION_TYPE == "redis": import redis
logger = logging.getLogger("geopbf") formatter = logging.Formatter( "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s") for item in settings.LOGGERS: level, filename = item.split(":", 1) if filename in ("stdout", "stderr"): handler = logging.StreamHandler(getattr(sys, filename)) else: handler = logging.FileHandler(filename) handler.setFormatter(formatter) logger.setLevel(getattr(logging, level.upper(), "DEBUG")) logger.addHandler(handler) if hasattr(settings, 'DB_URI') and not settings.DB_URI is None: from py4web import DAL db = DAL(settings.DB_URI, folder=settings.DB_FOLDER, pool_size=1 if not hasattr(settings, 'DB_POOL_SIZE') else settings.DB_POOL_SIZE, migrate=hasattr(settings, 'DB_MIGRATE') and settings.DB_MIGRATE, fake_migrate=hasattr(settings, 'DB_FAKE_MIGRATE') and settings.DB_FAKE_MIGRATE, lazy_tables=False, check_reserved=False) else: db = None
""" This file defines cache, session, and translator T object for the app These are fixtures that every app needs so probably you will not be editing this file """ import os from py4web import Session, Cache, Translator, DAL, Field from py4web.utils.auth import Auth from py4web.utils.tags import Tags from py4web.utils.factories import ActionFactory from py4web.utils.url_signer import URLSigner from . import settings db = DAL(settings.DB_URI, folder=settings.DB_FOLDER, pool_size=settings.DB_POOL_SIZE) # define global objects that may or may not be used by th actions cache = Cache(size=1000) T = Translator(settings.T_FOLDER) # pick the session type that suits you best if settings.SESSION_TYPE == 'cookies': session = Session(secret=settings.SESSION_SECRET_KEY) elif settings.SESSION_TYPE == 'redis': import redis host, port = settings.REDIS_SERVER.split(':') # for more options: https://github.com/andymccurdy/redis-py/blob/master/redis/client.py conn = redis.Redis(host=host, port=int(port)) conn.set = lambda k, v, e, cs=conn.set, ct=conn.ttl: (cs(k, v), e and ct(e) ) session = Session(secret=settings.SESSION_SECRET_KEY, storage=conn)
import copy import multiprocessing import os import time import unittest import uuid import mechanize from py4web import action, DAL, Field, Session, Cache from py4web.core import bottle, request, error404 os.environ["PY4WEB_APPS_FOLDER"] = os.path.sep.join( os.path.normpath(__file__).split(os.path.sep)[:-2]) db = DAL("sqlite://storage_%s" % uuid.uuid4(), folder="/tmp/") db.define_table("thing", Field("name")) session = Session(secret="my secret") cache = Cache() action.app_name = "tests" @action("index") @cache.memoize(expiration=1) @action.uses(db, session) @action.requires(lambda: True) def index(): db.thing.insert(name="test") session["number"] = session.get("number", 0) + 1
formatter = logging.Formatter( "%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s") for item in settings.LOGGERS: level, filename = item.split(":", 1) if filename in ("stdout", "stderr"): handler = logging.StreamHandler(getattr(sys, filename)) else: handler = logging.FileHandler(filename) handler.setLevel(getattr(logging, level.upper(), "ERROR")) handler.setFormatter(formatter) logger.addHandler(handler) # connect to db db = DAL( settings.DB_URI, folder=settings.DB_FOLDER, pool_size=settings.DB_POOL_SIZE, migrate_enabled=True, ) # define global objects that may or may not be used by th actions cache = Cache(size=1000) T = Translator(settings.T_FOLDER) # pick the session type that suits you best if settings.SESSION_TYPE == "cookies": session = Session(secret=settings.SESSION_SECRET_KEY) elif settings.SESSION_TYPE == "redis": import redis host, port = settings.REDIS_SERVER.split(":") # for more options: https://github.com/andymccurdy/redis-py/blob/master/redis/client.py
import os from py4web import action, request, DAL, Field, Session, Cache, user_in # define session and cache objects session = Session(secret="some secret") cache = Cache(size=1000) # define database and tables db = DAL("sqlite://storage.db", folder=os.path.join(os.path.dirname(__file__), "databases")) db.define_table("todo", Field("info")) db.commit() # example index page using session, template and vue.js @action("index") # the function below is exposed as a GET action @action.uses("index.html") # we use the template index.html to render it @action.uses(session) # action needs a session object (read/write cookies) def index(): session["counter"] = session.get("counter", 0) + 1 session["user"] = {"id": 1} # store a user in session return dict(session=session) # example of GET/POST/DELETE RESTful APIs @action("api") # a GET API function @action.uses(session) # we load the session @action.requires(user_in(session) ) # then check we have a valid user in session
# -*- coding: utf-8 -*- import os from . import settings from ..planetstore.common import logger try: from ..planetstore.models import db except ImportError: raise from py4web import DAL # connect to db db = DAL(settings.DB_URI, folder=settings.DB_FOLDER, pool_size=settings.DB_POOL_SIZE, lazy_tables=False, migrate=False, fake_migrate=False, check_reserved=False) from geopbf import settings as gpbfsettings if hasattr(gpbfsettings, "SHARE_DB") and gpbfsettings.SHARE_DB: from geopbf.pbfpp import common as pbfcommon pbfcommon.db = db from geopbf.pbfpp import Prototizerpp as PbfPrototizer from kilimanjaro.frameworks.py4web.controller import WebWrapper webWrapper = WebWrapper() pbfWebWrapper = PbfPrototizer()
import os from py4web import DAL, Field # define database and tables db = DAL('sqlite://storage.db', folder=os.path.join(os.path.dirname(__file__), 'databases')) db.define_table( 'person', Field('name'), Field('job')) db.define_table( 'superhero', Field('name'), Field('real_identity', 'reference person')) db.define_table( 'superpower', Field('description')) db.define_table( 'tag', Field('superhero', 'reference superhero'), Field('superpower', 'reference superpower'), Field('strength', 'integer')) if not db(db.person).count(): db.person.insert(name='Clark Kent', job='Journalist') db.person.insert(name='Peter Park', job='Photographer') db.person.insert(name='Bruce Wayne', job='CEO') db.superhero.insert(name='Superman', real_identity=1)
import multiprocessing import os import time import unittest import uuid import mechanize from py4web import action, DAL, Field, Session, Cache from py4web.core import bottle, request, error404 os.environ['PY4WEB_APPS_FOLDER'] = os.path.sep.join( os.path.normpath(__file__).split(os.path.sep)[:-2]) db = DAL('sqlite://storage_%s' % uuid.uuid4(), folder='/tmp/') db.define_table('thing', Field('name')) session = Session(secret='my secret') cache = Cache() action.app_name = 'tests' @action('index') @cache.memoize(expiration=1) @action.uses(db, session) @action.requires(lambda: True) def index(): db.thing.insert(name='test') session['number'] = session.get('number', 0) + 1 return 'ok %s %s' % (session['number'], db(db.thing).count())
import os from py4web import action, request, DAL, Field, Session, Cache, user_in # define session and cache objects session = Session(secret='some secret') cache = Cache(size=1000) # define database and tables db = DAL('sqlite://storage.db', folder=os.path.join(os.path.dirname(__file__), 'databases')) db.define_table('todo', Field('info')) # example index page using session, template and vue.js @action('index') # the function below is exposed as a GET action @action.uses('index.html') # we use the template index.html to render it @action.uses(session) # action needs a session object (read/write cookies) def index(): session['counter'] = session.get('counter', 0) + 1 session['user'] = {'id': 1} # store a user in session return dict(session=session) # example of GET/POST/DELETE RESTful APIs @action('api') # a GET API function @action.uses(session) # we load the session @action.requires(user_in(session) ) # then check we have a valid user in session @action.uses(db) # all before starting a db connection
""" This file defines cache, session, and translator T object for the app These are fixtures that every app needs so probably you will not be editing this file """ import os from py4web import Session, Cache, Translator, DAL, Field from py4web.utils.auth import Auth from py4web.utils.tags import Tags from py4web.utils.factories import ActionFactory from py4web.utils.url_signer import URLSigner from . import settings if os.environ.get("GAE_ENV"): # We are on appengine db = DAL(settings.GAE_DB_URI, migrate_enabled=False, pool_size=settings.DB_POOL_SIZE) else: # From Localhost db = DAL(settings.TESTING_DB_URI, folder=settings.DB_FOLDER, pool_size=settings.DB_POOL_SIZE) # define global objects that may or may not be used by th actions cache = Cache(size=1000) T = Translator(settings.T_FOLDER) # pick the session type that suits you best if settings.SESSION_TYPE == 'cookies': session = Session(secret=settings.SESSION_SECRET_KEY) elif settings.SESSION_TYPE == 'redis':