def load_session(self): self.app = SessionMiddleware(self.app, { 'session.type': 'mongodb', 'session.cookie_expires': self.cookie_expires, 'session.url': self.beaker_url, 'session.secret': self.secret, 'session.lock_dir': self.data_dir })
def load_session(self): # Since we vendor mongodb_beaker because of broken dep on pypi.python.org # we need to setup the beaker class map manually. beaker.cache.clsmap['mongodb'] = mongodb_beaker.MongoDBNamespaceManager self.app = SessionMiddleware(self.app, { 'session.type': 'mongodb', 'session.cookie_expires': self.cookie_expires, 'session.url': self.beaker_url, 'session.secret': self.secret, 'session.lock_dir': self.data_dir })
def __init__(self, options={}): self.usage = None self.callable = None self.prog = None self.options = options self.do_load_config() self.setup_cork() super(AddressServer, self).__init__() self.app = Bottle() self.add_routes() self.add_middleware()
def add_middleware(self): """Set up the session middleware.""" ENCRYPT_KEY = os.environ.get('ENCRYPT_KEY') session_opts = { 'session.cookie_expires': True, 'session.encrypt_key': ENCRYPT_KEY, 'session.httponly': True, 'session.timeout': 3600 * 24, # 1 day 'session.type': 'cookie', 'session.validate_key': True, } self.app = SessionMiddleware(self.app, session_opts)
def init_app(self): self.logger.info('Initialize gevent signal-handlers') gevent.signal(SIGTERM, self.exit) gevent.signal(SIGINT, self.exit) self.logger.info('Initialize WSGI Application') self.app = BottleApplication() self.load_auth_backends() self.load_webservices() self.load_session() self.logger.info('WSGI fully loaded.') return self
def __call__(self): self.logger.info('Initialize gevent signal-handlers') gevent.signal(SIGTERM, self.exit) gevent.signal(SIGINT, self.exit) self.logger.info('Start AMQP thread') self.amqp.start() self.logger.info('Initialize WSGI Application') self.app = BottleApplication() self.load_auth_backends() self.load_webservices() self.load_session() return self
def make_pylons_stack(conf, full_stack=True, static_files=True, **app_conf): """Create a Pylons WSGI application and return it ``conf`` The inherited configuration for this application. Normally from the [DEFAULT] section of the Paste ini file. ``full_stack`` Whether this application provides a full WSGI stack (by default, meaning it handles its own exceptions and errors). Disable full_stack when this application is "managed" by another WSGI middleware. ``static_files`` Whether this application serves its own static files; disable when another web server is responsible for serving them. ``app_conf`` The application's local configuration. Normally specified in the [app:<name>] section of the Paste ini file (where <name> defaults to main). """ # The Pylons WSGI app app = pylons_app = CKANPylonsApp() for plugin in PluginImplementations(IMiddleware): app = plugin.make_middleware(app, config) # Routing/Session/Cache Middleware app = RoutesMiddleware(app, config['routes.map']) # we want to be able to retrieve the routes middleware to be able to update # the mapper. We store it in the pylons config to allow this. config['routes.middleware'] = app app = SessionMiddleware(app, config) app = CacheMiddleware(app, config) # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares) # app = QueueLogMiddleware(app) if asbool(config.get('ckan.use_pylons_response_cleanup_middleware', True)): app = execute_on_completion(app, config, cleanup_pylons_response_string) # Fanstatic if asbool(config.get('debug', False)): fanstatic_config = { 'versioning': True, 'recompute_hashes': True, 'minified': False, 'bottom': True, 'bundle': False, } else: fanstatic_config = { 'versioning': True, 'recompute_hashes': False, 'minified': True, 'bottom': True, 'bundle': True, } app = Fanstatic(app, **fanstatic_config) for plugin in PluginImplementations(IMiddleware): try: app = plugin.make_error_log_middleware(app, config) except AttributeError: log.critical('Middleware class {0} is missing the method' 'make_error_log_middleware.'.format( plugin.__class__.__name__)) if asbool(full_stack): # Handle Python exceptions app = ErrorHandler(app, conf, **config['pylons.errorware']) # Display error documents for 400, 403, 404 status codes (and # 500 when debug is disabled) if asbool(config['debug']): app = StatusCodeRedirect(app, [400, 403, 404]) else: app = StatusCodeRedirect(app, [400, 403, 404, 500]) # Initialize repoze.who who_parser = WhoConfig(conf['here']) who_parser.parse(open(app_conf['who.config_file'])) app = PluggableAuthenticationMiddleware( app, who_parser.identifiers, who_parser.authenticators, who_parser.challengers, who_parser.mdproviders, who_parser.request_classifier, who_parser.challenge_decider, logging.getLogger('repoze.who'), logging.WARN, # ignored who_parser.remote_user_key) # Establish the Registry for this application app = RegistryManager(app) app = common_middleware.I18nMiddleware(app, config) if asbool(static_files): # Serve static files static_max_age = None if not asbool( config.get('ckan.cache_enabled')) \ else int(config.get('ckan.static_max_age', 3600)) static_app = StaticURLParser(config['pylons.paths']['static_files'], cache_max_age=static_max_age) static_parsers = [static_app, app] storage_directory = uploader.get_storage_path() if storage_directory: path = os.path.join(storage_directory, 'storage') try: os.makedirs(path) except OSError, e: # errno 17 is file already exists if e.errno != 17: raise storage_app = StaticURLParser(path, cache_max_age=static_max_age) static_parsers.insert(0, storage_app) # Configurable extra static file paths extra_static_parsers = [] for public_path in config.get('extra_public_paths', '').split(','): if public_path.strip(): extra_static_parsers.append( StaticURLParser(public_path.strip(), cache_max_age=static_max_age)) app = Cascade(extra_static_parsers + static_parsers)
log.warning('Using gevent for asynchronous processing') async = True config.async = async app = bottle.app() session_opts = { 'session.auto': False, 'session.type': 'file', 'session.key': 'drink_cookie', 'session.cookie_expires': False, 'session.data_dir': DB_PATH, #'session.validate_key': 'drink-key-you-must-change-this-in-cookies', #'session.encryption_key': ''.join(chr(randint(65, 122)) for x in xrange(100) } app = SessionMiddleware(app, session_opts) if not full: return app # handle debug mode debug = False if dbg_in_env: debug = True # trick to allow debug-wrapping app.catchall = False def dbg_repoze(app): from repoze.debug.pdbpm import PostMortemDebug app = PostMortemDebug(app) log.debug("Installed repoze.debug's debugging middleware")
def __init__(self): self.cfg = j.portal.servers.config self.cfg_main = self.cfg["main"] self.cfg_oauth = self.cfg.get('oauth', None) self.logger = j.logger.get('j.portal.tools.server') self.contentdirs = list() self.libpath = j.portal.tools.html.htmlfactory.getHtmllibDir() self.started = False self.epoch = time.time() self.force_oauth_url = None self.force_oauth_instance = self.cfg_oauth.get('force_oauth_instance', "") j.application.debug = self.cfg.get("debug", False) j.portal.tools.server.active = self self.watchedspaces = [] self.pageKey2doc = {} self.routes = {} self.proxies = {} self.authentication_method = self.cfg.get("authentication_method") session_opts = { 'session.cookie_expires': False, 'session.data_dir': '%s' % j.sal.fs.joinPaths(j.dirs.VARDIR, "beakercache") } # TODO change that to work with ays instance config instead of connection string connection = self.cfg.get('mongoengine', {}) self.port = connection.get('port', None) if not self.authentication_method: minimalsession = { 'session.type': 'MinimalBeaker', 'session.namespace_class': MinimalBeaker, 'session.namespace_args': { 'client': None } } session_opts.update(minimalsession) self.auth = PortalAuthenticatorMinimal() else: if self.authentication_method == 'gitlab': self.auth = PortalAuthenticatorGitlab( instance=self.gitlabinstance) else: j.portal.tools.models.system.connect2mongo( connection['host'], port=int(connection['port'])) mongoenginesession = { 'session.type': 'MongoEngineBeaker', 'session.namespace_class': MongoEngineBeaker, 'session.namespace_args': {} } session_opts.update(mongoenginesession) self.auth = PortalAuthenticatorMongoEngine() self.pageprocessor = PageProcessor() self.loadConfig() macros_dir = j.sal.fs.joinPaths(j.sal.fs.getcwd(), 'macros') macroPathsPreprocessor = [j.sal.fs.joinPaths(macros_dir, "preprocess")] macroPathsWiki = [j.sal.fs.joinPaths(macros_dir, "wiki")] macroPathsPage = [j.sal.fs.joinPaths(macros_dir, "page")] macroPathsMarkDown = [j.sal.fs.joinPaths(macros_dir, "markdown")] self.macroexecutorPreprocessor = MacroExecutorPreprocess( macroPathsPreprocessor) self.macroexecutorPage = MacroExecutorPage(macroPathsPage) self.macroexecutorMarkDown = MacroexecutorMarkDown(macroPathsMarkDown) self.macroexecutorWiki = MacroExecutorWiki(macroPathsWiki) self.errorhandler = ErrorHandler() templatedirs = [ self.portaldir.joinpath('templates'), self.appdir.joinpath('templates') ] for contentdir in self.contentdirs: templatedirs.append(j.sal.fs.joinPaths(contentdir, 'templates')) self.templates = PortalTemplate(templatedirs) self.bootstrap() self._router = SessionMiddleware(AuditMiddleWare(self.router), session_opts) self._megarouter = DispatcherMiddleware(self._router) self._webserver = WSGIServer((self.listenip, self.port), self._megarouter) self.confluence2htmlconvertor = j.portal.tools.docgenerator.docgeneratorfactory.getConfluence2htmlConvertor( ) self.activejobs = list() self.jobids2greenlets = dict() self.schedule1min = {} self.schedule15min = {} self.schedule60min = {} self.jslibroot = j.sal.fs.joinPaths(j.dirs.JSAPPSDIR, "portals", "jslib") # Load local spaces self.rest = PortalRest(self) self.loadSpaces()
import dbfuncs from userclass import TFuser from caseclass import TFcase from imageclass import TFimage, TFimagestack site = Bottle() session_opts = { 'session.type': 'cookie', 'session.validate_key': 'validkey', 'session.timeout': 900, 'session.cookie_expires': True, 'session.data_dir': './data', 'session.auto': True } app = SessionMiddleware(site, session_opts) ###### Static Routes @site.route('/static/<filepath:path>') def server_static(filepath): return static_file(filepath, root='./static') @site.get('/') def index(): return static_file('index.html', root=".") @site.get('/favicon.ico')
def __call__(self, environ, start_response): return SessionMiddleware.__call__(self, environ, start_response)
def init(config, app): global local_api_url logger.info('Web asset root: "%s"', ui_root) auth_module = config.get('auth', {'module': 'iris.ui.auth.noauth'})['module'] auth = importlib.import_module(auth_module) auth_manager = getattr(auth, 'Authenticator')(config) debug = config['server'].get('disable_auth', False) is True local_api_url = config['server'].get('local_api_url', 'http://localhost:16649') app.add_route('/static/bundles/{filename}', StaticResource('/static/bundles')) app.add_route('/static/images/{filename}', StaticResource('/static/images')) app.add_route('/static/fonts/{filename}', StaticResource('/static/fonts')) app.add_route('/', Index()) app.add_route('/stats', Stats()) app.add_route('/plans/', Plans()) app.add_route('/plans/{plan}', Plan()) app.add_route('/incidents/', Incidents()) app.add_route('/incidents/{incident}', Incident()) app.add_route('/messages/', Messages()) app.add_route('/messages/{message}', Message()) app.add_route('/templates/', Templates()) app.add_route('/templates/{template}', Template()) app.add_route('/applications/', Applications()) app.add_route('/applications/{application}', Application()) app.add_route('/login/', Login(auth_manager, debug)) app.add_route('/logout/', Logout()) app.add_route('/user/', User()) app.add_route('/validate/jinja', JinjaValidate()) # Configuring the beaker middleware mutilates the app object, so do it # at the end, after we've added all routes/sinks for the entire iris # app. session_opts = { 'session.type': 'cookie', 'session.cookie_expires': True, 'session.key': 'iris-auth', 'session.encrypt_key': config['user_session']['encrypt_key'], 'session.validate_key': config['user_session']['sign_key'], 'session.secure': not (config['server'].get('disable_auth', False) or config['server'].get('allow_http', False)), 'session.httponly': True, 'session.crypto_type': 'cryptography', 'session.samesite': 'Lax' } app = SessionMiddleware(app, session_opts) return app
def __init__(self, app, pm, engine): self.pm = pm SessionMiddleware.__init__(self, app) SimplePlugin.__init__(self, engine) self.subscribe()
def __init__(self, app, login_url): self.app = SessionMiddleware(app, _session_opts) self.nacl = j.me.encryptor self.login_url = login_url
from mybot import config # Add view paths to the Bottle template path TEMPLATE_SUB_PATHS = next(os.walk(config.BASE_TEMPLATE_PATH))[1] TEMPLATE_PATH.append(config.BASE_TEMPLATE_PATH) for templatePath in TEMPLATE_SUB_PATHS: TEMPLATE_PATH.append(os.path.join(config.BASE_TEMPLATE_PATH, templatePath)) session_opts = { 'session.type': 'file', 'session.cookie_expires': 30, # Время в сек через которое закончится текущая сессия 'session.data_dir': './data', # Директория для хранения сесии 'session.auto': True } # app = Bottle() app = SessionMiddleware(bottle.app(), session_opts) from .controllers import * # if config.DEBUG: # print("ROOT_PATH: %s" % config.ROOT_PATH) # print("Template Paths:") # # for it in bottle.TEMPLATE_PATH: # print(" %s" % it)
class WebServer(): CONF_PATH = 'etc/webserver.conf' LOG_FILE = root_path + '/var/log/webserver.log' @property def application(self): return self.app @property def beaker_url(self): return self.db.beaker_uri @property def skip_login(self): return [bname for bname in self.auth_backends.keys()] @property def skip_logout(self): return [ bname for bname in self.auth_backends.keys() if not self.auth_backends[bname].handle_logout ] def __init__(self, config, logger, amqp_pub): self.config = config self.logger = logger self.amqp_pub = amqp_pub server = self.config.get('server', {}) self.debug = server.get('debug', DEFAULT_DEBUG) self.enable_crossdomain_send_events = server.get( 'enable_crossdomain_send_events', DEFAULT_ECSE) self.root_directory = os.path.expanduser( server.get('root_directory', DEFAULT_ROOT_DIR)) auth = self.config.get('auth', {}) self.providers = cfg_to_array(auth.get('providers', '')) if len(self.providers) == 0: self.logger.critical( 'Missing providers. Cannot launch webcore module.') raise RuntimeError('Missing providers') session = self.config.get('session', {}) self.cookie_expires = int(session.get('cookie_expires', DEFAULT_COOKIES_EXPIRE)) self.secret = session.get('secret', DEFAULT_SECRET) self.data_dir = session.get('data_dir', DEFAULT_DATA_DIR) self.webservices = self.config.get('webservices', {}) # TODO: Replace with MongoStorage self.db = get_storage(account=Account(user='******', group='root')) self.stopping = False self.webmodules = {} self.auth_backends = {} def init_app(self): self.logger.info('Initialize gevent signal-handlers') gevent.signal(SIGTERM, self.exit) gevent.signal(SIGINT, self.exit) self.logger.info('Initialize WSGI Application') self.app = BottleApplication() self.load_auth_backends() self.load_webservices() self.load_session() self.logger.info('WSGI fully loaded.') return self def _load_webservice(self, modname): if modname in self.webmodules: return True if modname is None: return False self.logger.info('Loading webservice: {0}'.format(modname)) try: mod = importlib.import_module(modname) except ImportError as err: self.logger.error( 'Impossible to load webservice {0}: {1}'.format(modname, err) ) return False else: if hasattr(mod, 'exports'): self.webmodules[modname] = mod mod.exports(self) else: self.logger.error( 'Invalid module {0}, no exports()'.format(modname) ) return False return True def load_webservices(self): for module in sorted(self.webservices.keys()): enable = int(self.webservices[module]) if enable == 1: self._load_webservice(module) else: self.logger.info( u'Webservice {} skipped by configuration.'.format(module)) self.logger.info(u'Service loading completed.') def _load_auth_backend(self, modname): if modname in self.auth_backends: return True self.logger.info('Load authentication backend: {0}'.format(modname)) try: mod = importlib.import_module(modname) except ImportError as err: self.logger.error( 'Impossible to load authentication backend {}: {}'.format( modname, err ) ) return False else: backend = mod.get_backend(self) self.auth_backends[backend.name] = backend self.app.install(backend) return True def load_auth_backends(self): for provider in self.providers: self._load_auth_backend(provider) # Always add this backend which returns 401 when the login fails backend = EnsureAuthenticated(self) self.auth_backends[backend.name] = backend self.app.install(backend) def load_session(self): # Since we vendor mongodb_beaker because of broken dep on pypi.python.org # we need to setup the beaker class map manually. beaker.cache.clsmap['mongodb'] = mongodb_beaker.MongoDBNamespaceManager self.app = SessionMiddleware(self.app, { 'session.type': 'mongodb', 'session.cookie_expires': self.cookie_expires, 'session.url': self.beaker_url, 'session.secret': self.secret, 'session.lock_dir': self.data_dir }) def unload_session(self): pass def unload_auth_backends(self): pass def unload_webservices(self): pass def exit(self): if not self.stopping: self.stopping = True self.unload_session() self.unload_webservices() self.unload_auth_backends() self.amqp_pub.connection.disconnect() sys.exit(0) class Error(Exception): pass
DEBUG = config.get("general", "debug_mode") or "-d" in sys.argv or "--debug" in sys.argv bottle.debug(DEBUG) # Middlewares from beaker.middleware import SessionMiddleware session_opts = { 'session.type': 'file', 'session.cookie_expires': False, 'session.data_dir': './tmp', 'session.auto': False } session = SessionMiddleware(app(), session_opts) web = StripPathMiddleware(session) web = GZipMiddleWare(web) if PREFIX: web = PrefixMiddleware(web, prefix=PREFIX) import api_app import cnl_app import setup_app # Last routes to register, import pyload_app # Server Adapter def run_server(host, port, server):
class WebServer(Configurable): @property def debug(self): return setdefaultattr(self, '_debug', False) @debug.setter def debug(self, value): self._debug = value @property def enable_crossdomain_send_events(self): return setdefaultattr(self, '_crossdomain_evt', False) @enable_crossdomain_send_events.setter def enable_crossdomain_send_events(self, value): self._crossdomain_evt = value @property def root_directory(self): return setdefaultattr( self, '_rootdir', os.path.expanduser('~/var/www/') ) @root_directory.setter def root_directory(self, value): value = os.path.expanduser(value) if os.path.exists(value): self._rootdir = value @property def providers(self): return setdefaultattr(self, '_providers', []) @providers.setter def providers(self, value): self._providers = value @property def cookie_expires(self): return setdefaultattr(self, '_cookie', 300) @cookie_expires.setter def cookie_expires(self, value): self._cookie = value @property def secret(self): return setdefaultattr(self, '_secret', 'canopsis') @secret.setter def secret(self, value): self._secret = value @property def data_dir(self): return setdefaultattr( self, '_datadir', os.path.expanduser('~/var/cache/canopsis/webcore/') ) @data_dir.setter def data_dir(self, value): value = os.path.expanduser(value) if os.path.exists(value): self._datadir = value # dict properties do not need setters @property def webservices(self): if not hasattr(self, '_webservices'): self._webservices = {} return self._webservices @property def beaker_url(self): return '{0}.beaker'.format(self.db.uri) def __init__(self, *args, **kwargs): super(WebServer, self).__init__(*args, **kwargs) self.log_name = 'webserver' # TODO: Replace with MongoStorage self.db = get_storage(account=Account(user='******', group='root')) self.amqp = Amqp() self.stopping = False self.webmodules = {} self.auth_backends = {} def __call__(self): self.logger.info('Initialize gevent signal-handlers') gevent.signal(SIGTERM, self.exit) gevent.signal(SIGINT, self.exit) self.logger.info('Start AMQP thread') self.amqp.start() self.logger.info('Initialize WSGI Application') self.app = BottleApplication() self.load_auth_backends() self.load_webservices() self.load_session() return self def _load_webservice(self, name): modname = 'canopsis.webcore.services.{0}'.format(name) if name in self.webmodules: return True self.logger.info('Loading webservice: {0}'.format(name)) try: mod = importlib.import_module(modname) except ImportError as err: self.logger.error( 'Impossible to load webservice {0}: {1}'.format(name, err) ) return False else: if hasattr(mod, 'exports'): self.webmodules[name] = mod mod.exports(self) else: self.logger.error( 'Invalid module {0}, no exports()'.format(name) ) return False return True def load_webservices(self): for webservice in self.webservices: if self.webservices[webservice]: self._load_webservice(webservice) def _load_auth_backend(self, name): modname = 'canopsis.auth.{0}'.format(name) if name in self.auth_backends: return True self.logger.info('Load authentication backend: {0}'.format(name)) try: mod = importlib.import_module(modname) except ImportError as err: self.logger.error( 'Impossible to load authentication backend {}: {}'.format( name, err ) ) return False else: backend = mod.get_backend(self) self.auth_backends[backend.name] = backend self.app.install(backend) return True def load_auth_backends(self): for provider in self.providers: self._load_auth_backend(provider) # Always add this backend which returns 401 when the login fails backend = EnsureAuthenticated(self) self.auth_backends[backend.name] = backend self.app.install(backend) def load_session(self): self.app = SessionMiddleware(self.app, { 'session.type': 'mongodb', 'session.cookie_expires': self.cookie_expires, 'session.url': self.beaker_url, 'session.secret': self.secret, 'session.lock_dir': self.data_dir }) def unload_session(self): pass def unload_auth_backends(self): pass def unload_webservices(self): pass def exit(self): if not self.stopping: self.stopping = True self.unload_session() self.unload_webservices() self.unload_auth_backends() self.amqp.stop() # TODO: self.amqp.wait() not implemented sys.exit(0) @property def application(self): return self.app @property def skip_login(self): return [bname for bname in self.auth_backends.keys()] @property def skip_logout(self): return [ bname for bname in self.auth_backends.keys() if not self.auth_backends[bname].handle_logout ] def require(self, modname): if not self._load_webservice(modname): raise ImportError( 'Impossible to import webservice: {0}'.format(modname) ) return self.webmodules[modname] class Error(Exception): pass
# alias the authorization decorator with defaults authorize = aaa.make_auth_decorator(fail_redirect="/login", role="user") import datetime app = bottle.app() session_opts = { 'session.cookie_expires': True, 'session.encrypt_key': 'please use a random key and keep it secret!', 'session.httponly': True, 'session.timeout': 3600 * 24, # 1 day 'session.type': 'cookie', 'session.validate_key': True, } app = SessionMiddleware(app, session_opts) # # Bottle methods # # def postd(): return bottle.request.forms def post_get(name, default=''): return bottle.request.POST.get(name, default).strip() @bottle.post('/login') def login(): """Authenticate users"""
def get_app_webui(): """ Return global application object """ global app_webui return app_webui # -------------------------------------------------------------------------------------------------- # WebUI application is default bottle app bottle_app = bottle.app() # Bottle templates path bottle.TEMPLATE_PATH.append( os.path.join(os.path.abspath(os.path.dirname(__file__)), 'views')) # Extend default WSGI application with a session middleware session_opts = { # Important: somedata stored in the session cannot be pickled. Using file is not allowed! 'session.type': 'memory', 'session.data_dir': os.path.join('/tmp', __name__, 'sessions'), 'session.auto': True, 'session.cookie_expires': 21600, # 6 hours 'session.key': __application__, 'sesssion.webtest_varname': __application__, # For unit tests ... 'session.data_serializer': 'json' # Default is pickle ... not appropriate for our data! } webapp = SessionMiddleware(bottle_app, session_opts)
def main(): servicebroker = appcelerator.service_broker_factory({}) app = SessionMiddleware(servicebroker, key='appc22_session_key', secret='secretsecretsecret') util.run_wsgi_app(app)
from bottle import Bottle, run, template, request, static_file from beaker.middleware import SessionMiddleware from os.path import abspath, dirname, join app = Bottle() # # Beaker cookie handler configuration # session_options = { 'session.type': 'file', 'session.data_dir': './session/', 'session.auto': True, } app_middleware = SessionMiddleware(app, session_options) @app.hook('before_request') def setup_request(): """ pre-assign request.session for cookie access before every request """ request.session = request.environ['beaker.session'] # # Static files configuration for CSS, Javascript etc #
def create_app(config='config.ProductionDevelopmentConfig', apptype='profi'): app = Flask(__name__, static_folder='./static') app.config.from_object(config) # babel = Babel(app) app.teardown_request(close_database) app.debug = app.config['DEBUG'] if 'DEBUG' in app.config else False app.testing = app.config['TESTING'] if 'TESTING' in app.config else False app.before_request(load_database(app.config['SQLALCHEMY_DATABASE_URI'])) app.before_request(lambda: load_user(apptype)) app.before_request(setup_authomatic(app)) def add_map_headers_to_less_files(response): response.headers.add('Access-Control-Allow-Origin', '*') if request.path and re.search(r'\.css$', request.path): mapfile = re.sub(r'\.css$', r'.css.map', request.path) if os.path.isfile( os.path.realpath(os.path.dirname(__file__)) + mapfile): response.headers.add('X-Sourcemap', mapfile) return response app.after_request(add_map_headers_to_less_files) if apptype == 'front': # relative paths def join_path(template, parent): return os.path.join(os.path.dirname(parent), template) app.jinja_env.join_path = join_path def load_portal(): # class RelEnvironment(jinja2.Environment): # """Override join_path() to enable relative template paths.""" # def join_path(self, template, parent): # return os.path.join(os.path.dirname(parent), template) from profapp.models.portal import Portal portal = g.db.query(Portal).filter_by(host=request.host).first() # portal = g.db.query(Portal).filter_by(host=request.host).one() g.portal = portal if portal else None g.portal_id = portal.id if portal else None g.portal_layout_path = portal.layout.path if portal else '' g.lang = g.portal.lang if g.portal else g.user_dict[ 'lang'] if portal else 'en' app.before_request(load_portal) from profapp.controllers.blueprints_register import register_front as register_blueprints_front register_blueprints_front(app) elif apptype == 'static': from profapp.controllers.blueprints_register import register_static as register_blueprints_static register_blueprints_static(app) elif apptype == 'file': from profapp.controllers.blueprints_register import register_file as register_blueprints_file register_blueprints_file(app) else: from profapp.controllers.blueprints_register import register_profi as register_blueprints_profi register_blueprints_profi(app) bootstrap.init_app(app) mail.init_app(app) # moment.init_app(app) login_manager.init_app(app) login_manager.session_protection = 'basic' @login_manager.user_loader def load_user_manager(user_id): return g.db.query(User).get(user_id) # csrf.init_app(app) # read this: http://stackoverflow.com/questions/6036082/call-a-python-function-from-jinja2 # app.jinja_env.globals.update(flask_endpoint_to_angular=flask_endpoint_to_angular) def raise_helper(msg): raise Exception(msg) app.jinja_env.globals.update(raw_url_for=raw_url_for) app.jinja_env.globals.update(pre=pre) app.jinja_env.globals.update(utils=utils) app.jinja_env.globals.update(translates=translates) app.jinja_env.globals.update(fileUrl=utils.fileUrl) app.jinja_env.globals.update(prImage=prImage) app.jinja_env.globals.update(prImageUrl=prImageUrl) # app.jinja_env.globals.update(url_page=url_page) app.jinja_env.globals.update(config_variables=config_variables) app.jinja_env.globals.update(_=translate_phrase) app.jinja_env.globals.update(moment=moment) app.jinja_env.globals.update(__=translate_html) app.jinja_env.globals['raise'] = raise_helper app.jinja_env.globals.update( tinymce_format_groups=HtmlHelper.tinymce_format_groups) app.jinja_env.globals.update(pr_help_tooltip=pr_help_tooltip) # url_regenerate app.jinja_env.filters['nl2br'] = nl2br # app.jinja_env.filters['localtime'] = localtime # see: http://flask.pocoo.org/docs/0.10/patterns/sqlalchemy/ # Flask will automatically remove database sessions at the end of the # request or when the application shuts down: # from db_init import db_session # @app.teardown_appcontext # def shutdown_session(exception=None): # try: # db_session.commit() # except Exception: # session.rollback() # raise # finally: # session.close() # optional, depends on use case # # db_session.remove() session_opts = { 'session.type': 'ext:memcached', 'session.url': 'memcached.profi:11211' } class BeakerSessionInterface(SessionInterface): def open_session(self, app, request): _session = request.environ['beaker.session'] return _session def save_session(self, app, session, response): session.save() app.wsgi_app = SessionMiddleware(app.wsgi_app, session_opts) app.session_interface = BeakerSessionInterface() return app
return output @get('/signin') def contactus(): output = template('signin.tpl') return output @post('/googlesignin') def google(): if oauth.validateGoogle(): return HTTPResponse(body='', status=200, headers=None) else: return HTTPError(status=500, body=None, exception=None, traceback=None) @post('/facebooksignin') def facebook(): if oauth.validateFacebook(): return HTTPResponse(status=200) else: return HTTPError(status=500) if __name__ == "__main__": app = SessionMiddleware(bottle.app(), session_opts) debug(True) bottle.run(app=app, host='localhost', port=8080, reloader=True) else: application = SessionMiddleware(default_app(), session_opts)
def make_app(global_conf, full_stack=True, static_files=True, **app_conf): """Create a Pylons WSGI application and return it ``global_conf`` The inherited configuration for this application. Normally from the [DEFAULT] section of the Paste ini file. ``full_stack`` Whether this application provides a full WSGI stack (by default, meaning it handles its own exceptions and errors). Disable full_stack when this application is "managed" by another WSGI middleware. ``static_files`` Whether this application serves its own static files; disable when another web server is responsible for serving them. ``app_conf`` The application's local configuration. Normally specified in the [app:<name>] section of the Paste ini file (where <name> defaults to main). """ # Configure the Pylons environment config = load_environment(global_conf, app_conf) # The Pylons WSGI app app = PylonsApp(config=config) # Routing/Session/Cache Middleware app = RoutesMiddleware(app, config['routes.map'], singleton=False) app = SessionMiddleware(app, config) # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares) if asbool(full_stack): # Handle Python exceptions app = ErrorHandler(app, global_conf, **config['pylons.errorware']) # Display error documents for 401, 403, 404 status codes (and # 500 when debug is disabled) if asbool(config['debug']): app = StatusCodeRedirect(app) else: app = StatusCodeRedirect(app, [400, 401, 403, 404, 500]) # Establish the Registry for this application app = RegistryManager(app) if asbool(static_files): # Serve static files static_app = StaticURLParser(config['pylons.paths']['static_files']) app = Cascade([static_app, app]) app.config = config # gzip middleware app = make_gzip_middleware(app, config) # Add Access-Control headers if 'allowed_origins' in config: log.info("Adding ControlHeadersMiddleware") app = ControlHeadersMiddleware(app, config) return app
post['update[%s][id]' % i])) if 'delete[]' in post: for row in list(post.getall('delete[]')): if row != '': cur.execute( "delete from " + table + " where id = %s" "", (int(row), )) page = """{"result":"ok"}""" response = Response(body=page, content_type="application/json", charset="utf8", status="200 OK") else: page = pyad.login.login_again response = Response(body=page, content_type="text/html", charset="utf8", status="200 OK") con.commit() cur.close() con.close() return response(environment, start_response) import pyad.sess importlib.reload(pyad.sess) session_opts = pyad.sess.session_opts application = SessionMiddleware(application, session_opts)
if __name__ == '__main__': from beaker.middleware import SessionMiddleware from cherrypy import wsgiserver KW_ARGS = main_setup(logger) _conf = KW_ARGS["conf"] session_opts = { 'session.type': 'memory', 'session.cookie_expires': True, 'session.auto': True, 'session.timeout': 900 } SRV = wsgiserver.CherryPyWSGIServer( ('0.0.0.0', _conf.PORT), SessionMiddleware(application, session_opts)) if _conf.BASE.startswith("https"): from cherrypy.wsgiserver import ssl_pyopenssl SRV.ssl_adapter = ssl_pyopenssl.pyOpenSSLAdapter( _conf.SERVER_CERT, _conf.SERVER_KEY, _conf.CA_BUNDLE) logger.info("RP server starting listening on port:%s" % _conf.PORT) print("RP server starting listening on port:%s" % _conf.PORT) try: SRV.start() except KeyboardInterrupt: SRV.stop()
def make_app(global_conf, full_stack=True, static_files=True, **app_conf): """Create a Pylons WSGI application and return it ``global_conf`` The inherited configuration for this application. Normally from the [DEFAULT] section of the Paste ini file. ``full_stack`` Whether this application provides a full WSGI stack (by default, meaning it handles its own exceptions and errors). Disable full_stack when this application is "managed" by another WSGI middleware. ``static_files`` Whether this application serves its own static files; disable when another web server is responsible for serving them. ``app_conf`` The application's local configuration. Normally specified in the [app:<name>] section of the Paste ini file (where <name> defaults to main). """ # Configure the Pylons environment config = load_environment(global_conf, app_conf) # The Pylons WSGI app app = PylonsApp(config=config) # Routing/Session Middleware app = RoutesMiddleware(app, config['routes.map']) app = SessionMiddleware(app, config) # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares) if asbool(full_stack): # Handle Python exceptions app = ErrorHandler(app, global_conf, **config['pylons.errorware']) # Display error documents for 401, 403, 404 status codes (and # 500 when debug is disabled) if asbool(config['debug']): app = StatusCodeRedirect(app, [417]) else: app = StatusCodeRedirect(app, [400, 401, 403, 404, 417, 500]) # authenticator = OCSAuthenticator(config) # app = AuthBasicHandler(app, "OCSManager", authenticator) fqdn = "%(hostname)s.%(dnsdomain)s" % config["samba"] auth_handler = NTLMAuthHandler(app) def ntlm_env_setter(environ, start_response): for var in ["SAMBA_HOST", "NTLMAUTHHANDLER_WORKDIR"]: try: environ[var] = app_conf[var] except KeyError: # FIXME: logging? pass return auth_handler(environ, start_response) # Establish the Registry for this application app = RegistryManager(ntlm_env_setter) if asbool(static_files): # Serve static files static_app = StaticURLParser(config['pylons.paths']['static_files']) app = Cascade([static_app, app]) app.config = config return app
from flask import Flask, render_template import json from application import application import sample import folders import login import register import registration from beaker.middleware import SessionMiddleware session_opts = { #'session.type': 'ext:memcached', 'session.type': 'cookie', 'session.validate_key': 'abc', 'session.url': '127.0.0.1:5001', 'session.data_dir': './cache', 'session.auto': True, 'session.save_accessed_time': True } @application.route('/') def root(): return render_template('sample.html') if __name__ == '__main__': application.wsgi_app = SessionMiddleware(application.wsgi_app,session_opts) application.run(debug=True, threaded=True, port=5001)
return "Restricted area <br> <a href='/logout'>Log out</a>" else: return "Aðgangur bannaður" @route('/logout') def logout(): response.set_cookie('user', "", expires=0) return "Þú hefur verið skráður út. <br> <a href='/login'>Login</a>" #Session lausn session_options = {'session.type': 'file', 'session.data_dir': './data/'} my_session = SessionMiddleware(app(), session_options) products = [{ 'pid': 1, 'name': 'Vara 1', 'price': 100 }, { 'pid': 2, 'name': 'Vara 2', 'price': 400 }, { 'pid': 3, 'name': 'Vara 3', 'price': 200 }, { 'pid': 4,
@post('/setVal') def setVal(): try: # 短暂休眠,模拟计算消耗 time.sleep(0.001) data = request.json key = data["key"] val = data["val"] dbMgr.set_val(key, val) # 不可以返回数字,会说object is not iterable # return 1 return "1" except Exception as e: print('getsetValVal, error:', e.value) return "-1" # 函数主入口 if __name__ == '__main__': argv = sys.argv print(argv) port = int(argv[1]) app_argv = SessionMiddleware(default_app(), session_opts) # 通知负载均衡,服务器准备就绪 headers = {'content-type': 'application/json'} data = {'ip': "127.0.0.1", 'port': port} response = requests.post(_add_svr_path, data=json.dumps(data), headers=headers) run(app=app_argv, host='0.0.0.0', port=port, debug=True, reloader=True)
reload(sys) sys.setdefaultencoding('utf-8') T.insert(0, TEMPLATE_PATH) session_opts = { 'session.type': 'file', 'session.data_dir': '/tmp/openmining.data', 'session.lock_dir': '/tmp/openmining.lock', 'session.cookie_expires': 50000, 'session.auto': True } app = SessionMiddleware(Bottle(), session_opts) app.wrap_app.mount('/api', api_app) app.wrap_app.mount('/stream', stream_app) app.wrap_app.mount('/export', export_app) app.wrap_app.install(auth) @app.wrap_app.route('/assets/<path:path>', name='assets') def static(path): yield static_file(path, root=STATIC_PATH) @app.wrap_app.route('/') @login() @view('index.html')
def make_app(global_conf, full_stack=True, static_files=True, **app_conf): """ Create a Pylons WSGI application and return it ``global_conf`` The inherited configuration for this application. Normally from the [DEFAULT] section of the Paste ini file. ``full_stack`` Whether this application provides a full WSGI stack (by default, meaning it handles its own exceptions and errors). Disable full_stack when this application is "managed" by another WSGI middleware. ``static_files`` Whether this application serves its own static files; disable when another web server is responsible for serving them. ``app_conf`` The application's local configuration. Normally specified in the [app:<name>] section of the Paste ini file (where <name> defaults to main). """ # Configure the Pylons environment config = load_environment(global_conf, app_conf) # The Pylons WSGI app app = PylonsApp() # Routing/Session/Cache Middleware app = RoutesMiddleware(app, config['routes.map']) app = SessionMiddleware(app, config) app = CacheMiddleware(app, config) g = config['pylons.app_globals'] g.cache_manager = app.cache_manager # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares) if asbool(full_stack): # Handle Python exceptions app = ErrorHandler(app, global_conf, **config['pylons.errorware']) # Display error documents for 401, 403, 404 status codes (and # 500 when debug is disabled) if asbool(config['debug']): app = StatusCodeRedirect(app) else: app = StatusCodeRedirect(app, [400, 401, 403, 404, 500]) # Establish the Registry for this application app = RegistryManager(app) if asbool(static_files): # Serve static files static_app = StaticURLParser(config['pylons.paths']['static_files']) app = Cascade([static_app, app]) # this is a compatibility hack for pylons > 1.0!!! conf = PyConf(config) conf['global_conf'] = global_conf conf['app_conf'] = app_conf conf['__file__'] = global_conf['__file__'] conf['FILE'] = global_conf['__file__'] conf['routes.map'] = config['routes.map'] if not hasattr(conf, 'init_app'): setattr(conf, 'init_app', config.init_app) app.config = conf return app
def _make_core_app(root, global_conf, full_stack=True, **app_conf): """ Set allura up with the settings found in the PasteDeploy configuration file used. :param root: The controller module containing the TG root :param global_conf: The global settings for allura (those defined under the ``[DEFAULT]`` section). :type global_conf: dict :param full_stack: Should the whole TG2 stack be set up? :type full_stack: str or bool :return: The allura application with all the relevant middleware loaded. This is the PasteDeploy factory for the allura application. ``app_conf`` contains all the application-specific settings (those defined under ``[app:main]``. """ # Run all the initialization code here mimetypes.init([pkg_resources.resource_filename('allura', 'etc/mime.types')] + mimetypes.knownfiles) # Configure MongoDB ming.configure(**app_conf) # Configure ActivityStream if asbool(app_conf.get('activitystream.recording.enabled', False)): activitystream.configure(**h.convert_bools(app_conf, prefix='activitystream.')) # Configure EW variable provider ew.render.TemplateEngine.register_variable_provider(get_tg_vars) # Set FormEncode language to english, as we don't support any other locales formencode.api.set_stdtranslation(domain='FormEncode', languages=['en']) # Create base app base_config = ForgeConfig(root) load_environment = base_config.make_load_environment() # Code adapted from tg.configuration, replacing the following lines: # make_base_app = base_config.setup_tg_wsgi_app(load_environment) # app = make_base_app(global_conf, full_stack=True, **app_conf) # Configure the TG environment load_environment(global_conf, app_conf) app = tg.TGApp() for mw_ep in h.iter_entry_points('allura.middleware'): Middleware = mw_ep.load() if getattr(Middleware, 'when', 'inner') == 'inner': app = Middleware(app, config) # Required for sessions app = SessionMiddleware(app, config, data_serializer=BeakerPickleSerializerWithLatin1()) # Handle "Remember me" functionality app = RememberLoginMiddleware(app, config) # Redirect 401 to the login page app = LoginRedirectMiddleware(app) # Add instrumentation app = AlluraTimerMiddleware(app, app_conf) # Clear cookies when the CSRF field isn't posted if not app_conf.get('disable_csrf_protection'): app = CSRFMiddleware(app, '_session_id') if asbool(config.get('cors.enabled', False)): # Handle CORS requests allowed_methods = aslist(config.get('cors.methods')) allowed_headers = aslist(config.get('cors.headers')) cache_duration = asint(config.get('cors.cache_duration', 0)) app = CORSMiddleware(app, allowed_methods, allowed_headers, cache_duration) # Setup the allura SOPs app = allura_globals_middleware(app) # Ensure http and https used per config if config.get('override_root') != 'task': app = SSLMiddleware(app, app_conf.get('no_redirect.pattern'), app_conf.get('force_ssl.pattern'), app_conf.get('force_ssl.logged_in')) # Setup resource manager, widget context SOP app = ew.WidgetMiddleware( app, compress=True, use_cache=not asbool(global_conf['debug']), script_name=app_conf.get('ew.script_name', '/_ew_resources/'), url_base=app_conf.get('ew.url_base', '/_ew_resources/'), extra_headers=ast.literal_eval(app_conf.get('ew.extra_headers', '[]')), cache_max_age=asint(app_conf.get('ew.cache_header_seconds', 60*60*24*365)), # settings to pass through to jinja Environment for EW core widgets # these are for the easywidgets' own [easy_widgets.engines] entry point # (the Allura [easy_widgets.engines] entry point is named "jinja" (not jinja2) but it doesn't need # any settings since it is a class that uses the same jinja env as the rest of allura) **{ 'jinja2.auto_reload': asbool(config['auto_reload_templates']), 'jinja2.bytecode_cache': AlluraJinjaRenderer._setup_bytecode_cache(), 'jinja2.cache_size': asint(config.get('jinja_cache_size', -1)), } ) # Handle static files (by tool) app = StaticFilesMiddleware(app, app_conf.get('static.script_name')) # Handle setup and flushing of Ming ORM sessions app = MingMiddleware(app) # Set up the registry for stacked object proxies (SOPs). # streaming=true ensures they won't be cleaned up till # the WSGI application's iterator is exhausted app = RegistryManager(app, streaming=True) # "task" wsgi would get a 2nd request to /error/document if we used this middleware if config.get('override_root') not in ('task', 'basetest_project_root'): if asbool(config['debug']): # Converts exceptions to HTTP errors, shows traceback in debug mode # don't use TG footer with extra CSS & images that take time to load tg.error.footer_html = '<!-- %s %s -->' app = tg.error.ErrorHandler(app, global_conf, **config['tg.errorware']) else: app = ErrorMiddleware(app, config, **config['tg.errorware']) app = SetRequestHostFromConfig(app, config) # Redirect some status codes to /error/document if asbool(config['debug']): app = StatusCodeRedirect(app, base_config.handle_status_codes) else: app = StatusCodeRedirect( app, base_config.handle_status_codes + [500]) for mw_ep in h.iter_entry_points('allura.middleware'): Middleware = mw_ep.load() if getattr(Middleware, 'when', 'inner') == 'outer': app = Middleware(app, config) return app
def make_flask_stack(conf, **app_conf): """ This has to pass the flask app through all the same middleware that Pylons used """ root = os.path.dirname( os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) debug = asbool(conf.get('debug', conf.get('DEBUG', False))) testing = asbool(app_conf.get('testing', app_conf.get('TESTING', False))) app = flask_app = CKANFlask(__name__) app.debug = debug app.testing = testing app.template_folder = os.path.join(root, 'templates') app.app_ctx_globals_class = CKAN_AppCtxGlobals app.url_rule_class = CKAN_Rule app.jinja_options = jinja_extensions.get_jinja_env_options() # Update Flask config with the CKAN values. We use the common config # object as values might have been modified on `load_environment` if config: app.config.update(config) else: app.config.update(conf) app.config.update(app_conf) # Do all the Flask-specific stuff before adding other middlewares # Secret key needed for flask-debug-toolbar and sessions if not app.config.get('SECRET_KEY'): app.config['SECRET_KEY'] = config.get('beaker.session.secret') if not app.config.get('SECRET_KEY'): raise RuntimeError(u'You must provide a value for the secret key' ' with the SECRET_KEY config option') if debug: from flask_debugtoolbar import DebugToolbarExtension app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False DebugToolbarExtension(app) # Use Beaker as the Flask session interface class BeakerSessionInterface(SessionInterface): def open_session(self, app, request): if 'beaker.session' in request.environ: return request.environ['beaker.session'] def save_session(self, app, session, response): session.save() namespace = 'beaker.session.' session_opts = dict([(k.replace('beaker.', ''), v) for k, v in config.iteritems() if k.startswith(namespace)]) if (not session_opts.get('session.data_dir') and session_opts.get('session.type', 'file') == 'file'): cache_dir = app_conf.get('cache_dir') or app_conf.get('cache.dir') session_opts['session.data_dir'] = '{data_dir}/sessions'.format( data_dir=cache_dir) app.wsgi_app = SessionMiddleware(app.wsgi_app, session_opts) app.session_interface = BeakerSessionInterface() # Add Jinja2 extensions and filters app.jinja_env.filters['empty_and_escape'] = \ jinja_extensions.empty_and_escape # Common handlers for all requests app.before_request(ckan_before_request) app.after_request(ckan_after_request) # Template context processors app.context_processor(helper_functions) app.context_processor(c_object) @app.context_processor def ungettext_alias(): u''' Provide `ungettext` as an alias of `ngettext` for backwards compatibility ''' return dict(ungettext=ungettext) # Babel pairs = [(os.path.join(root, u'i18n'), 'ckan')] + [ (p.i18n_directory(), p.i18n_domain()) for p in PluginImplementations(ITranslation) ] i18n_dirs, i18n_domains = zip(*pairs) app.config[u'BABEL_TRANSLATION_DIRECTORIES'] = ';'.join(i18n_dirs) app.config[u'BABEL_DOMAIN'] = 'ckan' app.config[u'BABEL_MULTIPLE_DOMAINS'] = ';'.join(i18n_domains) babel = CKANBabel(app) babel.localeselector(get_locale) @app.route('/hello', methods=['GET']) def hello_world(): return 'Hello World, this is served by Flask' @app.route('/hello', methods=['POST']) def hello_world_post(): return 'Hello World, this was posted to Flask' # Auto-register all blueprints defined in the `views` folder _register_core_blueprints(app) _register_error_handler(app) # Set up each IBlueprint extension as a Flask Blueprint for plugin in PluginImplementations(IBlueprint): if hasattr(plugin, 'get_blueprint'): app.register_extension_blueprint(plugin.get_blueprint()) lib_plugins.register_package_blueprints(app) lib_plugins.register_group_blueprints(app) # Set flask routes in named_routes for rule in app.url_map.iter_rules(): if '.' not in rule.endpoint: continue controller, action = rule.endpoint.split('.') needed = list(rule.arguments - set(rule.defaults or {})) route = { rule.endpoint: { 'action': action, 'controller': controller, 'highlight_actions': action, 'needed': needed } } config['routes.named_routes'].update(route) # Start other middleware for plugin in PluginImplementations(IMiddleware): app = plugin.make_middleware(app, config) # Fanstatic if debug: fanstatic_config = { 'versioning': True, 'recompute_hashes': True, 'minified': False, 'bottom': True, 'bundle': False, } else: fanstatic_config = { 'versioning': True, 'recompute_hashes': False, 'minified': True, 'bottom': True, 'bundle': True, } root_path = config.get('ckan.root_path', None) if root_path: root_path = re.sub('/{{LANG}}', '', root_path) fanstatic_config['base_url'] = root_path app = Fanstatic(app, **fanstatic_config) for plugin in PluginImplementations(IMiddleware): try: app = plugin.make_error_log_middleware(app, config) except AttributeError: log.critical('Middleware class {0} is missing the method' 'make_error_log_middleware.' .format(plugin.__class__.__name__)) # Initialize repoze.who who_parser = WhoConfig(conf['here']) who_parser.parse(open(app_conf['who.config_file'])) app = PluggableAuthenticationMiddleware( app, who_parser.identifiers, who_parser.authenticators, who_parser.challengers, who_parser.mdproviders, who_parser.request_classifier, who_parser.challenge_decider, logging.getLogger('repoze.who'), logging.WARN, # ignored who_parser.remote_user_key ) # Update the main CKAN config object with the Flask specific keys # that were set here or autogenerated flask_config_keys = set(flask_app.config.keys()) - set(config.keys()) for key in flask_config_keys: config[key] = flask_app.config[key] # Add a reference to the actual Flask app so it's easier to access app._wsgi_app = flask_app return app
'map_prof': PROFILEMAP, 'client_factory': Factory(Client) }) WA = WebApplication(sessionhandler=SessionHandler, webio=WebIh, webtester=WebTester, check=check, webenv=app_args, pick_grp=pick_grp, path=_path) _conf = app_args['conf'] SRV = wsgiserver.CherryPyWSGIServer( ('0.0.0.0', args.port), SessionMiddleware(WA.application, session_opts)) if args.tls: from cherrypy.wsgiserver.ssl_builtin import BuiltinSSLAdapter SRV.ssl_adapter = BuiltinSSLAdapter(_conf.SERVER_CERT, _conf.SERVER_KEY, _conf.CERT_CHAIN) extra = " using SSL/TLS" else: extra = "" print(_path) txt = "AS test server starting listening on port:%s%s" % (args.port, extra) logger.info(txt) print(txt) try:
def session_middleware(self, app): return SessionMiddleware(app, session.config)
from bottle import app as bottleapp from bottle import run, route, request, template, static_file, abort from beaker.middleware import SessionMiddleware from json import dumps from random import randint beaker_opts = { 'session.type': 'file', 'session.data_dir': '.', 'session.auto': True } app = SessionMiddleware(bottleapp(), beaker_opts) @route('/assets/<filename:path>') def assets(filename): return static_file(filename, root='./assets/') @route('/') def index(): s = request.environ['beaker.session'] s['count'] = 0 s['num'] = randint(1, 100) s['num'] = 87 s.save() return template('index.html', locals()) @route('/get/<num:int>') def get(num):
#! /usr/bin/env python2 from bottle import route, run, template, request, app, redirect, static_file from beaker.middleware import SessionMiddleware import sys session_opts = { 'session.type': 'file', 'session.cookie_expires': 300000, 'session.data_dir': '/tmp/session', 'session.auto': True, 'session.key': "sessionid" } app = application = myapp = SessionMiddleware(app(), session_opts) @route('/') def root_page(): session = request.environ.get('beaker.session') if ('log_in' in session and session['log_in'] == True): return template("welcome.html", name=session['login']) else: session['log_in'] = False redirect("/login") @route('/login') def authentication(): username = request.params.get('username') password = request.params.get('password')
def __init__(self, app): SessionMiddleware.__init__(self, app, self.get_beaker_opts())
class AddressServer(Application): """ This class is the gunicorn wrapper to serve up bottle. Strongly borrowed from: http://damianzaremba.co.uk/2012/08/running-a-wsgi- app-via-gunicorn-from-python/ """ def __init__(self, options={}): self.usage = None self.callable = None self.prog = None self.options = options self.do_load_config() self.setup_cork() super(AddressServer, self).__init__() self.app = Bottle() self.add_routes() self.add_middleware() def setup_cork(self): """Set up cork using environment variables.""" EMAIL = os.environ.get('EMAIL_SENDER') EMAIL_PASS = os.environ.get('EMAIL_PASSWORD') self.MONGO_DB = os.environ.get('MONGOHQ_DB') self.MONGO_URL = os.environ.get('MONGOHQ_URL') mb = MongoDBBackend(self.MONGO_DB, self.MONGO_URL) self.loginPlugin = Cork(backend=mb, email_sender=EMAIL, smtp_url='starttls://' + EMAIL + ':' + EMAIL_PASS + '@smtp.gmail.com:587') def add_middleware(self): """Set up the session middleware.""" ENCRYPT_KEY = os.environ.get('ENCRYPT_KEY') session_opts = { 'session.cookie_expires': True, 'session.encrypt_key': ENCRYPT_KEY, 'session.httponly': True, 'session.timeout': 3600 * 24, # 1 day 'session.type': 'cookie', 'session.validate_key': True, } self.app = SessionMiddleware(self.app, session_opts) def add_routes(self): """Add all the application routes.""" self.app.route(LOGIN_PATH, 'GET', callback=get_login) self.app.route(LOGIN_PATH, 'POST', callback=post_login, apply=self.add_login_plugin) self.app.route('/logout', 'GET', callback=logout, apply=self.add_login_plugin) self.app.route('/register', 'GET', callback=get_register, apply=self.add_login_plugin) self.app.route('/register', 'POST', callback=post_register, apply=self.add_login_plugin) self.app.route(VALIDATE_REGISTRATION_PATH + '/<registration_code>', 'GET', callback=validate_registration, apply=self.add_login_plugin) self.app.route(CHANGE_PASSWORD_PATH + '/<reset_code>', 'GET', callback=get_change_password) self.app.route(CHANGE_PASSWORD_PATH, 'POST', callback=post_change_password, apply=self.add_login_plugin) self.app.route('/reset_password', 'GET', callback=get_reset_password) self.app.route('/reset_password', 'POST', callback=post_reset_password, apply=self.add_login_plugin) self.app.route('/', 'GET', callback=index, apply=self.check_login) self.app.route('/addresses', 'GET', callback=get_addresses, apply=self.check_login) self.app.route('/addresses', 'POST', callback=post_addresses, apply=self.check_login) self.app.route('/addresses', 'PUT', callback=put_addresses, apply=self.check_login) self.app.route('/addresses/<deleteId>', 'DELETE', callback=delete_addresses, apply=self.check_login) self.app.route('/csv', 'GET', callback=csv_export, apply=self.check_login) self.app.route('/christmas_card', 'GET', callback=christmas_card_csv_export, apply=self.check_login) # self.app.route('/import_csv', 'GET', callback=csv_import, # apply=self.check_login) self.app.route('/js/<filename>', 'GET', callback=js_static) self.app.route('/css/<filename>', 'GET', callback=css_static) def init(self, *args): """Add any options passed in to the config. :param *args: the arguments of the application :returns: config object :rtype: dict """ cfg = {} for k, v in self.options.items(): if k.lower() in self.cfg.settings and v is not None: cfg[k.lower()] = v return cfg def load(self): """Load and return the bottle app.""" return self.app @hook('before_request') def check_login(self, fn): """Hook for checking the login before doing logic. :param fn: the function to call if the user is logged in :returns: the wrapped function :rtype: def """ def check_uid(**kwargs): self.loginPlugin.require(fail_redirect=LOGIN_PATH) kwargs["helper"] = AddressModel(self.MONGO_URL, self.MONGO_DB) kwargs["userName"] = self.loginPlugin.current_user.username return fn(**kwargs) return check_uid @hook('before_request') def add_login_plugin(self, fn): """Hook for adding the plugin information. :param fn: the function to pass the plugin :returns: the wrapped function :rtype: def """ def add_plugin(**kwargs): kwargs["loginPlugin"] = self.loginPlugin return fn(**kwargs) return add_plugin