def __init__(self, ip, port, app, log='default'):
self.ip = ip
self.port = port
self.app = app
self.server = WSGIServer((self.ip, self.port), log=log,
application=self.app.application, spawn=Pool(500), handler_class=ProxyHandler)
from gevent.pywsgi import WSGIServer
app = Flask(__name__)
@app.before_request
def fix_transfer_encoding():
"""
Sets the "wsgi.input_terminated" environment flag, thus enabling
Werkzeug to pass chunked requests as streams. The gunicorn server
should set this, but it's not yet been implemented.
"""
transfer_encoding = request.headers.get("Transfer-Encoding", None)
if transfer_encoding == u"chunked":
request.environ["wsgi.input_terminated"] = True
@app.route("/", defaults={"path": ""}, methods=["POST", "GET"])
@app.route("/<path:path>", methods=["POST", "GET"])
def main_route(path):
ret = handler.handle(request)
return jsonify(ret)
if __name__ == '__main__':
#app.run(host='0.0.0.0', port=5000, debug=False)
http_server = WSGIServer(('', 5000), app)
http_server.serve_forever()
def runloop():
logger.info("WebhookTest runloop started")
http_server = WSGIServer((self.addr, self.port), app)
http_server.serve_forever()
def run_rest_server(self):
app = Flask(__name__)
logger.info(f'serving /vrops_list on {self.port}')
@app.route('/vrops_list', methods=['GET'])
def vrops_list():
return json.dumps(self.vrops_list)
logger.info(f'serving /inventory on {self.port}')
@app.route('/<target>/vcenters/<int:iteration>', methods=['GET'])
def vcenters(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('vcenters',
{}).get(target, {})
@app.route('/<target>/datacenters/<int:iteration>', methods=['GET'])
def datacenters(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('datacenters',
{}).get(target, {})
@app.route('/<target>/clusters/<int:iteration>', methods=['GET'])
def clusters(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('clusters',
{}).get(target, {})
@app.route('/<target>/hosts/<int:iteration>', methods=['GET'])
def hosts(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('hosts',
{}).get(target, {})
@app.route('/<target>/datastores/<int:iteration>', methods=['GET'])
def datastores(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('datastores',
{}).get(target, {})
@app.route('/<target>/vms/<int:iteration>', methods=['GET'])
def vms(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('vms',
{}).get(target, {})
@app.route('/<target>/dvs/<int:iteration>', methods=['GET'])
def distributed_virtual_switches(target, iteration):
return self.iterated_inventory.get(str(iteration), {}).get(
'distributed_virtual_switches', {}).get(target, {})
@app.route('/<target>/nsxt_adapter/<int:iteration>', methods=['GET'])
def nsxt_adapter(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('nsxt_adapter',
{}).get(target, {})
@app.route('/<target>/nsxt_mgmt_cluster/<int:iteration>',
methods=['GET'])
def nsxt_mgmt_cluster(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('nsxt_mgmt_cluster',
{}).get(target, {})
@app.route('/<target>/nsxt_mgmt_nodes/<int:iteration>',
methods=['GET'])
def nsxt_mgmt_nodes(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('nsxt_mgmt_nodes',
{}).get(target, {})
@app.route('/<target>/nsxt_mgmt_service/<int:iteration>',
methods=['GET'])
def nsxt_mgmt_service(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('nsxt_mgmt_service',
{}).get(target, {})
@app.route('/<target>/nsxt_transport_nodes/<int:iteration>',
methods=['GET'])
def nsxt_transport_nodes(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('nsxt_transport_nodes',
{}).get(target, {})
@app.route('/<target>/nsxt_logical_switches/<int:iteration>',
methods=['GET'])
def nsxt_logical_switches(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('nsxt_logical_switches',
{}).get(target, {})
@app.route('/<target>/vcops_objects/<int:iteration>', methods=['GET'])
def vcops_self_monitoring_objects(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('vcops_objects',
{}).get(target, {})
@app.route('/<target>/sddc_objects/<int:iteration>', methods=['GET'])
def sddc_health_objects(target, iteration):
return self.iterated_inventory.get(str(iteration),
{}).get('sddc_objects',
{}).get(target, {})
@app.route('/alertdefinitions/', methods=['GET'])
def alert_alertdefinitions():
return self.alertdefinitions
@app.route('/iteration', methods=['GET'])
def iteration():
return_iteration = self.successful_iteration_list[-1]
return str(return_iteration)
@app.route('/amount_resources', methods=['GET'])
def amount_resources():
amount_resources = self.amount_resources
return json.dumps(amount_resources)
@app.route('/collection_times', methods=['GET'])
def collection_times():
vrops_collection_times = self.vrops_collection_times
return json.dumps(vrops_collection_times)
@app.route('/api_response_codes', methods=['GET'])
def api_response_codes():
response_codes = self.response_codes
return json.dumps(response_codes)
# debugging purpose
@app.route('/iteration_store', methods=['GET'])
def iteration_store():
return_iteration = self.successful_iteration_list
return json.dumps(return_iteration)
# FIXME: this could basically be the always active token list. no active token? refresh!
@app.route('/target_tokens', methods=['GET'])
def token():
return json.dumps(self.target_tokens)
try:
if logger.level == 10:
# WSGi is logging on DEBUG Level
WSGIServer((self.wsgi_address, self.port), app).serve_forever()
else:
WSGIServer((self.wsgi_address, self.port), app,
log=None).serve_forever()
except TypeError as e:
logger.error(
'Problem starting server, you might want to try LOOPBACK=0 or LOOPBACK=1'
)
logger.error(
f'Current used options: {self.wsgi_address} on port {self.port}'
)
logger.error(f'TypeError: {e}')
from gevent.pywsgi import WSGIServer
from multiprocessing import Process, freeze_support
import json
from dnserver import startDNS
if __name__ == '__main__':
from app import app # only do this in main process because of logging
with open('config.json') as f:
useDNS = json.load(f)['useDNS']
if useDNS:
freeze_support()
dnsprocess = Process(target=startDNS)
dnsprocess.start()
http_server = WSGIServer(('127.0.0.1', 5000), app)
app.logger.info("App server started")
print("App server started")
http_server.serve_forever()
def make_server(host, port, app):
http_server = WSGIServer((host, port),
app,
handler_class=WebSocketHandler)
return http_server
# coding: utf-8
import json
from gevent.pywsgi import WSGIServer
from flask import Flask, request, Response, jsonify
from app.create import create_app
# from gevent import monkey;monkey.patch_all()
from utils.config import SERVER_PORT
from module.mtqq import mqtt_start_subscribe
app = create_app(True)
if __name__ == '__main__':
mqtt_start_subscribe() #启动mqtt订阅服务
WSGIServer(('0.0.0.0', SERVER_PORT), app).serve_forever()
def main():
"Start gevent WSGI server"
# use gevent WSGI server instead of the Flask
http = WSGIServer(('', 5000), app.wsgi_app)
# TODO gracefully handle shutdown
http.serve_forever()
#log('Serverscript has been invoked')
# Kill the old server if need be
if os.path.exists(PIDFILE):
f = open(PIDFILE)
#log('Going to kill old server')
oldpid = int(f.read())
#subprocess.call('kill -15 %d' % oldpid, shell=True)
code = subprocess.call(['kill', '-15', str(oldpid)])
#print code
f.close()
# Write the new pid
f = open(PIDFILE, 'w')
f.write(str(pid))
f.close()
application = django.core.handlers.wsgi.WSGIHandler()
TRIES = 5
if __name__ == '__main__':
print 'Real-time server on %d...' % PORT
for i in range(0, TRIES):
try:
WSGIServer(('', PORT), application).serve_forever()
except Exception as e:
print e
time.sleep(.01)
print 'Real-time server not running'
def run(self, host: str, port: int) -> None:
self.rest_server = WSGIServer((host, port), self.flask_app)
self.rest_server.start()
log.info("Running endpoint", endpoint=f"http://{host}:{port}")
def run_api(pg_db, mq_channel_connect, redis_connect, es):
print("Init RestAPI Python")
app = flask.Flask(__name__)
@app.route('/api/v1/food', methods=["GET"])
def get_all_food():
return controller.get_all_food_controller(pg_db, es, request)
@app.route('/api/v1/food', methods=["POST"])
def add_food():
return controller.add_food_controller(request, pg_db)
@app.route('/api/v1/food/status/<food_id>', methods=["PUT"])
def update_status_food(food_id):
return controller.update_status_food_controller(
request, pg_db, food_id)
@app.route('/api/v1/food/<food_id>', methods=["PUT"])
def update_info_food(food_id):
return controller.update_info_food_controller(request, pg_db, food_id)
@app.route('/api/v1/food/filter', methods=["GET"])
def food_filter():
return controller.get_food_filter_controller()
@app.route('/api/v1/material', methods=["POST"])
def add_material():
return controller.add_material_controller(pg_db, request)
@app.route('/api/v1/material', methods=["GET"])
def get_material():
return controller.get_material_controller(pg_db, request)
@app.route('/api/v1/material/file', methods=["POST"])
def add_file_material():
return controller.add_file_material_controller(pg_db,
mq_channel_connect,
request)
@app.route('/api/v1/material/file', methods=["GET"])
def download_file_material():
return controller.download_file_material_controller(
pg_db, mq_channel_connect, request)
@app.route('/api/v1/material/file', methods=["PUT"])
def update_file_material():
return controller.update_file_material_controller(
pg_db, mq_channel_connect, request)
@app.route('/api/v1/material_type', methods=["POST"])
def add_material_type():
return controller.add_material_type_controller(pg_db, redis_connect,
request)
@app.route('/api/v1/material_type', methods=["GET"])
def get_material_type():
return controller.get_material_type_controller(pg_db, redis_connect,
request)
@app.route('/api/v1/food_material/<food_id>', methods=["POST"])
def add_food_material(food_id):
return controller.add_food_material_controller(pg_db, request, food_id)
food_file_router(app, pg_db, mq_channel_connect, redis_connect)
es_router(app, pg_db, mq_channel_connect, redis_connect, es)
@app.errorhandler(HTTPStatus.NOT_FOUND)
def page_not_found(e):
result = model.ErrorResponseDto(HTTPStatus.NOT_FOUND, "Api Not Found")
return jsonify(result.__dict__), HTTPStatus.NOT_FOUND
config = configparser.ConfigParser()
config.read('config.ini')
if config.get('APP', 'ENVIRONMENT') == 'development':
app.run(host="127.0.0.1", port=3000, debug=False)
else:
http_server = WSGIServer(('', 3000), app)
http_server.serve_forever()
message = json.loads(web_socket.receive())
user = database_helper.get_user_data_by_token(
message['token'])[0]['email']
signed_in_users[user] = web_socket
while not web_socket.closed:
message = web_socket.receive()
if message is not None:
message = json.loads(message)
message = {'message': 'Successfully logged in'}
web_socket.send(json.dumps(message))
try:
del signed_in_users[user]
except:
pass
return 'None'
@app.teardown_request
def after_request(exception):
database_helper.disconnect_db()
if __name__ == '__main__':
# print("Server: http://127.0.0.1:5000/")
http_server = WSGIServer(('127.0.0.1', 5000),
app,
handler_class=WebSocketHandler)
#http_server = WSGIServer(('', int(os.environ.get('PORT'))), app, handler_class=WebSocketHandler)
http_server.serve_forever()
# app.run()
c.commit_action()
return c.finished()
@app.route("/order/pull_order_info.action", methods=["GET"])
@need_session
@response_and_logging
def get_shop_car_order_info():
with PullOrderInfo(DB_CONNECTION_POOL, REDIS_CONNECTION_POOL) as p:
p.commit_action()
return p.finished()
@app.route("/order/commit_order.action", methods=["POST"])
@need_session
@response_and_logging
def commit_order():
with CommitOrder(DB_CONNECTION_POOL, REDIS_CONNECTION_POOL) as c:
c.commit_action()
return c.finished()
if __name__ == '__main__':
MyRSA.init_secret_key()
app.config.update(ServiceConf.all_config)
# app.run(host="localhost", port=9999, threaded=True, processes=3)
http_server = WSGIServer((ServiceConf.BIND_ADDRESS, ServiceConf.BIND_PORT),
app,
log=None)
http_server.serve_forever()
userCheck[0]['password'], token)
cursorLG.close()
return jsonify(data=auth)
# Routes
api.add_resource(getInfo, '/getInfo')
api.add_resource(getOnline, '/getOnline')
api.add_resource(getClans, '/getClans')
api.add_resource(getUserSellActivity, '/getUserSellActivity')
api.add_resource(getUserBuyActivity, '/getUserBuyActivity')
api.add_resource(getWealth, '/getWealth')
api.add_resource(getUserClan, '/getUserClan')
api.add_resource(getUserInfo, '/getUserInfo')
api.add_resource(getReferral, '/getReferral')
api.add_resource(getCryptoPrices, '/getCryptoPrices')
api.add_resource(getAdeptioUserInfo, '/getAdeptioUserInfo')
api.add_resource(getMoneyCount, '/getMoneyCount')
api.add_resource(getUserMoneyCount, '/getUserMoneyCount')
api.add_resource(register, '/register')
api.add_resource(preregister, '/preregister')
api.add_resource(sellAdena, '/sellAdena')
api.add_resource(buyAdena, '/buyAdena')
api.add_resource(depositAdeptio, '/depositAdeptio')
api.add_resource(withdrawAdeptio, '/withdrawAdeptio')
api.add_resource(depositAdeptioApproval, '/depositAdeptioApproval')
# Serve the high performance http server
if __name__ == '__main__':
http_server = WSGIServer(('', 9005), app)
http_server.serve_forever()
def is_admin():
data = json.loads(request.data)
if clients[data["auth_token"]].is_admin:
return '', 200
else:
return '', 403
@app.errorhandler(500)
def internal_server_error(e):
print(e)
def start_server():
t = Thread(target=run_server)
t.daemon = True
t.start()
app.run(host='0.0.0.0', port=80)
if __name__ == "__main__":
t = Thread(target=run_server)
t.daemon = True
t.start()
http_server = WSGIServer(
("0.0.0.0", 80),
app,
certfile='/etc/letsencrypt/live/jesselupica.com/fullchain.pem',
keyfile='/etc/letsencrypt/live/jesselupica.com/privkey.pem')
http_server.serve_forever()
@app.route("/register", methods=["POST"])
def get_registration_data():
if request.method == "POST": # only if website sends sth
email = request.form["email"] # get userinput via HTML-form
username = request.form["username"]
if register_user(username, email): # if sth is wrong with the db
print("Failed to register!", file=sys.stderr)
return render_template(
'register.html',
action="register",
status="Failed to register! Please try again!",
status_color="#ff0033")
else: # db check successfull
print("Successfully registered!", file=sys.stderr)
return render_template(
'register.html',
action="finish",
status="You have been successfully registered!",
status_color="#08da94",
username=username)
if __name__ == "__main__":
check_db()
# development/debugging (flask default):
# app.run(host="0.0.0.0", port=8000, debug=True)
# basic server, ready for real-life usage [http://localhost:8000/]
server = WSGIServer(('0.0.0.0', 8000), app)
server.serve_forever()
elif pred == 20:
return "Vascular Tumors"
elif pred == 21:
return "Vasculitis Photos"
elif pred == 22:
return "Warts Molluscum and other Viral Infections"
else:
return "Class Not Found"
@app.route("/home")
def test():
dic = 'the diagnose is : ' + joblib.load("diseaseinfo.pkl")
xx = joblib.load("image.pkl")
return render_template('home.html', dic=dic, xx=xx)
def preprocess_single_image(filepath):
pic = cv2.imread(filepath)
pic = cv2.resize(pic, (224, 224))
pic = pic.astype('float32')
pic /= 255
pic = pic.reshape(-1, 224, 224, 3)
return pic
if __name__ == "__main__":
server = WSGIServer(("", 5000), app)
print('Server is up')
server.serve_forever()
print('subscribe', active_room, user)
messages = active_room.backlog()
return render_template('room.html', room=room, uid=uid, messages=messages)
@app.route("/put/<room>/<uid>", methods=["POST"])
def put(room, uid):
user = users[uid]
room = rooms[room]
message = request.form['message']
room.add(':'.join([uid, message]))
return ''
@app.route("/poll/<uid>", methods=["POST"])
def poll(uid):
try:
msg = users[uid].queue.get(timeout=10)
except queue.Empty:
msg = []
return json.dumps(msg)
if __name__ == "__main__":
http = WSGIServer(('', 5000), app)
http.serve_forever()
def main():
parser = ArgumentParser(description="a blog comment hosting service")
subparser = parser.add_subparsers(help="commands", dest="command")
parser.add_argument('--version',
action='version',
version='%(prog)s ' + dist.version)
parser.add_argument("-c",
dest="conf",
default="/etc/isso.conf",
metavar="/etc/isso.conf",
help="set configuration file")
imprt = subparser.add_parser('import', help="import Disqus XML export")
imprt.add_argument("dump", metavar="FILE")
imprt.add_argument("-n",
"--dry-run",
dest="dryrun",
action="store_true",
help="perform a trial run with no changes made")
imprt.add_argument("-t",
"--type",
dest="type",
default=None,
choices=["disqus", "wordpress"],
help="export type")
imprt.add_argument("--empty-id",
dest="empty_id",
action="store_true",
help="workaround for weird Disqus XML exports, #135")
# run Isso as stand-alone server
subparser.add_parser("run", help="run server")
args = parser.parse_args()
conf = config.load(join(dist.location, dist.project_name, "defaults.ini"),
args.conf)
if args.command == "import":
conf.set("guard", "enabled", "off")
if args.dryrun:
xxx = tempfile.NamedTemporaryFile()
dbpath = xxx.name
else:
dbpath = conf.get("general", "dbpath")
mydb = db.SQLite3(dbpath, conf)
migrate.dispatch(args.type, mydb, args.dump, args.empty_id)
sys.exit(0)
if conf.get("general", "log-file"):
handler = logging.FileHandler(conf.get("general", "log-file"))
logger.addHandler(handler)
logging.getLogger("werkzeug").addHandler(handler)
logger.propagate = False
logging.getLogger("werkzeug").propagate = False
if not any(conf.getiter("general", "host")):
logger.error("No website(s) configured, Isso won't work.")
sys.exit(1)
if conf.get("server", "listen").startswith("http://"):
host, port, _ = urlsplit(conf.get("server", "listen"))
try:
from gevent.pywsgi import WSGIServer
WSGIServer((host, port), make_app(conf)).serve_forever()
except ImportError:
run_simple(host,
port,
make_app(conf),
threaded=True,
use_reloader=conf.getboolean('server', 'reload'))
else:
sock = conf.get("server", "listen").partition("unix://")[2]
try:
os.unlink(sock)
except OSError as ex:
if ex.errno != errno.ENOENT:
raise
wsgi.SocketHTTPServer(sock, make_app(conf)).serve_forever()
# Call Function To Get Values For Gauge Charts
data = ObjjiraLibrary.getRMAChartsData(sStartDate, sEndDate)
return jsonify(data), 200
except Exception as e:
return "{0}Internal Server Error".format(e), 500
@app.route('/CreateChartForProactiveVsReactive', methods=['POST'])
def ProactiveVsReactive():
try:
global ObjjiraLibrary
sEndDate = request.form['enddate']
sStartDate = request.form['startdate']
# Call Function To Get Values For Gauge Charts
data = ObjjiraLibrary.getProactiveReactiveData(sStartDate, sEndDate)
return jsonify(data), 200
except Exception as e:
return "{0}Internal Server Error".format(e), 500
if __name__ == "__main__":
http_server = WSGIServer(('0.0.0.0', 5001), app)
http_server.serve_forever()
status=1,
predictions_statistics=predictions_statistics,
)
@app.route('/churning/getmodelstatistics', methods=['GET'])
def get_model_statistics():
# Validate authorization header with JWT
if request.headers.get(
'Authorization') is None or not app.config['API'].verify_jwt(
request.headers['Authorization']):
return jsonify(status=0, error='Unauthorized request.'), 401
model_statistics = app.config['CASSANDRA'].get_model_statistics()
return jsonify(status=1, model_statistics=model_statistics)
if __name__ == '__main__':
app.config['CASSANDRA'] = Cassandra()
app.config['API'] = API()
if getenv('DEBUG'):
app.config['DEBUG'] = True
flask_port = 5858
app.run(host='0.0.0.0', port=flask_port)
else:
app.config['DEBUG'] = False
flask_port = 6868
WSGIServer(('', flask_port), app).serve_forever()
if __name__ == "__main__":
import sys
if sys.argv[1] == 'debug':
prepare_app(app)
app.secret_key = "asdfa;lkja;sdlkfja;sdf"
app.debug = True
app.run(port=10000)
elif sys.argv[1] == 'socket':
prepare_app(app)
app.secret_key = "asdfa;lkja;sdlkfja;sdf"
app.debug = True
from gevent.pywsgi import WSGIServer
http_server = WSGIServer(
('', 10000),
app,
handler_class=WebSocketHandler,
)
import werkzeug.serving
@werkzeug.serving.run_with_reloader
def helper():
http_server.serve_forever()
elif sys.argv[1] == 'prod':
prepare_app(app)
app.secret_key = str(uuid.uuid4())
app.debug = False
from gevent.pywsgi import WSGIServer
http_server = WSGIServer(('', 9000),
app,
handler_class=WebSocketHandler,
from api import serve_app
from flask import Flask
from gevent.pywsgi import WSGIServer
app = serve_app()
server = WSGIServer(('0.0.0.0', 5000), application=app).serve_forever()
gevent.monkey.patch_all()
# ------- PRODUCTION CONFIG -------
if __name__ == '__main__':
try:
INTERFACE = app.config['INTERFACE']
# ----------------- For HTTPS -------------------#
HTTPS_PORT = app.config['HTTPS_PORT']
SSL_CERTFILE = app.config['SSL_CERTFILE']
SSL_KEYFILE = app.config['SSL_KEYFILE']
server = WSGIServer((INTERFACE, HTTPS_PORT),
app,
certfile=SSL_CERTFILE,
keyfile=SSL_KEYFILE)
if server:
print "Server Started on: https://" + str(INTERFACE) + ":" + str(
HTTPS_PORT) + "/"
# ---------------- For HTTP Only ----------------#
# HTTP_PORT = app.config['HTTP_PORT']
# server = WSGIServer((INTERFACE, HTTP_PORT), app)
# if server:
# print "Server Started on: http://"+str(INTERFACE)+":"+str(HTTP_PORT)+"/"
# -------Common for both HTTP and HTTPS----------#
server.serve_forever()
if __name__ == "__main__":
try:
load(path='config/database.json', name='db')
except FileNotFoundError as err:
print(err)
print('Making default config')
config['db'] = {
'host': 'localhost',
'port': '5432',
'user': '******',
'password': '',
'dbname': 'postgres',
'scheme': 'public'
}
except Exception as err:
print(err)
exit(1)
finally:
save('db')
try:
Connect(config['db'])
except Exception as err:
print(err)
exit(2)
http_server = WSGIServer(('', 80), app)
http_server.serve_forever()
Disconnect()
observer.start()
try:
while True:
event.wait(1)
except KeyboardInterrupt:
observer.stop()
observer.join()
threading.Thread(target=event_loop, daemon=True).start()
if __name__ == "__main__":
parser = optparse.OptionParser()
parser.add_option('-p', '--port', type="int", default=19951, dest="port")
opt, args = parser.parse_args()
server_port = opt.port
server_host = "0.0.0.0"
logger.info('Running on http://{}:{}/ <Press CTRL + C to quit>'.format(
server_host, server_port))
server = WSGIServer((server_host, server_port),
app,
handler_class=WebSocketHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
server.stop()
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")
args = parser.parse_args()
config = Config()
config.load(args.config)
if args.drop:
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
- in: query
name: name
required: true
description: get result manually.
schema:
type : string
example: jessica
responses:
200:
description: OK
"""
task_id = uuid.uuid1()
topic = request.json.get("topic")
message = request.json.get("message")
# build data
rpc.producer.get_data_from_web(task_id, topic, message)
# get result from topic
if topic == "topic_one":
result = rpc.consumer_one.read_data(task_id)
else:
result = rpc.consumer_two.read_data(task_id)
return result, 200
if __name__ == '__main__':
port = 8001
http_server = WSGIServer(('0.0.0.0', port), app)
http_server.serve_forever()
#!/usr/bin/python
"""WSGI server example"""
from __future__ import print_function
from gevent.pywsgi import WSGIServer
def application(env, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return ["You are visiting: " + env['PATH_INFO']]
if __name__ == '__main__':
print('Serving on 8088...')
WSGIServer(('', 8088), application).serve_forever()
# import camera driver
from camera_opencv import Camera
app = Flask(__name__)
camears = [Camera('videos/car1.avi')]
def gen(camera):
"""Video streaming generator function."""
while True:
time.sleep(0.02)
frame = camera.get_frame()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
@app.route('/video_feed')
def video_feed():
"""Video streaming routeSSS. Put this in the src attribute of an img tag."""
return Response(gen(camears[0]),
mimetype='multipart/x-mixed-replace; boundary=frame')
if __name__ == '__main__':
#socketio.run(app,debug=False,host='0.0.0.0', port=5000)
http_server = WSGIServer(('0.0.0.0', 7002), app)
http_server.serve_forever()
#app.run(host='0.0.0.0', port=5000)
