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