def run(): """Run gevent server""" http_server = WSGIServer((core_settings.SERVER_ADDRESS, core_settings.SERVER_PORT), app) try: http_server.serve_forever() except KeyboardInterrupt: http_server.stop()
class GeventWSGIServer(object): """Adapter for a gevent.wsgi.WSGIServer.""" def __init__(self, *args, **kwargs): from eden.web.patch import patch_cherrypy patch_cherrypy() self.args = args self.kwargs = kwargs self.ready = False def start(self): """Start the GeventWSGIServer.""" # We have to instantiate the server class here because its __init__ from gevent.wsgi import WSGIServer self.ready = True LOGGER.debug('Starting Gevent WSGI Server...') self.httpd = WSGIServer(*self.args, **self.kwargs) self.httpd.serve_forever() def stop(self): """Stop the HTTP server.""" LOGGER.debug('Stoping Gevent WSGI Server...') self.ready = False self.httpd.stop()
def main(): master = MasterServer() server = WSGIServer(("0.0.0.0", 9090), master) try: logging.info("Server running on port %s. Ctrl+C to quit" % 9090) server.serve_forever() except KeyboardInterrupt: server.stop() logging.info("Server stopped")
class ServiceGatewayService(BaseServiceGatewayService): """ The Service Gateway Service is the service that uses a gevent web server and Flask to bridge HTTP requests to AMQP RPC ION process service calls. """ def on_init(self): #defaults self.http_server = None self.server_hostname = DEFAULT_WEB_SERVER_HOSTNAME self.server_port = DEFAULT_WEB_SERVER_PORT self.web_server_enabled = True self.logging = None #retain a pointer to this object for use in ProcessRPC calls global service_gateway_instance service_gateway_instance = self #get configuration settings if specified if 'web_server' in self.CFG: web_server_cfg = self.CFG['web_server'] if web_server_cfg is not None: if 'hostname' in web_server_cfg: self.server_hostname = web_server_cfg['hostname'] if 'port' in web_server_cfg: self.server_port = web_server_cfg['port'] if 'enabled' in web_server_cfg: self.web_server_enabled = web_server_cfg['enabled'] if 'log' in web_server_cfg: self.logging = web_server_cfg['log'] #need to figure out how to redirect HTTP logging to a file if self.web_server_enabled: self.start_service(self.server_hostname,self.server_port) def on_quit(self): self.stop_service() def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT): """Responsible for starting the gevent based web server.""" if self.http_server is not None: self.stop_service() self.http_server = WSGIServer((hostname, port), app, log=self.logging) self.http_server.start() return True def stop_service(self): """Responsible for stopping the gevent based web server.""" if self.http_server is not None: self.http_server.stop() return True
def main(): parser = argparse.ArgumentParser(description='Run a Senpy server') parser.add_argument('--level', '-l', metavar='logging_level', type=str, default="INFO", help='Logging level') parser.add_argument('--debug', '-d', action='store_true', default=False, help='Run the application in debug mode') parser.add_argument('--default-plugins', action='store_true', default=False, help='Load the default plugins') parser.add_argument('--host', type=str, default="127.0.0.1", help='Use 0.0.0.0 to accept requests from any host.') parser.add_argument('--port', '-p', type=int, default=SERVER_PORT, help='Port to listen on.') parser.add_argument('--plugins-folder', '-f', type=str, default='plugins', help='Where to look for plugins.') parser.add_argument('--only-install', '-i', action='store_true', default=False, help='Do not run a server, only install the dependencies of the plugins.') args = parser.parse_args() logging.basicConfig() rl = logging.getLogger() rl.setLevel(getattr(logging, args.level)) app = Flask(__name__) app.debug = args.debug sp = Senpy(app, args.plugins_folder, default_plugins=args.default_plugins) if args.only_install: sp.install_deps() return sp.activate_all() http_server = WSGIServer((args.host, args.port), app) try: print('Senpy version {}'.format(senpy.__version__)) print('Server running on port %s:%d. Ctrl+C to quit' % (args.host, args.port)) http_server.serve_forever() except KeyboardInterrupt: http_server.stop() print('Bye!')
def run_gevent(app, host='127.0.0.1', port=8000, *args, **kwargs): from gevent.wsgi import WSGIServer server = WSGIServer((host, port), app) server.backlog = 1024 try: log.info("Server running on port %s:%d" % (host, port)) server.serve_forever() except KeyboardInterrupt: server.stop()
def run(self, host='0.0.0.0', port=8000): from gevent.wsgi import WSGIServer server = WSGIServer((host, port), self) server.backlog = 512 try: log.info("Server running on %s:%d" % (host, port)) server.serve_forever() except KeyboardInterrupt: server.stop()
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 from gevent.wsgi import WSGIServer # Set process memory limit as an extra safeguard _, hard = resource.getrlimit(resource.RLIMIT_AS) resource.setrlimit(resource.RLIMIT_AS, (config['limit_memory_hard'], hard)) if os.name == 'posix': 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()
def runserver(): # Create the server application = get_wsgi_application() address = host, port server = WSGIServer( address, application ) # Run the server try: server.serve_forever() except KeyboardInterrupt: server.stop() sys.exit(0)
def run_server(): server = WSGIServer(("", 5000), app) @app.route("/stop") def stop(): server.stop() return "ok" try: server.serve_forever() except KeyboardInterrupt: server.stop()
def runserver(): """Runs the Flask server""" if app.debug: app.run(host=app.config['HOST'], port=app.config['PORT']) else: app.wsgi_app = ProxyFix(app.wsgi_app) address = app.config['HOST'], app.config['PORT'] server = WSGIServer(address, app) try: print("Server running on port %s:%d. Ctrl+C to quit" % address) server.serve_forever() except KeyboardInterrupt: server.stop() print("\nBye bye")
class WebConsole(Console): def __init__(self): super(WebConsole, self).__init__() self._app = Flask('WebConsole') self._server = WSGIServer(('', 5000), self._app) self._app.config.update( DEBUG=True ) self._app.add_url_rule('/', None, self.index) def index(self): sps = self._spiderman.get_spiders() spinfo = [] for s in sps: si = s.get_info() info = {} info['name'] = s.name info['dcount'] = si[1] info['qcount'] = si[0] info['ccount'] = si[2] spinfo.append(info) return render_template('show_spider.html', spinfo=spinfo) def stop(self): super(WebConsole, self).stop() self._server.stop() def run(self): print 'Running...' if self._started == False: self.start() self._server.serve_forever()
class AdminUI(SimpleProcess): """ A simple Web UI to introspect the container and the ION datastores. """ def on_init(self): self.http_server = None self.server_hostname = self.CFG.get_safe(CFG_PREFIX + '.web_server.hostname', DEFAULT_WEB_SERVER_HOSTNAME) self.server_port = self.CFG.get_safe(CFG_PREFIX + '.web_server.port', DEFAULT_WEB_SERVER_PORT) self.url_prefix = self.CFG.get_safe(CFG_PREFIX + '.url_prefix') or "" self.web_server_enabled = True self.logging = None self.interaction_observer = None self.plugin = None app.secret_key = self.__class__.__name__ # Enables sessions (for mscweb) #retain a pointer to this object for use in ProcessRPC calls global adminui_instance adminui_instance = self #Start the gevent web server unless disabled if self.web_server_enabled: self.start_service(self.server_hostname, self.server_port) plugin_cls = CFG.get_safe(CFG_PREFIX + '.plugin') if plugin_cls: cls = named_any(plugin_cls) self.plugin = cls(app, self) def on_quit(self): if self.interaction_observer and self.interaction_observer.started: self.interaction_observer.stop() self.stop_service() def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT): """Responsible for starting the gevent based web server.""" if self.http_server is not None: self.stop_service() self.http_server = WSGIServer((hostname, port), app, log=self.logging) self.http_server.start() return True def stop_service(self): """Responsible for stopping the gevent based web server.""" if self.http_server is not None: self.http_server.stop() return True
def run(): from gevent.wsgi import WSGIServer http_server = WSGIServer(('', app.config['HTTP_PORT']), app) if app.config['DEBUG']: debugModeStr = '''Debug mode enabled!''' else: debugModeStr = '' try: print head.format(app.config['HTTP_HOST'], str(app.config['HTTP_PORT']), debugModeStr) http_server.serve_forever() except KeyboardInterrupt: http_server.stop() print tail
def main(): parser = argparse.ArgumentParser(description='Run a Senpy server') parser.add_argument('--level', "-l", metavar="logging_level", type=str, default="INFO", help='Logging level') parser.add_argument('--debug', "-d", action='store_true', default=False, help='Run the application in debug mode') parser.add_argument('--default-plugins', action='store_true', default=False, help='Load the default plugins') parser.add_argument('--host', type=str, default="127.0.0.1", help='Use 0.0.0.0 to accept requests from any host.') parser.add_argument('--port', '-p', type=int, default=5000, help='Port to listen on.') parser.add_argument('--plugins-folder', '-f', type=str, default="plugins", help='Where to look for plugins.') args = parser.parse_args() logging.basicConfig(level=getattr(logging, args.level)) app = Flask(__name__) app.debug = args.debug sp = Senpy(app, args.plugins_folder, default_plugins=args.default_plugins) sp.activate_all() http_server = WSGIServer((args.host, args.port), app) try: print("Server running on port %s:%d. Ctrl+C to quit" % (args.host, args.port)) http_server.serve_forever() except KeyboardInterrupt: http_server.stop() print("Bye!")
class RunServerInGreenlet(Greenlet): def __init__(self, mock_server): self._httpd = None self._mock_server = mock_server super(RunServerInGreenlet, self).__init__() def run(self): self._httpd = WSGIServer( (self._mock_server.config.HOST, self._mock_server.config.PORT), self._mock_server, log='default' if self._mock_server.config.DEBUG else None, ) self._httpd.start() def stop(self): if self._httpd: self._httpd.stop()
class LightweightPyDAP(SimpleProcess): def on_start(self): super(LightweightPyDAP,self).on_start() self.pydap_host = self.CFG.get_safe('server.pydap.host', 'localhost') self.pydap_port = self.CFG.get_safe('server.pydap.port', '8001') self.pydap_data_path = self.CFG.get_safe('server.pydap.data_path', 'RESOURCE:ext/pydap') self.pydap_data_path = FileSystem.get_extended_url(self.pydap_data_path) self.app = make_app(None, self.pydap_data_path, 'ion/core/static/templates/') self.log = getLogger('pydap') self.log.write = self.log.info self.server = WSGIServer((self.pydap_host, int(self.pydap_port)), self.app, log=self.log) self.server.start() def on_quit(self): self.server.stop() super(LightweightPyDAP,self).on_quit()
class RunServerInGreenlet(Greenlet): def __init__(self, mock_server): self._httpd = None self._mock_server = mock_server super(RunServerInGreenlet, self).__init__() def run(self): self._httpd = WSGIServer( (self._mock_server.host, self._mock_server.port), self._mock_server, log='default' if self._mock_server.debug else None, ) self._httpd.start() def stop(self): if self._httpd: self._httpd.stop()
class TestExtIPUtil(unittest.TestCase): def setUp(self): def application(environ, start_response): headers = [("Content-Type", "text/html")] start_response("200 OK", headers) return ["127.0.0.1"] self.server = WSGIServer(("localhost", 8000), application) gevent.spawn(self.server.serve_forever) def tearDown(self): self.server.stop() def test_ip_verify(self): self.assertTrue(conpot.utils.ext_ip._verify_address("127.0.0.1") is True) def test_ext_util(self): ip_address = conpot.utils.ext_ip._fetch_data(urls=["http://127.0.0.1:8000"]) self.assertTrue(conpot.utils.ext_ip._verify_address(ip_address) is True)
class GeventServer(CommonServer): def __init__(self, app): super(GeventServer, self).__init__(app) self.port = config['longpolling_port'] self.httpd = None def watch_parent(self, beat=4): import gevent ppid = os.getppid() while True: if ppid != os.getppid(): pid = os.getpid() _logger.info("LongPolling (%s) Parent changed", pid) # suicide !! os.kill(pid, signal.SIGTERM) return gevent.sleep(beat) def start(self): import gevent from gevent.wsgi import WSGIServer if os.name == 'posix': signal.signal(signal.SIGQUIT, dumpstacks) signal.signal(signal.SIGUSR1, log_ormcache_stats) gevent.spawn(self.watch_parent) 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()
def run(): from gevent.wsgi import WSGIServer http_server = WSGIServer(('', app.config['HTTP_PORT']), app) 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... ===========================================================================''' http_server.serve_forever() except KeyboardInterrupt: http_server.stop() print '''
class ContainerUI(StandaloneProcess): """ A simple Web UI to introspect the container and the ION datastores. """ def on_init(self): # defaults self.http_server = None self.server_hostname = DEFAULT_WEB_SERVER_HOSTNAME self.server_port = self.CFG.get_safe("container.flask_webapp.port", DEFAULT_WEB_SERVER_PORT) self.web_server_enabled = True self.logging = None # retain a pointer to this object for use in ProcessRPC calls global containerui_instance containerui_instance = self # Start the gevent web server unless disabled if self.web_server_enabled: self.start_service(self.server_hostname, self.server_port) def on_quit(self): self.stop_service() def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT): """Responsible for starting the gevent based web server.""" if self.http_server is not None: self.stop_service() self.http_server = WSGIServer((hostname, port), app, log=self.logging) self.http_server.start() return True def stop_service(self): """Responsible for stopping the gevent based web server.""" if self.http_server is not None: self.http_server.stop() return True
def run_server(): import socket from gevent.wsgi import WSGIServer from vnc.app import app # websocket conflict: WebSocketHandler if DEBUG: # from werkzeug.debug import DebuggedApplication app.debug = True # app = DebuggedApplication(app, evalex=True) try: log.info('Listening on http://localhost:{}'.format(PORT)) http_server = WSGIServer(('localhost', PORT), app) http_server.serve_forever() # app.run(host='localhost', port=PORT) except socket.error as e: log.exception(e) except KeyboardInterrupt: pass finally: http_server.stop(timeout=10) log.info('shutdown gracefully')
class ServiceGatewayService(BaseServiceGatewayService): """ The Service Gateway Service is the service that uses a gevent web server and Flask to bridge HTTP requests to AMQP RPC ION process service calls. """ def on_init(self): #defaults self.http_server = None #retain a pointer to this object for use in ProcessRPC calls global service_gateway_instance ###### # to prevent cascading failure, here's an attempted hack if service_gateway_instance is not None and service_gateway_instance.http_server is not None: service_gateway_instance.http_server.stop() # end hack ###### service_gateway_instance = self self.server_hostname = self.CFG.get_safe( 'container.service_gateway.web_server.hostname', DEFAULT_WEB_SERVER_HOSTNAME) self.server_port = self.CFG.get_safe( 'container.service_gateway.web_server.port', DEFAULT_WEB_SERVER_PORT) self.web_server_enabled = self.CFG.get_safe( 'container.service_gateway.web_server.enabled', True) self.web_logging = self.CFG.get_safe( 'container.service_gateway.web_server.log') self.log_errors = self.CFG.get_safe( 'container.service_gateway.log_errors', True) #Optional list of trusted originators can be specified in config. self.trusted_originators = self.CFG.get_safe( 'container.service_gateway.trusted_originators') if not self.trusted_originators: self.trusted_originators = None log.info( "Service Gateway will not check requests against trusted originators since none are configured." ) #Get the user_cache_size self.user_cache_size = self.CFG.get_safe( 'container.service_gateway.user_cache_size', DEFAULT_USER_CACHE_SIZE) #Initialize an LRU Cache to keep user roles cached for performance reasons #maxSize = maximum number of elements to keep in cache #maxAgeMs = oldest entry to keep self.user_role_cache = LRUCache(self.user_cache_size, 0, 0) #Start the gevent web server unless disabled if self.web_server_enabled: log.info("Starting service gateway on %s:%s", self.server_hostname, self.server_port) self.start_service(self.server_hostname, self.server_port) #Configure subscriptions for user_cache events self.user_role_event_subscriber = EventSubscriber( event_type=OT.UserRoleModifiedEvent, origin_type="Org", callback=self.user_role_event_callback) self.add_endpoint(self.user_role_event_subscriber) self.user_role_reset_subscriber = EventSubscriber( event_type=OT.UserRoleCacheResetEvent, callback=self.user_role_reset_callback) self.add_endpoint(self.user_role_reset_subscriber) def on_quit(self): self.stop_service() def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT): """Responsible for starting the gevent based web server.""" if self.http_server is not None: self.stop_service() self.http_server = WSGIServer((hostname, port), service_gateway_app, log=self.web_logging) self.http_server.start() return True def stop_service(self): """Responsible for stopping the gevent based web server.""" if self.http_server is not None: self.http_server.stop() return True def is_trusted_address(self, requesting_address): if self.trusted_originators is None: return True for addr in self.trusted_originators: if requesting_address == addr: return True return False def user_role_event_callback(self, *args, **kwargs): """ This method is a callback function for receiving Events when User Roles are modified. """ user_role_event = args[0] org_id = user_role_event.origin actor_id = user_role_event.actor_id role_name = user_role_event.role_name log.debug("User Role modified: %s %s %s" % (org_id, actor_id, role_name)) #Evict the user and their roles from the cache so that it gets updated with the next call. if service_gateway_instance.user_role_cache and service_gateway_instance.user_role_cache.has_key( actor_id): log.debug('Evicting user from the user_role_cache: %s' % actor_id) service_gateway_instance.user_role_cache.evict(actor_id) def user_role_reset_callback(self, *args, **kwargs): ''' This method is a callback function for when an event is received to clear the user data cache ''' self.user_role_cache.clear()
@virtualrest.route('/statics/<rtype>/<filename>') def statics(rtype, filename): if (rtype in ['imgs', 'fonts', 'css', 'js']): return send_from_directory(virtualrest.static_folder + '/' + rtype, filename, as_attachment=True) else: abort(404) if __name__ == '__main__': localaddress = config.get('MAIN', 'local_address') localport = config.getint('MAIN', 'local_port') if (config.getboolean('MAIN', 'debug')): virtualrest.run(host=localaddress, port=8080, debug=True) else: if (config.getboolean('MAIN', 'use_ssl')): key_file = config.get('MAIN', 'ssl_key_file') cert_file = config.get('MAIN', 'ssl_cert_file') http_server = WSGIServer((localaddress, localport), virtualrest, keyfile=key_file, certfile=cert_file) else: http_server = WSGIServer((localaddress, localport), virtualrest) try: http_server.serve_forever() except KeyboardInterrupt: http_server.stop()
class WebServer(object): def __init__(self, server_name='Sola', host='127.0.0.1', port=8080, encoding='utf-8'): self.httpd = None self.ready = False self.host = host self.port = port self.encoding = encoding def bootstrap(self): self.bootstrap_options() self.boostrap_command_parse() self.boostrap_database_configuration() def bootstrap_options(self): pass def boostrap_database_configuration(self): pass def boostrap_command_parse(self): pass def new_route(self): return cherrypy.dispatch.RoutesDispatcher() def create_app(self): raise NotImplemented('Must implement create_app in Subclass') def _start_app(self): ctl, routes = self.create_app() patch_cherrypy() conf = { 'engine.autoreload.on': False, 'log.screen': False, 'log.error_file': '', 'log.access_file': '', 'environment': 'embedded', 'tools.decode.on': unicode, 'tools.encode.on': unicode, 'tools.encode.encoding': self.encoding, 'tools.gzip.on': True, 'tools.log_headers.on': False, 'request.show_tracebacks': False, } config = {'/': {'request.dispatch': routes}, 'global': conf} cherrypy.config.clear() cherrypy.config.update(config) app = cherrypy.tree.mount(ctl, '/', config) cherrypy.server.unsubscribe() self.httpd = WSGIServer((self.host, self.port), app) def serve_forever(self): self.ready = True self._start_app() try: cherrypy.engine.start() self.httpd.serve_forever() except KeyboardInterrupt: self.stop() def stop(self): cherrypy.engine.stop() self.httpd.stop() self.ready = False
class UIServer(SimpleProcess): """ Process to start a generic UI server that can be extended with content and service gateway """ def on_init(self): # Retain a pointer to this object for use in routes global ui_instance ui_instance = self # Main references to basic components (if initialized) self.http_server = None self.socket_io = None self.service_gateway = None self.oauth = oauth # Configuration self.server_enabled = self.CFG.get_safe(CFG_PREFIX + ".server.enabled") is True self.server_debug = self.CFG.get_safe(CFG_PREFIX + ".server.debug") is True # Note: this may be the empty string. Using localhost does not make the server publicly accessible self.server_hostname = self.CFG.get_safe(CFG_PREFIX + ".server.hostname", DEFAULT_WEB_SERVER_HOSTNAME) self.server_port = self.CFG.get_safe(CFG_PREFIX + ".server.port", DEFAULT_WEB_SERVER_PORT) self.server_log_access = self.CFG.get_safe(CFG_PREFIX + ".server.log_access") is True self.server_log_errors = self.CFG.get_safe(CFG_PREFIX + ".server.log_errors") is True self.server_socket_io = self.CFG.get_safe(CFG_PREFIX + ".server.socket_io") is True self.server_secret = self.CFG.get_safe(CFG_PREFIX + ".security.secret") or "" self.session_timeout = int(self.CFG.get_safe(CFG_PREFIX + ".security.session_timeout") or DEFAULT_SESSION_TIMEOUT) self.extend_session_timeout = self.CFG.get_safe(CFG_PREFIX + ".security.extend_session_timeout") is True self.max_session_validity = int(self.CFG.get_safe(CFG_PREFIX + ".security.max_session_validity") or DEFAULT_SESSION_TIMEOUT) self.remember_user = self.CFG.get_safe(CFG_PREFIX + ".security.remember_user") is True self.set_cors_headers = self.CFG.get_safe(CFG_PREFIX + ".server.set_cors") is True self.develop_mode = self.CFG.get_safe(CFG_PREFIX + ".server.develop_mode") is True self.oauth_enabled = self.CFG.get_safe(CFG_PREFIX + ".oauth.enabled") is True self.oauth_scope = self.CFG.get_safe(CFG_PREFIX + ".oauth.default_scope") or "scioncc" self.has_service_gateway = self.CFG.get_safe(CFG_PREFIX + ".service_gateway.enabled") is True self.service_gateway_prefix = self.CFG.get_safe(CFG_PREFIX + ".service_gateway.url_prefix", DEFAULT_GATEWAY_PREFIX) self.extensions = self.CFG.get_safe(CFG_PREFIX + ".extensions") or [] self.extension_objs = [] # TODO: What about https? self.base_url = "http://%s:%s" % (self.server_hostname or "localhost", self.server_port) self.gateway_base_url = None self.idm_client = IdentityManagementServiceProcessClient(process=self) # One time setup if self.server_enabled: app.secret_key = self.server_secret or self.__class__.__name__ # Enables encrypted session cookies if self.server_debug: app.debug = True if self.server_socket_io: self.socket_io = SocketIO(app) if self.has_service_gateway: from ion.services.service_gateway import ServiceGateway, sg_blueprint self.gateway_base_url = self.base_url + self.service_gateway_prefix self.service_gateway = ServiceGateway(process=self, config=self.CFG, response_class=app.response_class) app.register_blueprint(sg_blueprint, url_prefix=self.service_gateway_prefix) for ext_cls in self.extensions: try: cls = named_any(ext_cls) except AttributeError as ae: # Try to nail down the error import importlib importlib.import_module(ext_cls.rsplit(".", 1)[0]) raise self.extension_objs.append(cls()) for ext_obj in self.extension_objs: ext_obj.on_init(self, app) if self.extensions: log.info("UI Server: %s extensions initialized", len(self.extensions)) # Start the web server self.start_service() log.info("UI Server: Started server on %s" % self.base_url) else: log.warn("UI Server: Server disabled in config") def on_quit(self): self.stop_service() def start_service(self): """ Starts the web server. """ if self.http_server is not None: self.stop_service() if self.server_socket_io: self.http_server = SocketIOServer((self.server_hostname, self.server_port), app.wsgi_app, resource='socket.io', log=None) self.http_server._gl = gevent.spawn(self.http_server.serve_forever) log.info("UI Server: Providing web sockets (socket.io) server") else: self.http_server = WSGIServer((self.server_hostname, self.server_port), app, log=None) self.http_server.start() if self.service_gateway: self.service_gateway.start() log.info("UI Server: Service Gateway started on %s", self.gateway_base_url) for ext_obj in self.extension_objs: ext_obj.on_start() return True def stop_service(self): """ Responsible for stopping the gevent based web server. """ for ext_obj in self.extension_objs: ext_obj.on_stop() if self.http_server is not None: self.http_server.stop() if self.service_gateway: self.service_gateway.stop() # Need to terminate the server greenlet? return True # ------------------------------------------------------------------------- # Authentication def auth_external(self, username, ext_user_id, ext_id_provider="ext"): """ Given username and user identifier from an external identity provider (IdP), retrieve actor_id and establish user session. Return user info from session. Convention is that system local username is ext_id_provider + ":" + username, e.g. "ext_johnbean" Return NotFound if user not registered in system. Caller can react and create a user account through the normal system means @param username the user name the user recognizes. @param ext_user_id a unique identifier coming from the external IdP @param ext_id_provider identifies the external IdP service """ try: if ext_user_id and ext_id_provider and username: local_username = "******" % (ext_id_provider, username) actor_id = self.idm_client.find_actor_identity_by_username(local_username) user_info = self._set_server_session(actor_id, local_username) return build_json_response(user_info) else: raise BadRequest("External user info missing") except Exception: return build_json_error() def login(self): """ Explicit (non-token) login and creation of a server session (Cookie based). """ try: username = get_arg("username") password = get_arg("password") if username and password: actor_id = self.idm_client.check_actor_credentials(username, password) user_info = self._set_server_session(actor_id, username) return build_json_response(user_info) else: raise BadRequest("Username or password missing") except Exception: return build_json_error() def _set_server_session(self, actor_id, username=None): """ Sets server session based on user_id and ActorIdentity. """ actor_user = self.idm_client.read_identity_details(actor_id) if actor_user.type_ != OT.UserIdentityDetails: raise BadRequest("Bad identity details") full_name = actor_user.contact.individual_names_given + " " + actor_user.contact.individual_name_family valid_until = int(get_ion_ts_millis() / 1000 + self.session_timeout) set_auth(actor_id, username, full_name, valid_until=valid_until, roles=actor_user.contact.roles) user_info = get_auth() return user_info def get_session(self): """ Returns user session information for current authentication. This can be polled regularly by client code to detect changes in session state and expiration. """ def call_extend_session_attrs(session_attrs, actor_user): """ Call UI extensions to make additions to user session """ for ext_obj in self.extension_objs: func = getattr(ext_obj, "extend_user_session_attributes", None) if func: try: func(session_attrs, actor_user) except Exception: log.exception("Error calling UI extension extend_user_session_attributes()") try: # Get user session from OAuth access token in HTTP Authorization header auth_hdr = request.headers.get("authorization", None) if auth_hdr: valid, req = self.oauth.verify_request([self.oauth_scope]) # Note: Do NOT extend session timeout here! if valid: actor_id = flask.g.oauth_user.get("actor_id", "") actor_user = self.idm_client.read_actor_identity(actor_id) session_attrs = dict(is_logged_in=True, is_registered=True, attributes={"roles": actor_user.details.contact.roles}, roles={}) if actor_user.session: session_attrs.update(actor_user.session) call_extend_session_attrs(session_attrs, actor_user) return build_json_response(session_attrs) if self.remember_user: # Get user session from user_id/access_token placed inside server session (Cookie) # This is a feature to allow returning users to resume a session if still valid access_token = flask.session.get("access_token", None) actor_id = flask.session.get("actor_id", None) if access_token and actor_id: actor_user = self.idm_client.read_actor_identity(actor_id) session_attrs = dict(access_token=access_token, is_logged_in=True, is_registered=True, attributes={"roles": actor_user.details.contact.roles}, roles={}) if actor_user.session: # Check validity in persisted user session if 0 < int(actor_user.session.get("valid_until", 0)) * 1000 < current_time_millis(): clear_auth() return build_json_response(get_auth()) session_attrs.update(actor_user.session) else: # No trace of existing session in user object clear_auth() return build_json_response(get_auth()) call_extend_session_attrs(session_attrs, actor_user) return build_json_response(session_attrs) # Get user session from Flask session and cookie (non-token mode) user_info = get_auth() if 0 < int(user_info.get("valid_until", 0)) * 1000 < current_time_millis(): clear_auth() # Clear expired session user_info = get_auth() call_extend_session_attrs(user_info, None) return build_json_response(user_info) except Exception: return build_json_error() def logout(self): try: access_token = get_req_bearer_token() or flask.session.get("access_token", None) if access_token: try: # Invalidate access token token_id = str("access_token_%s" % access_token) token_obj = ui_instance.container.object_store.read(token_id) token_obj.status = "CANCELLED" token_obj.attributes["cancel_ts"] = get_ion_ts_millis() token_obj.attributes["cancel_msg"] = "User logout" ui_instance.container.object_store.update(token_obj) log.info("Invalidated stored access token for user=%s", token_obj.actor_id) except NotFound: pass except Exception: log.exception("Error invalidating access token") clear_auth() return build_json_response("OK") except Exception: return build_json_error()
# Create a relationship with type 'knows' relationship = firstNode.toma(secondNode, cantidad=3) # Always shut down your database when your application exits db.shutdown() def application(env, start_response): start_response("200 OK", [("Content-Type", "text/html; charset=utf-8")]) if env['PATH_INFO'] == '/': return open('front.html', 'r').readlines() if env['PATH_INFO'] == '/user': post_data = post2dic(env['wsgi.input'].readline().decode()) addUser(post_data['usuario']) return ["Hello, World!"] if __name__ == "__main__": from gevent.wsgi import WSGIServer address = "localhost", 8080 server = WSGIServer(address, application) try: print "Server running on port %s:%d. Ctrl+C to quit" % address server.serve_forever() except KeyboardInterrupt: server.stop() print "Bye bye"
class Application(Singleton): """ Main class of your application. Pass options to constructor and all subsystems(eventer, router) will be configured. """ def __init__(self, options): self.init_options(options) self.init_eventer() self.init_router() self.init_templater() self.eventer.publish("BeforeDatabaseEngineConfiguration", self) self.init_db() self.eventer.publish("AfterDatabaseEngineConfiguration", self) self.init_session() self.eventer.publish("BeforeInitStatic", self) self.init_static() self.eventer.publish("AfterInitStatic", self) self.eventer.publish("BeforeInitServer", self) self.init_server() self.eventer.publish("AfterInitServer", self) self.eventer.publish("BeforeApplicationStarted", self) def init_options(self, options): logging.basicConfig(level=logging.CRITICAL) default_options = { "application": { "address": "127.0.0.1", "port": 8080, "system": { "log": None } }, "urls": {}, "views": { "templates_path": [], "templates_extensions": ["compressinja.html.HtmlCompressor", "jinja2.ext.i18n"], "static_path": [], "static_not_compile": [], "static_build": True, 'session_type': "cookie", "session_auto": True, 'session_cookie_expires': True, 'session_encrypt_key':'sldk24j0jf09w0jfg24', 'session_validate_key':';l[pfghopkqeq1234,fs' }, "events": {} } self.options = Dict.merge(default_options, options) def init_eventer(self): self.eventer = Eventer(self.options["events"]) def init_router(self): self.router = Router(self.options) def init_templater(self): self.templater = Templater(self) def init_static(self): static_builder = None self.add_static(self.options["views"]["static_path"], not_compile=self.options["views"]["static_not_compile"], merge=False, build=self.options["views"]["static_build"]) def add_static(self, sps, not_compile=[], url_path="/", merge=True, build=True): static_path = [] for sp in sps: try: sp = Importer.module_path(sp) except: pass try: static_path.append(sp) static_builder = StaticBuilder(sp, not_compile) if build: static_builder.build() if build: self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {url_path : sp + "/build"}, cache=False) else: self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {url_path : sp}, cache=False) except: pass if merge: self.options["views"]["static_path"] = self.options["views"]["static_path"] + static_path else: self.options["views"]["static_path"] = static_path def init_db(self): if "models" in self.options: metadata.bind = self.options["models"]["connection"] metadata.bind.echo = False def init_session(self): session_options = { 'session.type': self.options["views"]['session_type'], "session.auto": self.options["views"]["session_auto"], 'session.cookie_expires': self.options["views"]['session_cookie_expires'], 'session.encrypt_key': self.options["views"]['session_encrypt_key'], 'session.validate_key': self.options["views"]['session_validate_key'] } self.wsgi_app = SessionMiddleware(self.wsgi_app, session_options, environ_key="session") def init_server(self): #kwargs = dict(filter(lambda item: item[0] not in ["address", "port"], self.options["application"].iteritems())) kwargs = {} if "system" in self.options["application"]: kwargs = self.options["application"]["system"] self.server = WSGIServer((self.options["application"]["address"], self.options["application"]["port"]), self.wsgi_app, **kwargs) def wsgi_app(self, options, start_response): request = Request(options) response = self.router.route(request) return response(options, start_response) def start(self): gevent.signal(signal.SIGTERM, self.stop) gevent.signal(signal.SIGINT, self.stop) self.eventer.publish("ApplicationStarted", self) self.server.serve_forever() def start_no_wait(self): self.eventer.publish("ApplicationStarted", self) self.server.start() def stop(self): self.eventer.publish("ApplicationStopped", self) self.server.stop()
def stop(self, *args, **kwargs): WSGIServer.stop(self) Component.stop(self) self.logger.info("Exit")
if __name__ == '__main__': with virtualrest.app_context(): configs = mongodb.db.configs.find({},{'_id':0})[0] fallback = literal_eval(configs['fallbacks']) result_limit = configs['result_limit'] server_address = configs['server_address'] def_headers = { 'Access-Control-Allow-Origin' : '%s' % server_address, 'Content-Type' : 'application/json; charset=UTF-8', 'Access-Control-Max-Age': 86400, 'Access-Control-Allow-Credentials': True, } localport = config.getint('MAIN', 'local_port') localaddress = config.get('MAIN', 'local_address') if (config.getboolean('MAIN', 'debug')): virtualrest.run(host=localaddress,port=localport, debug=True) else: if (config.getboolean('MAIN', 'use_ssl')): cert_file = config.get('MAIN', 'ssl_cert_file') key_file = config.get('MAIN', 'ssl_key_file') http_server = WSGIServer((localaddress, localport), virtualrest, keyfile=key_file, certfile=cert_file) else: http_server = WSGIServer((localaddress, localport), virtualrest) try: http_server.serve_forever() except KeyboardInterrupt: http_server.stop()
class APIServer(object): """ Runs the sikorka API server """ # flask TypeConverter # links argument-placeholder in route (e.g. '/<hexaddress: channel_address>') to the Converter _type_converter_mapping = {'hexaddress': HexAddressConverter} _api_prefix = '/api/1' def __init__(self, rest_api, cors_domain_list=None, eth_rpc_endpoint=None, webui=False): self.rest_api = rest_api self.blueprint = create_blueprint() # TODO: Make configurable version self.rest_api.version = 1 if self.rest_api.version == 1: self.flask_api_context = Api( self.blueprint, prefix=self._api_prefix, ) else: raise ValueError('Invalid api version: {}'.format( self.rest_api.version)) rootpath = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) self.flask_app = Flask(__name__, static_url_path='/static', static_folder=os.path.join( rootpath, 'ui', 'static')) if cors_domain_list: CORS(self.flask_app, origins=cors_domain_list) self._add_default_resources() self._register_type_converters() self.flask_app.register_blueprint(self.blueprint) self.flask_app.config['WEBUI_PATH'] = os.path.join(rootpath, 'ui') if webui: for route in ['/index.html', '/']: self.flask_app.add_url_rule( route, route, view_func=self._serve_webui, methods=['GET'], ) def _add_default_resources(self): self.add_resource(AddressResource, '/address') self.add_resource(DetectorSignResource, '/detector_sign/<hexaddress:user_address>') def _register_type_converters(self, additional_mapping=None): # an additional mapping concats to class-mapping and will overwrite existing keys if additional_mapping: mapping = dict(self._type_converter_mapping, **additional_mapping) else: mapping = self._type_converter_mapping for key, value in mapping.items(): self.flask_app.url_map.converters[key] = value def add_resource(self, resource_cls, route): self.flask_api_context.add_resource( resource_cls, route, resource_class_kwargs={'rest_api_object': self.rest_api}) def _serve_webui(self, file='index.html'): try: assert file response = send_from_directory(self.flask_app.config['WEBUI_PATH'], file) except (NotFound, AssertionError): response = send_from_directory(self.flask_app.config['WEBUI_PATH'], 'index.html') return response def run(self, host='127.0.0.1', port=5011, **kwargs): self.flask_app.run(host=host, port=port, **kwargs) def start(self, host='127.0.0.1', port=5011): self.wsgiserver = WSGIServer((host, port), self.flask_app, log=log, error_log=log) self.wsgiserver.start() def stop(self, timeout=5): if getattr(self, 'wsgiserver', None): self.wsgiserver.stop(timeout) self.wsgiserver = None
class APIServer(object): """ Runs the API-server that routes the endpoint to the resources. The API is wrapped in multiple layers, and the Server should be invoked this way:: # instance of the raiden-api raiden_api = RaidenAPI(...) # wrap the raiden-api with rest-logic and encoding rest_api = RestAPI(raiden_api) # create the server and link the api-endpoints with flask / flask-restful middleware api_server = APIServer(rest_api) # run the server api_server.run('127.0.0.1', 5001, debug=True) """ # flask TypeConverter # links argument-placeholder in route (e.g. '/<hexaddress: channel_address>') to the Converter _type_converter_mapping = { 'hexaddress': HexAddressConverter } _api_prefix = '/api/1' def __init__(self, rest_api, cors_domain_list=None, web_ui=False, eth_rpc_endpoint=None): self.rest_api = rest_api self.blueprint = create_blueprint() if self.rest_api.version == 1: self.flask_api_context = Api( self.blueprint, prefix=self._api_prefix, ) else: raise ValueError('Invalid api version: {}'.format(self.rest_api.version)) self.flask_app = Flask(__name__) if cors_domain_list: CORS(self.flask_app, origins=cors_domain_list) self._add_default_resources() self._register_type_converters() self.flask_app.register_blueprint(self.blueprint) self.flask_app.config['WEBUI_PATH'] = '../ui/web/dist/' if eth_rpc_endpoint: if not eth_rpc_endpoint.startswith('http'): eth_rpc_endpoint = 'http://' + eth_rpc_endpoint self.flask_app.config['WEB3_ENDPOINT'] = eth_rpc_endpoint if web_ui: for route in ['/ui/<path:file>', '/ui', '/ui/', '/index.html', '/']: self.flask_app.add_url_rule( route, route, view_func=self._serve_webui, methods=['GET'], ) def _add_default_resources(self): self.add_resource(AddressResource, '/address') self.add_resource(ChannelsResource, '/channels') self.add_resource( ChannelsResourceByChannelAddress, '/channels/<hexaddress:channel_address>' ) self.add_resource(TokensResource, '/tokens') self.add_resource( PartnersResourceByTokenAddress, '/tokens/<hexaddress:token_address>/partners' ) self.add_resource( RegisterTokenResource, '/tokens/<hexaddress:token_address>' ) self.add_resource(NetworkEventsResource, '/events/network') self.add_resource( TokenEventsResource, '/events/tokens/<hexaddress:token_address>' ) self.add_resource( ChannelEventsResource, '/events/channels/<hexaddress:channel_address>' ) self.add_resource( TokenSwapsResource, '/token_swaps/<hexaddress:target_address>/<int:identifier>' ) self.add_resource( TransferToTargetResource, '/transfers/<hexaddress:token_address>/<hexaddress:target_address>' ) self.add_resource( ConnectionsResource, '/connection/<hexaddress:token_address>' ) def _serve_webui(self, file='index.html'): try: assert file web3 = self.flask_app.config.get('WEB3_ENDPOINT') if web3 and 'config.' in file and file.endswith('.json'): response = jsonify({'raiden': self._api_prefix, 'web3': web3}) else: response = send_from_directory(self.flask_app.config['WEBUI_PATH'], file) except (NotFound, AssertionError): response = send_from_directory(self.flask_app.config['WEBUI_PATH'], 'index.html') return response def _register_type_converters(self, additional_mapping=None): # an additional mapping concats to class-mapping and will overwrite existing keys if additional_mapping: mapping = dict(self._type_converter_mapping, **additional_mapping) else: mapping = self._type_converter_mapping for key, value in mapping.items(): self.flask_app.url_map.converters[key] = value def add_resource(self, resource_cls, route): self.flask_api_context.add_resource( resource_cls, route, resource_class_kwargs={'rest_api_object': self.rest_api} ) def run(self, host='127.0.0.1', port=5001, **kwargs): self.flask_app.run(host=host, port=port, **kwargs) def start(self, host='127.0.0.1', port=5001): self.wsgiserver = WSGIServer((host, port), self.flask_app) self.wsgiserver.start() def stop(self, timeout=5): if getattr(self, 'wsgiserver', None): self.wsgiserver.stop(timeout) self.wsgiserver = None
@app.route("/api/{v}/node/<path:node_name>".format(v=API_VER), methods=["GET"]) def get_node_info(node_name): """ GET /api/<version>/node/<node_name> Get information about a ROS node """ node_name = "/" + node_name state = rosnode_master.getSystemState() pubs = [t for t, l in state[0] if node_name in l] subs = [t for t, l in state[1] if node_name in l] srvs = [t for t, l in state[2] if node_name in l] return jsonify({ "node_name": node_name, "pubs": pubs, "subs": subs, "srvs": srvs }) if __name__ == '__main__': rospy.init_node("api") server = WSGIServer(('', 5000), app) try: rospy.loginfo("API now listening on http://0.0.0.0:5000") server.serve_forever() except KeyboardInterrupt: server.stop()
def stop(self, *args, **kwargs): self.application.real_logger.info("Stopping monitoring server") WSGIServer.stop(self, *args, **kwargs)
class PlatformRuntime(object): def __init__(self, registry, srnodes, container, attach=False): self.registry = registry self.container = container self.srnodes = srnodes self.attach = attach self._resolve = _ProxyResolver(self.registry) self._init() def _init(self): self._proxy = WSGIServer(('', 0), ProxyApp(self._resolve)) self._proxy.start() def dispose(self): self._proxy.stop() def _make_port_specs(self, ports): return [str(port) for port in ports] def make_config(self): """Given a L{Container}, construct a Docker config.""" ports = self._make_port_specs(self.container.ports) return self._container_config(self.container.image, self.container.command, hostname=self.container.instance, environment=self._make_environment(), tty=self.container.tty, stdin_open=self.attach, ports=ports) def _make_environment(self): proxy_netloc = 'http://%s:%d' % (_DOCKER_GATEWAY, self._proxy.server_port) environment = self.container.env or {} environment = environment.copy() for (n, v) in (('GILLIAM_FORMATION', self.container.formation), ('GILLIAM_SERVICE', self.container.service), ('GILLIAM_INSTANCE', self.container.instance), ('GILLIAM_SERVICE_REGISTRY_NODES', self.srnodes), ('GILLIAM_SERVICE_REGISTRY', self.srnodes), ('HTTP_PROXY', proxy_netloc), ('http_proxy', proxy_netloc), ('HTTPS_PROXY', proxy_netloc)): if v is not None: environment[n] = v return _convert_environment_dict_to_array(environment) def _container_config(self, image, command, hostname=None, user=None, detach=False, stdin_open=False, tty=False, mem_limit=0, ports=None, environment=None, dns=None, volumes=None, volumes_from=None): if isinstance(command, six.string_types): command = shlex.split(str(command)) d = { 'Hostname': hostname, 'PortSpecs': ports, 'User': user, 'Tty': tty, 'OpenStdin': stdin_open, 'Memory': mem_limit, 'AttachStdin': self.attach, 'AttachStdout': self.attach, 'AttachStderr': self.attach, 'Env': environment, 'Cmd': command, 'Dns': dns, 'Image': image, 'Volumes': volumes, 'VolumesFrom': volumes_from, } #print "CONFIG", d return d
class APIServer: """ Runs the API-server that routes the endpoint to the resources. The API is wrapped in multiple layers, and the Server should be invoked this way:: # instance of the raiden-api raiden_api = RaidenAPI(...) # wrap the raiden-api with rest-logic and encoding rest_api = RestAPI(raiden_api) # create the server and link the api-endpoints with flask / flask-restful middleware api_server = APIServer(rest_api) # run the server api_server.run('127.0.0.1', 5001, debug=True) """ _api_prefix = '/api/1' def __init__(self, rest_api, cors_domain_list=None, web_ui=False, eth_rpc_endpoint=None): if rest_api.version != 1: raise ValueError( 'Invalid api version: {}'.format(rest_api.version) ) flask_app = Flask(__name__) if cors_domain_list: CORS(flask_app, origins=cors_domain_list) if eth_rpc_endpoint: if not eth_rpc_endpoint.startswith('http'): eth_rpc_endpoint = 'http://{}'.format(eth_rpc_endpoint) flask_app.config['WEB3_ENDPOINT'] = eth_rpc_endpoint blueprint = create_blueprint() flask_api_context = Api(blueprint, prefix=self._api_prefix) restapi_setup_type_converters( flask_app, {'hexaddress': HexAddressConverter}, ) restapi_setup_urls( flask_api_context, rest_api, URLS_V1, ) self.rest_api = rest_api self.flask_app = flask_app self.blueprint = blueprint self.flask_api_context = flask_api_context self.wsgiserver = None self.flask_app.register_blueprint(self.blueprint) self.flask_app.config['WEBUI_PATH'] = '../ui/web/dist/' if is_frozen(): # Inside frozen pyinstaller image self.flask_app.config['WEBUI_PATH'] = '{}/raiden/ui/web/dist/'.format(sys.prefix) if web_ui: for route in ('/ui/<path:file_name>', '/ui', '/ui/', '/index.html', '/'): self.flask_app.add_url_rule( route, route, view_func=self._serve_webui, methods=('GET', ), ) def _serve_webui(self, file_name='index.html'): # pylint: disable=redefined-builtin try: assert file_name web3 = self.flask_app.config.get('WEB3_ENDPOINT') if web3 and 'config.' in file_name and file_name.endswith('.json'): host = request.headers.get('Host') if any(h in web3 for h in ('localhost', '127.0.0.1')) and host: _, _port = split_endpoint(web3) _host, _ = split_endpoint(host) web3 = 'http://{}:{}'.format(_host, _port) response = jsonify({'raiden': self._api_prefix, 'web3': web3}) else: response = send_from_directory(self.flask_app.config['WEBUI_PATH'], file_name) except (NotFound, AssertionError): response = send_from_directory(self.flask_app.config['WEBUI_PATH'], 'index.html') return response def run(self, host='127.0.0.1', port=5001, **kwargs): self.flask_app.run(host=host, port=port, **kwargs) def start(self, host='127.0.0.1', port=5001): self.wsgiserver = WSGIServer((host, port), self.flask_app, log=log, error_log=log) self.wsgiserver.start() def stop(self, timeout=5): if getattr(self, 'wsgiserver', None): self.wsgiserver.stop(timeout) self.wsgiserver = None
def stop(self, *args, **kwargs): self.application.real_logger.info("Stopping monitoring server") WSGIServer.stop(self, *args, **kwargs)
class ServiceGatewayService(BaseServiceGatewayService): """ The Service Gateway Service is the service that uses a gevent web server and Flask to bridge HTTP requests to AMQP RPC ION process service calls. """ def on_init(self): #defaults self.http_server = None #retain a pointer to this object for use in ProcessRPC calls global service_gateway_instance ###### # to prevent cascading failure, here's an attempted hack if service_gateway_instance is not None and service_gateway_instance.http_server is not None: service_gateway_instance.http_server.stop() # end hack ###### service_gateway_instance = self self.server_hostname = self.CFG.get_safe('container.service_gateway.web_server.hostname', DEFAULT_WEB_SERVER_HOSTNAME) self.server_port = self.CFG.get_safe('container.service_gateway.web_server.port', DEFAULT_WEB_SERVER_PORT) self.web_server_enabled = self.CFG.get_safe('container.service_gateway.web_server.enabled', True) self.web_logging = self.CFG.get_safe('container.service_gateway.web_server.log') self.log_errors = self.CFG.get_safe('container.service_gateway.log_errors', False) #Optional list of trusted originators can be specified in config. self.trusted_originators = self.CFG.get_safe('container.service_gateway.trusted_originators') if not self.trusted_originators: self.trusted_originators = None log.info("Service Gateway will not check requests against trusted originators since none are configured.") #Get the user_cache_size self.user_cache_size = self.CFG.get_safe('container.service_gateway.user_cache_size', DEFAULT_USER_CACHE_SIZE) #Initialize an LRU Cache to keep user roles cached for performance reasons #maxSize = maximum number of elements to keep in cache #maxAgeMs = oldest entry to keep self.user_data_cache = LRUCache(self.user_cache_size,0,0) #Start the gevent web server unless disabled if self.web_server_enabled: log.info("Starting service gateway on %s:%s", self.server_hostname, self.server_port) self.start_service(self.server_hostname, self.server_port) #Configure subscriptions for user_cache events self.user_role_event_subscriber = EventSubscriber(event_type=OT.UserRoleModifiedEvent, origin_type="Org", callback=self.user_role_event_callback) self.user_role_event_subscriber.start() self.user_role_reset_subscriber = EventSubscriber(event_type=OT.UserRoleCacheResetEvent, callback=self.user_role_reset_callback) self.user_role_reset_subscriber.start() def on_quit(self): self.stop_service() if self.user_role_event_subscriber is not None: self.user_role_event_subscriber.stop() if self.user_role_reset_subscriber is not None: self.user_role_reset_subscriber.stop() def start_service(self, hostname=DEFAULT_WEB_SERVER_HOSTNAME, port=DEFAULT_WEB_SERVER_PORT): """Responsible for starting the gevent based web server.""" if self.http_server is not None: self.stop_service() self.http_server = WSGIServer((hostname, port), service_gateway_app, log=self.web_logging) self.http_server.start() return True def stop_service(self): """Responsible for stopping the gevent based web server.""" if self.http_server is not None: self.http_server.stop() return True def is_trusted_address(self, requesting_address): if self.trusted_originators is None: return True for addr in self.trusted_originators: if requesting_address == addr: return True return False def user_role_event_callback(self, *args, **kwargs): """ This method is a callback function for receiving Events when User Roles are modified. """ user_role_event = args[0] org_id = user_role_event.origin actor_id = user_role_event.actor_id role_name = user_role_event.role_name log.debug("User Role modified: %s %s %s" % (org_id, actor_id, role_name)) #Evict the user and their roles from the cache so that it gets updated with the next call. if service_gateway_instance.user_data_cache and service_gateway_instance.user_data_cache.has_key(actor_id): log.debug('Evicting user from the user_data_cache: %s' % actor_id) service_gateway_instance.user_data_cache.evict(actor_id) def user_role_reset_callback(self, *args, **kwargs): ''' This method is a callback function for when an event is received to clear the user data cache ''' self.user_data_cache.clear()
class APIServer: """ Runs the API-server that routes the endpoint to the resources. The API is wrapped in multiple layers, and the Server should be invoked this way:: # instance of the raiden-api raiden_api = RaidenAPI(...) # wrap the raiden-api with rest-logic and encoding rest_api = RestAPI(raiden_api) # create the server and link the api-endpoints with flask / flask-restful middleware api_server = APIServer(rest_api) # run the server api_server.run('127.0.0.1', 5001, debug=True) """ _api_prefix = '/api/1' def __init__(self, rest_api, cors_domain_list=None, web_ui=False, eth_rpc_endpoint=None): if rest_api.version != 1: raise ValueError('Invalid api version: {}'.format( rest_api.version)) flask_app = Flask(__name__) if cors_domain_list: CORS(flask_app, origins=cors_domain_list) if eth_rpc_endpoint: if not eth_rpc_endpoint.startswith('http'): eth_rpc_endpoint = 'http://{}'.format(eth_rpc_endpoint) flask_app.config['WEB3_ENDPOINT'] = eth_rpc_endpoint blueprint = create_blueprint() flask_api_context = Api(blueprint, prefix=self._api_prefix) restapi_setup_type_converters( flask_app, {'hexaddress': HexAddressConverter}, ) restapi_setup_urls( flask_api_context, rest_api, URLS_V1, ) self.rest_api = rest_api self.flask_app = flask_app self.blueprint = blueprint self.flask_api_context = flask_api_context self.wsgiserver = None self.flask_app.register_blueprint(self.blueprint) self.flask_app.config['WEBUI_PATH'] = '../ui/web/dist/' if is_frozen(): # Inside frozen pyinstaller image self.flask_app.config[ 'WEBUI_PATH'] = '{}/raiden/ui/web/dist/'.format(sys.prefix) self.flask_app.errorhandler(HTTPStatus.NOT_FOUND)(endpoint_not_found) if web_ui: for route in ('/ui/<path:file_name>', '/ui', '/ui/', '/index.html', '/'): self.flask_app.add_url_rule( route, route, view_func=self._serve_webui, methods=('GET', ), ) def _serve_webui(self, file_name='index.html'): # pylint: disable=redefined-builtin try: assert file_name web3 = self.flask_app.config.get('WEB3_ENDPOINT') if web3 and 'config.' in file_name and file_name.endswith('.json'): host = request.headers.get('Host') if any(h in web3 for h in ('localhost', '127.0.0.1')) and host: _, _port = split_endpoint(web3) _host, _ = split_endpoint(host) web3 = 'http://{}:{}'.format(_host, _port) response = jsonify({'raiden': self._api_prefix, 'web3': web3}) else: response = send_from_directory( self.flask_app.config['WEBUI_PATH'], file_name) except (NotFound, AssertionError): response = send_from_directory(self.flask_app.config['WEBUI_PATH'], 'index.html') return response def run(self, host='127.0.0.1', port=5001, **kwargs): self.flask_app.run(host=host, port=port, **kwargs) def start(self, host='127.0.0.1', port=5001): self.wsgiserver = WSGIServer((host, port), self.flask_app, log=log, error_log=log) self.wsgiserver.start() def stop(self, timeout=5): if getattr(self, 'wsgiserver', None): self.wsgiserver.stop(timeout) self.wsgiserver = None