def runserver():
"Runs the App"
create_app()
if app.config['MEINHELD']:
meinheld.listen((app.config['SERVE_HOST'], app.config['SERVE_PORT']))
meinheld.run(app)
else:
app.run(host=app.config['SERVE_HOST'],
port=app.config['SERVE_PORT'],
threaded=app.config['THREADED'])
def main():
args = cmd_args()
if args.locale and args.locale != 'auto':
app.babel.locale_selector_func = lambda: args.locale
if SERVER_SETTINGS['type']=='flask':
app.run(SERVER_SETTINGS['host'], SERVER_SETTINGS['port'])
elif SERVER_SETTINGS['type']=='meinheld':
print 'On http://%s:%s/' % (SERVER_SETTINGS['host'], SERVER_SETTINGS['port'])
meinheld.listen((SERVER_SETTINGS['host'], SERVER_SETTINGS['port']))
meinheld.run(app)
def runserver():
"Runs the App"
create_app()
if app.config['MEINHELD']:
meinheld.listen((app.config['SERVE_HOST'],
app.config['SERVE_PORT']))
meinheld.run(app)
else:
app.run(host = app.config['SERVE_HOST'],
port = app.config['SERVE_PORT'],
threaded = app.config['THREADED'])
def run_server(self):
"""
run server for api
"""
if not ENABLE_SERVER:
logger.info('server not enabled, exit')
return
if IS_PROD:
if APP_PROD_METHOD == APP_PROD_METHOD_GEVENT:
try:
from gevent.pywsgi import WSGIServer
except ImportError as e:
logger.exception(e)
else:
http_server = WSGIServer((API_HOST, API_PORT), app)
http_server.serve_forever()
elif APP_PROD_METHOD == APP_PROD_METHOD_TORNADO:
try:
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
except ImportError as e:
logger.exception(e)
else:
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(API_PORT)
IOLoop.instance().start()
elif APP_PROD_METHOD == APP_PROD_METHOD_MEINHELD:
try:
import meinheld
except ImportError as e:
logger.exception(e)
else:
meinheld.listen((API_HOST, API_PORT))
meinheld.run(app)
else:
logger.error("unsupported APP_PROD_METHOD")
return
else:
app.run(host=API_HOST, port=API_PORT, threaded=API_THREADED)
password = request.form.get('password')
data = query_db("SELECT * from user where username='******' and password='******'".format(username, password))
if data != []:
return 'User {0} already exists.'.format(username), 422
uid = str(uuid4())
h_password = hashlib.sha512(password).hexdigest()
bin = {'id': uid,
'password': h_password,
'mail': mail
}
try:
data = insert_db("INSERT into user (username, mail, password) VALUES ('{0}', '{1}', '{2}')".format(username, mail, h_password))
except Exception as e:
logging.error('failed to put data on db // {0}'.format(e.message))
return 'KO', 500
return 'OK', 200
if __name__ == '__main__':
hostname = socket.gethostname()
if hostname == 'Stephanes-MacBook-Pro.local':
print 'DEV ' * 10
application.debug = True
application.run(host='0.0.0.0', port=80)
else:
print 'PROD ' * 10
meinheld.listen(("0.0.0.0", 80))
meinheld.run(application)
self.file = file
self.buffer_size = buffer_size
def close(self):
if hasattr(self.file, 'close'):
self.file.close()
def __iter__(self):
return self
def next(self):
data = self.file.read(self.buffer_size)
if data:
return data
raise StopIteration()
def simple_app(environ, start_response):
status = '200 OK'
#response_headers = [('Content-type','image/jpeg')]
response_headers = [('Content-type', 'image/jpeg'),
('Content-Length', '137823')]
start_response(status, response_headers)
# use sendfile(2)
return environ.get('wsgi.file_wrapper',
FileWrapper)(open('wallpaper.jpg', 'rb'))
meinheld.listen(("0.0.0.0", 8000))
meinheld.run(simple_app)
def run(app, i):
meinheld.run(app)
from app import app
import meinheld
if __name__ == '__main__':
meinheld.listen(("0.0.0.0", 8000))
meinheld.run(app)
from flask import Flask, render_template
import meinheld
app = Flask(__name__)
@app.route('/')
def index():
return render_template('hello.html')
meinheld.listen(("0.0.0.0", 8000))
meinheld.run(app)
log("ERROR: - Download failed.")
def parse_languages(csv_languages):
"""Parse languages string
Keyword arguments:
csv_languages -- Comma separated string of languages
"""
my_languages = []
for lang in csv_languages.split(","):
my_languages.append(Language(lang))
return set(my_languages)
def error(text, error_code):
"""Returns the error in json format
Keyword arguments:
text -- Human readable text for the error
error_code -- http status code
"""
return '{{"Error": "{}"}}'.format(text), error_code
# finally run the script if file is called directly
meinheld.listen(("0.0.0.0", 5500))
meinheld.run(APP)
def __init__(self, file, buffer_size=8192):
self.file = file
self.buffer_size = buffer_size
def close(self):
if hasattr(self.file, 'close'):
self.file.close()
def __iter__(self):
return self
def next(self):
data = self.file.read(self.buffer_size)
if data:
return data
raise StopIteration()
def simple_app(environ, start_response):
status = '200 OK'
response_headers = [('Content-type','image/jpeg')]
# response_headers = [('Content-type','image/jpeg'), ('Content-Length', '137823')]
start_response(status, response_headers)
# use sendfile(2)
return environ.get('wsgi.file_wrapper', FileWrapper)(open('wallpaper.jpg', 'rb'))
meinheld.listen(("0.0.0.0", 8000))
meinheld.run(simple_app)
return BaseResponse('no file uploaded')
f = req.files['uploaded_file']
return BaseResponse(wrap_file(req.environ, f),
mimetype=f.content_type,
direct_passthrough=True)
def upload_file(req):
return BaseResponse('''
<h1>Upload File</h1>
<form action="" method="post" enctype="multipart/form-data">
<input type="file" name="uploaded_file">
<input type="submit" value="Upload">
</form>
''',
mimetype='text/html')
def application(environ, start_response):
req = BaseRequest(environ)
if req.method == 'POST':
resp = view_file(req)
else:
resp = upload_file(req)
return resp(environ, start_response)
meinheld.set_max_content_length(1024 * 1024 * 1024)
meinheld.listen(("0.0.0.0", 8000))
meinheld.run(application)
def run():
#meinheld.spawn(subscribe_update)
th = threading.Thread(target=subscribe_update)
th.daemon = True
th.start()
meinheld.run(app.wsgi_app)
def run(app, i):
meinheld.run(app)
def run(app, i):
meinheld.set_process_name("hello_world-worker-%d" % i);
meinheld.run(app)
