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()