def run_flask(ip, port, response, exit_callback):
app = setup_flask_server(response)
server = wsgiserver.WSGIServer(app, host=ip, port=port)
try:
server.start()
finally:
# When the flask server finishes running, do any other cleanup
exit_callback()
def start_server(self, port=8080):
"""
Starts the http server of the Service
:param port: The port on which to start the server, defaults to 8080
"""
self.http_server = wsgiserver.WSGIServer(self.app, port=port)
self.http_server.start()
def server_function(self):
self.dispatcher = wsgiserver.WSGIPathInfoDispatcher({'/': self.app})
self.server = wsgiserver.WSGIServer(self.dispatcher,
host=self.host,
port=self.port)
try:
self.server.start()
except KeyboardInterrupt:
self.logger("Stopping server due to keyboard interrupt")
self.server.stop()
def _run_server(self):
host = self.app.settings.HOST
port = 8000
if self.app.settings.PORT:
port = self.app.settings.PORT
# print('Serving on: ' + f'{host}:{port}')
server = wsgiserver.WSGIServer(self.app.wsgi.app, host=host, port=port)
server.start()
def run_server(wsgi_app, global_conf, host='localhost',
port=8080):
import wsgiserver
logged_app = TransLogger(wsgi_app)
port = int(port)
# For some reason this is problematic on this server:
ensure_port_cleanup([(host, port)], maxtries=2, sleeptime=0.5)
server = wsgiserver.WSGIServer(logged_app, host=host, port=port)
logged_app.logger.info('Starting HTTP server on http://%s:%s',
host, port)
server.start()
def run_flask(ip, port, exit_callback):
"""
Runs the flask server, this is a daemon, so it exits when redirectd exits
"""
app = setup_flask_server()
server = wsgiserver.WSGIServer(app, host=ip, port=port)
try:
server.start()
finally:
# When the flask server finishes running, do any other cleanup
exit_callback()
def __init__(self, wsgi_app, host='0.0.0.0', port=8000, numthreads=10,
server_name='wsgi_server', threadpool_max=-1, request_queue_size=5, timeout=10,
shutdown_timeout=5, accepted_queue_size=-1,
accepted_queue_timeout=10, certfile=None, keyfile=None,
ca_certs=None,
*args, **kwargs):
super().__init__(*args, **kwargs)
if wsgi_app is None:
raise ValueError('wsgi_app must be defined.')
self.app = wsgi_app
self.server = wsgiserver.WSGIServer(
self.app, host=host, port=port, numthreads=numthreads,
server_name=server_name, max=threadpool_max, request_queue_size=request_queue_size,timeout=timeout,
shutdown_timeout=shutdown_timeout, accepted_queue_size=accepted_queue_size,
accepted_queue_timeout=accepted_queue_timeout,
certfile=certfile, keyfile=keyfile, ca_certs=ca_certs,
)
logger.debug('Initialized wsgiserver')
start_response(status, headers)
except Exception as e:
raise
finally:
appd.end_bt(custom_bt, e)
return [body_str_byte]
def my_orders(environ, start_response):
custom_bt = appd.start_bt('My orders BT')
body_str = 'My orders\n'
body_str_byte = bytes(body_str, 'utf-8')
status = '200 OK'
headers = [('Content-type', 'text/text')]
e = None
try:
start_response(status, headers)
except Exception as e:
raise
finally:
appd.end_bt(custom_bt, e)
return [body_str_byte]
d = wsgiserver.WSGIPathInfoDispatcher({'/': application, '/orders': my_orders})
server = wsgiserver.WSGIServer(d)
server.start()
login_url = url_for('flask_saml2_sp.login')
return redirect(login_url)
app.debug = False
app.secret_key = "debuguseonly"
app.config['SERVER_NAME'] = HTTP_HOSTNAME + ":" + str(HTTP_PORT)
app.config['SAML2_SP'] = {
'certificate': certificate_from_string(SP_CERTIFICATE),
'private_key': private_key_from_string(SP_CERTIFICATE_KEY),
}
app.config['SAML2_IDENTITY_PROVIDERS'] = [
{
'CLASS': 'flask_saml2.sp.idphandler.IdPHandler',
'OPTIONS': {
'display_name': IDP_DISPLAY_NAME,
'entity_id': IDP_ENTITY_ID,
'sso_url': IDP_SSO_URL,
'slo_url': IDP_SLO_URL,
'certificate': certificate_from_string(IDP_CERTIFICATE),
},
},
]
app.register_blueprint(sp.create_blueprint(), url_prefix='/saml/')
#dev only
#app.run("10.82.0.103", "9000")
server = wsgiserver.WSGIServer(app, host=HTTP_BIND_ADDRESS, port=HTTP_PORT)
server.start()
def main():
server = wsgiserver.WSGIServer(app, host=host_addr, port=int(host_port))
server.start()
from flask import Flask, render_template, request, redirect, url_for
from support_mail import send_mail
import wsgiserver
import cgi
support_app = Flask(__name__)
@support_app.route('/')
def index():
return render_template('index.tpl')
@support_app.route('/send-email', methods=['POST'])
def process_mail():
if request.method == 'POST':
send_mail(cgi.escape(request.form['form-employee']),
cgi.escape(request.form['form-subject']),
cgi.escape(request.form['form-room']),
cgi.escape(request.form['form-body']))
return redirect(url_for('index'))
if __name__ == "__main__":
# DAS IST NUR FUER DIE ENTWICKLUNG!
# support_app.jinja_env.auto_reload = True
# support_app.config['TEMPLATES_AUTO_RELOAD'] = True
# support_app.run('10.10.10.1', port=80, debug=True)
server = wsgiserver.WSGIServer(support_app, host="0.0.0.0", port=80)
server.start()
import wsgiserver
from PhoenixNow.config import ProductionConfig, DevelopmentConfig
from PhoenixNow.factory import create_app, extensions, app
import os
if os.environ.get('FLASK_DEBUG'):
create_app(DevelopmentConfig)
extensions()
else:
create_app(ProductionConfig)
extensions()
http_server = wsgiserver.WSGIServer(app, port=5000)
http_server.start()
import wsgiserver
def my_app(environ, start_response):
status = '200 OK'
hello = 'WSGIserver is running!'
response_headers = [('Content-type', 'text/plain')]
start_response(status, response_headers)
return hello
server = wsgiserver.WSGIServer(my_app)
server.start()
@sio.on('connect', namespace='/speedometer')
def connect(a, b):
global thread
if not thread.isAlive():
thread = MIDIThread()
thread.start()
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=
'Gather the power of your MIDI devices with the InfiMIDI Gauntlet')
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('-l',
'--list-devices',
action='store_true',
help='List available MIDI devices')
group.add_argument('-m',
'--midi-device',
type=int,
help='Selected MIDI device (required)')
args = parser.parse_args()
if args.list_devices:
midiin = rtmidi.MidiIn()
ports = range(midiin.get_port_count())
if ports:
for i in ports:
print('#' + str(i) + ': ' + midiin.get_port_name(i)[:-2])
elif args.midi_device is not None:
wsgiserver.WSGIServer(app, host='0.0.0.0', port=80).start()
return [str(rtt)]
def get_rtt(ip, port):
#TODO get rtt
key = ip+port
cond.acquire()
while key not in ips:
cond.wait()
#sleep
while "rtt" not in ips[key]:
cond.wait()
rtt = ips[key]["rtt"] ##check if ip exists and status
cond.release()
return rtt, None
err = "Error"
return None, err
d = wsgiserver.WSGIPathInfoDispatcher({'/rtt': my_rtt})
server = wsgiserver.WSGIServer(d, host=host, port=port)
#To add SSL support, just specify a certfile and a keyfile
#server = wsgiserver.WSGIServer(my_app, certfile='cert.pem', keyfile='privkey.pem')
print("Server running on: ", host, port)
server.start()
print("server stopped")
import wsgiserver from flask_cors import CORS from Model.Person import app from routes import routes_blueprint CORS(app) app.register_blueprint(routes_blueprint) server = wsgiserver.WSGIServer(app, host='127.0.0.1', port=5000) server.start() # if __name__ == '__main__': # app.run(debug=True)
def main():
http_server = wsgiserver.WSGIServer(app, host='0.0.0.0', port=8181)
http_server.start()
# -*- coding: utf-8 -*-
"""
Created on Fri May 3 16:04:52 2019
@author: demerss1
"""
import wsgiserver
from myApp.app import app
if __name__ == "__main__":
server = wsgiserver.WSGIServer(app, port=80, host='0.0.0.0')
server.start()
def index():
return render_template('index.html',
system_name=system_name,
active_function='home')
def setup_debug_logger():
if args.debug:
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
# noinspection SpellCheckingInspection
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
if __name__ == "__main__":
args = parse_args()
env = load_env_yaml(args)
keydir = env['keydir']
api = env['api']
setup_debug_logger()
server = wsgiserver.WSGIServer(app,
host='0.0.0.0',
port=env['webpanel_port'])
server.start()
""", (val, user.id))
start_response('200 OK', HEADERS_JSON + HEADERS_CORS)
return [util.json_bytes({"success": True})]
@rt.route("^.*$")
def appDefault(environ, start_response):
start_response('404 Not Found', HEADERS_HTML + HEADERS_CORS)
html = '''
<script>window.location = 'https://zzazzdzz.github.io/fools2019/'</script>
<center>
<span style="font-size: 200px">bepis 404</span>
<br><br><br>
<a href='https://zzazzdzz.github.io/fools2019/'>
Click here if your browser doesn't redirect you automatically
</a>
</center>
'''
return [bytes(html, 'utf-8')]
if __name__ == "__main__":
augment.init()
compiler.start_service()
tokens.start_service()
torbanlist.prepare()
import wsgiserver
server = wsgiserver.WSGIServer(rt, host='127.0.0.1', port=12710)
server.start()
web_app = WSGIApp()
@web_app.route("/led_on/<r>/<g>/<b>")
def led_on(request, r, g, b): # pylint: disable=unused-argument
print("led on!")
status_light.fill((int(r), int(g), int(b)))
return ("200 OK", [], "led on!")
@web_app.route("/led_off")
def led_off(request): # pylint: disable=unused-argument
print("led off!")
status_light.fill(0)
return ("200 OK", [], "led off!")
# Here we setup our server, passing in our web_app as the application
wsgiServer = server.WSGIServer(80, application=web_app)
print(f"open this IP in your browser: http://{HOST}:{PORT}/")
# Start the server
wsgiServer.start()
while True:
# Our main loop where we have the server poll for incoming requests
print("POLL")
wsgiServer.update_poll()
# Could do any other background tasks here, like reading sensors
def _run():
config.update(TestConfig())
configure()
server = wsgiserver.WSGIServer(application_handler, host=HOST, port=PORT)
server.start()
response.status_string,
http_error.message))
except Exception as error:
response = JsonResponse({'message': 'Internal server error, please contact server administrator'},
status_code=Status.INTERNAL_SERVER_ERROR)
_logger.error('{0} {1}'.format(env.get('PATH_INFO', ''), response.status_string))
_logger.exception(error, exc_info=True)
if response is not None:
start_response(response.status_string, response.headers_as_tuples())
for chunk in response:
yield chunk
if __name__ == '__main__':
import wsgiserver
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--host', type=str, default='0.0.0.0', help='Host')
parser.add_argument('--port', type=int, default=8081, help='Port')
parser.add_argument('--name', type=str, default='MindRecord API', help='Server name')
args = parser.parse_args()
configure()
logging.info('Starting WSGI server on: http://{0}:{1}'.format(args.host, args.port))
# Running
server = wsgiserver.WSGIServer(application_handler, host=args.host, port=args.port, server_name=args.name)
server.start()
def start_api(self):
server = wsgiserver.WSGIServer(self.app,
host='0.0.0.0',
port=self.config.api_port)
print("API listening at http://0.0.0.0:" + str(self.config.api_port))
server.start()
and also to cache the rendered page for 10 minutes.
"""
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
r.headers["Expires"] = "0"
r.headers['Cache-Control'] = 'public, max-age=0'
return r
@app.route('/')
def index():
return (render_template('index.html'))
#Consumer API
@app.route('/topic/<topicname>')
def get_messages(topicname):
client = get_kafka_client()
def events():
for i in client.topics[topicname].get_simple_consumer():
yield 'data:{0}\n\n'.format(i.value.decode())
return Response(events(), mimetype="text/event-stream")
if __name__ == '__main__':
http_server = wsgiserver.WSGIServer(app, host='0.0.0.0', port=5001)
http_server.start()
#app.run(debug=True, host='0.0.0.0', port=5001)
if __name__ == "__main__":
# Create Logger
logger = logging.getLogger("Cisco EoL EoS Logger")
handler = logging.handlers.RotatingFileHandler(LOGFILE, maxBytes=LOGFILE_MAX_SIZE, backupCount=LOGFILE_COUNT)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
logger.info("---------------------- STARTING ----------------------")
logger.info("cisco EoS EoL script started")
# Create Results logger
results_logger = logging.getLogger("Cisco EoL EoS Request Logger")
results_handler = logging.handlers.TimedRotatingFileHandler(RESULTSFILE, backupCount=365, when='D')
results_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
results_handler.setFormatter(results_formatter)
results_logger.addHandler(results_handler)
results_logger.setLevel(logging.INFO)
logger.info("Load stats")
logger.info("Load EoL data ")
logger.info("deleting old webhook")
delete_webhook(api=api)
logger.info("creating new webhook")
create_webhook(api=api)
http_server = wsgiserver.WSGIServer(host=FLASK_HOST, port=FLASK_PORT, wsgi_app=flask_app)
http_server.start()
