def run(): config = ConfigParser.ConfigParser() config.read("config.ini") ws_port = config.get('port_config', 'ws_port') server = WSGIServer(("0.0.0.0", int(ws_port)), vity_ws, handler_class=WebSocketHandler, keyfile=config.get('ssl', 'keyfile'), certfile=config.get('ssl', 'certfile')) server.serve_forever()
def run_server(options): api_listener = Api() gevent.spawn(api_listener.run) # # Setup flask app static_url_path = "/changed-so-it-doesnt-conflict-with-blueprint-static-path" app = Flask(__name__, static_url_path=static_url_path) app.config.from_pyfile(options["config"].name) app.register_blueprint(FrontendBlueprint()) # # JS/CSS & HTML minification in production if not app.config.get('DEBUG'): from .misc.jinja2htmlcompress import HTMLCompress app.jinja_env.add_extension(HTMLCompress) assets = Environment() assets.init_app(app) # # Run server http = WSGIServer((options['http_host'], options['http_port']), app) LOGGER.info('Listening on %s:%s', options['http_host'], options['http_port']) try: http.serve_forever() return 0 except KeyboardInterrupt: http.stop() api_listener.stop() LOGGER.info('Application Terminated') return 0
def main(): status = 0 parser = argparse.ArgumentParser() parser.add_argument('port', nargs='?', type=int, help='HTTP port', default=80) args = parser.parse_args() # start the dropbox service for handling file uploads dropbox.start() print 'starting web server on port %s' % args.port print 'press control-c to quit' try: server = WSGIServer(('0.0.0.0', args.port), api, handler_class=WebSocketHandler) log.info('entering main loop') server.serve_forever() except KeyboardInterrupt: dropbox.stop() log.info('exiting main loop') except Exception as e: str = 'could not start web server: %s' % e log.error(str) print str status = 1 dropbox.stop() dropbox.join(60) log.info('exiting with status %d', status) return status
def greenlet_admin(self): """ This greenlet is used to get status information about the worker when --admin_port was given """ if self.config["processes"] > 1: self.log.debug("Admin server disabled because of multiple processes.") return from flask import Flask from mrq.dashboard.utils import jsonify app = Flask("admin") @app.route("/") def route_index(): report = self.get_worker_report() report.update({"_id": self.id}) return jsonify(report) self.log.debug("Starting admin server on port %s" % self.config["admin_port"]) try: server = WSGIServer(("0.0.0.0", self.config["admin_port"]), app, log=open(os.devnull, "w")) server.serve_forever() except Exception, e: self.log.debug("Error in admin server : %s" % e)
def main(port): ini_path = './production.ini' setup_logging(ini_path) app = get_app(ini_path, 'main') server = WSGIServer(('', port), app) server.backlog = 256 server.serve_forever()
def run(self, host, port, *args, **kw): from gevent.pywsgi import WSGIServer from gevent.monkey import patch_all; patch_all() logger = logging.getLogger('gevent') logger.info('Starting gevent on port: {}'.format(port)) http_server = WSGIServer(('', port), self.manager.app) http_server.serve_forever()
def mmain(): manager = multiprocessing.Manager() global PROCESSES PROCESSES = {} global PLUGINS PLUGINS = manager.list() global CONTEXT CONTEXT = manager.dict() for plugin in os.listdir('plugins'): try: dir = os.path.join('plugins', plugin) if not os.path.isdir(dir): continue print 'Loading plugin {}'.format(plugin) p = Plugin(dir) PLUGINS.append(p) print 'Successfully loaded plugin: {}'.format(p) except Exception: traceback.print_exc(file=sys.stdout) print 'Failed to load plugin {}'.format(plugin) global http_server http_server = WSGIServer(('',5000), app) #http_server.log = open('http.log', 'w') http_server.serve_forever()
class Server(Greenlet): def __init__(self, name, addr, *args, **kwargs): Greenlet.__init__(self) self._application = Flask(name) self._server = WSGIServer(addr, self._application, *args, **kwargs) @self._application.errorhandler(404) def error_404(error): log.warning('web handler(%s) not found', request.path) return str(error), 404 @self._application.errorhandler(Exception) def error_500(error): log.exception('web handler(%s) is error(%s)', request.path, error) return str(error), 500 def _run(self): self._server.serve_forever() def close(self): self._server.stop() def getServer(self): return self._server def getApplication(self): return self._application def setHandler(self, handler, url=None, **kwargs): if not url: url = '/' + handler.__name__ self._application.route(url, **kwargs)(handler)
def run(self, host='localhost', port=80): """Run the moulinette Start a server instance on the given port to serve moulinette actions. Keyword arguments: - host -- Server address to bind to - port -- Server port to bind to """ try: if self.use_websocket: from gevent.pywsgi import WSGIServer from geventwebsocket.handler import WebSocketHandler server = WSGIServer((host, port), self._app, handler_class=WebSocketHandler) server.serve_forever() else: run(self._app, host=host, port=port) except IOError as e: if e.args[0] == errno.EADDRINUSE: raise MoulinetteError(errno.EADDRINUSE, m18n.g('server_already_running')) raise
def _run(): from gevent.pywsgi import WSGIServer server = WSGIServer(('127.0.0.1', 8999), app) try: server.serve_forever() except KeyboardInterrupt: server.stop()
def run_server(instance_dir, address, port, access_log=False): # workaround on osx, disable kqueue if sys.platform == "darwin": os.environ['EVENT_NOKQUEUE'] = "1" sys.path.insert(0, instance_dir) os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' # This application object is used by any WSGI server configured to use this # file. This includes Django's development server, if the WSGI_APPLICATION # setting points here. from django.core.wsgi import get_wsgi_application application = get_wsgi_application() from gevent import monkey monkey.patch_all(dns=False) from gevent.pywsgi import WSGIServer if access_log: logfile = 'default' else: logfile = file(os.devnull, 'a+') server = WSGIServer((address, port), application, log=logfile) try: server.serve_forever() except KeyboardInterrupt: server.stop()
def go(): app = get_app() app.debug = debug if app.debug: app.config.update(SEND_FILE_MAX_AGE_DEFAULT=0) # TODO: asset debug settings will cause bad YSLOW rating app.config['COMPRESS_DEBUG'] = False app.config['ASSETS_DEBUG'] = debug # Breaks web socket communication # (WebSocketConnectionClosedException in client) # app = DebuggedApplication(app, evalex=True) host = conf_global['serverHost'] port = conf_global['serverPort'] print('Server: {0}:{1}'.format(host, port)) http_server = WSGIServer((host, port), app, handler_class=WebSocketHandler) # gevent.spawn(send_dummy_notifications) gevent.spawn(send_bulk) http_server.serve_forever()
def start(host,port,allow_agent=False): import argparse from gevent.pywsgi import WSGIServer from geventwebsocket.handler import WebSocketHandler from jinja2 import FileSystemLoader import os root_path = os.path.dirname(wssh.__file__) # root_path = '/home/bob/test/wssh/wssh'#os.path.dirname(wssh.__file__) # print "RootPath===>",root_path app.jinja_loader = FileSystemLoader(os.path.join(root_path, 'templates')) app.static_folder = os.path.join(root_path, 'static') # global wssh_server_log_file handler = RotatingFileHandler(wssh_server_log_file, maxBytes=10000000, backupCount=5) handler.setLevel(logging.DEBUG) app.logger.addHandler(handler) app.config['WSSH_ALLOW_SSH_AGENT'] = allow_agent agent = 'wsshd/{0}'.format(wssh.__version__) print '{0} running on {1}:{2}'.format(agent, host, port) app.debug = True http_server = WSGIServer((host, port), app, log=None, handler_class=WebSocketHandler) try: http_server.serve_forever() except KeyboardInterrupt: pass
def main(): options = parser.parse_args() logging.basicConfig( level=getattr(logging, options.log_level.upper(), logging.INFO), format="[%(asctime)s] %(filename)s:%(lineno)d %(levelname)s %(message)s" ) app.config['DATABASE'] = options.db init_db() app.template_folder = TEMPLATES_PATH app.static_folder = STATIC_PATH log.info("Starting service on http://%s:%d/", options.listen, options.port) if options.debug: log.warning("Running on debug mode not for production.") app.run(host=options.listen, port=options.port, debug=True) else: http_server = WSGIServer((options.listen, options.port), app) with suppress(KeyboardInterrupt): http_server.serve_forever()
def start(self): '''Kickoff the TCP Server ''' try: address = self.config.get('listener', 'ip') port = self.config.getint('listener', 'port') listener.server.listener.config_file = self.config_filename listener.server.listener.tail_method = listener.windowslogs.tail_method listener.server.listener.config['iconfig'] = self.config user_cert = self.config.get('listener', 'certificate') if user_cert == 'adhoc': basepath = self.determine_relative_filename('') cert, key = listener.certificate.create_self_signed_cert(basepath, 'ncpa.crt', 'ncpa.key') else: cert, key = user_cert.split(',') ssl_context = {'certfile': cert, 'keyfile': key} listener.server.listener.secret_key = os.urandom(24) http_server = WSGIServer(listener=(address, port), application=listener.server.listener, handler_class=webhandler.PatchedWSGIHandler, spawn=Pool(100), **ssl_context) http_server.serve_forever() except Exception, e: logging.exception(e)
def run(): from gevent.pywsgi import WSGIServer http_server = WSGIServer(('', app.config['HTTP_PORT']), app) if app.config['DEBUG']: debugModeStr = '''Debug mode enabled!''' else: debugModeStr = '' try: print '''=========================================================================== __...____________________ , `(\ [ ===SPACEGDN===--|__|) ___..--"_`--.._____ `"""""""""""""""""| |""` [_""_-___________"_/ | | /..../`'-._.-'` ____| |__/::..'_ |\ ".`"` '_____//\\ `"'-. """"" \\\\/ `""""""""""` =========================================================================== SpaceGDN developed by pyxld.com and is OSS under the MPL-2.0 at https://github.com/connor4312/SpaceGDN. We're lifting off... =========================================================================== Running on '''+app.config['HTTP_HOST']+''':'''+str(app.config['HTTP_PORT'])+''' '''+debugModeStr+''' ===========================================================================''' http_server.serve_forever() except KeyboardInterrupt: http_server.stop() print '''
def main(): handler = logging.FileHandler('server.log') handler.setLevel(logging.DEBUG) app.logger.setLevel(logging.DEBUG) app.logger.addHandler(handler) http_server = WSGIServer(('127.0.0.1', 8001), app) http_server.serve_forever()
def main(): parser, options, arguments = parse_options() if not arguments: parser.print_help() return # configure logging setup_logging(options.loglevel, options.logfile) proxy = TransparentProxy(arguments[0]) throttler = WsgiThrottler(proxy, options.pool_size) # SSL settings if options.certfile and options.keyfile: ssl_settings = {"certfile": options.certfile, "keyfile": options.keyfile} else: ssl_settings = {} main_logger = getLogger(__name__) main_logger.info("Proxying %s on %s:%i with a maximum of %i concurrent requests" %( arguments[0], options.interface, options.port, options.pool_size, )) server = WSGIServer((options.interface, options.port), throttler, log=sys.stdout, **ssl_settings) server.serve_forever()
def main(): global ENVISALINKCLIENT parser = argparse.ArgumentParser('Flask powered Alarm Server') parser.add_argument('config', help='Configurationf file', default='') args = parser.parse_args() logger.info('Using configuration file %s' % args.config) config = AlarmServerConfig(args.config) # Create Envisalink client object ENVISALINKCLIENT = Envisalink.Client(config, CONNECTEDCLIENTS) gevent.spawn(ENVISALINKCLIENT.connect) app.debug = True server = WSGIServer(("", 5000), app, keyfile=config.KEYFILE, certfile=config.CERTFILE) gevent.spawn(publish) try: server.serve_forever() except KeyboardInterrupt: print "Crtl+C pressed. Shutting down." logger.info('Shutting down from Ctrl+C') server.stop() raise SystemExit
def django_worker_function(options, args): from django.core.handlers.wsgi import WSGIHandler from django.conf import settings from django.utils import translation translation.activate(settings.LANGUAGE_CODE) if options.logfile != 'error': sys.stderr = open(os.path.join(current_path, options.logfile), "ab", 1) if len(args) > 0: appfile = args[0] try: application = extract_application(appfile) except AttributeError: sys.exit("Could not find application in %s" % filename) if options.disable_logging: server = WSGIServer((options.host, int(options.port)), application, log=None) else: server = WSGIServer((options.host, int(options.port)), application) print >>sys.stderr, "Serving %s on %s:%s" % (appfile, options.host, options.port) server.serve_forever() else: server = WSGIServer((options.host, int(options.port)), WSGIHandler(), log=None) print >>sys.stderr, "Serving on %s:%s\n" % (options.host, options.port) server.serve_forever()
def web_main(): log = logging.getLogger('web') def server_factory(global_conf, host, port): port = int(port) def serve(app): server = WSGIServer(('', port), app, ) log.info('serving on port %s...', port) server.serve_forever() return serve port = 8000 log.info('starting web server on port %s', port) config = Configurator( settings={ 'mako.directories': 'templates', 'reload_templates': True }) config.add_static_view('static', path='static') config.add_route('root', '/') config.add_route('logcat', '/logcat') config.scan() app = config.make_wsgi_app() http_server = WSGIServer(('', 8000), app, handler_class=WebSocketHandler) http_server.serve_forever()
def main(): ip = config.listening_ip port = config.listening_port log.info("listening on %s:%d" % (ip, port)) server = WSGIServer((ip, port), app, handler_class=WebSocketHandler) server.serve_forever()
def run(self, host="0.0.0.0", port=5000, **kwargs): """Run a testing server in debug mode using gevent's wsgi server. """ # overwrite debug to True when running the app this way self.app.debug = True httpserver = WSGIServer((host, port), self.app) print "starting gevent.WSGIServer server on http://%s:%d" % (host, port) httpserver.serve_forever()
def start_app(verbose=False): global http_server if verbose: print "Starting server on port 5006..." http_server = WSGIServer(('', 5006), app, handler_class=WebSocketHandler, ) http_server.serve_forever()
def start_vaurien_httpserver(port): """Start a vaurien httpserver, controlling a fake proxy""" config = get_config() config.registry['proxy'] = FakeProxy() server = WSGIServer(('localhost', int(port)), config.make_wsgi_app(), log=None) server.serve_forever()
def main(): print u"OpenMining start server at: {}:{}".format(args.ip, args.port) if args.debug is None: server = WSGIServer((args.ip, args.port), app, handler_class=WebSocketHandler) server.serve_forever() run(app=app, host=args.ip, port=args.port, debug=args.debug, reloader=True, server=GeventWebSocketServer)
def start_app(app, verbose=False): global http_server if verbose: print "Starting server on port %d..." % cdx_app.port http_server = WSGIServer(('', cdx_app.port), app, handler_class=WebSocketHandler, ) http_server.serve_forever()
def runserver(port, ip, debug): if debug is None: server = WSGIServer((ip, port), app, handler_class=WebSocketHandler) server.serve_forever() click.echo(u"OpenMining start server at: {}:{}".format(ip, port)) run(app=app, host=ip, port=port, debug=debug, reloader=True, server=GeventWebSocketServer)
def main(): server = WSGIServer(('', port), application) try: print("Fishes on %s" % port) server.serve_forever() except KeyboardInterrupt: print(' now sleeping with the fishes') server.stop()
class Engine(BaseEngine, Signaler): # # 引擎本身只需实现 BaseEngine 接口,信号处理属于额外增强功能。 # 子进程创建、退出都属于系统信号范畴,统一由 Singaler 处理。 # def __init__(self, server): self._server = server self._pool = ThreadPool(CPUS * 4) self._listen_sock = None self._wsgi_server = None BaseEngine.__init__(self, server) Signaler.__init__(self) def run(self): from engine.config import HOST, PORT self._listen_sock = socket(family=AF_INET) self._listen_sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) self._listen_sock.bind((HOST, PORT)) self._listen_sock.listen(2048) self._listen_sock.setblocking(0) self.fork_workers(WORKERS or CPUS + 1) self.parent_execute() def fork_workers(self, num): for i in range(num): if fork() == 0: self.worker_execute() exit(0) def worker_execute(self): Signaler.worker_execute(self) # 启动服务器。 kwargs = HTTPS and \ {k: app_path("ssl/" + v) for k, v in (("keyfile", HTTPS_KEY), ("certfile", HTTPS_CERT))} or \ {} self._wsgi_server = WSGIServer(self._listen_sock, self._server.execute, log=None, **kwargs) self._wsgi_server.serve_forever() # 等待所有处理结束,超时 10 秒。 hasattr(self._wsgi_server, "__graceful__") and gwait(timeout=10) def worker_stop(self, graceful): stop = lambda *args: self._wsgi_server and self._wsgi_server.stop() graceful and (setattr(self._wsgi_server, "__graceful__", True), stop()) or stop() def async_execute(self, func, *args, **kwargs): e = Event() g = self._pool.apply_async(func, args, kwargs, callback=lambda ret: e.set()) e.wait() return g.get()
def main(): server = WSGIServer(('0.0.0.0', 5000), app) try: server.serve_forever() except KeyboardInterrupt: gevent.shutdown()
def main(args): global name name = args.get('name', 'stranger') port = int('5000') server = WSGIServer(('', port), proxy, log=None) server.serve_forever()
@app.route('/') def upload_form(): return render_template('upload.html') @app.route('/', methods=['POST', 'GET']) def upload_file(): if request.method == 'POST': # check if the post request has the file part if 'file' not in request.files: flash('No file part') return redirect(request.url) file = request.files['file'] if file.filename == '': flash('No file selected for uploading') return redirect(request.url) if file and allowed_file(file.filename): filename = secure_filename(file.filename) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) flash('File successfully uploaded') return redirect('/') else: flash('Allowed file types are txt, pdf, png, jpg, jpeg, gif') return redirect(request.url) if __name__ == "__main__": app_server = WSGIServer(('192.168.1.109', 9999), app) app_server.serve_forever()
def run(host, port, wsgi=False, https_mode=False): ''' Автовыбор доступного порта (если указан порт 0), загрузка языковой модели и нейронной сети и запуск сервера. 1. wsgi - True: запуск WSGI сервера, False: запуск тестового Flask сервера 2. https - True: запуск в режиме https (сертификат и ключ должны быть в cert.pem и key.pem), False: запуск в режиме http Самоподписанный сертификат можно получить, выполнив: openssl req -x509 -newkey rsa:4096 -nodes -out temp/cert.pem -keyout temp/key.pem -days 365 ''' if port == 0: # Если был введён порт 0, то автовыбор любого доступного порта try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind((host, 0)) port = sock.getsockname()[1] log('выбран порт ' + str(port)) sock.close() except socket.gaierror: log('адрес ' + host + ':' + str(port) + ' некорректен', level='error') sock.close() return except OSError: log('адрес ' + host + ':' + str(port) + ' недоступен', level='error') sock.close() return log('Flask v.' + flask_version + ', WSGIServer v.' + wsgi_version) log('установлен максимальный размер принимаемых данных: {:.2f} Кб'.format( max_content_length / 1024)) name_dataset = f_name_w2v_model_plays[ f_name_w2v_model_plays.rfind('w2v_model_') + len('w2v_model_'):f_name_w2v_model_plays.rfind('.bin')] log('загрузка обученной на наборе данных ' + name_dataset + ' модели seq2seq...') global ttt print() ttt = TextToText(f_name_w2v_model=f_name_w2v_model_plays, f_name_model=f_name_model_plays, f_name_model_weights=f_name_model_weights_plays) print() log('загрузка языковой модели для распознавания речи...') global stt stt = SpeechToText('from_file', name_dataset) log('загрузка синтезатора речи...') global tts tts = TextToSpeech('anna') if wsgi: global http_server if https_mode: log('WSGI сервер запущен на https://' + host + ':' + str(port) + ' (нажмите Ctrl+C или Ctrl+Z для выхода)') else: log('WSGI сервер запущен на http://' + host + ':' + str(port) + ' (нажмите Ctrl+C или Ctrl+Z для выхода)') try: if https_mode: http_server = WSGIServer((host, port), app, log=app.logger, error_log=app.logger, keyfile='temp/key.pem', certfile='temp/cert.pem') else: http_server = WSGIServer((host, port), app, log=app.logger, error_log=app.logger) http_server.serve_forever() except OSError: print() log('адрес ' + host + ':' + str(port) + ' недоступен', level='error') else: log('запуск тестового Flask сервера...') try: if https_mode: app.run(host=host, port=port, ssl_context=('temp/cert.pem', 'temp/key.pem'), threaded=True, debug=False) else: app.run(host=host, port=port, threaded=True, debug=False) except OSError: print() log('адрес ' + host + ':' + str(port) + ' недоступен', level='error')
def runServer(): server = WSGIServer(("127.0.0.1", 5000), create_app()) server.serve_forever()
def run(debug, no_browser, m, mu, mc, f): """ Sacredboard. \b Sacredboard is a monitoring dashboard for Sacred. Homepage: http://github.com/chovanecm/sacredboard Example usage: \b sacredboard -m sacred Starts Sacredboard on default port (5000) and connects to a local MongoDB database called 'sacred'. Opens web browser. Note: MongoDB must be listening on localhost. \b sacredboard -m 192.168.1.1:27017:sacred Starts Sacredboard on default port (5000) and connects to a MongoDB database running on 192.168.1.1 on port 27017 to a database called 'sacred'. Opens web browser. \b sacredboard -mu mongodb://user:pwd@host/admin?authMechanism=SCRAM-SHA-1 sacred Starts Sacredboard on default port (5000) and connects to a MongoDB database running on localhost on port 27017 to a database called 'sacred'. Opens web browser. \b sacredboard -m sacred -mc default.runs Starts Sacredboard on default port (5000) and connects to a local MongoDB database called 'sacred' and uses the Sacred's 0.6 default collection 'default.runs' to search the runs in. Opens web browser. Note: MongoDB must be listening on localhost. """ if m or mu != (None, None): add_mongo_config(app, m, mu, mc) app.config["data"].connect() elif f: app.config["data"] = FileStorage(f) else: print("Must specify either a mongodb instance or " + "a path to a file storage.\nRun sacredboard --help " "for more information.", file=sys.stderr) sys.exit(1) app.config['DEBUG'] = debug app.debug = debug jinja_filters.setup_filters(app) routes.setup_routes(app) metrics.initialize(app) if debug: app.run(host="0.0.0.0", debug=True) else: for port in range(5000, 5050): http_server = WSGIServer(('0.0.0.0', port), app) try: http_server.start() except OSError as e: # try next port continue print("Starting sacredboard on port %d" % port) if not no_browser: click.launch("http://127.0.0.1:%d" % port) http_server.serve_forever() break
class GeventServer(CommonServer): def __init__(self, app): super(GeventServer, self).__init__(app) self.port = config['longpolling_port'] self.httpd = None def process_limits(self): restart = False if self.ppid != os.getppid(): _logger.warning("LongPolling Parent changed", self.pid) restart = True memory = memory_info(psutil.Process(self.pid)) if config['limit_memory_soft'] and memory > config['limit_memory_soft']: _logger.warning('LongPolling virtual memory limit reached: %s', memory) restart = True if restart: # suicide !! os.kill(self.pid, signal.SIGTERM) def watchdog(self, beat=4): import gevent self.ppid = os.getppid() while True: self.process_limits() gevent.sleep(beat) def start(self): import gevent try: from gevent.pywsgi import WSGIServer, WSGIHandler except ImportError: from gevent.wsgi import WSGIServer, WSGIHandler class ProxyHandler(WSGIHandler): """ When logging requests, try to get the client address from the environment so we get proxyfix's modifications (if any). Derived from werzeug.serving.WSGIRequestHandler.log / werzeug.serving.WSGIRequestHandler.address_string """ def format_request(self): old_address = self.client_address if getattr(self, 'environ', None): self.client_address = self.environ['REMOTE_ADDR'] elif not self.client_address: self.client_address = '<local>' # other cases are handled inside WSGIHandler try: return super().format_request() finally: self.client_address = old_address set_limit_memory_hard() if os.name == 'posix': # Set process memory limit as an extra safeguard signal.signal(signal.SIGQUIT, dumpstacks) signal.signal(signal.SIGUSR1, log_ormcache_stats) gevent.spawn(self.watchdog) self.httpd = WSGIServer( (self.interface, self.port), self.app, log=logging.getLogger('longpolling'), error_log=logging.getLogger('longpolling'), handler_class=ProxyHandler, ) _logger.info('Evented Service (longpolling) running on %s:%s', self.interface, self.port) try: self.httpd.serve_forever() except: _logger.exception("Evented Service (longpolling): uncaught error during main loop") raise def stop(self): import gevent self.httpd.stop() gevent.shutdown() def run(self, preload, stop): self.start() self.stop()
def run(self): logging.info(f'ixu server listening to {self.host}:{self.port}') http_server = WSGIServer((self.host, self.port), self) http_server.serve_forever()
def start(self): # Check if there is a start delay try: delay_start = self.config.get('listener', 'delay_start') if delay_start: logging.info( 'Delayed start in configuration. Waiting %s seconds to start.', delay_start) time.sleep(int(delay_start)) except Exception: pass # Run DB maintenance on start self.db.run_db_maintenance(self.config) try: try: address = self.config.get('listener', 'ip') except Exception: self.config.set('listener', 'ip', '0.0.0.0') address = '0.0.0.0' try: port = self.config.getint('listener', 'port') except Exception: self.config.set('listener', 'port', 5693) port = 5693 listener.server.listener.config_files = self.config_filenames listener.server.listener.tail_method = listener.windowslogs.tail_method listener.server.listener.config['iconfig'] = self.config try: ssl_str_version = self.config.get('listener', 'ssl_version') ssl_version = getattr(ssl, 'PROTOCOL_' + ssl_str_version) except: ssl_version = getattr(ssl, 'PROTOCOL_TLSv1') ssl_str_version = 'TLSv1' try: ssl_str_ciphers = self.config.get('listener', 'ssl_ciphers') except Exception: ssl_str_ciphers = None logging.info('Using SSL version %s', ssl_str_version) user_cert = self.config.get('listener', 'certificate') if user_cert == 'adhoc': basepath = self.determine_relative_filename('') certpath = os.path.abspath(os.path.join(basepath, 'var')) cert, key = listener.certificate.create_self_signed_cert( certpath, 'ncpa.crt', 'ncpa.key') else: cert, key = user_cert.split(',') # Create SSL context that will be passed to the server ssl_context = { 'certfile': cert, 'keyfile': key, 'ssl_version': ssl_version } # Add SSL cipher list if one is given if ssl_str_ciphers: ssl_context['ciphers'] = ssl_str_ciphers listener.server.listener.secret_key = os.urandom(24) http_server = WSGIServer(listener=(address, port), application=listener.server.listener, handler_class=WebSocketHandler, spawn=Pool(200), **ssl_context) http_server.serve_forever() except Exception as e: logging.exception(e)
from gevent.pywsgi import WSGIServer from app import app http_server = WSGIServer(('', 5000), app) http_server.serve_forever()
@login_required def test(): global pred_class_name dic = {"pred_class_name": pred_class_name} return render_template('display.html', dic=dic) @app.route('/login') def login(): return 'Login' def get_pred_class_name(pred_class_number): global mapper return mapper[pred_class_number] def preprocess_single_image(filepath): pic = cv2.imread(filepath) pic = cv2.resize(pic, (120, 120)) pic = pic.astype('float32') pic /= 255 pic = pic.reshape(-1, 120, 120, 3) return pic if __name__ == "__main__": server = WSGIServer(("", 5000), app) print('Server is up and running on port 5000......') print('Go to http://localhost:5000') server.serve_forever()
def stop_replicant(): # TODO: Unused at this moment replicant_id = json.loads( request.form.get("replicant_id", json.dumps(None))) replicant.terminate(False) #TODO: Maybe json.dumps({}) return json.dumps("Replicant stopped") @app.route('/', defaults={"path": ''}) @app.route("/<path:path>/") def index(path): return render_template("index.html") if __name__ == "__main__": try: os.mkdir(USERS_DIRECTORY) except: pass # app.run(debug = True, threaded = True) # Use this in production code HTTPServer = WSGIServer( (IP_ADDRESS, PORT), app) #, keyfile="server.key", certfile="server.crt") HTTPServer.serve_forever()
from gevent.pywsgi import WSGIServer from flask import Flask app = Flask(__name__) @app.route('/') def hello_world(): return 'Hello World!' if __name__ == '__main__': ws = WSGIServer(('0.0.0.0', 5001), app) ws.serve_forever()
class fHDHR_HTTP_Server(): app = None def __init__(self, fhdhr): self.fhdhr = fhdhr self.template_folder = fhdhr.config.internal["paths"]["www_templates_dir"] self.fhdhr.logger.info("Loading Flask.") self.fhdhr.app = Flask("fHDHR", template_folder=self.template_folder) self.instance_id = str(uuid.uuid4()) # Allow Internal API Usage self.fhdhr.app.testing = True self.fhdhr.api.client = self.fhdhr.app.test_client() # Set Secret Key For Sessions self.fhdhr.app.secret_key = self.fhdhr.config.dict["fhdhr"]["friendlyname"] self.route_list = {} self.endpoints_obj = {} self.endpoints_obj["brython"] = fHDHR_Brython(fhdhr) self.endpoints_obj["api"] = fHDHR_API(fhdhr) # Load Plugins before pages so they can override core web pages self.selfadd_web_plugins() self.endpoints_obj["pages"] = fHDHR_Pages(fhdhr) self.endpoints_obj["files"] = fHDHR_Files(fhdhr) for endpoint_type in list(self.endpoints_obj.keys()): self.fhdhr.logger.info("Loading HTTP %s Endpoints." % endpoint_type) self.add_endpoints(endpoint_type) self.fhdhr.app.before_request(self.before_request) self.fhdhr.app.after_request(self.after_request) self.fhdhr.app.before_first_request(self.before_first_request) self.fhdhr.threads["flask"] = threading.Thread(target=self.run) def selfadd_web_plugins(self): for plugin_name in list(self.fhdhr.plugins.plugins.keys()): if self.fhdhr.plugins.plugins[plugin_name].type == "web": method = self.fhdhr.plugins.plugins[plugin_name].name.lower() plugin_utils = self.fhdhr.plugins.plugins[plugin_name].plugin_utils try: self.endpoints_obj[method] = self.fhdhr.plugins.plugins[plugin_name].Plugin_OBJ(self.fhdhr, plugin_utils) except Exception as e: print(e) def start(self): self.fhdhr.logger.info("Flask HTTP Thread Starting") self.fhdhr.threads["flask"].start() def stop(self): self.fhdhr.logger.info("Flask HTTP Thread Stopping") self.http.stop() def before_first_request(self): self.fhdhr.logger.info("HTTP Server Online.") def before_request(self): session["session_id"] = str(uuid.uuid4()) session["instance_id"] = self.instance_id session["route_list"] = self.route_list session["user_agent"] = request.headers.get('User-Agent') session["is_internal_api"] = self.detect_internal_api(request) if session["is_internal_api"]: self.fhdhr.logger.debug("Client is using internal API call.") session["is_mobile"] = self.detect_mobile(request) if session["is_mobile"]: self.fhdhr.logger.debug("Client is a mobile device.") session["is_plexmediaserver"] = self.detect_plexmediaserver(request) if session["is_plexmediaserver"]: self.fhdhr.logger.debug("Client is a Plex Media Server.") session["deviceauth"] = self.detect_plexmediaserver(request) session["tuner_used"] = None session["restart"] = False self.fhdhr.logger.debug("Client %s requested %s Opening" % (request.method, request.path)) def after_request(self, response): # Close Tuner if it was in use, and did not close already # if session["tuner_used"] is not None: # tuner = self.fhdhr.device.tuners.tuners[str(session["tuner_used"])] # if tuner.tuner_lock.locked(): # self.fhdhr.logger.info("Shutting down Tuner #%s after Request." % session["tuner_used"]) # tuner.close() self.fhdhr.logger.debug("Client %s requested %s Closing" % (request.method, request.path)) if not session["restart"]: return response else: return self.stop() def detect_internal_api(self, request): user_agent = request.headers.get('User-Agent') if not user_agent: return False elif str(user_agent).lower().startswith("fhdhr"): return True else: return False def detect_deviceauth(self, request): return request.args.get('DeviceAuth', default=None, type=str) def detect_mobile(self, request): user_agent = request.headers.get('User-Agent') phones = ["iphone", "android", "blackberry"] if not user_agent: return False elif any(phone in user_agent.lower() for phone in phones): return True else: return False def detect_plexmediaserver(self, request): user_agent = request.headers.get('User-Agent') if not user_agent: return False elif str(user_agent).lower().startswith("plexmediaserver"): return True else: return False def add_endpoints(self, index_name): item_list = [x for x in dir(self.endpoints_obj[index_name]) if self.isapath(x)] endpoint_main = self.endpoints_obj[index_name] endpoint_main.fhdhr.version # dummy line for item in item_list: endpoints = eval("endpoint_main.%s.%s" % (item, "endpoints")) if isinstance(endpoints, str): endpoints = [endpoints] handler = eval("endpoint_main.%s" % item) endpoint_name = eval("endpoint_main.%s.%s" % (item, "endpoint_name")) try: endpoint_methods = eval("endpoint_main.%s.%s" % (item, "endpoint_methods")) except AttributeError: endpoint_methods = ['GET'] try: endpoint_access_level = eval("endpoint_main.%s.%s" % (item, "endpoint_access_level")) except AttributeError: endpoint_access_level = 0 try: pretty_name = eval("endpoint_main.%s.%s" % (item, "pretty_name")) except AttributeError: pretty_name = endpoint_name try: endpoint_category = eval("endpoint_main.%s.%s" % (item, "endpoint_category")) except AttributeError: endpoint_category = index_name try: endpoint_default_parameters = eval("endpoint_main.%s.%s" % (item, "endpoint_default_parameters")) except AttributeError: endpoint_default_parameters = {} endpoint_added = True try: for endpoint in endpoints: self.add_endpoint(endpoint=endpoint, endpoint_name=endpoint_name, handler=handler, methods=endpoint_methods) except AssertionError: endpoint_added = False if endpoint_added: self.fhdhr.logger.debug("Adding endpoint %s available at %s with %s methods." % (endpoint_name, ",".join(endpoints), ",".join(endpoint_methods))) if endpoint_category not in list(self.route_list.keys()): self.route_list[endpoint_category] = {} if endpoint_name not in list(self.route_list[endpoint_category].keys()): self.route_list[endpoint_category][endpoint_name] = {} self.route_list[endpoint_category][endpoint_name]["name"] = endpoint_name self.route_list[endpoint_category][endpoint_name]["endpoints"] = endpoints self.route_list[endpoint_category][endpoint_name]["endpoint_methods"] = endpoint_methods self.route_list[endpoint_category][endpoint_name]["endpoint_access_level"] = endpoint_access_level self.route_list[endpoint_category][endpoint_name]["endpoint_default_parameters"] = endpoint_default_parameters self.route_list[endpoint_category][endpoint_name]["pretty_name"] = pretty_name self.route_list[endpoint_category][endpoint_name]["endpoint_category"] = endpoint_category def isapath(self, item): not_a_page_list = ["fhdhr", "plugin_utils"] if item in not_a_page_list: return False elif item.startswith("__") and item.endswith("__"): return False else: return True def add_endpoint(self, endpoint=None, endpoint_name=None, handler=None, methods=['GET']): self.fhdhr.app.add_url_rule(endpoint, endpoint_name, handler, methods=methods) def run(self): self.http = WSGIServer(self.fhdhr.api.address_tuple, self.fhdhr.app.wsgi_app, log=self.fhdhr.logger.logger, error_log=self.fhdhr.logger.logger) try: self.http.serve_forever() self.stop() except AttributeError: self.fhdhr.logger.info("HTTP Server Offline")
def main(): http_server = WSGIServer(('', args.listen_port), app) http_server.serve_forever()
import getopt from gevent import monkey monkey.patch_all() from gevent.pywsgi import WSGIServer from cplatform.wsgi import application from multiprocessing import Process addr, port = '127.0.0.1', 8000 opts, _ = getopt.getopt(sys.argv[1:], "b:") for opt, value in opts: if opt == '-b': addr, port = value.split(":") server = WSGIServer((addr, int(port)), application) process_count = 4 for i in range(process_count - 1): Process(target=server.serve_forever(), args=tuple()).start()
""" username: String: a String of the user page requested in the url. generates the requested user page if it exists, if not, generates the page saying that the user was not found. """ if username_in_db(username): db = sqlite3.connect(DB_PATH) cur = db.cursor() cur.execute( "SELECT about, age, sex, favorite_food FROM users WHERE username=?", (username, )) # Retrieves the info about the user. row = cur.fetchone() about, age, sex, favorite_food = row return render_template('video_feed.html', video_url=url_for('video_feed', username=username), about=about, age=age, sex=sex, favorite_food=favorite_food) return render_template('user_not_found.html') if __name__ == "__main__": print CODE_FILES_PATH thread = threading.Thread(target=ImageReceiveServer().start_server) thread.daemon = True thread.start() app.config["SECRET_KEY"] = "ITSASECRET" http = WSGIServer(('', WEB_SERVER_PORT), app) http.serve_forever()
def __init__(self, args): for arg in args: temp = arg.split("=") if temp[0] == "env": Container.env = temp[1] # 获取项目根目录 Container.project_path = os.getcwd() # 加载配置文件信息 Container.config = Config(root_path=Container.project_path, env=Container.env) # 初始化日志 level_info = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR } logging.basicConfig(level=level_info[Container.config.getProperty("logging.level")] , format=Container.config.getProperty("logging.format")) logger.info("run env: %s" % Container.env) logger.debug("config: %s" % Container.config.config) logger.debug("project_root_path = %s" % Container.project_path) # 打印logo logger.info(''' ('-. ('-. .-') _ _( OO) ( OO ).-. ( OO ) ) .-'),-----. .-----. (,------./ . --. /,--./ ,--,' ( OO' .-. ' ' .--./ | .---'| \-. \ | \ | |\ / | | | | | |('-. | | .-'-' | || \| | ) \_) | |\| | /_) |OO )(| '--.\| |_.' || . |/ \ | | | | || |`-'| | .--' | .-. || |\ | `' '-' '(_' '--'\ | `---.| | | || | \ | `-----' `-----' `------'`--' `--'`--' `--' ''') # 加载数据库 database_list = Container.config.getProperty("postgres") logger.info("load database start") for key, database in database_list.items(): logger.info( "load database, host: %s, port: %s, path: %s" % (database["host"], database["port"], database["path"])) Container.database_conn_pool_dict[database["path"]] \ = ThreadedConnectionPool(database["minconn"] , database["maxconn"] , host=database["host"] , user=database["user"] , password=database["password"] , dbname=database["database"] , port=int(database["port"])) logger.info("load database complete") # 初始化定时任务 logger.info("init scheduler start") Container.scheduler = BackgroundScheduler(job_defaults={ 'coalesce': Container.config.getProperty("scheduler.coalesce", False), 'max_instances': Container.config.getProperty("scheduler.max_instances", 1), 'misfire_grace_time': Container.config.getProperty("scheduler.misfire_grace_time", 60) }) # 初始化jobs job_list = Container.config.getProperty("scheduler.job") module_dict = {} for key, job in job_list.items(): logger.debug("add scheduler: %s" % key) func_info = job["path"].split(".") method = func_info[-1] from_info = ".".join(func_info[0: -2]) if len(func_info) > 3 else func_info[0] module_info = ".".join(func_info[0: -1]) module = None try: module = module_dict[module_info] except Exception as e: logger.warn(e) if not module: module = __import__(module_info, fromlist=[from_info]) module_dict[module_info] = module fn = getattr(module, method) if job["schema"] == "cron": Container.scheduler.add_job(fn, CronTrigger.from_crontab(job["cron"])) else: Container.scheduler.add_job(fn, job["schema"], seconds=job["seconds"]) Container.scheduler.start() logger.info("init scheduler end") # 初始化web port = Container.config.getProperty("server.port", 8080) logger.info("init web start, port: %s" % port) routeLen = len("@route(") errorhandlerLen = len("@errorhandler(") for root, dirs, files in os.walk(Container.project_path): for file in files: with open(os.path.join(root, file), mode='r') as rp: try: lines = rp.readlines() flag = False for line in lines: content = line.rstrip() if len(content) > routeLen and (content[:routeLen] == "@route(" or content[:errorhandlerLen] == "@errorhandler("): flag = True break if flag: f = root[len(Container.project_path) + 1:] f = ".".join(f.split("/")) name = ".".join([f, file.split(".")[0]]) logger.info("init web, path: %s" % name) __import__(name, fromlist=[f]) except Exception as e: logger.debug("init controller failed, path: %s Exception: %s" % (os.path.join(root, file), e)) # app.run(host="0.0.0.0", port=int(port)) monkey.patch_all() http_server = WSGIServer(("0.0.0.0", port), app) http_server.serve_forever()
class server: wsgiserver = None restart = False def __init__(self): signal.signal(signal.SIGINT, self.killServer) signal.signal(signal.SIGTERM, self.killServer) def start_gevent(self): try: ssl_args = dict() certfile_path = web.ub.config.get_config_certfile() keyfile_path = web.ub.config.get_config_keyfile() if certfile_path and keyfile_path: if os.path.isfile(certfile_path) and os.path.isfile( keyfile_path): ssl_args = { "certfile": certfile_path, "keyfile": keyfile_path } else: web.app.logger.info( 'The specified paths for the ssl certificate file and/or key file seem to be broken. Ignoring ssl. Cert path: %s | Key path: %s' % (certfile_path, keyfile_path)) if os.name == 'nt': self.wsgiserver = WSGIServer( ('0.0.0.0', web.ub.config.config_port), web.app, spawn=Pool(), **ssl_args) else: self.wsgiserver = WSGIServer(('', web.ub.config.config_port), web.app, spawn=Pool(), **ssl_args) web.py3_gevent_link = self.wsgiserver self.wsgiserver.serve_forever() except SocketError: try: web.app.logger.info( 'Unable to listen on \'\', trying on IPv4 only...') self.wsgiserver = WSGIServer( ('0.0.0.0', web.ub.config.config_port), web.app, spawn=Pool(), **ssl_args) web.py3_gevent_link = self.wsgiserver self.wsgiserver.serve_forever() except (OSError, SocketError) as e: web.app.logger.info("Error starting server: %s" % e.strerror) print("Error starting server: %s" % e.strerror) web.helper.global_WorkerThread.stop() sys.exit(1) except Exception: web.app.logger.info("Unknown error while starting gevent") def startServer(self): if gevent_present: web.app.logger.info('Starting Gevent server') # leave subprocess out to allow forking for fetchers and processors self.start_gevent() else: try: ssl = None web.app.logger.info('Starting Tornado server') certfile_path = web.ub.config.get_config_certfile() keyfile_path = web.ub.config.get_config_keyfile() if certfile_path and keyfile_path: if os.path.isfile(certfile_path) and os.path.isfile( keyfile_path): ssl = { "certfile": certfile_path, "keyfile": keyfile_path } else: web.app.logger.info( 'The specified paths for the ssl certificate file and/or key file seem to be broken. Ignoring ssl. Cert path: %s | Key path: %s' % (certfile_path, keyfile_path)) # Max Buffersize set to 200MB http_server = HTTPServer(WSGIContainer(web.app), max_buffer_size=209700000, ssl_options=ssl) http_server.listen(web.ub.config.config_port) self.wsgiserver = IOLoop.instance() self.wsgiserver.start() # wait for stop signal self.wsgiserver.close(True) except SocketError as e: web.app.logger.info("Error starting server: %s" % e.strerror) print("Error starting server: %s" % e.strerror) web.helper.global_WorkerThread.stop() sys.exit(1) # ToDo: Somehow caused by circular import under python3 refactor if sys.version_info > (3, 0): self.restart = web.py3_restart_Typ if self.restart == True: web.app.logger.info("Performing restart of Calibre-Web") web.helper.global_WorkerThread.stop() if os.name == 'nt': arguments = ["\"" + sys.executable + "\""] for e in sys.argv: arguments.append("\"" + e + "\"") os.execv(sys.executable, arguments) else: os.execl(sys.executable, sys.executable, *sys.argv) else: web.app.logger.info("Performing shutdown of Calibre-Web") web.helper.global_WorkerThread.stop() sys.exit(0) def setRestartTyp(self, starttyp): self.restart = starttyp # ToDo: Somehow caused by circular import under python3 refactor web.py3_restart_Typ = starttyp def killServer(self, signum, frame): self.stopServer() def stopServer(self): # ToDo: Somehow caused by circular import under python3 refactor if sys.version_info > (3, 0): if not self.wsgiserver: if gevent_present: self.wsgiserver = web.py3_gevent_link else: self.wsgiserver = IOLoop.instance() if self.wsgiserver: if gevent_present: self.wsgiserver.close() else: self.wsgiserver.add_callback(self.wsgiserver.stop) @staticmethod def getNameVersion(): if gevent_present: return {'Gevent': 'v' + geventVersion} else: return {'Tornado': 'v' + tornadoVersion}
class LANServer: def __init__(self, shared_state): app = Flask(__name__) self.app = app self.host = config.get('lan.bind_ip', '') self.server = None if self.host == '': self.host = best_ip self.port = None @app.before_request def dns_rebinding_prevention(): if request.remote_addr in lan_ips or ipaddress.ip_address( request.remote_addr).is_loopback: if time.time() - _start_time > 600: abort(403) if request.host != f'{self.host}:{self.port}': logger.warn('Potential DNS rebinding attack on LAN server:') logger.warn( f'Hostname {request.host} was used instead of {self.host}:{self.port}' ) abort(403) @app.route('/blist/<time>') def get_block_list_for_lan(time): return Response('\n'.join(get_block_list(dateRec=time))) @app.route('/get/<block>') def get_block_data(block): if not stringvalidators.validate_hash(block): raise ValueError return Response(Block(block).raw, mimetype='application/octet-stream') @app.route("/ping") def ping(): return Response("onionr!") @app.route('/upload', methods=['POST']) def upload_endpoint(): return accept_upload(request) def start_server(self): def _show_lan_bind(port): better_sleep(1) if self.server.started and port == self.server.server_port: logger.info(f'Serving to LAN on {self.host}:{self.port}', terminal=True) if self.host == "": logger.info( "Not binding to LAN due to no private network configured.", terminal=True) return for i in ports: self.server = WSGIServer((self.host, i), self.app, log=None, handler_class=FDSafeHandler) self.port = self.server.server_port try: Thread(target=_show_lan_bind, args=[i], daemon=True).start() self.server.serve_forever() except OSError: pass else: break else: logger.warn("Could not bind to any LAN ports " + str(min(ports)) + "-" + str(max(ports)), terminal=True) return
def main(): global engine global connection global metadata global Session global solutions global submissions global correct global incorrect global users global hints global hintreqs global chattext # database location handling db_loc = os.getenv("CTF_DB_LOC") if db_loc is None: logging.error("FLASK : No database location provided. exiting...") exit(1) if not os.path.isfile(db_loc) or not os.access(db_loc, os.R_OK): logging.error("FLASK : database does not exist. exiting...") exit(1) # sqlalchemy setup engine = sql.create_engine("sqlite:///" + db_loc) connection = engine.connect() metadata = sql.MetaData() Session = sql.orm.sessionmaker(bind=engine) try: users = sql.Table("users", metadata, autoload=True, autoload_with=engine) solutions = sql.Table("solutions", metadata, autoload=True, autoload_with=engine) correct = sql.Table("correct", metadata, autoload=True, autoload_with=engine) incorrect = sql.Table("incorrect", metadata, autoload=True, autoload_with=engine) submissions = sql.Table("submissions", metadata, autoload=True, autoload_with=engine) starttime = sql.Table("starttime", metadata, autoload=True, autoload_with=engine) hints = sql.Table("hints", metadata, autoload=True, autoload_with=engine) hintreqs = sql.Table("hintreqs", metadata, autoload=True, autoload_with=engine) chattext = sql.Table("chattext", metadata, autoload=True, autoload_with=engine) hint_config = sql.Table("hint_config", metadata, autoload=True, autoload_with=engine) except NoSuchTableError: logging.error("FLASK : database exists, " + "but does not have required tables. exiting...") exit(1) # mapping the loaded tables onto our classes mapper(User, users) mapper(Solution, solutions) mapper(Submission, submissions) mapper(Correct, correct) mapper(Incorrect, incorrect) mapper(Starttime, starttime) mapper(Hint, hints) mapper(Hintreq, hintreqs) mapper(Chattext, chattext) mapper(Hintconfig, hint_config) # setting up and starting the server logger = logging.getLogger() logging.basicConfig( level='INFO', format='FLASK : %(levelname)-8s %(asctime)s %(message)s') logging.info("Connecting to MQTT server...") mqtt_addr = os.getenv("MQTT_ADDR") mqtt_port = os.getenv("MQTT_PORT") mqtt_username = os.getenv("MQTT_USERNAME") mqtt_password = os.getenv("MQTT_PASSWORD") global mclient if mqtt_addr is None or mqtt_port is None: logging.warning( "FLASK : MQTT_PORT or MQTT_ADDR not set, disabling mqtt...") else: mclient = mqtt.Client() try: if mqtt_username is not None: if mqtt_password is not None: mclient.username_pw_set(mqtt_username, mqtt_password) else: mclient.username_pw_set(mqtt_username) mclient.connect(mqtt_addr, int(mqtt_port), 60, "0.0.0.0") mclient.loop_start() except ValueError: logging.error("FLASK : MQTT_PORT must be an integer. exiting...") exit(1) except ConnectionRefusedError as e: logging.error( f"FLASK : connection to MQTT broker refused. exiting...\n{e}") exit(1) except Exception as e: logging.error( f"FLASK : unexpected error while connecting to MQTT broker: {str(e)}" ) exit(1) time = datetime.datetime.utcnow() session = Session() if session.query(Starttime).count() == 0: session.add(Starttime(time=time)) session.commit() logging.info("Initialization of the hintbot...") configs = session.query(Hintconfig).all() config_dict = {} for config in configs: config_dict[config.k] = config.v global hintbot hintbot = Hintbot(config_dict) try: global fails_until_hints fails_until_hints = int(config_dict["failures_until_hints"]) except ValueError: logging.error("Using default 2 failures until hints.") fails_until_hints = 2 except KeyError: logging.error("Using default 2 failures until hints.") fails_until_hints = 2 session.close() logging.info("Starting ctf server...") http_server = WSGIServer(("0.0.0.0", 8443), app, log=logger, error_log=logger) http_server.serve_forever()
def main(): global input_args app.jinja_env.filters['str2datetime'] = str2datetime input_args = parse_input_args() # setup logging level if input_args.log_level: logging.root.setLevel(input_args.log_level) # On `init` command, create directory args.project_name with initial project state and exit if input_args.command == 'init': Project.create_project_dir(input_args.project_name, input_args) return elif input_args.command == 'start': # If `start --init` option is specified, do the same as with `init` command, but continue to run app if input_args.init: Project.create_project_dir(input_args.project_name, input_args) if not os.path.exists( Project.get_project_dir(input_args.project_name, input_args)): raise FileNotFoundError( 'Project directory "{pdir}" not found. ' 'Did you miss create it first with `label-studio init {pdir}` ?' .format(pdir=Project.get_project_dir(input_args.project_name, input_args))) # On `start` command, launch browser if --no-browser is not specified and start label studio server if input_args.command == 'start': import label_studio.utils.functions import label_studio.utils.auth config = Project.get_config(input_args.project_name, input_args) # set username and password label_studio.utils.auth.USERNAME = input_args.username or \ config.get('username') or label_studio.utils.auth.USERNAME label_studio.utils.auth.PASSWORD = input_args.password or config.get( 'password', '') # set host name host = input_args.host or config.get( 'host', 'localhost') # name for external links generation port = input_args.port or config.get('port', 8080) server_host = 'localhost' if host == 'localhost' else '0.0.0.0' # web server host # ssl certificate and key cert_file = input_args.cert_file or config.get('cert') key_file = input_args.key_file or config.get('key') ssl_context = None if cert_file and key_file: config['protocol'] = 'https://' ssl_context = (cert_file, key_file) # check port is busy if not input_args.debug and check_port_in_use('localhost', port): old_port = port port = int(port) + 1 print('\n*** WARNING! ***\n* Port ' + str(old_port) + ' is in use.\n' + '* Trying to start at ' + str(port) + '\n****************\n') set_web_protocol(input_args.protocol or config.get('protocol', 'http://')) set_full_hostname(get_web_protocol() + host.replace('0.0.0.0', 'localhost') + ':' + str(port)) start_browser('http://localhost:' + str(port), input_args.no_browser) if input_args.use_gevent: app.debug = input_args.debug ssl_args = { 'keyfile': key_file, 'certfile': cert_file } if ssl_context else {} http_server = WSGIServer((server_host, port), app, log=app.logger, **ssl_args) http_server.serve_forever() else: app.run(host=server_host, port=port, debug=input_args.debug, ssl_context=ssl_context) # On `start-multi-session` command, server creates one project per each browser sessions elif input_args.command == 'start-multi-session': server_host = input_args.host or '0.0.0.0' port = input_args.port or 8080 if input_args.use_gevent: app.debug = input_args.debug http_server = WSGIServer((server_host, port), app, log=app.logger) http_server.serve_forever() else: app.run(host=server_host, port=port, debug=input_args.debug)
def _run(self): print("WSGI Server Listen at port {0}".format(self.port)) server = WSGIServer(('0.0.0.0', self.port), self.app or self._app) server.serve_forever()
console_handler.setLevel(logging.ERROR) # create formatter formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler.setFormatter(formatter) console_handler.setFormatter(formatter) # add handlers to the logger loggerA.addHandler(file_handler) loggerA.addHandler(console_handler) return loggerA if __name__ == '__main__': logger = createLogger() logger.info('Started') freeze_support() game_servers = {} tracker_server = TrackerServer() tracker_server.start() state_server = StateServer(tracker_server) state_server.start() rest_app = RESTAPI(game_servers, state_server) rest_server = WSGIServer(('0.0.0.0', 8088), rest_app) rest_server.serve_forever()
def run(): http_server = WSGIServer(('', 7210), app) http_server.serve_forever()
def start(self): http_server = WSGIServer(('', self.port), self.app) http_server.serve_forever()
class WebfrontEngine(object): """ The client-facing web interface. """ def __init__(self): logger.debug("Initializing webfront engine...") global webfront webfront = self self._http_listener = None self._https_listener = None self.listen_port = 5000 self.listen_addr = '127.0.0.1' self.secure_listen_port = 0 # 0 means not binding self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, ) self.secure_base_url = "https://127.0.0.1:%d/" % ( self.secure_listen_port, ) self._token = None @property def access_token(self): return self._token def _acquire_access_token(self): self._token = os.environ.get('AVA_ACCESS_TOKEN', base58.b58encode(os.urandom(16))) def start(self, ctx=None): logger.debug("Starting webfront engine...") disabled = settings[_CONF_SECTION].get('disabled') if disabled: logger.debug("Webfront is not enabled.") return self._acquire_access_token() logger.info("Access Token: %s", self._token) self.listen_port = settings[_CONF_SECTION]['listen_port'] self.listen_addr = settings[_CONF_SECTION]['listen_addr'] self.secure_listen_port = settings[_CONF_SECTION]['secure_listen_port'] self.local_base_url = "http://127.0.0.1:%d/" % (self.listen_port, ) logger.debug("Local base URL:%s", self.local_base_url) if self.listen_port > 0: ctx.add_child_greenlet(gevent.spawn(self._run_http)) if self.secure_listen_port > 0: ctx.add_child_greenlet(gevent.spawn(self._run_https)) else: logger.debug("HTTPS listener is disabled.") ctx.bind('webfront', self) logger.debug("Webfront engine started.") def stop(self, ctx=None): logger.debug("Webfront engine stopped.") def _run_https(self): logger.debug("Webfront engine(HTTPS) is running...") conf_dir = environ.conf_dir() keyfile = os.path.join(conf_dir, 'ava.key') certfile = os.path.join(conf_dir, 'ava.crt') self._https_listener = WSGIServer( (self.listen_addr, self.secure_listen_port), dispatcher, keyfile=keyfile, certfile=certfile) logger.debug("Webfront engine(HTTPS) is listening on port: %d", self._https_listener.address[1]) self._https_listener.serve_forever() def _run_http(self): logger.debug("Webfront engine(HTTP) is running...") self._http_listener = WSGIServer((self.listen_addr, self.listen_port), dispatcher) logger.debug("Webfront engine(HTTP) is listening on port: %d", self._http_listener.address[1]) self._http_listener.serve_forever()
raise ValueError('User agent must be set to adhere to metno ToS: https://api.met.no/doc/TermsOfService') content, headers = _fetch_content_and_headers(path, query, headers={ 'User-Agent': USER_AGENT }) content = create_standard_json_from_metno(content, days) else: # WWO tweaks query_string += "&extra=localObsTime" query_string += "&includelocation=yes" content, headers = _fetch_content_and_headers(path, query_string) content = add_translations(content, lang) return content, 200, headers if __name__ == "__main__": #app.run(host='0.0.0.0', port=5001, debug=False) #app.debug = True if len(sys.argv) == 1: bind_addr = "0.0.0.0" SERVER = WSGIServer((bind_addr, PROXY_PORT), APP) SERVER.serve_forever() else: print('running single request from command line arg') APP.testing = True with APP.test_client() as c: resp = c.get(sys.argv[1]) print('Status: ' + resp.status) # print('Headers: ' + dumps(resp.headers)) print(resp.data.decode('utf-8'))
class PsDashRunner(object): DEFAULT_LOG_INTERVAL = 60 DEFAULT_NET_IO_COUNTER_INTERVAL = 3 DEFAULT_REGISTER_INTERVAL = 60 DEFAULT_BIND_HOST = "0.0.0.0" DEFAULT_PORT = 5000 LOCAL_NODE = "localhost" @classmethod def create_from_cli_args(cls): return cls(args=None) def __init__(self, config_overrides=None, args=tuple()): self._nodes = {} config = self._load_args_config(args) if config_overrides: config.update(config_overrides) self.app = self._create_app(config) self._setup_nodes() self._setup_logging() self._setup_context() def _get_args(cls, args): parser = argparse.ArgumentParser( description="psdash %s - system information web dashboard" % __version__) parser.add_argument( "-l", "--log", action="append", dest="logs", default=None, metavar="path", help= "log files to make available for psdash. Patterns (e.g. /var/log/**/*.log) are supported. " "This option can be used multiple times.", ) parser.add_argument( "-b", "--bind", action="store", dest="bind_host", default=None, metavar="host", help="host to bind to. Defaults to 0.0.0.0 (all interfaces).", ) parser.add_argument( "-p", "--port", action="store", type=int, dest="port", default=None, metavar="port", help="port to listen on. Defaults to 5000.", ) parser.add_argument( "-d", "--debug", action="store_true", dest="debug", help="enables debug mode.", ) parser.add_argument( "-a", "--agent", action="store_true", dest="agent", help= "Enables agent mode. This launches a RPC server, using zerorpc, on given bind host and port.", ) parser.add_argument( "--register-to", action="store", dest="register_to", default=None, metavar="host:port", help= "The psdash node running in web mode to register this agent to on start up. e.g 10.0.1.22:5000", ) parser.add_argument( "--register-as", action="store", dest="register_as", default=None, metavar="name", help= "The name to register as. (This will default to the node's hostname)", ) return parser.parse_args(args) def _load_args_config(self, args): config = {} for k, v in vars(self._get_args(args)).items(): if v: key = "PSDASH_%s" % k.upper() if k != "debug" else "DEBUG" config[key] = v return config def _setup_nodes(self): self.add_node(LocalNode()) nodes = self.app.config.get("PSDASH_NODES", []) logger.info("Registering %d nodes", len(nodes)) for n in nodes: self.register_node(n["name"], n["host"], int(n["port"])) def add_node(self, node): self._nodes[node.get_id()] = node def get_local_node(self): return self._nodes.get(self.LOCAL_NODE) def get_node(self, name): return self._nodes.get(name) def get_nodes(self): return self._nodes def register_node(self, name, host, port): n = RemoteNode(name, host, port) node = self.get_node(n.get_id()) if node: n = node logger.debug("Updating registered node %s", n.get_id()) else: logger.info("Registering %s", n.get_id()) n.update_last_registered() self.add_node(n) return n def _create_app(self, config=None): app = Flask(__name__) app.psdash = self app.config.from_envvar("PSDASH_CONFIG", silent=True) if config and isinstance(config, dict): app.config.update(config) self._load_allowed_remote_addresses(app) # If the secret key is not read from the config just set it to something. if not app.secret_key: app.secret_key = "whatisthissourcery" app.add_template_filter(fromtimestamp) from psdash.web import webapp prefix = app.config.get("PSDASH_URL_PREFIX") if prefix: prefix = "/" + prefix.strip("/") webapp.url_prefix = prefix app.register_blueprint(webapp) return app def _load_allowed_remote_addresses(self, app): key = "PSDASH_ALLOWED_REMOTE_ADDRESSES" addrs = app.config.get(key) if not addrs: return if isinstance(addrs, str): app.config[key] = [a.strip() for a in addrs.split(",")] def _setup_logging(self): level = (self.app.config.get("PSDASH_LOG_LEVEL", logging.INFO) if not self.app.debug else logging.DEBUG) format = self.app.config.get("PSDASH_LOG_FORMAT", "%(levelname)s | %(name)s | %(message)s") logging.basicConfig(level=level, format=format) logging.getLogger("werkzeug").setLevel( logging.WARNING if not self.app.debug else logging.DEBUG) def _setup_workers(self): net_io_interval = self.app.config.get( "PSDASH_NET_IO_COUNTER_INTERVAL", self.DEFAULT_NET_IO_COUNTER_INTERVAL, ) gevent.spawn_later(net_io_interval, self._net_io_counters_worker, net_io_interval) if "PSDASH_LOGS" in self.app.config: logs_interval = self.app.config.get("PSDASH_LOGS_INTERVAL", self.DEFAULT_LOG_INTERVAL) gevent.spawn_later(logs_interval, self._logs_worker, logs_interval) if self.app.config.get("PSDASH_AGENT"): register_interval = self.app.config.get( "PSDASH_REGISTER_INTERVAL", self.DEFAULT_REGISTER_INTERVAL) gevent.spawn_later( register_interval, self._register_agent_worker, register_interval, ) def _setup_locale(self): # This set locale to the user default (usually controlled by the LANG env var) locale.setlocale(locale.LC_ALL, "") def _setup_context(self): self.get_local_node().net_io_counters.update() if "PSDASH_LOGS" in self.app.config: self.get_local_node().logs.add_patterns( self.app.config["PSDASH_LOGS"]) def _logs_worker(self, sleep_interval): while True: logger.debug("Reloading logs...") self.get_local_node().logs.add_patterns( self.app.config["PSDASH_LOGS"]) gevent.sleep(sleep_interval) def _register_agent_worker(self, sleep_interval): while True: logger.debug("Registering agent...") self._register_agent() gevent.sleep(sleep_interval) def _net_io_counters_worker(self, sleep_interval): while True: logger.debug("Updating net io counters...") self.get_local_node().net_io_counters.update() gevent.sleep(sleep_interval) def _register_agent(self): register_name = self.app.config.get("PSDASH_REGISTER_AS") if not register_name: register_name = socket.gethostname() url_args = { "name": register_name, "port": self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT), } register_url = "%s/register?%s" % ( self.app.config["PSDASH_REGISTER_TO"], urllib.parse.urlencode(url_args), ) if ("PSDASH_AUTH_USERNAME" in self.app.config and "PSDASH_AUTH_PASSWORD" in self.app.config): auth_handler = urllib.request.HTTPBasicAuthHandler() auth_handler.add_password( realm="psDash login required", uri=register_url, user=self.app.config["PSDASH_AUTH_USERNAME"], passwd=self.app.config["PSDASH_AUTH_PASSWORD"], ) opener = urllib.request.build_opener(auth_handler) urllib.request.install_opener(opener) try: urllib.request.urlopen(register_url) except urllib.error.HTTPError as e: logger.error('Failed to register agent to "%s": %s', register_url, e) def _run_rpc(self): logger.info("Starting RPC server (agent mode)") if "PSDASH_REGISTER_TO" in self.app.config: self._register_agent() service = self.get_local_node().get_service() self.server = zerorpc.Server(service) self.server.bind("tcp://%s:%s" % ( self.app.config.get("PSDASH_BIND_HOST", self.DEFAULT_BIND_HOST), self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT), )) self.server.run() def _run_web(self): logger.info("Starting web server") log = "default" if self.app.debug else None ssl_args = {} if self.app.config.get("PSDASH_HTTPS_KEYFILE") and self.app.config.get( "PSDASH_HTTPS_CERTFILE"): ssl_args = { "keyfile": self.app.config.get("PSDASH_HTTPS_KEYFILE"), "certfile": self.app.config.get("PSDASH_HTTPS_CERTFILE"), } listen_to = ( self.app.config.get("PSDASH_BIND_HOST", self.DEFAULT_BIND_HOST), self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT), ) self.server = WSGIServer(listen_to, application=self.app, log=log, **ssl_args) self.server.serve_forever() def run(self): logger.info("Starting psdash v%s" % __version__) self._setup_locale() self._setup_workers() logger.info( "Listening on %s:%s", self.app.config.get("PSDASH_BIND_HOST", self.DEFAULT_BIND_HOST), self.app.config.get("PSDASH_PORT", self.DEFAULT_PORT), ) if self.app.config.get("PSDASH_AGENT"): return self._run_rpc() else: return self._run_web()
def spawn(host: Tuple[str, int]): global _standalone server = WSGIServer(host, _standalone, log=None, error_log=None) _ping() server.serve_forever()