def store(self, engine): metadata = MetaData(bind=engine) store = SQLAlchemyStore(engine, metadata, 'simplekv_test') # create table store.table.create() yield store metadata.drop_all()
def setUp(self): (fd, self.tmpfile) = tempfile.mkstemp('.sqlite', 'simplekv-test') self.engine = create_engine('sqlite:///%s' % self.tmpfile) self.metadata = MetaData(bind=self.engine) self.store = SQLAlchemyStore(self.engine, self.metadata, 'simplekv_test') # create table self.store.table.create()
def create_app(config_name): # App Factory app = Flask(__name__) app.config.from_object(config[config_name]) if os.environ.get("DATABASE_URL") is None: app.config["SQLALCHEMY_DATABASE_URI"] = app.config.get( "SQLALCHEMY_DATABASE_URI") else: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URL") config[config_name].init_app(app) bootstrap.init_app(app) mail.init_app(app) moment.init_app(app) migrate.init_app(app, db) db.init_app(app) with app.app_context(): # load_db(db) store = SQLAlchemyStore(db.engine, db.metadata, "sessions") kvsession = KVSessionExtension(store, app) logfile_name = "Timeclock" + time.strftime("%Y%m%d-%H%M%S") + ".log" handler = RotatingFileHandler(logfile_name, maxBytes=10000, backupCount=1) handler.setFormatter( Formatter("%(asctime)s %(levelname)s: %(message)s " "[in %(pathname)s:%(lineno)d]")) handler.setLevel(logging.INFO) app.logger.addHandler(handler) login_manager.init_app(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix="/auth") from .health_screen import health_screen_bp as health_screen_blueprint app.register_blueprint(health_screen_blueprint, url_prefix="/healthscreen") app.permanent_session_lifetime = timedelta(minutes=15) @app.before_request def func(): session.modified = True return app
def session(app): """ Sessions It uses KV session to allow multiple backend for the session """ store = None uri = app.config.get("SESSION_URL") if uri: parse_uri = urlparse(uri) scheme = parse_uri.scheme username = parse_uri.username password = parse_uri.password hostname = parse_uri.hostname port = parse_uri.port bucket = parse_uri.path.strip("/") if "redis" in scheme: import redis from simplekv.memory.redisstore import RedisStore conn = redis.StrictRedis.from_url(url=uri) store = RedisStore(conn) elif "s3" in scheme or "google_storage" in scheme: from simplekv.net.botostore import BotoStore import boto if "s3" in scheme: _con_fn = boto.connect_s3 else: _con_fn = boto.connect_gs conn = _con_fn(username, password) _bucket = conn.create_bucket(bucket) store = BotoStore(_bucket) elif "memcache" in scheme: import memcache from simplekv.memory.memcachestore import MemcacheStore host_port = "%s:%s" % (hostname, port) conn = memcache.Client(servers=[host_port]) store = MemcacheStore(conn) elif "sql" in scheme: from simplekv.db.sql import SQLAlchemyStore from sqlalchemy import create_engine, MetaData engine = create_engine(uri) metadata = MetaData(bind=engine) store = SQLAlchemyStore(engine, metadata, 'kvstore') metadata.create_all() else: raise Error("Invalid Session Store. '%s' provided" % scheme) if store: flask_kvsession.KVSessionExtension(store, app)
def init_session(app, engine, metadata) : """ init flask-kvsession export: app.kvsession_ext app.kvsession_store """ store = SQLAlchemyStore(engine, metadata, app.config['KVSESSION_TABLE']) app.kvsession_ext = NewKVSessionExtension(store, app) metadata.create_all() @app.before_request def cleanup_expired_sessions(): """ clear expired sessions at a fixed period. note: when open_session, if current session outdated, new session will created. """ interval = app.config['KVSESSION_CLEANUP_PERIOD'] try: # use the same store to keep deadline. # note: # the key name "session_cleanup_deadline" should not match KVSessionExtension.key_regex, # as data with a key mathcing KVSessionExtension.key_regex is treated as session data, # and will be handled in KVSessionExtension.cleanup_sessions deadline = float(app.kvsession_store.get('session_cleanup_deadline')) except KeyError as e: deadline = time.time() if time.time() > deadline or \ deadline - time.time() > interval: print 'do cleaning up sessions' app.kvsession_ext.cleanup_sessions(app) deadline = time.time() + interval app.kvsession_store.put('session_cleanup_deadline', str(deadline))
def invalid_json(e): return json_response(status_=400, description='Not a Json') @json.error_handler def error_handler(e): return json_response(status_=401, description='An error occured') #------------------------------------ # More Complex Intialization of Extensions #------------------------------------ engine = create_engine(VWM.config['SQLALCHEMY_DATABASE_URI']) metadata = MetaData(bind=engine) session_store = SQLAlchemyStore(engine, metadata, 'kvsession_table') metadata.create_all() kvsession_extension = KVSessionExtension(session_store, VWM) #---------------------------------------------------------------------------------- # end initialize all required values #---------------------------------------------------------------------------------- #------------------------------------------------------ #||||||||||||||||||||||||||||||||||||||||||||||||||||| #routing blueprints starts now VWM.register_blueprint(api_v1, url_prefix='/paywallet/v1') #end of blueprint route #|||||||||||||||||||||||||||||||||||||||||||||||||||||||| #----------------------------------------------------------
import os from flask import Flask from flask.ext.login import LoginManager from flask.ext.sqlalchemy import SQLAlchemy from simplekv.db.sql import SQLAlchemyStore from flask.ext.kvsession import KVSessionExtension from config import * APP_ROOT = os.path.dirname(os.path.abspath(__file__)) app = Flask(__name__, static_url_path='') lm = LoginManager() lm.init_app(app) app.config.from_object(DevelopmentConfig) db = SQLAlchemy(app) store = SQLAlchemyStore(db.engine, db.metadata, 'sessions') kvsession = KVSessionExtension(store, app) if not app.debug and os.environ.get('HEROKU') is None: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler('tmp/microblog.log', 'a', 1 * 1024 * 1024, 10) file_handler.setLevel(logging.INFO) file_handler.setFormatter( logging.Formatter( '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]' )) app.logger.addHandler(file_handler) app.logger.setLevel(logging.INFO) app.logger.info('microblog startup')
import os from flask_kvsession import KVSessionExtension from flask_kvsession import SessionID from flask import current_app from simplekv.memory.redisstore import RedisStore from simplekv.db.sql import SQLAlchemyStore from sqlalchemy import create_engine, MetaData from simplekv.decorator import PrefixDecorator if os.environ.get('IS_PROD', None): store = RedisStore( redis.StrictRedis(host=os.environ.get('redis_host', None), port=os.environ.get('redis_port', None), db=os.environ.get('db', None), password=os.environ.get('redis_password'))) prefix_store = PrefixDecorator('session_', store) s = KVSessionExtension(prefix_store, current_app) else: if os.environ.get('IS_PROD'): engine = create_engine(os.environ.get('CLEARDB_DATABASE_URL')) else: from techmarketplace import Configuration engine = create_engine( 'mysql+mysqlconnector://{0}:{1}@localhost/projectdb'.format( Configuration.dbuser, Configuration.dbpw)) metadata = MetaData(bind=engine) store = SQLAlchemyStore(engine, metadata, 'session') # metadata.create_all() prefix_store = PrefixDecorator('session_', store) kvsession_extension = KVSessionExtension(prefix_store, current_app)
'PERMANENT_SESSION_LIFETIME': timedelta(minutes=config.main.session_lifetime), 'SECRET_KEY': config.main.secret_key }) # mandrill middlelware if config.email.use_mandrill: app.config['MANDRILL_API_KEY'] = config.email.mandrill_api_key app.config['MANDRILL_DEFAULT_FROM'] = config.email.from_ # add sqlalchemy middleware db = SQLAlchemy(app) # add flask_kvsession middleware app.config['SESSION_KEY_BITS'] = 128 engine = create_engine('sqlite:///beerme/sessions.sqlite') metadata = MetaData(bind=engine) store = SQLAlchemyStore(engine, metadata, 'kvstore') metadata.create_all() KVSessionExtension(store, app) # add flask csrf middleware csrf = SeaSurf(app) # add rate limiting middleware limiter = Limiter(app) auth_limit = limiter.shared_limit("5/minute;1/second", scope="auth") # app constants SATOSHIS = 1e8 class User(db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String, unique=True)
env_var_value = os.getenv(SETTINGS_FILE_ENV_VAR, None) if env_var_value is not None: print 'loading settings from: "' + str(env_var_value) + '"' app.config.from_envvar(SETTINGS_FILE_ENV_VAR) else: print 'Environment variable "SETTINGS_FILE_ENV_VAR" was not defined -> using debug mode' # assume debug environment app.config.from_pyfile('regularroutes.cfg') app.debug = True db = SQLAlchemy(app) metadata = MetaData() # Run session storage also on SQLAlchemy store = SQLAlchemyStore(db.engine, metadata, 'kv_session') KVSessionExtension(store, app) ''' These types are the same as are defined in: https://developer.android.com/reference/com/google/android/gms/location/DetectedActivity.html ''' activity_types = ('IN_VEHICLE', 'ON_BICYCLE', 'ON_FOOT', 'RUNNING', 'STILL', 'TILTING', 'UNKNOWN', 'WALKING') activity_type_enum = Enum(*activity_types, name='activity_type_enum') ''' These types are the same as here: https://github.com/HSLdevcom/navigator-proto/blob/master/src/routing.coffee#L43 ''' mass_transit_types = ("FERRY", "SUBWAY", "TRAIN", "TRAM", "BUS") mass_transit_type_enum = Enum(*mass_transit_types, name='mass_transit_type_enum')
from datetime import datetime from flaskext.kvsession import KVSessionExtension from simplekv.db.sql import SQLAlchemyStore import pytz logging_conf = '/etc/narwhal/logging.conf' if os.path.exists(logging_conf): logging.config.fileConfig(logging_conf, disable_existing_loggers=False) logger = logging.getLogger(__name__) app = Flask(__name__) app.config.from_pyfile('config.py') db = SQLAlchemy(app) kv_store = SQLAlchemyStore(db.engine, db.metadata, 'kvstore') KVSessionExtension(kv_store, app) class GoogleAccount(db.Model): __tablename__ = 'GoogleAccount' id = db.Column(db.String(80), primary_key=True) credentials = db.Column(db.PickleType) email = db.Column(db.String(256)) reddit_accounts = db.relationship('RedditAccount', backref='google_account', cascade="all, delete, delete-orphan") settings = db.relationship('AccountSettings', uselist=False, cascade="all, delete, delete-orphan") sent_posts = db.relationship('SentPost', lazy='dynamic', cascade="all, delete, delete-orphan") sent_pms = db.relationship('SentPrivateMessage', lazy='dynamic',
def create_kvsession_store(): metadata = MetaData(bind=db.get_engine(application)) store = SQLAlchemyStore(db.get_engine(application), metadata, 'kvstore') store.table.create(checkfirst=True) KVSessionExtension(store, application)
#app.config.update(SESSION_SQLALCHEMY=db) Session(app) else: # init Flask-KVSession from flask.ext.kvsession import KVSessionExtension from simplekv.db.sql import SQLAlchemyStore from sqlalchemy import create_engine, MetaData print 'KVSESSION_DATABASE_URI:', app.config['KVSESSION_DATABASE_URI'] print 'KVSESSION_DATABASE_TABLE:', app.config['KVSESSION_DATABASE_TABLE'] engine = create_engine(app.config['KVSESSION_DATABASE_URI']) metadata = MetaData(bind=engine) store = SQLAlchemyStore(engine, metadata, \ app.config['KVSESSION_DATABASE_TABLE']) metadata.create_all() KVSessionExtension(store, app) # init user and login check from login_check import apply_login_check, login_check_exempt, user #apply_login_check(app) # =========== steps before request handling =========== @app.before_request def step1(): #app.logger.debug('step1') # abort(401) # return a http 401 error page (generated by flask) as response pass