def spawn_processes(log, args): """ Launch the subprocesses and hang until completion. """ shared = SharedState() log.info("Spawning RPC process...") _PROCESSES.append( mpm.spawn_rpc_process(mpm.mpmtypes.MPM_RPC_PORT, shared, args.default_args)) log.debug("RPC process has PID: %d", _PROCESSES[-1].pid) if watchdog.has_watchdog(): watchdog.transfer_control(_PROCESSES[-1].pid) log.info("Spawning discovery process...") _PROCESSES.append(mpm.spawn_discovery_process(shared, args.discovery_addr)) log.debug("Discovery process has PID: %d", _PROCESSES[-1].pid) log.info("Processes launched. Registering signal handlers.") # Launch the kill thread # This is used because we cannot block in a signal handler, # meaning we cannot join threads Thread(target=kill_thread, daemon=False).start() signal.signal(signal.SIGTERM, kill_time) signal.signal(signal.SIGINT, kill_time) if JOIN_PROCESSES: for proc in _PROCESSES: proc.join() return True
def consume_forever(self): """ start consume forever """ signal(SIGTERM, self.sign_handler) signal(SIGINT, self.sign_handler) if self.debug: consume_func = self.mock_consume produce_func = self.mock_kafka else: consume_func = self.consume produce_func = self.kafka_to_queue task_list = [] for _ in range(self.num): task_list.append(gevent.spawn(consume_func)) produce_func() self.queue.join() if not self.debug: logger.info("closing kafka...") self.consumer.close() gevent.joinall(task_list, timeout=5) logger.info('Exiting with qsize:%d' % self.queue.qsize())
def get_http_server(self): with ImportExtensions(required=True): from flask import Flask, Response, jsonify, request from flask_cors import CORS, cross_origin from gevent.pywsgi import WSGIServer app = Flask(__name__) app.config['CORS_HEADERS'] = 'Content-Type' CORS(app) def http_error(reason, code): return jsonify({'reason': reason}), code @app.route('/ready') @cross_origin() def is_ready(): return Response(status=200) @app.route('/api/<mode>', methods=['POST']) @cross_origin() def api(mode): from ..clients import python mode_fn = getattr(python.request, mode, None) if mode_fn is None: return http_error(f'mode: {mode} is not supported yet', 405) content = request.json if 'data' not in content: return http_error('"data" field is empty', 406) content['mode'] = RequestType.from_string(mode) results = get_result_in_json(getattr(python.request, mode)(**content)) return Response(asyncio.run(results), status=200, mimetype='application/json') async def get_result_in_json(req_iter): return [MessageToJson(k) async for k in self._p_servicer.Call(req_iter, None)] # os.environ['WERKZEUG_RUN_MAIN'] = 'true' # log = logging.getLogger('werkzeug') # log.disabled = True # app.logger.disabled = True # app.run('0.0.0.0', 5000) server = WSGIServer((self.args.host, self.args.port_expose), app, log=None) def close(*args, **kwargs): server.stop() self.unset_ready() self.is_shutdown.set() from gevent import signal signal.signal(signal.SIGTERM, close) signal.signal(signal.SIGINT, close) # CTRL C self.set_ready() self.logger.warning('you are using a REST gateway, which is still in early beta version. ' 'advanced features such as prefetch and streaming are disabled.') server.serve_forever()
def enable_autoreload(signum): from .autoreload import ModuleReloader reloader = ModuleReloader() reloader.enabled = True def autoreload(sig, frame): reloader.check() signal.signal(signum, autoreload)
def main(): parser = argparse.ArgumentParser(description="Basic smartglass client") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): console = discovered[0] console.on_timeout += on_timeout console.add_manager(InputManager) state = console.connect(userhash, token) if state != ConnectionState.Connected: print("Connection failed") sys.exit(1) console.wait(1) getch = get_getch_func() while True: ch = getch() print(ch) if ord(ch) == 3: # CTRL-C sys.exit(1) elif ch not in input_map: continue button = input_map[ch] console.gamepad_input(button) console.wait(0.1) console.gamepad_input(GamePadButton.Clear) signal.signal(signal.SIGINT, lambda *args: console.protocol.stop()) console.protocol.serve_forever() else: print("No consoles discovered") sys.exit(1)
def handle_signal(self): """register signal""" def handler(signum, frame): logging.info("bee.rpc > kill service={}, nid={}".format( self.opts.name, self.nid)) self.registry.deregister(self.opts.name, self.nid) signal.signal(signal.SIGINT, handler) signal.signal(signal.SIGTERM, handler)
def start(self): """ Start the proxy service :return: returns nothing """ self.log.info('Starting DNS TLS proxy service...') self.conn_pool = TLSConnectionPool(addresses=self.nameservers, size=self.pool_size) signal.signal(signal.SIGTERM, self._sig_term) try: try: if self.tcp: self.log.info('Starting TCP listener on port %i...', self.port) server = ServerTCP( listener=':{}'.format(self.port), conn_pool=self.conn_pool, stats_queue=self.stats.queue() if self.stats else None) self.servers.append(server) server.start() if self.udp: self.log.info('Starting UDP listener on port %i...', self.port) server = ServerUDP( listener=':{}'.format(self.port), conn_pool=self.conn_pool, stats_queue=self.stats.queue() if self.stats else None) self.servers.append(server) server.start() except Exception as exc: self.log.critical('starting server failed: %s', exc) sys.exit(1) if self.stats: self.log.info('Starting stats collector...') gevent.spawn(self.stats.collector()) gevent.wait() except (SystemExit, KeyboardInterrupt): self.log.warning('Stoping proxy service...') except Exception as exc: self.log.critical('Unexpected error: %s', exc) sys.exit(1) finally: for server in self.servers: self.log.info('Stoping listener %s...', server) server.stop()
def main(): parser = argparse.ArgumentParser(description="Basic smartglass client") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") parser.add_argument('--verbose', '-v', action='store_true', help="Verbose flag, also log message content") args = parser.parse_args() if args.verbose: fmt = VerboseFormatter(logging.BASIC_FORMAT) else: fmt = logging.Formatter(logging.BASIC_FORMAT) handler = logging.StreamHandler() handler.setFormatter(fmt) logging.root.addHandler(handler) logging.root.setLevel(logging.DEBUG) # logging.basicConfig(level=logging.DEBUG, format=logfmt) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): console = discovered[0] console.on_timeout += on_timeout state = console.connect(userhash, token) if state != ConnectionState.Connected: logging.error("Connection failed") sys.exit(1) signal.signal(signal.SIGINT, lambda *args: console.protocol.stop()) console.protocol.serve_forever() else: logging.error("No consoles discovered") sys.exit(1)
def main(): parser = argparse.ArgumentParser(description="Basic smartglass client") parser.add_argument('--tokens', '-t', default=TOKENS_FILE, help="Token file, created by xbox-authenticate script") parser.add_argument('--address', '-a', help="IP address of console") parser.add_argument('--refresh', '-r', action='store_true', help="Refresh xbox live tokens in provided token file") args = parser.parse_args() logging.basicConfig(level=logging.DEBUG) try: auth_mgr = AuthenticationManager.from_file(args.tokens) auth_mgr.authenticate(do_refresh=args.refresh) auth_mgr.dump(args.tokens) except Exception as e: print("Failed to authenticate with provided tokens, Error: %s" % e) print("Please re-run xbox-authenticate to get a fresh set") sys.exit(1) userhash = auth_mgr.userinfo.userhash token = auth_mgr.xsts_token.jwt discovered = Console.discover(timeout=1, addr=args.address) if len(discovered): console = discovered[0] console.on_timeout += on_timeout console.add_manager(TextManager) console.text.on_systemtext_configuration += on_text_config console.text.on_systemtext_input += functools.partial( on_text_input, console) console.text.on_systemtext_done += on_text_done state = console.connect(userhash, token) if state != ConnectionState.Connected: print("Connection failed") sys.exit(1) console.wait(1) signal.signal(signal.SIGINT, lambda *args: console.protocol.stop()) console.protocol.serve_forever() else: print("No consoles discovered") sys.exit(1)
def __call__(self, *args, **kwargs): signal.signal(signal.SIGINT, self.signal_handler) while True: c_socket, c_addr = self.sock_obj.accept() auth = AuthFlow(client_socket=c_socket) success = auth.start_server_operation() if not success: try: c_socket.shutdown(socket.SHUT_RDWR) c_socket.close() except error: pass continue c_socket.settimeout(config.get('CONNECTION_TIMEOUT', 60)) # todo: log the client address glet = gevent.spawn(self.listener, c_socket, c_addr, auth.boundary) glet.start() self._clients.update({c_socket: glet})
def setup(): args = parse_args() app = create_app(args) server = WSGIServer((args.host, args.port), app, log='default' if args.log else None) # On a termination or interrupt signal, we want the server to end gracefully! def graceful_exit(*args): print('Terminating the server now...', file=sys.stderr) server.stop() sig.signal(signal.SIGTERM, graceful_exit) sig.signal(signal.SIGINT, graceful_exit) print('Running Amera at http://{}{}{}.'.format( args.host, ':' if args.port != 80 else '', args.port), file=sys.stderr) server.serve_forever()
def spawn_processes(log, args): """ Launch the subprocesses and hang until completion. """ shared = SharedState() log.info("Spawning RPC process...") _PROCESSES.append( mpm.spawn_rpc_process(mpm.mpmtypes.MPM_RPC_PORT, shared, args.default_args)) log.debug("RPC process has PID: %d", _PROCESSES[-1].pid) if watchdog.has_watchdog(): watchdog.transfer_control(_PROCESSES[-1].pid) log.info("Spawning discovery process...") _PROCESSES.append(mpm.spawn_discovery_process(shared, args.discovery_addr)) log.debug("Discovery process has PID: %d", _PROCESSES[-1].pid) log.info("Processes launched. Registering signal handlers.") signal.signal(signal.SIGTERM, kill_time) signal.signal(signal.SIGINT, kill_time) for proc in _PROCESSES: proc.join() return True
def _rpc_server_process(shared_state, port, default_args): """ This is the actual process that's running the RPC server. """ connections = Pool(1000) server = StreamServer(('0.0.0.0', port), handle=MPMServer(shared_state, default_args), spawn=connections) # catch signals and stop the stream server # Previously, the signal callbacks simply called server.stop() # gevent doesn't like this because server.stop() may block waiting # for greenlets to stop, and signal callbacks are not supposed to block stop_event = threading.Event() def stop_worker(): stop_event.wait() server.stop() sys.exit(0) threading.Thread(target=stop_worker, daemon=True).start() signal.signal(signal.SIGTERM, lambda *args: stop_event.set()) signal.signal(signal.SIGINT, lambda *args: stop_event.set()) server.serve_forever()
def spawn_processes(log, args): """ Launch the subprocesses and hang until completion. """ shared = SharedState() log.info("Spawning RPC process...") _PROCESSES.append( mpm.spawn_rpc_process( mpm.mpmtypes.MPM_RPC_PORT, shared, args.default_args)) log.debug("RPC process has PID: %d", _PROCESSES[-1].pid) if watchdog.has_watchdog(): watchdog.transfer_control(_PROCESSES[-1].pid) log.info("Spawning discovery process...") _PROCESSES.append( mpm.spawn_discovery_process(shared, args.discovery_addr) ) log.debug("Discovery process has PID: %d", _PROCESSES[-1].pid) log.info("Processes launched. Registering signal handlers.") signal.signal(signal.SIGTERM, kill_time) signal.signal(signal.SIGINT, kill_time) for proc in _PROCESSES: proc.join() return True
def _with_sighandlers(self): from signal import SIGTERM, SIGHUP, SIG_DFL from gevent import signal def handle_term(signum, frame): sys.exit(0) def handle_hup(signum, frame): self.loop_interrupt.set('reload') old_term = signal.signal(SIGTERM, handle_term) or SIG_DFL old_hup = signal.signal(SIGHUP, handle_hup) or SIG_DFL try: yield finally: signal.signal(SIGTERM, old_term) signal.signal(SIGHUP, old_hup)
def init(schedule): signal.signal(signal.SIGINT, schedule.stop) signal.signal(signal.SIGTERM, schedule.stop)
def catch_signal(): signal.signal(2, signal_handler) signal.signal(15, signal_handler)
def run(self): # Setup all of the robot management functions # TODO some of these should probably be POST methods... robot_flask = flask.Flask(__name__) @robot_flask.route('/', methods=['GET']) def __hello(): return flask.jsonify("Hello, I am the BenchBot robot controller") @robot_flask.route('/config/', methods=['GET']) def __config_full(): return flask.jsonify(self.config) @robot_flask.route('/config/<config>', methods=['GET']) def __config(config): if config in self.config: return flask.jsonify(self.config[config]) else: rospy.logerr("Requested non-existent config: %s" % config) flask.abort(404) @robot_flask.route('/configure', methods=['POST']) def __configure(): try: self.set_config(flask.request.json) except Exception as e: print(traceback.format_exc()) raise (e) return flask.jsonify({'configuration_valid': self.config_valid}) @robot_flask.route('/connections/<connection>', methods=['GET', 'POST']) def __connection(connection): # Handle all connection calls (typically sent via the supervisor) if connection not in self.config['robot']['connections']: rospy.logerr("Requested undefined connection: %s" % connection) flask.abort(404) try: return flask.jsonify( jsonpickle.encode( self._call_connection(connection, data=flask.request.get_json()))) except Exception as e: rospy.logerr( "Robot Controller failed on processing connection " "'%s' with error:\n%s\n%s" % (connection, repr(e), traceback.format_exc())) flask.abort(500) @robot_flask.route('/is_collided', methods=['GET']) def __is_collided(): return flask.jsonify({'is_collided': self.instance.is_collided()}) @robot_flask.route('/is_dirty', methods=['GET']) def __is_dirty(): return flask.jsonify({'is_dirty': self.instance.is_dirty()}) @robot_flask.route('/is_finished', methods=['GET']) def __is_finished(): return flask.jsonify({ 'is_finished': (False if 'trajectory_pose_next' not in self.state else self.state['trajectory_pose_next'] >= len( self.state['trajectory_poses'])) }) @robot_flask.route('/is_running', methods=['GET']) def __is_running(): try: return flask.jsonify( {'is_running': self.instance.is_running()}) except Exception as e: rospy.logerr(e) @robot_flask.route('/next', methods=['GET']) def __next(): try: if self._env_next() == 0: raise ValueError( "There is no next map; at the end of the list") self.stop() self.state['selected_environment'] = self._env_next() self.start() success = True except Exception as e: rospy.logerr(e) success = False return flask.jsonify({'next_success': success}) @robot_flask.route('/reset', methods=['GET']) def __reset(): # Resets the robot in the current scene try: self.restart() success = self.instance.is_running() except Exception as e: rospy.logerr(e) success = False return flask.jsonify({'reset_success': success}) @robot_flask.route('/restart', methods=['GET']) def __restart(): # Restarts the robot in the FIRST scene self.wipe() resp = __reset() resp.data = resp.data.replace('reset', 'restart') return resp @robot_flask.route('/selected_environment', methods=['GET']) def __selected_env(): try: return flask.jsonify({ 'name': self.config['environments'][ self.state['selected_environment']]['name'], 'variant': self.config['environments'][ self.state['selected_environment']]['variant'], 'number': self.state['selected_environment'] }) except Exception as e: rospy.logerr(e) # Configure our server robot_server = pywsgi.WSGIServer( re.split('http[s]?://', self.robot_address)[-1], robot_flask) evt = event.Event() signal.signal(signal.SIGINT, evt.set) signal.signal(signal.SIGQUIT, evt.set) signal.signal(signal.SIGTERM, evt.set) # Run the server & start the real robot controller robot_server.start() print("\nRobot controller is now available @ '%s' ..." % self.robot_address) print("Waiting to receive valid config data...") while not self.config_valid: if evt.wait(0.1): break if self._auto_start and self.config_valid: print("Starting the requested real robot ROS stack ... ", end="") sys.stdout.flush() self.start() print("Done") # Wait until we get an exit signal or crash, then shut down gracefully while self.instance.health_check(): if evt.wait(0.1): break print("\nShutting down the real robot ROS stack & exiting ...") robot_server.stop() self.stop() print("Stopped")
def _godaemon(self): """ daemonize us """ logger.debug("Entering, pid=%s", os.getpid()) # Limit self._set_limits() # Fork1 logger.debug("fork1, %s", SolBase.get_current_pid_as_string()) try: pid = gevent.fork() if pid > 0: # Exit first parent logger.debug("exit(0) first parent") sys.exit(0) except OSError as ex: logger.error("fork1 failed, exit(1) now : errno=%s, err=%s, ex=%s", ex.errno, ex.strerror, SolBase.extostr(ex)) sys.exit(1) logger.debug("fork1 done, %s", SolBase.get_current_pid_as_string()) # Diverge from parent if self._changeDir: logger.debug("chdir now") os.chdir("/") # Set stuff logger.debug("setsid and umask") # noinspection PyArgumentList os.setsid() os.umask(0) # Fork2 logger.debug("fork2, %s", SolBase.get_current_pid_as_string()) try: pid = gevent.fork() if pid > 0: # exit from second parent logger.debug("exit(0) second parent") sys.exit(0) except OSError as ex: logger.error("fork2 failed, exit(2) now : errno=%s, err=%s, ex=%s", ex.errno, ex.strerror, SolBase.extostr(ex)) sys.exit(2) logger.debug("fork2 done, %s", SolBase.get_current_pid_as_string()) # Redirect std self._redirect_all_std() # Go logger.debug("initializing _pidfile=%s", self._pidfile) # Register the method called at exit atexit.register(self._remove_pid_file) # Write pidfile pid = str(os.getpid()) try: f = open(self._pidfile, "w") f.write("%s" % pid) f.close() except IOError as ex: logger.error( "pid file initialization failed, going exit(3), ex=%s", SolBase.extostr(ex)) sys.exit(3) # Ok logger.debug("pid file set") # Finish logger.debug("registering gevent signal handler : SIGUSR1") signal(SIGUSR1, self._on_reload) logger.debug("registering gevent signal handler : SIGUSR2") signal(SIGUSR2, self._on_status) logger.debug("registering gevent signal handler : SIGTERM") signal(SIGTERM, self._exit_handler) logger.debug("registering gevent signal handler : done") # Fatality SolBase.voodoo_init() logger.debug("process started, pid=%s, pidfile=%s", os.getpid(), self._pidfile)
print("Code coverage collection for worker in pid {}: {}".format( os.getpid(), ('COVERAGE' in os.environ))) if 'COVERAGE' in os.environ: cov = coverage.coverage( data_file='/coverage/.coverage-{}'.format(os.getpid()), concurrency="gevent") cov.start() def save_coverage(): cov.stop() cov.save() atexit.register(save_coverage) gevent_signal.signal(signal.SIGTERM, save_coverage) gevent_signal.signal(signal.SIGINT, save_coverage) def get_app(): from cnaas_nms.scheduler.scheduler import Scheduler from cnaas_nms.plugins.pluginmanager import PluginManagerHandler from cnaas_nms.db.session import sqla_session from cnaas_nms.db.joblock import Joblock from cnaas_nms.db.job import Job # If running inside uwsgi, a separate "mule" will run the scheduler try: import uwsgi print("Running inside uwsgi") except (ModuleNotFoundError, ImportError): scheduler = Scheduler()
def get_http_server(self): try: from flask import Flask, Response, jsonify, request from flask_cors import CORS, cross_origin from gevent.pywsgi import WSGIServer except ImportError: raise ImportError( 'Flask or its dependencies are not fully installed, ' 'they are required for serving HTTP requests.' 'Please use pip install "jina[http]" to install it.') app = Flask(__name__) app.config['CORS_HEADERS'] = 'Content-Type' CORS(app) def http_error(reason, code): return jsonify({'reason': reason}), code @app.route('/ready') @cross_origin() def is_ready(): return Response(status=200) @app.route('/api/<mode>', methods=['POST']) @cross_origin() def api(mode): from ..clients import python mode_fn = getattr(python.request, mode, None) if mode_fn is None: return http_error(f'mode: {mode} is not supported yet', 405) content = request.json if 'data' not in content: return http_error('"data" field is empty', 406) content['mode'] = ClientMode.from_string(mode) results = get_result_in_json( getattr(python.request, mode)(**content)) actual_fucking_results = asyncio.run(results) def parse(response): d = json.loads(response) matches = d['search']['docs'][0]['matches'] l = [] for match in matches: dic = { 'doc_id': base64.b64decode(match['metaInfo']).decode(), 'score': match['score']['value'] } # d['text'] = match['chunks'][0]['text'] l.append(dic) return l return Response(json.dumps(parse(actual_fucking_results[0])), status=200, mimetype='application/json') async def get_result_in_json(req_iter): return [ MessageToJson(k) async for k in self._p_servicer.Call(req_iter, None) ] # os.environ['WERKZEUG_RUN_MAIN'] = 'true' # log = logging.getLogger('werkzeug') # log.disabled = True # app.logger.disabled = True # app.run('0.0.0.0', 5000) server = WSGIServer((self.args.host, self.args.port_expose), app, log=None) def close(*args, **kwargs): server.stop() self.unset_ready() self.is_shutdown.set() from gevent import signal signal.signal(signal.SIGTERM, close) signal.signal(signal.SIGINT, close) # CTRL C self.set_ready() self.logger.warning( 'you are using a REST gateway, which is still in early beta version. ' 'advanced features such as prefetch and streaming are disabled.') server.serve_forever()
def main(command=None): """ Main entrypoint """ auth_manager = None repl_server_handle = None # Used for Command.REPLServer if command: # Take passed command and append actual cmdline cmdline_arguments = sys.argv[1:] cmdline_arguments.insert(0, command) else: cmdline_arguments = None args = parse_arguments(cmdline_arguments) handle_logging_setup(args) LOGGER.debug('Parsed arguments: {0}'.format(args)) command = args.command LOGGER.debug('Chosen command: {0}'.format(command)) if command == Commands.RESTServer: LOGGER.info( 'Make sure you used the dedicated \'xbox-rest-server\' script' ' to start the REST server!') elif 'interactive' in args and args.interactive and \ (args.address or args.liveid): LOGGER.error( 'Flag \'--interactive\' is incompatible with' ' providing an IP address (--address) or LiveID (--liveid) explicitly' ) sys.exit(ExitCodes.ArgParsingError) elif args.liveid and args.address: LOGGER.warning( 'You passed --address AND --liveid: Will only use that specific' 'combination!') elif command == Commands.PowerOff and args.all and (args.liveid or args.address): LOGGER.error( 'Poweroff with --all flag + explicitly provided LiveID / IP address makes no sense' ) sys.exit(ExitCodes.ArgParsingError) elif command == Commands.PowerOff and args.interactive and args.all: LOGGER.error('Combining args --all and --interactive not supported') sys.exit(ExitCodes.ArgParsingError) print('Xbox SmartGlass main client started') if command == Commands.RESTServer: """ REST Server """ if args.port == 0: LOGGER.info('No defaults provided, ' 'Setting REST server port to {0}'.format( REST_DEFAULT_SERVER_PORT)) args.port = REST_DEFAULT_SERVER_PORT print('Xbox Smartglass REST server started on {0}:{1}'.format( args.bind, args.port)) flask_app.token_file = args.tokens server = rest_pywsgi.WSGIServer((args.bind, args.port), flask_app) server.serve_forever() sys.exit(ExitCodes.OK) elif command == Commands.TUI: """ Text user interface (powered by urwid) """ # Removing stream handlers to not pollute TUI for h in [ sh for sh in logging.root.handlers if isinstance(sh, logging.StreamHandler) ]: LOGGER.debug( 'Removing StreamHandler {0} from root logger'.format(h)) logging.root.removeHandler(h) sys.exit( tui.run_tui(args.consoles, args.address, args.liveid, args.tokens, args.refresh)) elif 'tokens' in args: """ Do Xbox live authentication """ LOGGER.debug( 'Command {0} supports authenticated connection'.format(command)) try: auth_manager = do_authentication(args.tokens, args.refresh) except AuthenticationException: LOGGER.exception('Authentication failed!') LOGGER.error("Please re-run xbox-authenticate to get a fresh set") sys.exit(ExitCodes.AuthenticationError) elif command == Commands.PowerOn: """ Powering up console """ if not args.liveid: LOGGER.error('No LiveID (--liveid) provided for power on!') sys.exit(ExitCodes.ArgParsingError) LOGGER.info('Sending poweron packet for LiveId: {0} to {1}'.format( args.liveid, 'IP: ' + args.address if args.address else '<MULTICAST>')) Console.power_on(args.liveid, args.address, tries=10) sys.exit(0) """ Discovery """ discovered = cli_discover_consoles(args) if command == Commands.Discover: """ Simply print discovered consoles """ print("Discovered %d consoles: " % len(discovered)) for console in discovered: print(" %s" % console) sys.exit(ExitCodes.OK) elif command == Commands.PowerOff and args.all: """ Early call for poweroff --all """ """Powering off all discovered consoles""" for c in discovered: print('Powering off console {0}'.format(c)) c.power_off() sys.exit(ExitCodes.OK) """ Choosing/filtering a console from the discovered ones """ console = None if args.interactive: LOGGER.debug('Starting interactive console choice') console = choose_console_interactively(discovered) elif len(discovered) == 1: LOGGER.debug('Choosing sole console, no user interaction required') console = discovered[0] elif len(discovered) > 1: LOGGER.error('More than one console was discovered and no exact' ' connection parameters were provided') if not console: LOGGER.error('Choosing a console failed!') sys.exit(ExitCodes.ConsoleChoice) LOGGER.info('Choosen target console: {0}'.format(console)) LOGGER.debug('Setting console callbacks') console.on_device_status += \ lambda x: LOGGER.info('Device status: {0}'.format(x)) console.on_connection_state += \ lambda x: LOGGER.info('Connection state: {0}'.format(x)) console.on_pairing_state += \ lambda x: LOGGER.info('Pairing state: {0}'.format(x)) console.on_console_status += \ lambda x: LOGGER.info('Console status: {0}'.format(x)) console.on_timeout += \ lambda x: LOGGER.error('Timeout occured!') or sys.exit(1) userhash = auth_manager.userinfo.userhash xtoken = auth_manager.xsts_token LOGGER.debug('Authentication info:') LOGGER.debug('Userhash: {0}'.format(userhash)) LOGGER.debug('XToken: {0}'.format(xtoken)) LOGGER.info('Attempting connection...') state = console.connect(userhash, xtoken.jwt) if state != ConnectionState.Connected: LOGGER.error('Connection failed! Console: {0}'.format(console)) sys.exit(1) # FIXME: Waiting explicitly LOGGER.info('Connected to console: {0}'.format(console)) LOGGER.debug('Waiting a second before proceeding...') console.wait(1) if command == Commands.PowerOff: """ Power off (single console) """ print('Powering off console {0}'.format(console)) console.power_off() sys.exit(ExitCodes.OK) elif command == Commands.REPL or \ command == Commands.REPLServer: banner = 'You are connected to the console @ {0}\n'\ .format(console.address) banner += 'Type in \'console\' to acccess the object\n' banner += 'Type in \'exit()\' to quit the application' scope_vars = {'console': console} if command == Commands.REPL: LOGGER.info('Starting up local REPL console') repl_local = InteractiveConsole(locals=scope_vars) repl_local.interact(banner) else: if args.port == 0: LOGGER.info('No defaults provided, ' 'Setting REPL server port to {0}'.format( REPL_DEFAULT_SERVER_PORT)) args.port = REPL_DEFAULT_SERVER_PORT startinfo = 'Starting up REPL server @ {0}:{1}'.format( args.bind, args.port) print(startinfo) LOGGER.info(startinfo) repl_server_handle = backdoor.BackdoorServer(listener=(args.bind, args.port), banner=banner, locals=scope_vars) elif command == Commands.FalloutRelay: """ Fallout 4 relay """ print('Starting Fallout 4 relay service...') console.add_manager(TitleManager) console.title.on_connection_info += fallout4_relay.on_connection_info console.start_title_channel(title_id=fallout4_relay.FALLOUT_TITLE_ID) print('Fallout 4 relay started') elif command == Commands.GamepadInput: """ Gamepad input """ print('Starting gamepad input handler...') console.add_manager(manager.InputManager) gamepad_input.input_loop(console) elif command == Commands.TextInput: """ Text input """ print('Starting text input handler...') console.add_manager(manager.TextManager) console.text.on_systemtext_configuration += text_input.on_text_config console.text.on_systemtext_input += functools.partial( text_input.on_text_input, console) console.text.on_systemtext_done += text_input.on_text_done LOGGER.debug('Installing gevent SIGINT handler') signal.signal(signal.SIGINT, lambda *a: console.protocol.stop()) if repl_server_handle: LOGGER.debug('Starting REPL server protocol') LOGGER.debug('Starting console.protocol.serve_forever()') console.protocol.serve_forever() LOGGER.debug('Protocol serving exited') if repl_server_handle: LOGGER.debug('Stopping REPL server protocol') repl_server_handle.stop()
spawn(datum.send_email_reminders) spawn(send_email_queue) spawn(send_sms_queue) green_pool = pool.Pool() server = WSGIServer( ('127.0.0.1', 9191), application, spawn=green_pool, log=logger, error_log=logger ) def shutdown(a, b): print('Shutting down ...') server.close() server.stop(timeout=4) exit() signal.signal(signal.SIGTERM, shutdown) signal.signal(signal.SIGINT, shutdown) # CTRL C server.serve_forever(stop_timeout=4) else: green_pool = pool.Pool() send_pool = pool.Pool() server = WSGIServer( ('127.0.0.1', 9292), application, spawn=green_pool, log=logger, error_log=logger )
def get_http_server(self): try: from flask import Flask, Response, jsonify, request from flask_cors import CORS from gevent.pywsgi import WSGIServer except ImportError: raise ImportError('Flask or its dependencies are not fully installed, ' 'they are required for serving HTTP requests.' 'Please use pip install "jina[flask]" to install it.') app = Flask(__name__) CORS(app) def datauri2binary(datauri: str): import urllib.request if datauri.startswith('data:'): _tmp = urllib.request.urlopen(datauri) return _tmp.file.read() else: self.logger.error(f'expecting data URI, but got {datauri}') def http_error(reason, code): return jsonify({'reason': reason}), code @app.route('/ready') def is_ready(): return Response(status=200) @app.route('/api/<mode>', methods=['POST']) def api(mode): from ..clients import python mode_fn = getattr(python.request, mode, None) if mode_fn is None: return http_error(f'mode: {mode} is not supported yet', 405) content = request.json content['mode'] = mode if 'data' in content: content['data'] = [datauri2binary(d) for d in content['data']] else: return http_error('"data" field is empty', 406) results = get_result_in_json(getattr(python.request, mode)(**content)) return Response(asyncio.run(results), status=200, mimetype='application/json') async def get_result_in_json(req_iter): return [MessageToJson(k) async for k in self._p_servicer.Call(req_iter, None)] # os.environ['WERKZEUG_RUN_MAIN'] = 'true' # log = logging.getLogger('werkzeug') # log.disabled = True # app.logger.disabled = True # app.run('0.0.0.0', 5000) server = WSGIServer((self.args.host, self.args.port_grpc), app, log=None) def close(*args, **kwargs): server.stop() self.unset_ready() self.is_shutdown.set() from gevent import signal signal.signal(signal.SIGTERM, close) signal.signal(signal.SIGINT, close) # CTRL C self.set_ready() server.serve_forever()