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 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 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 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 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()
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 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_server(input_channels, cors, auth_token, port, initial_agent, enable_api=True): """Run the agent.""" if enable_api: app = server.create_app(initial_agent, cors_origins=cors, auth_token=auth_token) else: app = Flask(__name__) CORS(app, resources={r"/*": {"origins": cors or ""}}) if input_channels: rasa_core.channels.channel.register(input_channels, app, initial_agent.handle_message, route="/webhooks/") if logger.isEnabledFor(logging.DEBUG): utils.list_routes(app) http_server = WSGIServer(('0.0.0.0', port), app) logger.info("Rasa Core server is up and running on " "{}".format(constants.DEFAULT_SERVER_URL)) http_server.start() return http_server
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(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_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
class WebServiceInterface(Interface): http_port = 80 def __init__(self, *args, **kwargs): super(WebServiceInterface, self).__init__(*args, **kwargs) self.wsgi_server = None def on_start(self): super(WebServiceInterface, self).on_start() self.http_socket = create_socket('fd://%s' % self.container.get_shared_socket_fd(self.http_port)) self.wsgi_server = WSGIServer(self.http_socket, Request.application(self.dispatch_request)) self.wsgi_server.start() def on_stop(self): self.wsgi_server.stop() super(WebServiceInterface, self).on_stop() def dispatch_request(self, request): trace.set_id() urls = self.url_map.bind_to_environ(request.environ) request.urls = urls try: endpoint, args = urls.match() if callable(endpoint): handler = endpoint(self, request) response = handler.dispatch(args) else: try: handler = getattr(self, endpoint) except AttributeError: raise # FIXME response = handler(request, **args) except HTTPException as e: response = e.get_response(request.environ) return response
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 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 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 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()
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 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 make_server(config, listener, app): """Make a Gevent server for WSGI apps.""" max_concurrency = int(config.get("max_concurrency", 0)) or None stop_timeout = int(config.get("stop_timeout", 0)) handler = config.get("handler", None) pool = Pool(size=max_concurrency) log = LoggingLogAdapter(logger, level=logging.DEBUG) kwargs = {} if gevent.version_info[:2] >= (1, 1): # error_log is new in 1.1 kwargs["error_log"] = LoggingLogAdapter(logger, level=logging.ERROR) if handler: kwargs["handler_class"] = _load_factory(handler, default_name=None) # pylint: disable=star-args server = WSGIServer( listener, application=app, spawn=pool, log=log, **kwargs ) server.stop_timeout = stop_timeout return server
def main(): loglevel = 'INFO' datefmt = '%b %d %H:%M:%S' logformat = '%(asctime)s %(levelname)s pysms: %(message)s' logging.basicConfig(level=loglevel, stream=sys.stdout, format=logformat, datefmt=datefmt) application = web.application(urls, globals()).wsgifunc() server = WSGIServer(('', 8088), application) signal(SIGTERM, exit, arping, server=server) signal(SIGQUIT, exit, arping, server=server) signal(SIGINT, exit, arping, server=server) print "Starting message dispatcher" dispatcher.start() print "Starting arping monitor" arping.start() print 'Serving on 8088...' server.start() while True: try: gevent.sleep(0) except KeyboardInterrupt: # Switch to main thread, to quit gracefully gevent.hub.get_hub().switch() exit(arping, server)
def start_http_server(self): try: sock = StreamServer.get_listener((SandeshHttp._HTTP_SERVER_IP, self._http_port), family=socket.AF_INET) except socket.error as e: self._logger.error('Unable to open HTTP Port %d, %s' % (self._http_port, e)) sys.exit() else: self._http_port = sock.getsockname()[1] self._sandesh.record_port("http", self._http_port) self._logger.error('Starting Introspect on HTTP Port %d' % self._http_port) if self._sandesh_config and \ self._sandesh_config.introspect_ssl_enable: ca_certs=self._sandesh_config.ca_cert keyfile=self._sandesh_config.keyfile certfile=self._sandesh_config.certfile self._http_server = WSGIServer(sock, self._http_app, ca_certs=ca_certs, keyfile=keyfile, certfile=certfile, ssl_version=ssl.PROTOCOL_TLSv1, cert_reqs=ssl.CERT_REQUIRED, log=self._std_log) else: self._http_server = WSGIServer(sock, self._http_app, log=self._std_log) self._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 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 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()
from __future__ import print_function from gevent.pywsgi import WSGIServer def application(env, start_response): if env['PATH_INFO'] == '/new_content': start_response('200 OK', [('Content-Type', 'application/json')]) return [b'''ok'''] else: start_response('404 Not Found', [('Content-Type', 'text/html')]) return [b'<h1>Not Found</h1>'] if __name__ == '__main__': print('Serving on 8088...') WSGIServer(('', 8088), application).serve_forever()
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str, hydradoc: str, port: int, serverurl: str, token: bool, serve: None) -> None: """ Python Hydrus CLI :param openapi: : Sets the link to the Open Api Doc file. :param adduser <tuple> : Contains the user credentials. :param api <str> : Sets the API name for the server. :param auth <bool> : Toggles the authentication. :param dburl <str> : Sets the database URL. :param hydradoc <str> : Sets the link to the HydraDoc file (Supported formats - [.py, .jsonld, .yaml]) :param port <int> : Sets the API server port. :param serverurl <str> : Sets the API server url. :param token <bool> : Toggle token based user auth. :param serve : Starts up the server. :return : None. Raises: Error: If `hydradoc` is not of a supported format[.py, .jsonld, .yaml]. """ # The database connection URL # See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html for more info # DB_URL = 'sqlite:///database.db' DB_URL = dburl # Define the server URL, this is what will be displayed on the Doc HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port)) # The name of the API or the EntryPoint, the api will be at # http://localhost/<API_NAME> API_NAME = api click.echo("Setting up the database") # Create a connection to the database you want to use engine = create_engine(DB_URL) click.echo("Creating models") # Add the required Models to the database Base.metadata.create_all(engine) # Define the Hydra API Documentation # NOTE: You can use your own API Documentation and create a HydraDoc object # using doc_maker or you may create your own HydraDoc Documentation using # doc_writer [see hydra_python_core/doc_writer_sample] click.echo("Creating the API Documentation") if hydradoc: # Getting hydradoc format # Currently supported formats [.jsonld, .py, .yaml] try: hydradoc_format = hydradoc.split(".")[-1] if hydradoc_format == 'jsonld': with open(hydradoc, 'r') as f: doc = json.load(f) elif hydradoc_format == 'py': doc = SourceFileLoader("doc", "./examples/drones/doc.py")\ .load_module().doc elif hydradoc_format == 'yaml': with open(hydradoc, 'r') as stream: doc = parse(yaml.load(stream)) else: raise("Error - hydradoc format not supported.") click.echo("Using %s as hydradoc" % hydradoc) apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME) except BaseException: click.echo("Problem parsing specified hydradoc file, " "using sample hydradoc as default.") apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL, API_NAME) else: click.echo("No hydradoc specified, using sample hydradoc as default.") apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL, API_NAME) # Start a session with the DB and create all classes needed by the APIDoc session = scoped_session(sessionmaker(bind=engine)) click.echo("Adding Classes and Properties") # Get all the classes from the doc # You can also pass dictionary defined in # hydra_python_core/doc_writer_sample_output.py classes = doc_parse.get_classes(apidoc.generate()) # Get all the properties from the classes properties = doc_parse.get_all_properties(classes) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) click.echo("Adding authorized users") add_user(id_=adduser[0], paraphrase=adduser[1], session=session) # Insert them into the database doc_parse.insert_classes(classes, session) doc_parse.insert_properties(properties, session) click.echo("Creating the application") # Create a Hydrus app with the API name you want, default will be "api" app = app_factory(API_NAME) # Set the name of the API click.echo("Starting the application") with set_authentication(app, auth): # Use authentication for all requests with set_token(app, token): with set_api_name(app, api): # Set the API Documentation with set_doc(app, apidoc): # Set HYDRUS_SERVER_URL with set_hydrus_server_url(app, HYDRUS_SERVER_URL): # Set the Database session with set_session(app, session): # Start the Hydrus app http_server = WSGIServer(('', port), app) click.echo("Server running at:") click.echo( "{}{}".format( HYDRUS_SERVER_URL, API_NAME)) try: http_server.serve_forever() except KeyboardInterrupt: pass
@app.route('/test/', methods=['GET']) def test(): return 'hello test' @app.route('/test/websocket/page/') def test_websocket_page(): return render_template('test_websocket.html') @sockets.route('/test/websocket/') def test_websocket(ws): data = None while not ws.closed: todo_list, count = get_todo_list() if not data == todo_list: data = todo_list send_data = {'data': data, 'count': count} ws.send(json.dumps(send_data)) if __name__ == "__main__": # app.run() http_server = WSGIServer(('', 5000), app, handler_class=WebSocketHandler) http_server.serve_forever()
from gevent import monkey monkey.patch_all() import os import sys from scout.server import parse_options # Create WSGI app using command-line options. app = parse_options() if __name__ == '__main__': # Serve app using gevent WSGI server. from gevent.pool import Pool from gevent.pywsgi import WSGIServer MAX_CONNECTIONS = int(os.environ.get('SCOUT_MAX_CONNECTIONS') or 128) pool = Pool(MAX_CONNECTIONS) try: (WSGIServer((app.config['HOST'], app.config['PORT']), app, spawn=pool).serve_forever()) except KeyboardInterrupt: app.logger.info('Shutting down!') sys.exit(0)
client = MongoClient(dburl) db = client.get_default_database() members = db.members data = [] for mem in members.find(): data.append(mem) data = sorted(data, key=lambda k: k['totalCommits']) return data[::-1] app = Flask(__name__, static_url_path='/static') @app.route("/") def index(): content = getContent() total = sum([x['totalCommits'] for x in content]) return render_template('index.html', context=content, totalC=total) if __name__ == '__main__': port = int(os.environ.get('PORT', 5000)) http_server = WSGIServer(('', port), app) http_server.serve_forever()
def main(): http_server = WSGIServer(('0.0.0.0', 5000), app) print("Serving at 0.0.0.0:5000") http_server.serve_forever()
def _run_gevent(app, config, mode): """Run WsgiDAV using gevent if gevent is installed. See https://github.com/gevent/gevent/blob/master/src/gevent/pywsgi.py#L1356 https://github.com/gevent/gevent/blob/master/src/gevent/server.py#L38 for more options """ import gevent import gevent.monkey gevent.monkey.patch_all() from gevent.pywsgi import WSGIServer server_args = { "bind_addr": (config["host"], config["port"]), "wsgi_app": app } server_name = "WsgiDAV/{} gevent/{} Python/{}".format( __version__, gevent.__version__, util.PYTHON_VERSION) # Support SSL ssl_certificate = _get_checked_path(config.get("ssl_certificate"), config) ssl_private_key = _get_checked_path(config.get("ssl_private_key"), config) ssl_certificate_chain = _get_checked_path( config.get("ssl_certificate_chain"), config) # Override or add custom args server_args.update(config.get("server_args", {})) protocol = "http" if ssl_certificate: assert ssl_private_key protocol = "https" _logger.info("SSL / HTTPS enabled.") dav_server = WSGIServer( server_args["bind_addr"], app, keyfile=ssl_private_key, certfile=ssl_certificate, ca_certs=ssl_certificate_chain, ) else: dav_server = WSGIServer(server_args["bind_addr"], app) # If the caller passed a startup event, monkey patch the server to set it # when the request handler loop is entered startup_event = config.get("startup_event") if startup_event: def _patched_start(): dav_server.start_accepting = org_start # undo the monkey patch org_start() _logger.info("gevent is ready") startup_event.set() org_start = dav_server.start_accepting dav_server.start_accepting = _patched_start _logger.info("Running {}".format(server_name)) _logger.info("Serving on {}://{}:{} ...".format(protocol, config["host"], config["port"])) try: gevent.spawn(dav_server.serve_forever()) except KeyboardInterrupt: _logger.warning("Caught Ctrl-C, shutting down...") return
response = None while attempts: try: response = requests.get(url, timeout=2) except requests.ReadTimeout: attempts -= 1 continue try: json.loads(response.content) break except ValueError: attempts -= 1 _touch_empty_file(path, query_string, content, headers) if response: headers = {} headers['Content-Type'] = response.headers['content-type'] _save_content_and_headers(path, query_string, response.content, headers) content = add_translations(response.content, lang) else: content = "{}" return content, 200, headers if __name__ == "__main__": #app.run(host='0.0.0.0', port=5001, debug=False) #app.debug = True bind_addr = "0.0.0.0" SERVER = WSGIServer((bind_addr, PROXY_PORT), APP) SERVER.serve_forever()
def run(self): http_server = WSGIServer(('0.0.0.0', 8080), app) http_server.serve_forever()
active_room.subscribe(user) print('subscribe', active_room, user) messages = active_room.backlog() return render_template('room.html', room=room, uid=uid, messages=messages) @app.route("/put/<room>/<uid>", methods=["POST"]) def put(room, uid): user = users[uid] room = rooms[room] message = request.form['message'] room.add(':'.join([uid, message])) return '' @app.route("/poll/<uid>", methods=["POST"]) def poll(uid): try: msg = users[uid].queue.get(timeout=10) except queue.Empty: msg = [] return json.dumps(msg) if __name__ == "__main__": http = WSGIServer(('', 5000), app) http.serve_forever()
if topic is None: topic = ":firstpage" if topic.startswith(':shell-x/'): return _proxy() #return requests.get('http://127.0.0.1:3000'+topic[8:]).text ip_address = get_request_ip(request) if '+' in topic: not_allowed = LIMITS.check_ip(ip_address) if not_allowed: return "429 %s\n" % not_allowed, 429 html_is_needed = is_html_needed( user_agent) and not is_result_a_script(topic) result, found = cheat_wrapper(topic, request_options=options, html=html_is_needed) if 'Please come back in several hours' in result and html_is_needed: return MALFORMED_RESPONSE_HTML_PAGE log_query(ip_address, found, topic, user_agent) if html_is_needed: return result return Response(result, mimetype='text/plain') SRV = WSGIServer((SERVER_ADDRESS, SERVER_PORT), app) # log=None) SRV.serve_forever()
from gevent.pywsgi import WSGIServer from flask_app.app import app # As flask is not a production suitable server, we use will # a WSGIServer instance to serve our flask application. if __name__ == '__main__': WSGIServer(('0.0.0.0', 8000), app).serve_forever()
finally: if config.chmod(): os.chmod(filename, config.chmod()) os.chown(filename, config.owner_id(), config.group_id()) print >> sys.stderr, 'Closing websocket' wsock.close() end_time = time.time() print >> sys.stderr, 'Took %.3f seconds' % (end_time - start_time) with open(filename, 'rb') as f: print >> sys.stderr, hashlib.md5(f.read()).hexdigest() @app.error(404) def error404(error): return '<h1>404 Error</h1>' # Monkey patch geventwebsocket.websocket.Header.mask_payload() and # geventwebsocket.websocket.Header.unmask_payload(), for efficiency Header.mask_payload = util.mask_payload_fast Header.unmask_payload = util.mask_payload_fast if __name__ == '__main__': if len(sys.argv) == 3: hostname = sys.argv[1] port = int(sys.argv[2]) else: hostname, port = ('localhost', 8080) server = WSGIServer((hostname, port), app, handler_class=util.UploadHandler) print >> sys.stderr, 'Listening on %s:%d' % (hostname, port) server.serve_forever()
def run(self): # Set absolute plugin path plugins_abs = os.path.abspath(os.path.join(filename.get_dirname_file(), self.config_parser.get(u'plugin directives', u'plugin_path'))) self.config_parser.set(u'plugin directives', u'plugin_path', plugins_abs) # Check if there is a start delay try: delay_start = self.config_parser.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 # Handle DB maintenance self.db.run_db_maintenance(self.config_parser) try: try: address = self.config_parser.get('listener', 'ip') except Exception: self.config_parser.set('listener', 'ip', '::') address = '::' try: port = self.config_parser.getint('listener', 'port') except Exception: self.config_parser.set('listener', 'port', 5693) port = 5693 listener.server.listener.config['iconfig'] = self.config_parser user_cert = self.config_parser.get('listener', 'certificate') ssl_str_version = self.config_parser.get('listener', 'ssl_version') try: ssl_str_ciphers = self.config_parser.get('listener', 'ssl_ciphers') except Exception: ssl_str_ciphers = None try: ssl_version = getattr(ssl, 'PROTOCOL_' + ssl_str_version) except: ssl_version = getattr(ssl, 'PROTOCOL_TLSv1') ssl_str_version = 'TLSv1' logging.info('Using SSL version %s', ssl_str_version) if user_cert == 'adhoc': basepath = filename.get_dirname_file() 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, e: logging.exception(e)
class SandeshHttp(object): _HTTP_SERVER_IP = '0.0.0.0' _http_response = None _http_response_context = None _logger = None WebFilesList = [ '/css/bootstrap.min.css', '/css/DT_bootstrap.css', '/css/images/sort_asc.png', '/css/images/sort_asc_disabled.png', '/css/images/sort_both.png', '/css/images/sort_desc.png', '/css/images/sort_desc_disabled.png', '/css/style.css', '/js/bootstrap.min.js', '/js/DT_bootstrap.js', '/js/jquery-2.0.3.min.js', '/js/jquery.dataTables.min.js', '/js/util.js', '/universal_parse.xsl' ] def __init__(self, sandesh, module, port, pkg_list): self._sandesh = sandesh self._logger = sandesh.logger() self._module = module self._http_port = port self._http_request_dict = {} self._http_app = bottle.Bottle() self._create_homepage(pkg_list) # Register the homepage self._http_app.route('/', 'GET', self._get_homepage) self._http_app.route('/index.html', 'GET', self._get_homepage) self._http_app.route('/<link:re:\w+.xml>', 'GET', self._get_indexpage) # Get the path of universal_parse.xsl and jquery and register the same self._webfiles_path = None self._universal_parse_xsl_path = None self._jquery_collapse_storage_js_path = None self._jquery_collapse_js_path = None self._jquery_1_8_1_js_path = None self._http_server = None try: imp_pysandesh = __import__('pysandesh') except ImportError: self._logger.error('Failed to import "pysandesh"') else: self._webfiles_path = imp_pysandesh.__path__[0] self._universal_parse_xsl_path = imp_pysandesh.__path__[0] self._jquery_collapse_storage_js_path = imp_pysandesh.__path__[0] self._jquery_collapse_js_path = imp_pysandesh.__path__[0] self._jquery_1_8_1_js_path = imp_pysandesh.__path__[0] for elem in SandeshHttp.WebFilesList: #import pdb; pdb.set_trace() self._http_app.route(elem, 'GET', self._get_webfiles) #end __init__ def stop_http_server(self): if self._http_server: self._http_server.stop() self._http_server = None self._logger.error('Stopped http server') # end stop_http_server def start_http_server(self): try: sock = StreamServer.get_listener( (SandeshHttp._HTTP_SERVER_IP, self._http_port), family=socket.AF_INET) except socket.error as e: self._logger.error('Unable to open HTTP Port %d, %s' % (self._http_port, e)) sys.exit() else: self._http_port = sock.getsockname()[1] self._sandesh.record_port("http", self._http_port) self._logger.error('Starting Introspect on HTTP Port %d' % self._http_port) self._http_server = WSGIServer(sock, self._http_app) self._http_server.serve_forever() # end start_http_server def get_port(self): return self._http_port #end get_port @staticmethod def http_error(err_msg): return '<h3>%s</h3>' % (err_msg) #end http_error @staticmethod def create_http_response(sandesh_resp, sandesh_init): universal_xsl_str = '<?xml-stylesheet type="text/xsl" href="/universal_parse.xsl"?>' transport = TTransport.TMemoryBuffer() protocol_factory = TXMLProtocol.TXMLProtocolFactory() protocol = protocol_factory.getProtocol(transport) if sandesh_resp.write(protocol) < 0: sandesh_init.logger().error( 'Http Response: Failed to encode sandesh (%s)', sandesh_resp.__class__.__name__) return sandesh_resp_xml = transport.getvalue() if not SandeshHttp._http_response: SandeshHttp._state = 'HXMLNew' SandeshHttp._http_response = cStringIO.StringIO() SandeshHttp._http_response.write(universal_xsl_str) if sandesh_resp._more: sandesh_name_end = sandesh_resp_xml.find(' ') if sandesh_name_end == -1: sandesh_init.logger().error( 'Http Response: Failed to get Sandesh name (%s)', sandesh_resp.__class__.__name__) return SandeshHttp._http_response_context = sandesh_resp_xml[ 1:sandesh_name_end] SandeshHttp._http_response.write( '<__%s_list type="slist">' % (SandeshHttp._http_response_context)) SandeshHttp._state = 'HXMLIncomplete' SandeshHttp._http_response.write(sandesh_resp_xml) if not sandesh_resp._more and SandeshHttp._state != 'HXMLNew': SandeshHttp._http_response.write( '</__%s_list>' % (SandeshHttp._http_response_context)) #end create_http_response @staticmethod def get_http_response(): if SandeshHttp._http_response: bottle.response.headers['Content-Type'] = 'text/xsl' resp = SandeshHttp._http_response.getvalue() SandeshHttp._http_response.close() SandeshHttp._http_response = None SandeshHttp._http_response_context = None return resp return None #end get_http_response def _get_homepage(self): bottle.response.headers['Content-Type'] = 'text/html' return self._homepage #end _get_homepage def _get_indexpage(self, link): try: path = self._homepage_links[link] except KeyError: return self.http_error('Invalid Sandesh Request "%s"' % (link)) else: return bottle.static_file(link, root=path) #end _get_indexpage def _get_webfiles(self): terms = bottle.request.url.rsplit('/', 1) fname = "/" + terms[1] upath = terms[0].split('//', 1)[-1] pterms = upath.split('/', 1) if len(pterms) == 1: fpath = self._webfiles_path + '/webs' else: fpath = self._webfiles_path + '/webs/' + pterms[1] #import pdb; pdb.set_trace() return bottle.static_file(fname, root=fpath) #end _get_webfiles def _create_homepage(self, pkg_list): self._homepage_links = {} for pkg_name in pkg_list: self._extract_http_requests(pkg_name) homepage_str = cStringIO.StringIO() homepage_str.write( "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" + " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" + "<html xmlns=\"http://www.w3.org/1999/xhtml\">" + "<head>" + "<link href=\"css/style.css\" rel=\"stylesheet\" type=\"text/css\"/>" + ("<title>%s</title></head><body>" % self._module)) homepage_str.write('<h1>Modules for %s</h1>' % (self._module)) for link in self._homepage_links.iterkeys(): http_link = '<a href="%s">%s</a><br/>' % (link, link[:link.find('.')]) homepage_str.write(http_link) self._homepage = homepage_str.getvalue() homepage_str.close() #end _create_homepage def _extract_http_requests(self, package): try: imp_pkg = __import__(package) except ImportError: self._logger.error('Failed to import package "%s"' % (package)) else: try: pkg_path = imp_pkg.__path__ except AttributeError: self._logger.error('Failed to get package [%s] path' % (package)) return for importer, mod, ispkg in \ pkgutil.walk_packages(path=pkg_path, prefix=imp_pkg.__name__+'.'): if not ispkg: if 'http_request' == mod.rsplit('.', 1)[-1]: self._add_http_request_links(pkg_path[0], mod) #end _extract_http_requests def _add_http_request_links(self, pkg_path, mod): try: http_module = importlib.import_module(mod) except ImportError: self._logger.error('Failed to import Module "%s"' % (mod)) else: try: http_req_list = getattr(http_module, '_HTTP_REQUEST_LIST') except AttributeError: self._logger.error( '"%s" module does not have http request list' % (mod)) else: # Add the link to the homepage, only if the request list is non-empty if len(http_req_list): pkg = mod.rsplit('.', 1)[0] link = pkg.rsplit('.', 1)[-1] + '.xml' sub_path = pkg.split('.', 1)[-1].replace('.', '/') path = pkg_path + '/' + sub_path self._logger.debug('Add [%s:%s] to home page' % (link, path)) # TODO: Check for the existence of the html file self._homepage_links[link] = path self._register_http_requests(http_req_list) #end _add_http_request_links def _register_http_requests(self, http_req_list): for req in http_req_list: self._logger.debug('Add http request [%s]' % (req['uri'])) self._http_request_dict[req['uri']] = req['method'] self._http_app.route(req['uri'], 'GET', self._http_handle_request) #end _register_http_requests def _http_handle_request(self): # Call the handler method = self._http_request_dict[bottle.request.path] return method(self._sandesh)
import os import leancloud from gevent.pywsgi import WSGIServer from geventwebsocket.handler import WebSocketHandler from app import app from cloud import Engine from leancloud import HttpsRedirectMiddleware monkey.patch_all() APP_ID = os.environ['LC_APP_ID'] MASTER_KEY = os.environ['LC_APP_MASTER_KEY'] PORT = int(os.environ['LC_APP_PORT']) leancloud.init(APP_ID, master_key=MASTER_KEY) # app 为您的 wsgi 函数 app = HttpsRedirectMiddleware(app) engine = Engine(app) application = engine if __name__ == '__main__': # 只在本地开发环境执行的代码 app.debug = True server = WSGIServer(('localhost', PORT), application, handler_class=WebSocketHandler) server.serve_forever()
from gevent.pywsgi import WSGIServer from bottle import Bottle, request app = Bottle() @app.post('/callback/') def callback(): data = request.body.read() data = json.loads(data) print data now = int(time.time()) text = "time diff = {0}\n".format(now - data['start'] - data['seconds']) with open('callback.log', 'a') as f: f.write(text) return {'ret': 0} # return { # 'ret': 0, # 'data': { # 'callback_cmd': 'http://127.0.0.1:8000/callback/', # 'callback_data': json.dumps({'start': now, 'seconds': 2}), # 'seconds': 2, # } # } WSGIServer(('127.0.0.1', 8000), app).serve_forever()
class OctoFlowStatus(): def __init__(self): self.listener = _tcp_listener(('0.0.0.0', wsport), reuse_addr=1) self.access_log = access_log self.error_log = errors_log self.ipaddress = ipaddress self.client_address = None self.client_raddress = None self.pprocess_id = os.getpid() # parent pid self.process_id = None self.request_line = None self.http_user_agent = None self.http_host = None self.status = None self.real_ip = None self.file_size = None self.time_start = timeit.default_timer() self.time_finish = 0 self.server = None self.serverName = "OctoFlowStatus" self.redisPool = redis.ConnectionPool(host=config.redisServer, port=config.redisPort, db=config.redisDB) self.redis = redis.Redis(connection_pool=self.redisPool) self.redisSub = self.redis.pubsub() self.redisPSName = config.pubsubName self.mqServer = config.mqServer self.mqAuth = config.mqAuth self.session_name = config.sessionName self.session_domain = config.sessionDomain self.session_id = "" self.session_key = "" self.session_val = "" self.headers = "" self.session_expires = config.sessionExpires self.session_info = {} self.hostname = hostname self.request_method = "" self.environ = "" self.memdb = "" self.config = config self.txid = None self.__stop = False self.logger1 = OctoflowLogger('octoFlowRest1') self.logger2 = OctoflowLogger('octoFlowRest2') self.infoFile = '{0}/{1}-{2}.log'.format(config.statLogDir, config.statLogLevel.lower(), self.hostname) self.errorFile = '{0}/error-{1}.log'.format(config.statLogDir, self.hostname) #self.logger1.streamHandler(config.restLogLevel) self.log_info = self.logger1.timeRotateHandler( filename=self.infoFile, when="m", interval=60, backupCount=0, level=config.restLogLevel) #self.logger2.streamHandler("ERROR") self.log_error = self.logger2.timeRotateHandler( filename=self.errorFile, when="m", interval=60, backupCount=0, level="ERROR") self.adminQueue = config.adminQueue self.database = cmysql.DataBase() #self.recvConnection = pika.BlockingConnection( pika.URLParameters(self.mqServer) ) def stop(self, signum, frame): self.__stop = True def sessionCache(self, rtype, key, val="", timeout=""): if rtype == 'set': if timeout != "": self.redis.set(key, val, timeout) else: self.redis.set(key, val) elif rtype == 'get': try: return self.redis.get(key) except: return None def logWrite(self, data): self._redisPublish(data) def _redisPublish(self, data): excTime = round(timeit.default_timer() - self.time_start, 6) if self.real_ip and self.client_address: client_address = '%s => %s' % (self.real_ip, self.client_address) else: client_address = "localhost" logform = "[{0}] [{1}] [{2}] [{3}] [{4}] [{5}] [{6}] [{7}] [{8}]".format( self.txid, datetime.now(), self.hostname, self.ipaddress, self.pprocess_id, self.process_id, client_address, excTime, data, ) self.redis.publish(self.redisPSName, logform) def errorLog(self, funcName, e, data): self.error_log.write( '[{0}] [{1}] [{2}] [{3}] [{4}] [{5}] [{6}] [{7}]\n {8}\n\n'.format( self.txid, datetime.now(), self.hostname, self.ipaddress, self.pprocess_id, self.process_id, funcName, str(e), data)) def _clientAddress(self, environ): try: self.real_ip = environ['HTTP_X_FORWARDED_FOR'] except Exception as e: #self.errorLog( '_clientAddress', e, traceback.format_exc() ) self.real_ip = environ['REMOTE_ADDR'] self.client_address = environ['REMOTE_ADDR'] self.client_raddress = '%s' % (self.client_address) if self.real_ip: self.client_raddress = '%s => %s' % (self.real_ip, self.client_address) def format_request(self): delta = self.time_finish - self.time_start return '[%s] [%s] [%s] [%s] [%s] [%s] [%s] [%.6f] "%s" "%s" %s %s %s' % ( self.txid, datetime.now(), self.hostname, self.ipaddress, self.pprocess_id, os.getpid(), self.client_raddress, delta, self.request_line or '', self.http_user_agent, self.http_host, (self.status or '000').split()[0], self.file_size) def request_data(self, file=False): method_dict = {} try: if self.environ['REQUEST_METHOD'] != 'GET': if file == True: fileNum = 0 method_dict['file'] = {} method_list = cgi.FieldStorage( fp=self.environ['wsgi.input'], environ=self.environ.copy(), keep_blank_values=True) for k in method_list: item = method_list.getvalue(k) if isinstance(item, list): method_dict[self.request_method][ k] = method_list.getlist(k) elif method_list[k].filename != None: method_dict['file'][fileNum] = { 'filename': method_list[k].filename, 'value': method_list[k].value } fileNum = fileNum + 1 else: method_dict[k] = method_list[k].value else: method_dict = json.loads(self.environ['wsgi.input'].read()) elif self.environ['REQUEST_METHOD'] == 'GET': if self.environ['QUERY_STRING']: d = cgi.parse_qs(self.environ['QUERY_STRING']) for x in d: method_dict[x] = cgi.escape(d[x][0]) except Exception as e: self.errorLog('request_data', e, traceback.format_exc()) finally: return method_dict def header(self, key=None, val=None): if key.lower() == 'length': key = 'Content-Length' val = str(len(val)) self.headers.append((key, val)) def _mimetypes(self, file): return mimetypes.guess_type(file)[0] def session_register(self, userUid, environ): self.session_val = "" expiration = datetime.now() + timedelta(seconds=self.session_expires) sesssion_expires = expiration.strftime("%a, %d-%b-%Y %H:%M:%S GMT") session_lst = [self.session_name, 'KEY_VAL', 'KEY_DTA', 'KEY_HDA'] session_dic = {} for x in session_lst: session_key = hashlib.sha256('{0}{1}'.format( userUid, datetime.now().strftime( "%Y-%m-%d %H:%M:%S%f").encode()).encode()).hexdigest() """ if self._session_name == 'BITINUS_DEVELOPE': session_dic[x] = {'name': x, 'key': session_key, 'val': "{0}={1}; Expires={2}; Max-age={3};".format(x, session_key, sesssion_expires, self.session_expires ) } """ session_dic[x] = { 'name': x, 'key': session_key, 'val': "{0}={1}; Expires={2}; Max-age={3}; Domain={4}; path=/; Secure; HttpOnly;" .format(x, session_key, sesssion_expires, self.session_expires, self.session_domain) } expires_time = self.session_expires etag = hashlib.sha224(datetime.now().strftime( "%Y-%m-%d %H:%M:%S%f").encode()).hexdigest() session_key = None session_data = {} sd = session_dic for x in sd: self.header('Set-Cookie', sd[x]['val']) if sd[x]['name'] == self.session_name: session_key = sd[x]['key'] else: session_data[sd[x]['name']] = sd[x]['key'] self.header('Pragma', 'no-cache') self.header('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate') self.header('Expires', '-1') self.header('Server', 'OctoFlowStatus Server ') self.header('Expt', str(expires_time)) self.header('ETag', etag) session_data['USER_UID'] = userUid session_data['HTTP_USER_AGENT'] = environ['HTTP_USER_AGENT'] # return session_dic self.redisConnect('set', session_key, str(session_data), expires_time) def session_delete(self, environ): session_dict = {} session_lst = [self.session_name, 'KEY_VAL', 'KEY_DTA', 'KEY_HDA'] try: d = {} sess = environ['HTTP_COOKIE'].split(';') for x in sess: k, y = x.split('=') d[k.strip()] = y.strip() self.redis.delete(d[self.session_name]) expiration = datetime.now() + timedelta(seconds=0) sesssion_expires = expiration.strftime("%a, %d-%b-%Y %H:%M:%S GMT") for x in session_lst: session_dict[ x] = "{0}={1}; Expires={2}; Max-age={3}; Domain={4}; path=/; Secure; HttpOnly;".format( x, 'delete', sesssion_expires, 0, self.session_domain) except KeyError: pass except Exception as e: self.errorLog('session_delete', e, traceback.format_exc()) finally: return session_dict # CM : session clear # DT : 2019-02-09 14:45 # WT : [email protected] def session_clear(self, environ): sd = self.session_delete(environ) for x in sd: self.header('Set-Cookie', sd[x]) self.header('Pragma', 'no-cache') self.header('Cache-Control', 'no-cache, no-store, max-age=0, must-revalidate') self.header('Expires', '-1') self.header('Server', 'Pinotnoir Server ') def session_check(self, environ): d = {} rst = False try: sess = environ['HTTP_COOKIE'].split(';') for x in sess: k, y = x.split('=') d[k.strip()] = y.strip() redis_key = d[self.session_name] key_validity = d['KEY_VAL'] key_dta = d['KEY_DTA'] key_hda = d['KEY_HDA'] agent = environ['HTTP_USER_AGENT'] r = self.redisConnect('get', redis_key) if r != None: r = eval(r) # and r['HTTP_USER_AGENT'] == agent: if r['KEY_VAL'] == key_validity and r[ 'KEY_DTA'] == key_dta and r['KEY_HDA'] == key_hda: user_get = self.redisConnect('get', r['USER_UID']) if user_get != None: user_get = eval(user_get) self.session_info = user_get rst = True else: rst = False else: rst = False else: rst = False except KeyError: pass except Exception as e: self.errorLog('session_check', e, traceback.format_exc()) rst = False finally: return rst def routing(self, environ, start_response): pathinfo = environ["PATH_INFO"] self.request_method = environ["REQUEST_METHOD"] try: rm = router.router[pathinfo]['MEHTOD'] mo = router.router[pathinfo]['MODULE'] fu = router.router[pathinfo]['FUNCTION'] ss = router.router[pathinfo]['SESSION'] if rm.upper() == self.request_method.upper(): # mehtod check if ss == True: # session check if self.session_check(environ) == True: mod = __import__(mo, fromlist=[mo]) data = getattr(mod, fu)(self, environ, start_response) else: start_response( '555 OK', [('Content-Type', 'text/html'), ('Content-Length', str(len('Auth Error')))]) data = bytes( '{0} : {1}'.format(environ["PATH_INFO"], 'Auth Error'), 'utf-8') self.status = "209" self.file_size = len(data) elif ss == False: mod = __import__(mo, fromlist=[mo]) data = getattr(mod, fu)(self, environ, start_response) else: # session no check start_response('555 OK', [('Content-Type', 'text/html'), ('Content-Length', str(len('METHOD DENY')))]) data = bytes( '{0} : {1}'.format(environ["PATH_INFO"], 'METHOD DENY'), 'utf-8') self.status = "444" self.file_size = len(data) except Exception as e: self.errorLog('routing', e, traceback.format_exc()) self.status = "404" data = bytes('{0} : {1}'.format(environ["PATH_INFO"], str(e)), 'utf-8') finally: return data def application(self, environ, start_response): #signal.signal(signal.SIGINT, self.stop) #signal.signal(signal.SIGTERM, self.stop) if environ['HTTP_HOST'] in config.sessionDomain: self.session_domain = environ['HTTP_HOST'] self.txid = str(uuid.uuid4()) self.environ = environ self._clientAddress(environ) # self.postgres.connect() self.http_user_agent = environ['HTTP_USER_AGENT'] self.headers = [('Content-Type', 'application/json'), ('X-Powered-By', "{0} v1.0".format(self.serverName))] #self.memdb = memdb.MemDB(self.redisConnect, self.environ) #self._session_name = self.session_name # if environ['HTTP_HOST'].split(":")[0] in config.devHost: # self._session_name = "BITINUS_DEVELOPE" try: self.time_start = timeit.default_timer() data = None mime = self._mimetypes(environ["PATH_INFO"]) if environ["PATH_INFO"] == '/index.html' or environ[ "PATH_INFO"] == '/': data = open(os.path.join(config.webdocs, 'index.html'), 'rb').read() self.file_size = len(data) start_response('200 OK', [('Content-Type', 'text/html'), ('Content-Length', str(len(data)))]) elif environ["PATH_INFO"] == '/static/img/octoflow.png': data = bs64.b64decode(config.octopng) self.file_size = len(data) start_response('200 OK', [('Content-Type', mime), ('Content-Length', str(len(data)))]) elif '/static' in environ["PATH_INFO"]: data = open( os.path.join(config.webdocs, environ["PATH_INFO"][1:]), 'rb').read() self.file_size = len(data) start_response('200 OK', [('Content-Type', mime), ('Content-Length', str(len(data)))]) elif environ["PATH_INFO"] == '/favicon.ico': data = bs64.b64decode(config.favicon) self.file_size = len(data) start_response('200 OK', [('Content-Type', mime), ('Content-Length', str(len(data)))]) else: data = self.routing(environ, start_response) except Exception as e: print(traceback.format_exc()) # self.postgres.rollBack() self.status = "500" self.errorLog('application', e, traceback.format_exc()) start_response('500 Not Found', [('Content-Type', 'text/html')]) data = bytes('{0} : {1}'.format(environ["PATH_INFO"], '500'), 'utf-8') self.status = "500" self.file_size = len(data) finally: self.time_finish = timeit.default_timer() self.http_host = environ['HTTP_HOST'] self.request_line = "%s %s %s %s" % ( environ['REQUEST_METHOD'], environ['PATH_INFO'], environ['QUERY_STRING'], environ['SERVER_PROTOCOL']) self.session_info = {} """ if environ["HTTP_ACCEPT"].lower() == "text/event-stream": return data else: """ return [data] def server_start(self): try: self.txid = str(uuid.uuid4()) self.process_id = os.getpid() #self._redisPublish(config.serverName) # self.historydb.mgdb_connect('user_login') pool = Pool(1024) self.server = WSGIServer(self.listener, application=self.application, spawn=pool, handler_class=WebSocketHandler) #self.server = WSGIServer(self.listener, application=self.application, spawn=pool, log=self.access_log, error_log=self.error_log ) self.server.handler_class.format_request = self.format_request self.server.serve_forever() except Exception as e: print("T ===========> ", e)
verb = env['REQUEST_METHOD'] path = env['PATH_INFO'] args = parseAndDelistArguments(env['QUERY_STRING']) if 'verb' in args: verb = args['verb'].upper() del args['verb'] print 'args: ', args print 'path: ', path if path == '/favicon.ico': start_response('301 Moved Permanently', [('Location', 'http://hyperdrive.me/favicon.ico')]) return '' # domain = args['domain'] # path = args['path'][1:] # persisted_data = domains.get(domain) start_response('200 OK', [('Content-Type', 'text/plain')]) return 'true' if __name__ == '__main__': wsgi_port = 8882 print 'serving on %s...' % wsgi_port WSGIServer(('', wsgi_port), application).serve_forever() # http://localhost:8882/hello?data=world
def __init__(self, halt_event): self._log = logging.getLogger("WebWriter") memcached_client = memcache.Client(_memcached_nodes) self._interaction_pool = gdbpool.interaction_pool.DBInteractionPool( get_central_database_dsn(), pool_name=_central_pool_name, pool_size=_database_pool_size, do_log=True) authenticator = InteractionPoolAuthenticator(memcached_client, self._interaction_pool) # Ticket #25: must run database operation in a greenlet greenlet = gevent.Greenlet.spawn(_get_cluster_row_and_node_row, self._interaction_pool) greenlet.join() self._cluster_row, node_row = greenlet.get() self._unified_id_factory = UnifiedIDFactory(node_row.id) self._deliverator = Deliverator() self._zeromq_context = zmq.Context() self._pull_server = GreenletPULLServer(self._zeromq_context, _web_writer_pipeliner_address, self._deliverator) self._pull_server.link_exception(self._unhandled_greenlet_exception) self._data_writer_clients = list() for node_name, address in zip(_node_names, _data_writer_addresses): resilient_client = GreenletResilientClient( self._zeromq_context, node_name, address, _client_tag, _web_writer_pipeliner_address, self._deliverator, connect_messages=[]) resilient_client.link_exception(self._unhandled_greenlet_exception) self._data_writer_clients.append(resilient_client) self._space_accounting_dealer_client = GreenletDealerClient( self._zeromq_context, _local_node_name, _space_accounting_server_address) self._space_accounting_dealer_client.link_exception( self._unhandled_greenlet_exception) push_client = GreenletPUSHClient( self._zeromq_context, _local_node_name, _space_accounting_pipeline_address, ) self._accounting_client = SpaceAccountingClient( _local_node_name, self._space_accounting_dealer_client, push_client) self._event_push_client = EventPushClient(self._zeromq_context, "web-server") # message sent to data writers telling them the server # is (re)starting, thereby invalidating any archives # that are in progress for this node unified_id = self._unified_id_factory.next() timestamp = create_timestamp() self._event_push_client.info("web-writer-start", "web writer (re)start", unified_id=unified_id, timestamp_repr=repr(timestamp), source_node_name=_local_node_name) id_translator_keys_path = os.environ.get( "NIMBUS_IO_ID_TRANSLATION_KEYS", os.path.join(_repository_path, "id_translator_keys.pkl")) with open(id_translator_keys_path, "r") as input_file: id_translator_keys = pickle.load(input_file) self._id_translator = InternalIDTranslator( id_translator_keys["key"], id_translator_keys["hmac_key"], id_translator_keys["iv_key"], id_translator_keys["hmac_size"]) redis_queue = gevent.queue.Queue() self._redis_sink = OperationalStatsRedisSink(halt_event, redis_queue, _local_node_name) self._redis_sink.link_exception(self._unhandled_greenlet_exception) self.application = Application(self._cluster_row, self._unified_id_factory, self._id_translator, self._data_writer_clients, authenticator, self._accounting_client, self._event_push_client, redis_queue) self.wsgi_server = WSGIServer((_web_writer_host, _web_writer_port), application=self.application, backlog=_wsgi_backlog)
return str() # Launch a shell on the remote server and bridge the connection # This won't return as long as the session is alive bridge.shell() # Alternatively, you can run a command on the remote server # bridge.execute('/bin/ls -l /') # We have to manually close the websocket and return an empty response, # otherwise flask will complain about not returning a response and will # throw a 500 at our websocket client request.environ['wsgi.websocket'].close() return str() if __name__ == '__main__': from gevent.pywsgi import WSGIServer from geventwebsocket.handler import WebSocketHandler app.debug = True http_server = WSGIServer(('localhost', 5000), app, log=None, handler_class=WebSocketHandler) print('Server running on ws://localhost:5000/remote') try: http_server.serve_forever() except KeyboardInterrupt: pass
def server(): http_server = WSGIServer(('0.0.0.0', 5000), app) http_server.serve_forever()
assert 0 < p < 2**1025 @app.route('/oracle', methods=['GET']) @ORACLE_TIME.time() def oracle(): try: x = int(request.args['x']) % p except Exception: return Response("(._.)???", mimetype="text/plain; charset=utf8") return Response(str(pow(x, s, p)), mimetype="text/plain; charset=utf8") @app.route('/flag', methods=['GET']) @FLAG_TIME.time() def flag(): try: x = int(request.args['x']) % p except Exception: return Response("(._.)???", mimetype="text/plain; charset=utf8") if pow(x, s, p) == 1337: return Response(FLAG, mimetype="text/plain; charset=utf8") else: return Response("{>_<}!!!", mimetype="text/plain; charset=utf8") app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {'/metrics': make_wsgi_app()}) if __name__ == '__main__': WSGIServer(('0.0.0.0', 27492), app).serve_forever()
} return jsonify(data) except: print(sys.exc_info()[0]) print(sys.exc_info()[1]) @app.route("/writeLED/<status>") def writePin(status): if status == 'On': response = ledOn() else: response = ledOff() return response @app.route("/") def mainpage(): return render_template('index.html') if __name__ == '__main__': try: http_server = WSGIServer(('0.0.0.0', 80), app) app.debug = True http_server.serve_forever() except: print("Exception")
print "restore:",restoreState time.sleep(.1) except Exception as x: print "STATES: An error occured:",x app = Flask(__name__) app.debug = True # Simple catch-all server @app.route('/', defaults={'path': ''}, methods=['GET', 'POST']) @app.route('/<path:path>', methods=['GET', 'POST']) def catch_all(path): return render_template('show_data.html', templateAvailable=availableInfo) if __name__ == '__main__': http_server = WSGIServer(('', 8080), app) srv_greenlet = gevent.spawn(http_server.start) stateAssignmentThread = gevent.spawn(manageStates) restoreThread = gevent.spawn(makeRestoreToAvailableState) stateAssignmentThread.start() restoreThread.start() try: gevent.joinall([srv_greenlet, stateAssignmentThread, restoreThread]) except KeyboardInterrupt: print "Exiting"
abort(400) pic = BytesIO() pic.write(base64.b64decode(bytes(data["image"], encoding='utf8'))) pic.seek(0) file_bytes = np.asarray(bytearray(pic.read()), dtype=np.uint8) img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)[..., ::-1] raw_result = blackmanba(img) result = { 'retid': data['reqid'], 'rettime': datetime.datetime.now().strftime('%Y%m%d%H%M%S'), } result.update(raw_result) print(raw_result) print(raw_result['feature_vector']) name,dis=nearest_face(raw_result['feature_vector']) result['name']=name result['distance']=dis result = json.dumps(result) return jsonify(result) if __name__ == '__main__': ip = '0.0.0.0' post = 5000 print('running server http://{0}'.format(ip + ':' + str(post))) WSGIServer((ip, post), app).serve_forever()
output += '<tr><th>Classification</th><th>Model</th><th>Confidence</th><th>Time</th><th>Top1-Acc</th><th>Top5-Acc</th></tr>' # feed predict_image(model_name, top1_acc, top5_acc, ptime, confidence, label) directly into html html_content_list = [ '<tr><td>%s </td><td>%s</td><td>%s%%</td><td> %ss </td><td> %s%% </td><td> %s%% </td></tr>' % predict_image(image_path, key, values) for key, values in mymodels.model_data.items() ] output += '\n'.join(html_content_list) output += '</table>' toc = time() print("Total time for all predictions >> %.2f s" % (toc - tic)) return output return None if (__name__ == '__main__'): print('*** Starting WSGI Server...') print('****************************************************') print('*** Server is available at http://127.0.0.1:5000') print('****************************************************') # Get wsgi server to replace flask app.run() from gevent.pywsgi import WSGIServer web_server = WSGIServer(('', 5000), app) web_server.serve_forever()
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 rss, vms = memory_info(psutil.Process(self.pid)) if vms > config['limit_memory_soft']: _logger.warning('LongPolling virtual memory limit reached: %s', vms) 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 except ImportError: from gevent.wsgi import WSGIServer if os.name == 'posix': # Set process memory limit as an extra safeguard _, hard = resource.getrlimit(resource.RLIMIT_AS) resource.setrlimit(resource.RLIMIT_AS, (config['limit_memory_hard'], hard)) 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) _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()
class WebhookServer(): def __init__(self, bot): self.bot = bot self.routes = {} self.app = falcon.API() self.app.add_sink(self.handle, '/') self.logger = logging.getLogger(__name__) self.server = WSGIServer(('', 8080), self.app, log=None) def start(self): self.logger.debug('Spawning WebhookServer greenlet') self.server.serve_forever() def get_webhooks(self): for plugin in self.bot.plugins: if plugin.enabled is False: continue for webhook in plugin.webhooks: yield webhook def handle(self, request, response): start_time = time.time() for webhook in self.get_webhooks(): if not request.path == webhook.route: continue else: if request.method not in webhook.methods: continue else: try: if request.method in ["POST", "PATCH"]: request_data = json.loads(request.stream.read()) elif request.method == "GET": request_data = request.params else: request_data = {} ret = webhook.callback(request_data, request.headers) if isinstance(ret, str): response.body = ret elif isinstance(ret, dict): response.body = json.dumps(ret) response.status = falcon.HTTP_200 break except Exception as e: self.logger.warning( f'Caught exception handling webhook: {e}') response.status = falcon.HTTP_500 break else: response.status = falcon.HTTP_404 dash = "-" line = (f"{request.method.upper()} " f"{request.path} " f"{request.content_length or dash} " f"{request.host} " f"{request.user_agent or dash} " f"{time.time() - start_time:.2f}ms " f"{response.status}") self.logger.info(line) return response
def data_loop(wsock, message): try: while True: data = lora.get_data() wsock.send(json.dumps({"action": "payload_data", "data": data})) time.sleep(5) except: print("WebSocketError, finish thread") lora = Lora(simulate=config.simulate, storage_manager=storage_manager) app.debug = True server = WSGIServer(("0.0.0.0", config.server_port), app, handler_class=WebSocketHandler) try: print("Serving on IP: {}".format(socket.gethostbyname( socket.gethostname()))) except: print('Serving on IP: 0.0.0.0') print("Serving on port: {}".format(config.server_port)) try: server.serve_forever() except KeyboardInterrupt: print('Script interrupted. Software is not running now!') try: sys.exit(0) except SystemExit: