def start_backdoor(self): self.backdoor_server = BackdoorServer( ('127.0.0.1', 9999), banner='DebugService backdoor server', locals={'dispatcher': self.dispatcher}) gevent.spawn(self.backdoor_server.serve_forever)
def __init__(self, name='', devices=(), backdoor=None): self.name = name self._log = logging.getLogger('{0}.{1}'.format(_log.name, name)) self._log.info('Bootstraping server') if backdoor: from gevent.backdoor import BackdoorServer banner = 'Welcome to Bliss emulator server console.\n' \ 'My name is {0!r}. You can access me through the ' \ '\'server()\' function. Have fun!'.format(name) self.backdoor = BackdoorServer( backdoor, banner=banner, locals=dict(server=weakref.ref(self))) self.backdoor.start() self._log.info('Backdoor opened at %r', backdoor) else: self._log.info('no backdoor declared') self.devices = {} for device in devices: try: self.create_device(device) except Exception as error: dname = device.get('name', device.get('class', 'unknown')) self._log.error( 'error creating device %s (will not be available): %s', dname, error) self._log.debug('details: %s', error, exc_info=1)
def run(self): from gevent.server import StreamServer from gevent.pywsgi import WSGIServer from gevent.backdoor import BackdoorServer import gm.app # NOQA from gm.init_app import application import settings as st # wait for proxy self.ping_proxy() threads = [] logger.info('listening 0.0.0.0:%d', st.WORLD['port']) self.mainServer = StreamServer(('0.0.0.0', st.WORLD['port']), self.handle_client) threads.append(Greenlet.spawn(self.mainServer.serve_forever)) logger.info('listening %s:%d', st.WORLD['managehost'], st.WORLD['manageport']) threads.append( Greenlet.spawn( WSGIServer((st.WORLD['managehost'], st.WORLD['manageport']), application, spawn=pool.Pool(10)).serve_forever)) if os.environ.get("DOCKER_MANAGEHOST"): backdoorhost = "0.0.0.0" else: backdoorhost = "127.0.0.1" logger.info('listening %s:%d', backdoorhost, st.WORLD['backdoorport']) threads.append( Greenlet.spawn( BackdoorServer( (backdoorhost, st.WORLD['backdoorport'])).serve_forever)) # start cron thread import cron_settings # NOQA threads.append(Greenlet.spawn(self.heart_beat)) joinall(threads)
def main(): parser = argparse.ArgumentParser('aya') parser.add_argument('--dbc-username') parser.add_argument('--dbc-password') parser.add_argument('--bearybot') parser.add_argument('--upyun-bucket') parser.add_argument('--upyun-username') parser.add_argument('--upyun-password') parser.add_argument('--redis-url', default='redis://*****:*****@sentry.thbattle.net/4' ) State.options = options = parser.parse_args() utils.logging.init_server(logging.DEBUG, options.sentry, 'aya-1.0', 'aya.log', with_gr_name=False) db.session.init(options.db) gevent.spawn(BackdoorServer(('127.0.0.1', 11111)).serve_forever) def loop(): State.aya = Aya() # State.aya.wait_ready() State.interconnect = AyaInterconnect.spawn('aya', options.redis_url) State.dao = AyaDAO(options.redis_url) State.aya.join() gevent.spawn(loop).join() gevent.sleep(10) # for sentry
def __init__(self, addr, *args, **kwargs): if self.__class__.__instance is not None: raise RuntimeError( 'only one backdoor server allowed to be running') self.addr = addr self.server = BackdoorServer(addr) Greenlet.__init__(self, *args, **kwargs)
def run(self): container = create_container(self.config) install_plugins(container, self.config.get('plugins', {})) install_interfaces(container, self.config.get('interfaces', {})) for cls_name in self.args.get('--interface', ()): cls = import_object(cls_name) container.install(cls) if self.args.get('--debug'): from gevent.backdoor import BackdoorServer backdoor = BackdoorServer(('127.0.0.1', 5005), locals={'container': container}) gevent.spawn(backdoor.serve_forever) def handle_signal(): logger.info('caught SIGINT/SIGTERM, pid=%s', os.getpid()) container.stop() container.join() sys.exit(0) gevent.signal(signal.SIGINT, handle_signal) gevent.signal(signal.SIGTERM, handle_signal) setproctitle('lymph-instance (identity: %s, endpoint: %s, config: %s)' % ( container.identity, container.endpoint, self.config.source, )) container.start(register=not self.args.get('--isolated', False)) if self.args.get('--reload'): set_source_change_callback(container.stop) container.join()
def start_backdoor(self, backlog=50): """Start a backdoor server on a local UNIX domain socket. """ backdoor_path = self.get_backdoor_path() try: os.remove(backdoor_path) except OSError as error: if error.errno != errno.ENOENT: raise else: logger.warning("A backdoor socket has been found and deleted.") mkdir(os.path.dirname(backdoor_path)) backdoor_sock = gevent.socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) backdoor_sock.setblocking(0) backdoor_sock.bind(backdoor_path) user = pwd.getpwnam(config.cmsuser) # We would like to also set the user to "cmsuser" but only root # can do that. Therefore we limit ourselves to the group. os.chown(backdoor_path, os.getuid(), user.pw_gid) os.chmod(backdoor_path, 0o770) backdoor_sock.listen(backlog) self.backdoor = BackdoorServer(backdoor_sock, locals={'service': self}) self.backdoor.start()
def main(): global context global app parser = argparse.ArgumentParser() parser.add_argument("-p", "--pid-file", help="location to write process ID", required=False) args = parser.parse_args() if args.pid_file is not None: with open(args.pid_file, "w") as pid_file: pid_file.write(str(os.getpid()) + "\n") app = create_app() #from . import emergency # we do this late so app is available for import with app.app_context(): try: backdoor = BackdoorServer( ('127.0.0.1', app.config["BACKEND_BACKDOOR_SERVER_PORT"]), locals=locals()) backdoor.start() server() except KeyboardInterrupt as e: l.debug("shutting down")
def __init__(self, devices=(), backdoor=None): self._log = _log self._log.info("Bootstraping server") if backdoor: from gevent.backdoor import BackdoorServer banner = ("Welcome to Simulator server console.\n" "You can access me through the " "'server()' function. Have fun!") self.backdoor = BackdoorServer( backdoor, banner=banner, locals=dict(server=weakref.ref(self))) self.backdoor.start() self._log.info("Backdoor opened at %r", backdoor) else: self._log.info("no backdoor declared") self.devices = {} for device in devices: try: self.create_device(device) except Exception as error: dname = device.get("name", device.get("class", "unknown")) self._log.error( "error creating device %s (will not be available): %s", dname, error) self._log.debug("details: %s", error, exc_info=1)
def startbackdoor(host=None, port=8998): if get_config('DONT_USE_GEVENT'): raise('Backdoor is not available') if host is None: host=HOST from gevent.backdoor import BackdoorServer print('Backdoor is on %s:%s' % (host, port)) bs = BackdoorServer((host, port), locals()) bs.start()
def main(): global interconnect, aya logging.basicConfig(level=logging.DEBUG) gevent.spawn(BackdoorServer(('127.0.0.1', 11111)).serve_forever) aya = Aya() # aya.wait_ready() interconnect = AyaInterconnect.spawn('aya', options.redis_url) aya.join()
def start_server(self, host='localhost', port=None): "Start a server on HOST and PORT." assert port is not None if self.where is not None: self.stop_server() self.where = host, port log.info("Installing backdoor on %s, port %d.", host, port) from gevent.backdoor import BackdoorServer server = BackdoorServer(self.where) server.start()
def handle_run(args): store = Storage(args.root) transport = Transport(args.listen) node = LogicNode(transport.endpoint(), store) if args.backdoor: from gevent.backdoor import BackdoorServer BackdoorServer(('127.0.0.1', args.backdoor), banner="Hello from gevent backdoor!", locals={ 'node': node }).start() gevent.wait()
def start_backdoor(self): if not self.gevent: raise RpcException(errno.ENOTSUP, 'Not supported') from gevent import spawn from gevent.backdoor import BackdoorServer self.backdoor_server = BackdoorServer( ('127.0.0.1', 9999), banner='DebugService backdoor server', locals=self.backdoor_locals) spawn(self.backdoor_server.serve_forever())
def start_server(): def _exit_handler(*a, **k): gevent.kill(MAIN, SystemExit) sig(signal.SIGTERM, _exit_handler) from game import autoenv import argparse parser = argparse.ArgumentParser(prog=sys.argv[0]) parser.add_argument('node', type=str) parser.add_argument('--host', default='0.0.0.0', type=str) parser.add_argument('--port', default=9999, type=int) parser.add_argument('--backdoor-host', default='127.0.0.1', type=str) parser.add_argument('--backdoor-port', default=19999, type=int) parser.add_argument('--no-backdoor', action='store_true') parser.add_argument('--freeplay', action='store_true') parser.add_argument('--log', default='INFO') parser.add_argument('--logfile', default='') parser.add_argument('--gidfile', default='') parser.add_argument('--credit-multiplier', type=float, default=1) parser.add_argument('--no-counting-flee', action='store_true') parser.add_argument('--archive-path', default='') parser.add_argument('--interconnect', action='store_true', default=False) parser.add_argument('--redis-url', default='redis://localhost:6379') parser.add_argument('--discuz-authkey', default='Proton rocks') parser.add_argument('--db', default='sqlite:////dev/shm/thb.sqlite3') options = parser.parse_args() import options as opmodule opmodule.options = options import db.session db.session.init(options.db) autoenv.init('Server') import settings utils.logging.init_server(getattr(logging, options.log.upper()), settings.SENTRY_DSN, settings.VERSION, options.logfile) if not options.no_backdoor: from gevent.backdoor import BackdoorServer gevent.spawn(BackdoorServer((options.backdoor_host, options.backdoor_port)).serve_forever) from server.core import Client root = logging.getLogger() root.info('=' * 20 + settings.VERSION + '=' * 20) server = StreamServer((options.host, options.port), Client.serve, None) server.serve_forever()
def init_device(self): Device.init_device(self) self.debug_stream("In init_device() of controller") self.group_dict = {} if self.BackdoorPort: print "Starting Backdoor server on port", self.BackdoorPort server = BackdoorServer(('127.0.0.1', self.BackdoorPort), banner="BlissAxisManager back door", locals={'axis_manager': self}) gevent.spawn(server.serve_forever) self.__backdoor_server = server else: print " no backdoor"
def backdoor(self): self.logger.debug('Spawning Backdoor Greenlet') self.logger.warning( "The backdoor server should be used for dev purposes only!") if self.config.backdoor_host == "0.0.0.0": self.logger.warning( "Backdoor server should never bind to 0.0.0.0! This is extremely dangerous!" ) server = BackdoorServer( (self.config.backdoor_host, self.config.backdoor_port), locals={'bot': self}) server.serve_forever()
def run(self, auto_join=False): """ Runs Dissonance, loading all the modules, starting the web service, and starting the adapter. If auto_join=True, this function will not return, and will run until dissonance stops if starting dissonance from outside of a greenlet. """ if self.running: raise RuntimeError("Dissonance is already running!") logger.info("Starting Dissonance v%s", self.version) logger.info("Starting storage %s", self._storage) self._storage.start() logger.info("Loading modules") self.modules.load_all() if getattr(self.config, 'web', False) or str( self._opts.get('web', False)).upper() == 'TRUE': self._web = Web( self, EnvFallbackDict('web', getattr(self.config, 'web_opts', {}))) self._web.start() if getattr(self.config, 'manhole', False): from gevent.backdoor import BackdoorServer manhole_opts = EnvFallbackDict( 'manhole', getattr(self.config, 'manhole_opts', {})) self._manhole = BackdoorServer( (manhole_opts.get('listen_host', '127.0.0.1'), int(manhole_opts.get('listen_port', 9001))), locals={'client': self.client}) self._manhole.start() logger.info("Attempting to log in as %s" % self._opts['email']) self.client.login(self._opts['email'], self._opts['password']) logger.info("Starting connection to Discord") self.client.start() self._storage_sync_periodic.start(right_away=False) self._stop_event.clear() # If we are the main greenlet, chances are we probably want to never return, # so the main greenlet won't exit, and tear down everything with it. if auto_join and gevent.get_hub().parent == gevent.getcurrent(): self.join()
def get_backdoor_server(self, listen_addr, **context): """Add a backdoor (debug) server.""" from django.conf import settings local_vars = { 'launcher': self, 'servers': self.servers, 'pgworker': self.pgworker, 'stop': self.stop, 'api': self.api, 'resource': self.resource, 'settings': settings, 'wsgi_app': self.wsgi_app, 'wsgi_name': self.wsgi_name, } local_vars.update(context) return BackdoorServer( listen_addr, banner='Django DDP', locals=local_vars, )
def _start_backdoor_terminal(self): # XXX(Mouad): Imported here since this is still broken in Python3.x from gevent.backdoor import BackdoorServer try: ip = self.config.get_raw('debug.backdoor_ip') except KeyError: ip = '127.0.0.1' port = get_unused_port() endpoint = '%s:%s' % (ip, port) banner = "Welcome to backdoor Terminal of %s" % self.container.service_name backdoor = BackdoorServer( endpoint, locals={'container': self.container, 'dump_stacks': dump_stacks}, banner=banner) gevent.spawn(backdoor.serve_forever) self.container.backdoor_endpoint = endpoint
def provide_backdoor_server(self, debug_console_context): backdoor = BackdoorServer(('127.0.0.1', self.console_port), debug_console_context) return gevent.Greenlet(backdoor.serve_forever)
(rec.msg, rec.args)), ) fmter = ServerLogFormatter() root = logging.getLogger() root.setLevel(getattr(logging, options.log.upper())) std = logging.StreamHandler(stream=sys.stdout) std.setFormatter(fmter) root.handlers = [] root.addHandler(std) if options.logfile: from logging.handlers import WatchedFileHandler filehdlr = WatchedFileHandler(options.logfile) filehdlr.setFormatter(fmter) root.addHandler(filehdlr) if not options.no_backdoor: from gevent.backdoor import BackdoorServer gevent.spawn( BackdoorServer(('127.0.0.1', options.backdoor_port)).serve_forever) from server.core import Client root.info('=' * 20 + settings.VERSION + '=' * 20) server = StreamServer(('0.0.0.0', options.port), Client.spawn, None) server.serve_forever()
def start_backdoor(self): from gevent.backdoor import BackdoorServer import gevent self.bds = BackdoorServer(('127.0.0.1', 12345)) self.gr_bds = gevent.spawn(self.bds.serve_forever)
) groups_on = [int(i) for i in dao.get_all_groups_on()] gids = [ g['gid'] for g in aya.group_list if aya.gcode2groupnum(g['code']) in groups_on ] pool.map_async( lambda f: f(), [partial(aya.send_group_message, i, send) for i in gids]) def publish(self, topic, data): lock = self.lock if not lock: lock = RLock() self.lock = lock with lock: return InterconnectBase.publish(self, topic, data) logging.basicConfig(level=logging.DEBUG) from gevent.backdoor import BackdoorServer gevent.spawn(BackdoorServer(('127.0.0.1', 11111)).serve_forever) aya = Aya(options.qq, options.password) aya.loop()
self.msg(user.nick, "Yahoo answers cannot answer %r" % match.group(1)) self.msg(user.nick, "Try: \"Does napping make you smarter?\"") else: self.msg(user.nick, "Can't understand your command: \"%s\"" % message) if __name__ == '__main__': from girclib.helpers import setup_logging setup_logging(level=5) client = YahooAnswerBot('irc.freenode.net', 6667, 'girclib', 'gIRClib') # Just for the fun, start telnet backdoor on port 2000 from gevent.backdoor import BackdoorServer server = BackdoorServer(('127.0.0.1', 2000), locals=locals()) server.start() @signals.on_signed_on.connect def _on_motd(emitter): log.info("Signed on. Let's join #ufs") client.join("#ufs") @signals.on_disconnected.connect def disconnected(emitter): log.info("Exited!?") try: gevent.shutdown() except AssertionError: # Shutting down is only possible from MAIN greenlet pass
def start_server(): def _exit_handler(*a, **k): gevent.kill(MAIN, SystemExit) sig(signal.SIGTERM, _exit_handler) from game import autoenv import argparse parser = argparse.ArgumentParser(prog=sys.argv[0]) parser.add_argument('node', type=str) parser.add_argument('--host', default='0.0.0.0', type=str) parser.add_argument('--port', default=9999, type=int) parser.add_argument('--backdoor-host', default='127.0.0.1', type=str) parser.add_argument('--backdoor-port', default=19999, type=int) parser.add_argument('--no-backdoor', action='store_true') parser.add_argument('--freeplay', action='store_true') parser.add_argument('--log', default='INFO') parser.add_argument('--logfile', default='') parser.add_argument('--gidfile', default='') parser.add_argument('--credit-multiplier', type=float, default=1) parser.add_argument('--no-counting-flee', action='store_true') parser.add_argument('--archive-path', default='') parser.add_argument('--interconnect', action='store_true', default=False) parser.add_argument('--redis-url', default='redis://localhost:6379') parser.add_argument('--member-service', default='localhost:7000') options = parser.parse_args() import options as opmodule opmodule.options = options autoenv.init('Server') import settings class ServerLogFormatter(logging.Formatter): def format(self, rec): if rec.exc_info: s = [] s.append('>>>>>>' + '-' * 74) s.append(self._format(rec)) import traceback s.append(u''.join(traceback.format_exception(*rec.exc_info)).strip()) s.append('<<<<<<' + '-' * 74) return u'\n'.join(s) else: return self._format(rec) def _format(self, rec): from game.autoenv import Game import time try: g = Game.getgame() except: g = gevent.getcurrent() gr_name = getattr(g, 'gr_name', None) or repr(g) gr_name = 'MAIN' if g is MAIN else gr_name return u'[%s %s %s] %s' % ( rec.levelname[0], time.strftime('%y%m%d %H:%M:%S'), gr_name.decode('utf-8'), rec.msg % rec.args if isinstance(rec.msg, basestring) else repr((rec.msg, rec.args)), ) fmter = ServerLogFormatter() root = logging.getLogger() root.setLevel(getattr(logging, options.log.upper())) std = logging.StreamHandler(stream=sys.stdout) std.setFormatter(fmter) root.handlers = [] root.addHandler(std) if options.logfile: from logging.handlers import WatchedFileHandler filehdlr = WatchedFileHandler(options.logfile) filehdlr.setFormatter(fmter) root.addHandler(filehdlr) if not options.no_backdoor: from gevent.backdoor import BackdoorServer gevent.spawn(BackdoorServer((options.backdoor_host, options.backdoor_port)).serve_forever) from server.core import Client root.info('=' * 20 + settings.VERSION + '=' * 20) server = StreamServer((options.host, options.port), Client.spawn, None) server.serve_forever()
from gevent.backdoor import BackdoorServer server = BackdoorServer(('148.70.186.152', 8885), banner="Hello from gevent backdoor!", locals={'foo': "From defined scope!"}) server.serve_forever()
def handle_backdoor(num, stack): server = BackdoorServer(('127.0.0.1', 4998)) server.start()
#!/usr/bin/env python #!encoding=utf8 from gevent.backdoor import BackdoorServer BackdoorServer(('127.0.0.1', 9000)).serve_forever()
def main(stdscr, *args, **kwargs): global answer, feedback, candidates gevent.signal( signal.SIGUSR1, lambda *args: game_close.set()) # For standard/graceful restart # gevent.signal(signal.SIGINT, lambda *args: None) # Disable SIGINT # signal.signal(signal.SIGQUIT, signal.SIG_IGN) # Disable SIGQUIT # signal.signal(signal.SIGTSTP, signal.SIG_IGN) # Disable SIGTSTP logging.info("Window bounds: %s", stdscr.getmaxyx()) backdoor = BackdoorServer(('0.0.0.0', 4200)) backdoor.start() logging.info("Backdoor started") curses.curs_set(0) # Cursor invisible stdscr.nodelay(1) # Nonblocking input MAXY, MAXX = stdscr.getmaxyx() curses.init_pair(PAIR_MAIN, *DEFAULT_COLORS) curses.init_pair(PAIR_AI, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(PAIR_FEEDBACK, curses.COLOR_WHITE, curses.COLOR_BLACK) curses.init_pair(PAIR_TAGGED, curses.COLOR_YELLOW, curses.COLOR_BLACK) rightscr = stdscr.subwin(0, SPLIT) leftscr = stdscr.subwin(VERTSPLIT, SPLIT, 0, 0) logging.info("Right screen from %s, size %s", rightscr.getbegyx(), rightscr.getmaxyx()) logging.info("Left screen from %s, size %s", leftscr.getbegyx(), leftscr.getmaxyx()) feedback = SlowtypeWindow((VERTSPLIT, 1), (MAXY - VERTSPLIT - 1, SPLIT - 1)) answer = random.choice(get_words(WORDS_PATH)) candidates = get_closest(answer, WORDS_PATH, NUM_CANDIDATES - 1) + [answer] shuffle_main(leftscr, candidates) g_key_handler = spawn(key_handler, stdscr, leftscr) first_key.wait() g_chatter = spawn(timed_chat, rightscr, MAXY - 2) won = game_win_state.get() do_ai_fast.set() ai_done.wait() g_key_handler.kill() g_chatter.kill() feedback.wait() if not won: end(stdscr, "LOSS") attr = curses.color_pair(PAIR_MAIN) leftscr.move(0, 0) leftscr.clear() leftscr.addstr( """WARNING Experiment 203 (Synthetic Reasoning, Combat) has breached containment. Please select a course of action. (1) Isolate system and scrub disks (This will destroy all research on Experiment 203) (2) Release remaining locks, allow experiment full access to base (MAY BE DANGEROUS) (3) Activate Emergency Base Procedure XK-682 """, attr) leftscr.refresh() first = True while 1: c = gevent_getch(sys.stdin, stdscr) if c == ord('1'): end(stdscr, "DESTROY") elif c == ord('2'): end(stdscr, "RELEASE") elif c == ord('3') and first: first = False logging.info("User attempted to arm the nukes") n = 3 leftscr.addstr("Arming nuclear warheads.\nActivation in ", attr) y, x = leftscr.getyx() for i in range(n, -1, -1): leftscr.move(y, x) leftscr.addstr("%d seconds..." % i, attr) leftscr.refresh() gevent.sleep(1) leftscr.addstr( "\nERROR\nYou do not have security permissions\n to perform this action.", attr) leftscr.refresh()