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