}
@app.route('/<id>/<int:scene_idx>/preview')
@app.route('/<id>/<int:scene_idx>/<image_id>/preview')
def preview(id, **kwargs):
with app.app_context():
return render_template('preview.html',
tilejson_url=url_for('meta',
id=id,
_external=True,
_scheme='',
**kwargs),
**kwargs), 200, {
'Content-Type': 'text/html'
}
@app.route('/favicon.ico')
def favicon():
return '', 404
static = app.send_static_file
app.wsgi_app = DispatcherMiddleware(
None, {app.config['APPLICATION_ROOT']: app.wsgi_app})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8000, debug=True)
def wsgi_app(self, environ, start_response):
dispatcher = DispatcherMiddleware(self.real_wsgi_app, self.services)
return dispatcher(environ, start_response)
def init_request_processors(app):
@app.context_processor
def inject_user():
if session:
return dict(session)
return dict()
@app.url_defaults
def inject_theme(endpoint, values):
if "theme" not in values and app.url_map.is_endpoint_expecting(
endpoint, "theme"
):
values["theme"] = ctf_theme()
@app.before_request
def needs_setup():
return
if request.path == url_for("views.setup") or request.path.startswith("/themes"):
return
if not is_setup():
return redirect(url_for("views.setup"))
@app.before_request
def tracker():
if request.endpoint in ("views.themes", "views.custom_css"):
return
if authed():
track = Tracking.query.filter_by(ip=get_ip(), user_id=session["id"]).first()
if not track:
visit = Tracking(ip=get_ip(), user_id=session["id"])
db.session.add(visit)
else:
track.date = datetime.datetime.utcnow()
try:
db.session.commit()
except (InvalidRequestError, IntegrityError):
db.session.rollback()
logout_user()
if authed():
user = get_current_user()
team = get_current_team()
if request.path.startswith("/themes") is False:
if user and user.banned:
return (
render_template(
"errors/403.html",
error="You have been banned from this CTF",
),
403,
)
if team and team.banned:
return (
render_template(
"errors/403.html",
error="Your team has been banned from this CTF",
),
403,
)
db.session.close()
@app.before_request
def csrf():
try:
func = app.view_functions[request.endpoint]
except KeyError:
abort(404)
if hasattr(func, "_bypass_csrf"):
return
if not session.get("nonce"):
session["nonce"] = generate_nonce()
if request.method not in ("GET", "HEAD", "OPTIONS", "TRACE"):
if request.content_type == "application/json":
if session["nonce"] != request.headers.get("CSRF-Token"):
abort(403)
if request.content_type != "application/json":
if session["nonce"] != request.form.get("nonce"):
abort(403)
application_root = app.config.get("APPLICATION_ROOT")
application_root = "/"
import traceback
if application_root != "/":
@app.before_request
def force_subdirectory_redirect():
# print(traceback.print_stack())
# app.wsgi_app = ReverseProxied(app.wsgi_app)
print("request.path")
print(request.path)
print(application_root)
print(request.script_root)
print(request.full_path)
original_uri = request.environ['HTTP_X_ORIGINAL_URI']
print("original_uri")
print(original_uri)
if request.path == "/":
pass
#return redirect(request.script_root+ request.full_path)
else:
return
if request.path.startswith(application_root) is False:
return redirect(
application_root + request.script_root + request.full_path
# application_root + request.script_root
#request.environ['HTTP_X_ORIGINAL_URI']
)
app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {application_root: app})
app.config.from_envvar('FLASK_SETTINGS')
app.debug = True
@app.route('/login')
def login():
return render_template('login.html')
@app.route('/logged_in', methods=['POST'])
def login_callback():
token = request.form['token']
payload = {'format': 'json', 'token': token}
response = requests.get(request.host_url + 'velruse/auth_info',
params=payload)
return render_template('result.html', result=response.json)
velruse = make_velruse_app({}, **app.config['VELRUSE'])
application = DispatcherMiddleware(app, {
'/velruse': velruse,
})
if __name__ == '__main__':
import os
from werkzeug.serving import run_simple
# Bind to PORT if defined, otherwise default to 5000.
port = int(os.environ.get('PORT', 5020))
run_simple('0.0.0.0', port, application, use_reloader=True, threaded=True)
"""Main entrypoint of the Python-based SOAP service
Here, the dispatcher middleware is created and all required parts of the app
are "hooked in".
Adapt this file if you want to add new services to this app.
"""
import os
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
from frontend import app as frontend
from ImageConverterService import app as imageconverter
# Read deployment route from environment variable
CONTEXT_ROOT = os.environ['CONTEXT_ROOT']
# We use a simple, static frontend page and then "hook in" all sub-apps we like
# to have.
# Currently, this is only the calculator, for which we define the hosting
# location
app = DispatcherMiddleware(frontend, {
CONTEXT_ROOT + '/imageconverter': imageconverter,
})
if __name__ == "__main__":
# Only for debugging! (Will start the app in a simple Python thread
# without nginx or uwsgi when main.py is directly executed.)
run_simple('0.0.0.0', 80, app, use_reloader=True)
class JSONResponse(Response):
@classmethod
def force_type(cls, rv, environ=None):
if isinstance(rv, dict):
rv = jsonify(rv)
return super(JSONResponse, cls).force_type(rv, environ)
json_page.response_class = JSONResponse
@json_page.route('/hello/')
def hello():
return {'message': 'Hello World!'}
@app.route('/')
def index():
return 'The index page'
# 当访问以/json开头的地址时都默认自动用jsonify格式化, 访问其他地址不受影响
app.wsgi_app = DispatcherMiddleware(app.wsgi_app, OrderedDict((
('/json', json_page),
)))
# 使用这个中间件对访问地址是有副作用的，“@json_page.route('/')”等价于“@app.route('/json/')”，也就是子路径的地址前面是有/json前缀的，这一点比较隐晦。
if __name__ == '__main__':
app.run(host='0.0.0.0', port=9000)
def wsgi_app(self, environ, start_response):
"""Returns the WSGI app for this application (including all mounted WSGI apps)."""
apps = self.apps.copy()
main = apps.pop("/")
return DispatcherMiddleware(main, apps)(environ, start_response)
@app1.route('/index')
def index():
return "app01"
@app2.route('/index2')
def index2():
return "app2"
# http://www.oldboyedu.com/index
# http://www.oldboyedu.com/sec/index2
dm = DispatcherMiddleware(app1, {
'/sec': app2,
})
if __name__ == "__main__":
run_simple('localhost', 5000, dm)
问题：Web访问多app应用时，上下文管理是如何实现？
总结：
1. threading.local (哪里还用到过threading.local: DBUtils )
2. 上下文
- 请求
- request
- session
- 应用
@app.route('/')
def index():
return 'Running...'
@app.route('/write', methods=['POST'])
def addMetrics():
if request.method == 'POST':
data = request.get_json()
adapter.write(data)
return 'Finished addMetrics'
app.wsgi_app = DispatcherMiddleware(app.wsgi_app,
{'/metrics': make_wsgi_app()})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=80)
# class ReviewForm(Form):
# filename = TextAreaField('',[validators.DataRequired(), validators.length(min = 5)])
# metricname = TextAreaField('',[validators.DataRequired(), validators.length(min = 5)])
# period = TextAreaField('')
# @app.route('/toCSV')
# def toCSV():
# form = ReviewForm(request.form)
# return render_template('index.html', form = form)
# @app.route('/todb', methods=['POST'])
if __name__ == '__main__':
eggroll.init(mode=WORK_MODE)
manager.url_map.strict_slashes = False
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10),
options=[(cygrpc.ChannelArgKey.max_send_message_length, -1),
(cygrpc.ChannelArgKey.max_receive_message_length, -1)])
proxy_pb2_grpc.add_DataTransferServiceServicer_to_server(
UnaryServicer(), server)
server.add_insecure_port("{}:{}".format(IP, GRPC_PORT))
server.start()
JobCron(interval=5 * 1000).start()
app = DispatcherMiddleware(
manager, {
'/data': data_access_manager,
'/model': model_manager,
'/workflow': workflow_manager,
'/dtable': dtable_manager,
'/job': manager
})
run_simple(hostname=IP, port=HTTP_PORT, application=app, threaded=True)
try:
while True:
time.sleep(_ONE_DAY_IN_SECONDS)
except KeyboardInterrupt:
server.stop(0)
sys.exit(0)
def init_request_processors(app):
@app.context_processor
def inject_user():
if session:
return dict(session)
return dict()
@app.url_defaults
def inject_theme(endpoint, values):
if "theme" not in values and app.url_map.is_endpoint_expecting(
endpoint, "theme"):
values["theme"] = ctf_theme()
@app.after_request
def apply_header(response):
response.headers["X-CTFProxy-I-Served-By"] = platform.node()
try:
db.session.close()
except:
pass
return response
@app.before_request
def needs_setup():
if is_setup() is False:
if request.endpoint in (
"views.setup",
"views.integrations",
"views.themes",
):
return
else:
return redirect(url_for("views.setup"))
@app.before_request
def tracker():
if request.endpoint == "views.themes":
return
if authed():
user_ips = get_current_user_recent_ips()
ip = get_ip()
track = None
if (ip not in user_ips) or (request.method != "GET"):
track = Tracking.query.filter_by(
ip=get_ip(), user_id=session["id"]).first()
if track:
track.date = datetime.datetime.utcnow()
else:
track = Tracking(ip=get_ip(), user_id=session["id"])
db.session.add(track)
if track:
try:
db.session.commit()
except (InvalidRequestError, IntegrityError):
db.session.rollback()
logout_user()
clear_user_recent_ips(user_id=session["id"])
@app.before_request
def banned():
if request.endpoint == "views.themes":
return
if authed():
user = get_current_user_attrs()
team = get_current_team_attrs()
if user and user.banned:
return (
render_template(
"errors/403.html",
error="You have been banned from this CTF"),
403,
)
if team and team.banned:
return (
render_template(
"errors/403.html",
error="Your team has been banned from this CTF",
),
403,
)
@app.before_request
def tokens():
token = request.headers.get("Authorization")
if token and request.content_type == "application/json":
try:
token_type, token = token.split(" ", 1)
user = lookup_user_token(token)
except UserNotFoundException:
abort(401)
except UserTokenExpiredException:
abort(401)
except Exception:
abort(401)
else:
login_user(user)
@app.before_request
def csrf():
try:
func = app.view_functions[request.endpoint]
except KeyError:
abort(404)
if hasattr(func, "_bypass_csrf"):
return
if request.headers.get("Authorization"):
return
if not session.get("nonce"):
session["nonce"] = generate_nonce()
if request.method not in ("GET", "HEAD", "OPTIONS", "TRACE"):
if request.content_type == "application/json":
if session["nonce"] != request.headers.get("CSRF-Token"):
abort(403)
if request.content_type != "application/json":
if session["nonce"] != request.form.get("nonce"):
abort(403)
application_root = app.config.get("APPLICATION_ROOT")
if application_root != "/":
@app.before_request
def force_subdirectory_redirect():
if request.path.startswith(application_root) is False:
return redirect(application_root + request.script_root +
request.full_path)
app.wsgi_app = DispatcherMiddleware(app.wsgi_app,
{application_root: app})
parser.add_argument('--ssl-key')
parser.add_argument('--api', action='store_true')
parser.add_argument('--host', '-H', default='127.0.0.1')
parser.add_argument('--port', '-p', default=5000, type=int)
args = parser.parse_args()
app = make_application()
app.debug = True
app.acoustid_script.setup_console_logging()
run_args = {
'use_debugger': True,
'use_reloader': True,
'extra_files': [app.acoustid_config_filename],
}
if args.ssl:
if args.ssl_crt and args.ssl_key:
run_args['ssl_context'] = args.ssl_crt, args.ssl_key
else:
run_args['ssl_context'] = 'adhoc'
if args.api:
app = DispatcherMiddleware(
app, {
'/api': make_api_application(app.acoustid_config_filename)[1],
})
run_simple(args.host, args.port, app, **run_args) # type: ignore
from werkzeug.wsgi import DispatcherMiddleware
from app import app as app_homepage
import fantasydrafts
import fantasypl
from flask import render_template
from flask_sslify import SSLify
sslify_fantasydrafts = SSLify(fantasydrafts.app)
sslify_fantasypl = SSLify(fantasypl.app)
sslify_homepage = SSLify(app_homepage)
app = DispatcherMiddleware(app_homepage, {'/drafts': fantasydrafts.app,
'/fantasypl': fantasypl.app})
@app_homepage.route('/')
def index():
return render_template('index.html',
url_draft = '/drafts/necessary-roughness-2014/',
url_fantasypl = '/fantasypl/')
if __name__ == '__main__':
app.run()
def main():
"""Entry point for RWS.
return (int): exit code (0 on success, 1 on error)
"""
parser = argparse.ArgumentParser(description="Ranking for CMS.")
parser.add_argument("--config",
type=argparse.FileType("rt"),
help="override config file")
parser.add_argument("-d",
"--drop",
action="store_true",
help="drop the data already stored")
parser.add_argument("-y",
"--yes",
action="store_true",
help="do not require confirmation on dropping data")
args = parser.parse_args()
config = Config()
config.load(args.config)
if args.drop:
if args.yes:
ans = 'y'
else:
ans = input(
"Are you sure you want to delete directory %s? [y/N] " %
config.lib_dir).strip().lower()
if ans in ['y', 'yes']:
print("Removing directory %s." % config.lib_dir)
shutil.rmtree(config.lib_dir)
else:
print("Not removing directory %s." % config.lib_dir)
return 0
stores = dict()
stores["subchange"] = Store(Subchange,
os.path.join(config.lib_dir, 'subchanges'),
stores)
stores["submission"] = Store(Submission,
os.path.join(config.lib_dir, 'submissions'),
stores, [stores["subchange"]])
stores["user"] = Store(User, os.path.join(config.lib_dir, 'users'), stores,
[stores["submission"]])
stores["team"] = Store(Team, os.path.join(config.lib_dir, 'teams'), stores,
[stores["user"]])
stores["task"] = Store(Task, os.path.join(config.lib_dir, 'tasks'), stores,
[stores["submission"]])
stores["contest"] = Store(Contest, os.path.join(config.lib_dir,
'contests'), stores,
[stores["task"]])
stores["contest"].load_from_disk()
stores["task"].load_from_disk()
stores["team"].load_from_disk()
stores["user"].load_from_disk()
stores["submission"].load_from_disk()
stores["subchange"].load_from_disk()
stores["scoring"] = ScoringStore(stores)
stores["scoring"].init_store()
toplevel_handler = RoutingHandler(
RootHandler(config.web_dir), DataWatcher(stores, config.buffer_size),
ImageHandler(os.path.join(config.lib_dir, '%(name)s'),
os.path.join(config.web_dir, 'img', 'logo.png')),
ScoreHandler(stores), HistoryHandler(stores))
wsgi_app = SharedDataMiddleware(
DispatcherMiddleware(
toplevel_handler, {
'/contests':
StoreHandler(stores["contest"], config.username,
config.password, config.realm_name),
'/tasks':
StoreHandler(stores["task"], config.username, config.password,
config.realm_name),
'/teams':
StoreHandler(stores["team"], config.username, config.password,
config.realm_name),
'/users':
StoreHandler(stores["user"], config.username, config.password,
config.realm_name),
'/submissions':
StoreHandler(stores["submission"], config.username,
config.password, config.realm_name),
'/subchanges':
StoreHandler(stores["subchange"], config.username,
config.password, config.realm_name),
'/faces':
ImageHandler(os.path.join(config.lib_dir, 'faces', '%(name)s'),
os.path.join(config.web_dir, 'img', 'face.png')),
'/flags':
ImageHandler(os.path.join(config.lib_dir, 'flags', '%(name)s'),
os.path.join(config.web_dir, 'img', 'flag.png')),
'/sublist':
SubListHandler(stores),
}), {'/': config.web_dir})
servers = list()
if config.http_port is not None:
http_server = WSGIServer((config.bind_address, config.http_port),
wsgi_app)
servers.append(http_server)
if config.https_port is not None:
https_server = WSGIServer((config.bind_address, config.https_port),
wsgi_app,
certfile=config.https_certfile,
keyfile=config.https_keyfile)
servers.append(https_server)
try:
gevent.joinall(list(gevent.spawn(s.serve_forever) for s in servers))
except KeyboardInterrupt:
pass
finally:
gevent.joinall(list(gevent.spawn(s.stop) for s in servers))
return 0
extra_files = []
try:
extra_files.append(os.path.join(app.root_path, os.environ['ZWL_SETTINGS']))
except KeyError:
pass
# Allow testing if everything still works when not running under /
if len(sys.argv) > 1 and sys.argv[1] == 'subdir':
notfound = Response('Use <a href="/zwl/">/zwl/</a>, please!', status=404)
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
application = DispatcherMiddleware(notfound, {
'/zwl': app,
})
run_simple('localhost',
8232,
application,
use_reloader=True,
extra_files=extra_files,
threaded=True)
# Listen on all interfaces instead of just localhost. Force-deactivate debug mode
elif len(sys.argv) > 1 and sys.argv[1] == 'public':
app.run(host='0.0.0.0',
port=8231,
extra_files=extra_files,
threaded=True,
import os.path
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
import sys
sys.path.insert(0, '/opt/ori')
from ocd_frontend import rest
application = DispatcherMiddleware(rest.create_app(),
{'/v0': rest.create_app()})
# For testing purposes, add a route that serves static files from a directory.
# DO NOT USE IN PRODUCTION. Serve static files through your webserver instead.
if application.app.config.get('DEBUG', False):
from flask import send_from_directory
@application.app.route('/data/<path:filename>')
def download_dump(filename):
collection_name = '_'.join(filename.split('_')[:2])
base_dir = os.path.join(application.app.config.get('DUMPS_DIR'),
collection_name)
return send_from_directory(base_dir, filename, as_attachment=True)
@application.app.route('/media/<path:filename>')
def serve_media(filename):
base_dir = os.path.join(application.app.config.get('THUMBNAILS_DIR'),
os.path.dirname(filename))
return send_from_directory(base_dir, os.path.basename(filename))
# -*-coding:utf-8 -*-
from werkzeug.wsgi import DispatcherMiddleware
from spyne.server.wsgi import WsgiApplication
from apps import spyned
from apps.flasked import app
# SOAP services are distinct wsgi applications, we should use dispatcher
# middleware to bring all aps together
app.wsgi_app = DispatcherMiddleware(
app.wsgi_app, {'/soap': WsgiApplication(spyned.create_app(app))})
if __name__ == '__main__':
app.run()
def _start_tornado(ibs_, port_):
# Get Flask app
app = controller_inject.get_flask_app()
app.ibs = ibs_
# Try to ascertain the socket's domain name
socket.setdefaulttimeout(0.1)
try:
app.server_domain = socket.gethostbyname(socket.gethostname())
except socket.gaierror:
app.server_domain = '127.0.0.1'
socket.setdefaulttimeout(None)
app.server_port = port_
# URL for the web instance
app.server_url = 'http://%s:%s' % (app.server_domain, app.server_port)
logger.info('[web] Tornado server starting at %s' % (app.server_url, ))
# Launch the web browser to view the web interface and API
if browser:
url = app.server_url + url_suffix
import webbrowser
logger.info('[web] opening browser with url = %r' % (url, ))
webbrowser.open(url)
if PROMETHEUS:
# Add prometheus wsgi middleware to route /metrics requests
logger.info('LOADING PROMETHEUS')
app_ = DispatcherMiddleware(
app, {'/metrics': prometheus_client.make_wsgi_app()})
# Migrate the most essential settings
app_.server_port = app.server_port
app_.server_url = app.server_url
app_.ibs = app.ibs
app = app_
else:
logger.info('SKIPPING PROMETHEUS')
# Start the tornado web handler
# WSGI = Web Server Gateway Interface
# WSGI is Python standard described in detail in PEP 3333
wsgi_container = TimedWSGIContainer(app)
# # Try wrapping with newrelic performance monitoring
# try:
# import newrelic
# wsgi_container = newrelic.agent.WSGIApplicationWrapper(wsgi_container)
# except (ImportError, AttributeError):
# pass
http_server = tornado.httpserver.HTTPServer(wsgi_container)
try:
http_server.listen(app.server_port)
except socket.error:
fallback_port = ut.find_open_port(app.server_port)
if fallback:
logger.info(
'Port %s is unavailable, using fallback_port = %r' %
(port, fallback_port))
start_tornado(
ibs,
port=fallback_port,
browser=browser,
url_suffix=url_suffix,
start_web_loop=start_web_loop,
fallback=False,
)
else:
raise RuntimeError(
(('The specified IBEIS web port %d is not available, '
'but %d is') % (app.server_port, fallback_port)))
# Add more verbose logging
try:
utool_logfile_handler = ut.util_logging.__UTOOL_ROOT_LOGGER__
except Exception:
utool_logfile_handler = None
if utool_logfile_handler is not None:
logger_list = []
try:
logger_list += [
app.logger,
]
except AttributeError:
pass
try:
logger_list += [
app.app.logger,
]
except AttributeError:
pass
logger_list += [
logging.getLogger('concurrent'),
logging.getLogger('concurrent.futures'),
logging.getLogger('flask_cors.core'),
logging.getLogger('flask_cors'),
logging.getLogger('flask_cors.decorator'),
logging.getLogger('flask_cors.extension'),
logging.getLogger('urllib3'),
logging.getLogger('requests'),
logging.getLogger('tornado'),
logging.getLogger('tornado.access'),
logging.getLogger('tornado.application'),
logging.getLogger('tornado.general'),
logging.getLogger('websocket'),
]
for logger_ in logger_list:
logger_.setLevel(logging.INFO)
logger_.addHandler(utool_logfile_handler)
if start_web_loop:
tornado.ioloop.IOLoop.instance().start()
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
from test.test_database import *
import unittest, sqlite3
from app.resources import *
from app.resources import app as apis
from client.application import app as client
application = DispatcherMiddleware(apis, {'/shareit/client': client})
if __name__ == "__main__":
#app.run(debug=True, port=3000)
run_simple('localhost',
5000,
application,
use_reloader=True,
use_debugger=True,
use_evalex=True)
def initialize(app):
app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {
'/mapserv': create_mapserver_app(),
})
log_table.insert({
'datetime': arrow.now().format('DD.MM.YYYY HH:mm:ss'),
'message': json_data['message']
})
return 'ok'
@app.route('/api/remove/<id_>')
def remove_data(id_):
eid = int(id_)
ring_table.remove(eids=[eid])
return 'ok'
@app.route('/api/clear')
def clear_data():
log_table.purge()
ring_table.purge()
return 'ok'
@mqtt.subscribe('/home/temperature')
def print_it(client, userdata, message):
data = {'temperature': float(message.payload.decode())}
socketio.emit('new temperature', data)
if __name__ == '__main__':
application = DispatcherMiddleware(None, {'/bell': app})
run_simple('0.0.0.0', 8081, application)
except Exception as e:
pass
logger.setLevel(logging.INFO)
debug_log = logging.getLogger("debug")
logging.basicConfig()
debug_log.setLevel(logging.DEBUG)
import debugpy
debugpy.listen(('0.0.0.0', 5678))
debug_log.info("wait_for_client on port 5678")
debugpy.wait_for_client()
from instance.settings import OPERATOR_ROOT_PATH, OPERATOR_CR_PATH, OPERATOR_SLR_PATH, OPERATOR_DUMMYUI_PATH
application = DispatcherMiddleware(
Operator_Root.create_app(), {
OPERATOR_ROOT_PATH + OPERATOR_CR_PATH: Operator_CR.create_app(),
OPERATOR_ROOT_PATH + OPERATOR_SLR_PATH: Operator_SLR.create_app(),
OPERATOR_ROOT_PATH + OPERATOR_DUMMYUI_PATH:
Operator_DummyUI.create_app()
})
if __name__ == "__main__":
run_simple('0.0.0.0',
5000,
application,
use_reloader=False,
use_debugger=False,
threaded=False)
def create_wsgi(app, **kwargs):
mounts = {
mount: factory(**kwargs)
for mount, factory in mounts_factories.items()
}
return DispatcherMiddleware(app.wsgi_app, mounts)
def init_request_processors(app):
@app.context_processor
def inject_user():
if session:
return dict(session)
return dict()
@app.url_defaults
def inject_theme(endpoint, values):
if 'theme' not in values and app.url_map.is_endpoint_expecting(
endpoint, 'theme'):
values['theme'] = ctf_theme()
@app.before_request
def needs_setup():
if request.path == url_for('views.setup') or request.path.startswith(
'/themes'):
return
if not is_setup():
return redirect(url_for('views.setup'))
@app.before_request
def tracker():
# TODO: This function shouldn't cause a DB hit for lookups if possible
if authed():
track = Tracking.query.filter_by(ip=get_ip(),
user_id=session['id']).first()
if not track:
visit = Tracking(ip=get_ip(), user_id=session['id'])
db.session.add(visit)
else:
track.date = datetime.datetime.utcnow()
try:
db.session.commit()
except (InvalidRequestError, IntegrityError) as e:
print(e.message)
db.session.rollback()
session.clear()
if authed():
user = get_current_user()
team = get_current_team()
if request.path.startswith('/themes') is False:
if user and user.banned:
return render_template(
'errors/403.html',
error='You have been banned from this CTF'), 403
if team and team.banned:
return render_template(
'errors/403.html',
error='Your team has been banned from this CTF'
), 403
db.session.close()
@app.before_request
def csrf():
try:
func = app.view_functions[request.endpoint]
except KeyError:
abort(404)
if hasattr(func, '_bypass_csrf'):
return
if not session.get('nonce'):
session['nonce'] = generate_nonce()
if request.method not in ('GET', 'HEAD', 'OPTIONS', 'TRACE'):
if request.content_type == 'application/json':
if session['nonce'] != request.headers.get('CSRF-Token'):
abort(403)
if request.content_type != 'application/json':
if session['nonce'] != request.form.get('nonce'):
abort(403)
application_root = app.config.get('APPLICATION_ROOT')
if application_root != '/':
@app.before_request
def force_subdirectory_redirect():
if request.path.startswith(application_root) is False:
return redirect(application_root + request.script_root +
request.full_path)
app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {
application_root: app,
})
import os
import sys
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
sys.path.insert(0, '../ajna_docs/commons')
sys.path.insert(0, '../virasana')
from ajna_commons.flask.conf import BHADRASANA_URL
os.environ['DEBUG'] = '1'
from bhadrasana.main import app
if __name__ == '__main__':
print('Iniciando Servidor Bhadrasana...')
port = 5000
if BHADRASANA_URL:
port = int(BHADRASANA_URL.split(':')[-1])
application = DispatcherMiddleware(app, {'/bhadrasana': app})
run_simple('localhost', port, application, use_reloader=True)
from werkzeug.wsgi import DispatcherMiddleware
from server.apps import api
from server.apps import frontend
# This is the entry point for callable or entry point function for uwsgi.
application = DispatcherMiddleware(
frontend.create_app(),
{
'/api': api.create_app(),
},
)
from werkzeug.wsgi import DispatcherMiddleware
# Switch logging on
import logging
from logging.handlers import RotatingFileHandler
log_dir = os.path.abspath(config.logs.server)
# Create the directory if it does not exist
if not os.path.isdir(log_dir):
os.makedirs(log_dir)
# File handle for server logs
file_handler = RotatingFileHandler(
os.path.join(log_dir, 'vizier-webapi.log'),
maxBytes=1024 * 1024 * 100,
backupCount=20
)
file_handler.setLevel(logging.ERROR)
file_handler.setFormatter(
logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
)
app.logger.addHandler(file_handler)
# Load a dummy app at the root URL to give 404 errors.
# Serve app at APPLICATION_ROOT for localhost development.
application = DispatcherMiddleware(Flask('dummy_app'), {
app.config['APPLICATION_ROOT']: app,
})
run_simple(
'0.0.0.0',
config.webservice.server_local_port,
application,
use_reloader=config.run.debug
)
from flask import Flask
from werkzeug.wsgi import DispatcherMiddleware
from api_service.app import app as api_service_app
from api_service.ui import app as api_service_ui
app = DispatcherMiddleware(Flask(__name__), {
"/api/v1": api_service_app,
"/ui": api_service_ui
})
from flask import Flask
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
app = Flask('app01')
app2 = Flask('app02') #生成两个app
@app.route('/index', methods=['GET'])
def home():
return 'index'
@app2.route('/index2', methods=['GET'])
def index():
return 'index2'
app3 = DispatcherMiddleware(
app,
{
'/sec': app2, # 做了 分发，必须要加'/sec/index2' 才能触发app2
})
if __name__ == '__main__':
app.__call__
run_simple('localhost', 9000, app3)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
from app.frontend import create_app
frontend = create_app(settings_override="app.config.Development")
application = DispatcherMiddleware(frontend, {})
if __name__ == "__main__":
with frontend.app_context():
# db.create_all()
pass
run_simple('0.0.0.0',
5000,
application,
use_reloader=True,
use_debugger=True)
