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