def init(logger):
logger.info('starting server')
loop = asyncio.get_event_loop()
coro = asyncio.start_unix_server(handle_message,
path=settings.sys.get('socket'),
loop=loop)
return loop.run_until_complete(coro)
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--log-level', default='INFO')
arg_parser.add_argument('--port', type=int, default=8888)
arg_parser.add_argument('--maintenance-port', type=int, default=None)
arg_parser.add_argument('--maintenance-unix-path', default=None)
args = arg_parser.parse_args()
logging.basicConfig(format='%(levelname)s: %(message)s', level=args.log_level)
loop = asyncio.get_event_loop()
server = loop.run_until_complete(asyncio.start_server(handle_client, port=args.port))
log.info('Serving on %s', format_sockname(server.sockets[0].getsockname()))
servers.add(server)
if args.maintenance_port:
server = loop.run_until_complete(asyncio.start_server(handle_maintenance_client, port=args.maintenance_port))
servers.add(server)
log.info('Serving maintenance on %s', format_sockname(server.sockets[0].getsockname()))
if args.maintenance_unix_path:
path = args.maintenance_unix_path
server = loop.run_until_complete(asyncio.start_unix_server(handle_maintenance_client, path))
servers.add(server)
log.info('Serving maintenance on %s', path)
try:
loop.run_until_complete(asyncio.gather(*(s.wait_closed() for s in servers)))
except KeyboardInterrupt:
pass
loop.close()
print_stats()
def test_forward_remote_path(self):
"""Test forwarding of a remote UNIX domain path"""
# pylint doesn't think start_unix_server exists
# pylint: disable=no-member
server = yield from asyncio.start_unix_server(echo, 'local')
# pylint: enable=no-member
path = os.path.abspath('echo')
with (yield from self.connect()) as conn:
listener = yield from conn.forward_remote_path(path, 'local')
yield from self._check_local_unix_connection('echo')
listener.close()
yield from listener.wait_closed()
yield from conn.wait_closed()
server.close()
yield from server.wait_closed()
os.remove('echo')
os.remove('local')
def setup_inputs(args, cfg, queue, stats, loop, geoip_reader, outputs_enabled):
"""setup inputs"""
# define callback on new connection
cb_lambda = lambda r, w: cb_onconnect(r, w, cfg, queue, stats, geoip_reader, outputs_enabled)
# asynchronous unix socket
if cfg["input"]["unix-socket"]["path"] is not None:
clogger.debug("Input handler: unix socket")
clogger.debug("Input handler: listening on %s" % args.u)
socket_server = asyncio.start_unix_server(cb_lambda,
path=cfg["input"]["unix-socket"]["path"],
loop=loop)
# default mode: asynchronous tcp socket
else:
clogger.debug("Input handler: tcp socket")
ssl_context = None
if cfg["input"]["tcp-socket"]["tls-support"]:
ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_context.load_cert_chain(certfile=cfg["input"]["tcp-socket"]["tls-server-cert"],
keyfile=cfg["input"]["tcp-socket"]["tls-server-key"])
clogger.debug("Input handler - tls support enabled")
clogger.debug("Input handler: listening on %s:%s" % (cfg["input"]["tcp-socket"]["local-address"],
cfg["input"]["tcp-socket"]["local-port"])),
socket_server = asyncio.start_server(cb_lambda,
cfg["input"]["tcp-socket"]["local-address"],
cfg["input"]["tcp-socket"]["local-port"],
ssl=ssl_context,
loop=loop)
# run until complete
loop.run_until_complete(socket_server)
def start_manhole(banner=None,
host='127.0.0.1',
port=None,
path=None,
namespace=None,
loop=None,
threaded=False,
command_timeout=5,
shared=False):
"""Starts a manhole server on a given TCP and/or UNIX address.
Keyword arguments:
banner - Text to display when client initially connects.
host - interface to bind on.
port - port to listen on over TCP. Default is disabled.
path - filesystem path to listen on over UNIX sockets. Deafult is disabled.
namespace - dictionary namespace to provide to connected clients.
threaded - if True, use a threaded interpreter. False, run them in the
middle of the event loop. See ThreadedInteractiveInterpreter
for details.
command_timeout - timeout in seconds for commands. Only applies if
`threaded` is True.
shared - If True, share a single namespace between all clients.
Returns a Future for starting the server(s).
"""
loop = loop or asyncio.get_event_loop()
if (port, path) == (None, None):
raise ValueError('At least one of port or path must be given')
if threaded:
interpreter_class = functools.partial(ThreadedInteractiveInterpreter,
command_timeout=command_timeout)
else:
interpreter_class = InteractiveInterpreter
client_cb = InterpreterFactory(interpreter_class,
shared=shared,
namespace=namespace,
banner=banner,
loop=loop)
coros = []
if path:
f = asyncio.ensure_future(
asyncio.start_unix_server(client_cb, path=path, loop=loop))
coros.append(f)
if port:
f = asyncio.ensure_future(asyncio.start_server(client_cb,
host=host,
port=port,
loop=loop),
loop=loop)
coros.append(f)
return asyncio.gather(*coros, loop=loop)
async def _do_accept(self,
address: SocketAddrT,
ssl: Optional[SSLContext] = None) -> None:
"""
Acting as the transport server, accept a single connection.
:param address:
Address to listen on; UNIX socket path or TCP address/port.
:param ssl: SSL context to use, if any.
:raise OSError: For stream-related errors.
"""
self.logger.debug("Awaiting connection on %s ...", address)
connected = asyncio.Event()
server: Optional[asyncio.AbstractServer] = None
async def _client_connected_cb(reader: asyncio.StreamReader,
writer: asyncio.StreamWriter) -> None:
"""Used to accept a single incoming connection, see below."""
nonlocal server
nonlocal connected
# A connection has been accepted; stop listening for new ones.
assert server is not None
server.close()
await server.wait_closed()
server = None
# Register this client as being connected
self._reader, self._writer = (reader, writer)
# Signal back: We've accepted a client!
connected.set()
if isinstance(address, tuple):
coro = asyncio.start_server(
_client_connected_cb,
host=None if self._sock else address[0],
port=None if self._sock else address[1],
ssl=ssl,
backlog=1,
limit=self._limit,
sock=self._sock,
)
else:
coro = asyncio.start_unix_server(
_client_connected_cb,
path=None if self._sock else address,
ssl=ssl,
backlog=1,
limit=self._limit,
sock=self._sock,
)
server = await coro # Starts listening
await connected.wait() # Waits for the callback to fire (and finish)
assert server is None
self._sock = None
self.logger.debug("Connection accepted.")
def main(args):
cfg = NetConfig(args.config)
nw = NetWatcher(cfg.query_class(cfg.cfg), cfg.notify_class(cfg.cfg),
cfg.activate_class(cfg.cfg))
if args.daemon:
signal.signal(signal.SIGTERM, CleanExitException.exit_handler)
loop = asyncio.get_event_loop()
try:
asyncio.ensure_future(poll_handler(nw))
loop.create_task(
asyncio.start_unix_server(functools.partial(socket_handler,
nw=nw),
path='/run/pircons/sock'))
loop.run_forever()
except (KeyboardInterrupt, CleanExitException):
sys.exit(0)
elif args.trip:
socket_client(0)
elif args.reset:
socket_client(1)
else:
logger.debug(
"Don't know how we got here, but somehow no mode option was chosen. Guess we'll quit."
)
sys.exit(255)
def main():
config = _parse_command_line()
if config.debug:
# Equivalent of PYTHONASYNCIODEBUG=1 in 3.4; pylint: disable=protected-access
asyncio.tasks._DEBUG = True
_configure_logging(verbose=config.verbose, debug=config.debug)
ports_to_serve = _parse_port_ranges(config.portserver_static_pool)
if not ports_to_serve:
log.error('No ports. Invalid port ranges in --portserver_static_pool?')
sys.exit(1)
request_handler = _PortServerRequestHandler(ports_to_serve)
event_loop = asyncio.get_event_loop()
event_loop.add_signal_handler(signal.SIGUSR1, request_handler.dump_stats)
coro = asyncio.start_unix_server(
request_handler.handle_port_request,
path=config.portserver_unix_socket_address.replace('@', '\0', 1),
loop=event_loop)
server_address = config.portserver_unix_socket_address
server = event_loop.run_until_complete(coro)
log.info('Serving on %s', server_address)
try:
event_loop.run_forever()
except KeyboardInterrupt:
log.info('Stopping due to ^C.')
server.close()
event_loop.run_until_complete(server.wait_closed())
event_loop.remove_signal_handler(signal.SIGUSR1)
event_loop.close()
request_handler.dump_stats()
log.info('Goodbye.')
def __init__(self, app, name, config):
self._app = app
self._name = name
self._config = config
self._procs = {}
self._handler = LogRotator(_log_prefix(app, name)+".json", maxBytes=2**24, backupCount=16, encoding="utf-8")
self._control = asyncio.ensure_future(asyncio.start_unix_server(self._handle_control, path=_log_prefix(self._app, self._name) + '.sock'))
def test_forward_remote_path(self):
"""Test forwarding of a remote UNIX domain path"""
# pylint doesn't think start_unix_server exists
# pylint: disable=no-member
server = yield from asyncio.start_unix_server(echo, 'local')
# pylint: enable=no-member
path = os.path.abspath('echo')
with (yield from self.connect()) as conn:
listener = yield from conn.forward_remote_path(path, 'local')
yield from self._check_local_unix_connection('echo')
listener.close()
yield from listener.wait_closed()
yield from conn.wait_closed()
server.close()
yield from server.wait_closed()
os.remove('echo')
os.remove('local')
def client_run(self, args):
async def handler(reader, writer):
await self.conn.put((reader, writer))
if self.uri.unix:
return asyncio.start_unix_server(handler, path=self.uri.bind)
else:
return asyncio.start_server(handler, host=self.uri.host_name, port=self.uri.port, reuse_port=args.get('ruport'))
def run():
loop = asyncio.get_event_loop()
# Register socket-server coroutine
server_coro = asyncio.start_unix_server(handle_client,
config.SOCK_FILE,
loop=loop)
server = loop.run_until_complete(server_coro)
print('Servier on {}'.format(server.sockets[0].getsockname()),
file=sys.stdout,
flush=True)
if not config.JOBS_SCHEDULE_PATH.exists(): create_jobs_schedule()
# Register handle of jobs's schedule coroutine
h_jobs_schedule = loop.create_task(handle_jobs_schedule())
# Set mode to allow anyone to access
os.chmod(config.SOCK_FILE, 0o777)
os.chmod(config.JOBS_SCHEDULE_PATH, 0o777)
# Run loop
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Close all
h_jobs_schedule.cancel()
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
def start(self, loop=None, run_loop=True):
loop = loop or asyncio.get_event_loop()
if self.debug:
print('Starting block server (%r) on %s:%s' % (self.cas, self.host, self.port))
socket_coro = asyncio.start_server(self.handle_client, self.host, self.port, loop=loop)
socket_server = loop.run_until_complete(socket_coro)
if self.unix_socket:
if self.debug:
print('Starting block server (%r) on %s' % (self.cas, self.unix_socket))
unix_coro = asyncio.start_unix_server(self.handle_client, path=self.unix_socket, loop=loop)
unix_server = loop.run_until_complete(unix_coro)
else:
unix_server = None
if run_loop:
try:
loop.run_forever()
except KeyboardInterrupt:
pass
socket_server.close()
loop.run_until_complete(socket_server.wait_closed())
if unix_server:
unix_server.close()
loop.run_until_complete(unix_server.wait_closed())
loop.close()
else:
return socket_server
def main():
global USocketServer
with open(sys.argv[1], 'r') as f:
conf.update(json.load(f))
tasks = []
## Start UNIX socket listening
USocketServer = asyncio.start_unix_server(sockHandler,
path=conf['UNIXSocket'])
ssl_context = None
if (conf['SSL']):
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS)
ssl_context.load_cert_chain(conf['SSLCert'], conf['SSLPrivKey'])
wsserver = websockets.serve(wshandler,
conf['host'],
conf['port'],
ssl=ssl_context)
#tasks.append(asyncio.ensure_future(closews()))
#tasks.append(asyncio.ensure_future(broadcast('/qwerty/')))
tasks.append(asyncio.ensure_future(wsserver))
tasks.append(asyncio.ensure_future(USocketServer))
return tasks
def main():
config = _parse_command_line()
if config.debug:
# Equivalent of PYTHONASYNCIODEBUG=1 in 3.4; pylint: disable=protected-access
asyncio.tasks._DEBUG = True
_configure_logging(verbose=config.verbose, debug=config.debug)
ports_to_serve = _parse_port_ranges(config.portserver_static_pool)
if not ports_to_serve:
log.error(
'No ports. Invalid port ranges in --portserver_static_pool?')
sys.exit(1)
request_handler = _PortServerRequestHandler(ports_to_serve)
event_loop = asyncio.get_event_loop()
event_loop.add_signal_handler(signal.SIGUSR1, request_handler.dump_stats)
coro = asyncio.start_unix_server(
request_handler.handle_port_request,
path=config.portserver_unix_socket_address.replace('@', '\0', 1),
loop=event_loop)
server_address = config.portserver_unix_socket_address
server = event_loop.run_until_complete(coro)
log.info('Serving on %s', server_address)
try:
event_loop.run_forever()
except KeyboardInterrupt:
log.info('Stopping due to ^C.')
server.close()
event_loop.run_until_complete(server.wait_closed())
event_loop.remove_signal_handler(signal.SIGUSR1)
event_loop.close()
request_handler.dump_stats()
log.info('Goodbye.')
def bridge_sockets(localpath: str, targetpath: str, loop=None) -> Coroutine:
"""Create a socket bridge UNIX listener."""
# Read the socket early to error out if something is wrong
read_assuan_socket_config(targetpath)
return asyncio.start_unix_server(create_handler(targetpath),
localpath,
loop=loop)
def initialize(self):
# Make all exceptions fatal for easier debugging
self.loop.set_exception_handler(self._exception_handler)
tasks = []
logger.info("Loading network state")
self.ns = NetworkState()
self.ctx = rulebook.runtime.Context()
self.ctx.ns.ns = self.ns # Make the NetworkState available under the name 'ns'
# in the namespace of the rulebooks (a bit unfortunate
# clash of acronyms, TODO better naming).
self.ctx.ns.logger = logging.getLogger('ns_rbk')
yield from self.ns.start()
logger.info("Loading configuration")
self._load_rules([RULES_BUILTIN, RULES_USER])
ctl_path = str(RUNDIR / 'ctl.sock')
try: os.unlink(ctl_path)
except FileNotFoundError: pass
yield from asyncio.start_unix_server(self._unix_conn, ctl_path)
if HAVE_IPYTHON:
self.ipython.ns['ns'] = self.ns
self.ipython.ns['ctx'] = self.ctx
self.ipython.start()
logger.info("IPython ready. Connect with: ``nsctl console`` or ``ipython console --existing %s``",
self.ipython.app.connection_file)
def set_up_unix_server():
global loop, unix_server
if not loop:
loop = uvloop.new_event_loop()
asyncio.set_event_loop(loop)
coro = asyncio.start_unix_server(serve, PATH)
unix_server = loop.run_until_complete(coro)
def start_server(self, args):
handler = functools.partial(reuse_stream_handler if self.reuse else stream_handler, **vars(self), **args)
if self.backward:
return self.backward.start_server(handler)
elif self.unix:
return asyncio.start_unix_server(handler, path=self.bind, ssl=self.sslserver)
else:
return asyncio.start_server(handler, host=self.host_name, port=self.port, ssl=self.sslserver, reuse_port=args.get('ruport'))
def start(self) -> None:
"""Start the server"""
assert self.server is None
logger.debug("Starting server")
server_coroutine = asyncio.start_unix_server(self._server_callback,
sock=self.sock)
self.server = self.loop.run_until_complete(server_coroutine)
def start(self):
self.loop = asyncio.get_event_loop()
self.loop.add_signal_handler(signal.SIGTERM, self.stop)
self._watcher = self.loop.create_task(self.ghost_killer())
import sys
if sys.hexversion >= 0x30A00B1:
# py3.10 drops the loop argument of create_task.
self.loop.create_task(
asyncio.start_unix_server(self.handle, path=self.socket_path))
else:
self.loop.create_task(
asyncio.start_unix_server(self.handle,
path=self.socket_path,
loop=self.loop))
self.loop.run_forever()
def start_server(self, args):
handler = functools.partial(reuse_stream_handler if self.reuse else stream_handler, **vars(self), **args)
if self.backward:
return self.backward.start_server(handler)
elif self.unix:
return asyncio.start_unix_server(handler, path=self.bind, ssl=self.sslserver)
else:
return asyncio.start_server(handler, host=self.host_name, port=self.port, ssl=self.sslserver, reuse_port=args.get('ruport'))
def run_servers():
tasks = []
for pair in config.proxies:
server = ForwardServer(config.cygwin, pair[0])
tasks.append(
asyncio.start_unix_server(server.handle_connected, pair[1]))
return asyncio.gather(*tasks)
async def start(self) -> None:
"""Start the server"""
assert self.server is None
logger.debug("Starting server")
server_coroutine = asyncio.start_unix_server(self._server_callback,
sock=self.sock)
self.server = await server_coroutine
def _command_server(self):
if os.path.exists("/home/austin/uds_socket"):
os.remove("/home/austin/uds_socket")
loop = new_event_loop()
set_event_loop(loop)
loop.create_task(
start_unix_server(self._read_commands_from_socket,
"/home/austin/uds_socket"))
loop.run_forever()
def start(self, path):
"""Start a new mock SSH agent"""
self._path = path
# pylint doesn't think start_unix_server exists
# pylint: disable=no-member
self._server = \
yield from asyncio.start_unix_server(self.process_request, path)
def start_server(self, args, stream_handler=stream_handler):
handler = functools.partial(stream_handler, **vars(self), **args)
if self.unix:
return asyncio.start_unix_server(handler, path=self.bind)
else:
return asyncio.start_server(handler,
host=self.host_name,
port=self.port,
reuse_port=args.get('ruport'))
def start(self, path):
"""Start a new mock SSH agent"""
self._path = path
# pylint doesn't think start_unix_server exists
# pylint: disable=no-member
self._server = \
yield from asyncio.start_unix_server(self.process_request, path)
def start(self):
self.loop = asyncio.get_event_loop()
self.loop.add_signal_handler(signal.SIGTERM, self.stop)
self._watcher = self.loop.create_task(self.ghost_killer())
self.loop.create_task(
asyncio.start_unix_server(self.handle,
path=self.socket_path,
loop=self.loop))
self.loop.run_forever()
def __init__(self):
super().__init__([])
loop = self.loop = QEventLoop(self)
asyncio.set_event_loop(loop)
self.loop.add_signal_handler(signal.SIGINT, loop.stop)
asyncio. async (asyncio.start_unix_server(self.ipc_handler,
str(sockfile)))
self.w = Kya('applauncher')
self.w.show()
self.ipc_cmds = {'show': self.w.show}
def start_connection_listener(self):
try:
self._loop = asyncio.new_event_loop()
self._server = asyncio.start_unix_server(self.handle_connection,
self.socket_path,
backlog=self.backlog)
self._loop.create_task(self._server)
self._loop.run_forever()
finally:
self._loop.close()
def run(self, sub_incoming=None):
if self.unix_sock:
logger.info("Starting SMPP server at {}".format(self.unix_sock))
else:
logger.info("Starting SMPP server at {}:{}".format(
self.host, self.port))
self.loop = asyncio.new_event_loop()
if self.incoming_queue or sub_incoming:
self._zmq_ctx = zmq.Context()
if self.incoming_queue:
logger.debug('Setting up pub socker for incoming queue')
self._incoming_pub_socket = self._zmq_ctx.socket(zmq.PUB)
self._incoming_pub_socket.bind(self.incoming_queue)
if sub_incoming:
logger.debug('Setting up sub socket for incoming queue')
self._incoming_sub_socket = self._zmq_ctx.socket(zmq.SUB)
self._incoming_sub_socket.setsockopt_string(
zmq.SUBSCRIBE, self.INCOMING_QUEUE_TOPIC)
for url in sub_incoming:
self._incoming_sub_socket.connect(url)
self._run_incoming_sub()
async def conncb(r: asyncio.StreamReader, w: asyncio.StreamWriter):
conn = Connection(self, r, w)
await self._on_client_connected(conn)
if self.unix_sock:
if os.path.exists(self.unix_sock):
logger.warning(
"Socket at '{}' already exists. Deleting it...".format(
self.unix_sock))
os.remove(self.unix_sock)
server_gen = asyncio.start_unix_server(conncb,
self.unix_sock,
loop=self.loop)
else:
server_gen = asyncio.start_server(conncb,
self.host,
self.port,
loop=self.loop)
self.aserver = self.loop.run_until_complete(server_gen)
try:
self.loop.run_until_complete(self.aserver.wait_closed())
except asyncio.CancelledError:
logger.info('Event loop has been cancelled')
self.loop.close()
def start(self):
Logger.info(tag=_TAG, msg="start() start")
if self._running:
return
self._running = True
co = asyncio.start_unix_server(self._on_accepted, self._path)
asyncio.ensure_future(co)
Logger.info(tag=_TAG, msg="start() end")
def client_run(self):
async def handler(reader, writer):
while not self.conn.empty():
r, w = await self.conn.get()
try: w.close()
except Exception: pass
await self.conn.put((reader, writer))
if self.uri.unix:
return asyncio.start_unix_server(handler, path=self.uri.bind, ssl=self.uri.sslserver)
else:
return asyncio.start_server(handler, host=self.uri.host_name, port=self.uri.port, ssl=self.uri.sslserver)
def pfftserv(path):
log("pfftserv on %s" % path)
loop = asyncio.get_event_loop()
if (os.path.exists(path)):
os.unlink(path)
f = asyncio.start_unix_server(accept_client, path=path)
loop.run_until_complete(f)
loop.run_forever()
loop.close()
def start(self):
"""Start a new mock SSH agent"""
_Agent._seq += 1
path = "bad_agent_" + str(_Agent._seq)
# pylint doesn't think start_unix_server exists
# pylint: disable=no-member
self._server = yield from asyncio.start_unix_server(self.process_request, path)
return path
def test_server():
loop = asyncio.get_event_loop()
@asyncio.coroutine
def connected(reader, writer):
log.info("server: connection from client")
try:
with tap.Connection(reader, writer) as conn:
count = 0
while True:
log.info("server: receiving object from client")
obj = yield from conn.receive()
if obj is None:
break
log.info("server: received object from client")
g = obj[3][0]
print("dir(g) =", dir(g))
print("g.gi_code =", g.gi_code)
print("g.gi_frame =", g.gi_frame)
print("g.gi_running =", g.gi_running)
print("g.send =", g.send)
print("g.throw =", g.throw)
print("repr(g) =", repr(g))
print("GEN BEGIN")
for x in g:
print("GEN:", x)
print("GEN END")
func = obj[0]
func(obj)
count += 1
if count == 2:
obj2 = obj[1:3]
yield from conn.send(obj2)
log.info("server: EOF from client")
log.info("server: connection closed")
finally:
loop.stop()
if os.path.exists("socket"):
os.remove("socket")
loop.run_until_complete(asyncio.start_unix_server(connected, "socket"))
loop.run_forever()
async def start(self, parent_ctx: Context) -> None:
await super().start(parent_ctx)
if isinstance(self.tls_context, str):
self.tls_context = await parent_ctx.request_resource(SSLContext, self.tls_context)
if self.socket_path:
self._server = start_unix_server(
self.handle_client, self.socket_path, backlog=self.backlog, ssl=self.tls_context)
else:
self._server = start_server(
self.handle_client, self.host, self.port, backlog=self.backlog,
ssl=self.tls_context)
async def _connect(self):
while True:
try:
self.device = soco.discovery.by_name(self.zone)
break
except (OSError, TypeError):
await asyncio.sleep(1)
self.rendering_control = self.device.renderingControl.subscribe(
auto_renew=True)
self.executor = ThreadPoolExecutor(max_workers=1)
self.volume_server = asyncio.create_task(
asyncio.start_unix_server(
self._volume_client_connnected,
path=f"/run/user/{os.getuid()}/sonos_volume"))
def start_manhole(banner=None, host='127.0.0.1', port=None, path=None,
namespace=None, loop=None, threaded=False, command_timeout=5,
shared=False):
"""Starts a manhole server on a given TCP and/or UNIX address.
Keyword arguments:
banner - Text to display when client initially connects.
host - interface to bind on.
port - port to listen on over TCP. Default is disabled.
path - filesystem path to listen on over UNIX sockets. Deafult is disabled.
namespace - dictionary namespace to provide to connected clients.
threaded - if True, use a threaded interpreter. False, run them in the
middle of the event loop. See ThreadedInteractiveInterpreter
for details.
command_timeout - timeout in seconds for commands. Only applies if
`threaded` is True.
shared - If True, share a single namespace between all clients.
"""
if (port, path) == (None, None):
raise ValueError('At least one of port or path must be given')
if threaded:
interpreter_class = functools.partial(
ThreadedInteractiveInterpreter, command_timeout=command_timeout)
else:
interpreter_class = InteractiveInterpreter
client_cb = InterpreterFactory(interpreter_class,
shared=shared, namespace=namespace, banner=banner,
loop=loop or asyncio.get_event_loop())
if path:
f = asyncio.async(asyncio.start_unix_server(client_cb, path=path))
@f.add_done_callback
def done(task):
def remove_manhole():
try:
os.unlink(path)
except OSError:
pass
if task.exception() is None:
import atexit
atexit.register(remove_manhole)
if port:
asyncio.async(asyncio.start_server(client_cb, host=host, port=port))
def start_manhole(banner=None, host='127.0.0.1', port=None, path=None,
namespace=None, loop=None, threaded=False, command_timeout=5,
shared=False):
"""Starts a manhole server on a given TCP and/or UNIX address.
Keyword arguments:
banner - Text to display when client initially connects.
host - interface to bind on.
port - port to listen on over TCP. Default is disabled.
path - filesystem path to listen on over UNIX sockets. Deafult is disabled.
namespace - dictionary namespace to provide to connected clients.
threaded - if True, use a threaded interpreter. False, run them in the
middle of the event loop. See ThreadedInteractiveInterpreter
for details.
command_timeout - timeout in seconds for commands. Only applies if
`threaded` is True.
shared - If True, share a single namespace between all clients.
Returns a Future for starting the server(s).
"""
loop = loop or asyncio.get_event_loop()
if (port, path) == (None, None):
raise ValueError('At least one of port or path must be given')
if threaded:
interpreter_class = functools.partial(
ThreadedInteractiveInterpreter, command_timeout=command_timeout)
else:
interpreter_class = InteractiveInterpreter
client_cb = InterpreterFactory(
interpreter_class, shared=shared, namespace=namespace, banner=banner,
loop=loop)
coros = []
if path:
f = asyncio.async(asyncio.start_unix_server(client_cb, path=path, loop=loop))
coros.append(f)
if port:
f = asyncio.async(asyncio.start_server(
client_cb, host=host, port=port, loop=loop), loop=loop)
coros.append(f)
return asyncio.gather(*coros, loop=loop)
def start(path, chain=None, loop=None):
'''
:returns: initialized server
:rtype: asyncio.Server
'''
if loop is None:
loop = asyncio.get_event_loop()
rpc = RPCServer(chain)
server = loop.run_until_complete(asyncio.start_unix_server(
connection_handler(rpc.execute),
path,
loop=loop,
limit=MAXIMUM_REQUEST_BYTES,
))
return server
def update_socket_relay(self, update_socket):
logging.info("Starting bridge socket")
glossia_socket = update_socket
_, writer = yield from asyncio.open_unix_connection(glossia_socket, loop=self._loop)
logging.info("Connected")
socket_location = os.path.join('/shared', 'update.sock')
yield from asyncio.start_unix_server(
functools.partial(handle_relay, writer),
socket_location,
loop=self._loop
)
uid = pwd.getpwnam('glossia').pw_uid
gid = grp.getgrnam('glossia').gr_gid
os.chown(socket_location, uid, gid)
logging.info("Server started")
def factory(name, protocol, address, port):
path = None
threaded = False
shared = False
import aio.app
namespace = {'aio': aio}
banner = 'hello...\n'
loop = asyncio.get_event_loop()
host = address
if (port, path) == (None, None):
raise ValueError('At least one of port or path must be given')
if threaded:
interpreter_class = functools.partial(
ThreadedInteractiveInterpreter)
else:
interpreter_class = InteractiveInterpreter
client_cb = InterpreterFactory(
interpreter_class,
shared=shared, namespace=namespace, banner=banner,
loop=loop or asyncio.get_event_loop())
if path:
f = asyncio.async(asyncio.start_unix_server(client_cb, path=path))
@f.add_done_callback
def done(task):
def remove_manhole():
try:
os.unlink(path)
except OSError:
pass
if task.exception() is None:
import atexit
atexit.register(remove_manhole)
if port:
return asyncio.async(
asyncio.start_server(
client_cb, host=host, port=port))
def test_start_unix_server_1(self):
HELLO_MSG = b'1' * 1024 * 5 + b'\n'
started = threading.Event()
def client(sock, addr):
sock.settimeout(2)
started.wait(5)
sock.connect(addr)
sock.send(HELLO_MSG)
sock.recv_all(1)
sock.close()
async def serve(reader, writer):
await reader.readline()
main_task.cancel()
writer.write(b'1')
writer.close()
await writer.wait_closed()
async def main(srv):
async with srv:
self.assertFalse(srv.is_serving())
await srv.start_serving()
self.assertTrue(srv.is_serving())
started.set()
await srv.serve_forever()
with test_utils.unix_socket_path() as addr:
srv = self.loop.run_until_complete(asyncio.start_unix_server(
serve, addr, loop=self.loop, start_serving=False))
main_task = self.loop.create_task(main(srv))
with self.assertRaises(asyncio.CancelledError):
with self.unix_client(lambda sock: client(sock, addr)):
self.loop.run_until_complete(main_task)
self.assertEqual(srv.sockets, [])
self.assertIsNone(srv._sockets)
self.assertIsNone(srv._waiters)
self.assertFalse(srv.is_serving())
with self.assertRaisesRegex(RuntimeError, r'is closed'):
self.loop.run_until_complete(srv.serve_forever())
def on_page_created(self, extension, web_page):
page_id = web_page.get_id()
log.info("Starting page server for {}", page_id)
self.pages[page_id] = web_page
path = runtime_path('webprocess.{}.sock'.format(page_id))
try:
os.unlink(path)
except FileNotFoundError:
pass
f = asyncio.ensure_future(asyncio.start_unix_server(functools.partial(self.client_connected, page_id=page_id), path=path, loop=self.loop), loop=self.loop)
f.add_done_callback(lambda *args: log.info("Started page server for {}", page_id))
web_page.connect("document-loaded", self.on_document_loaded)
web_page.connect("send-request", self.on_send_request)
def run(self):
'''
Listen to events from polling and notifying.
'''
try:
os.remove("/tmp/jom")
except OSError:
pass
loop = asyncio.get_event_loop()
server = loop.run_until_complete(
asyncio.start_unix_server(self.notifier(), path="/tmp/jom", loop=loop))
self.debug('Serving', server.sockets[0].getsockname())
loop.run_until_complete(self.polling(loop))
try:
loop.run_forever()
finally:
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
def init_percentage_socket_server(self):
"""Start up the status server."""
if self._shadowing:
logger.debug('No percentages: shadowing')
self._percentage_socket_server = None
return
# Create the socket for the simulation to reach
working_directory = self.get_dir()
self._percentage_socket_location = self._model_builder.get_percentage_socket_location(working_directory)
logger.debug('Status socket for %s : %s' % (self._guid, self._percentage_socket_location))
try:
# Start the socket server
self._percentage_socket_server = yield from asyncio.start_unix_server(
self._handle_percentage_connection,
self._percentage_socket_location
)
except Exception as e:
logger.debug('Could not connect to socket: %s' % str(e))
self._percentage_socket_server = None
def serve(self):
yield from asyncio.start_unix_server(self._client_connected, path=self._bind_path)
while True:
try:
data += yield from asyncio.wait_for(reader.read(100), timeout=10)
except asyncio.TimeoutError:
print("TimeoutError!")
writer.write(b"Timeout!")
writer.close()
return
header_end_ix = data.find(b"\r\n\r\n")
if header_end_ix != -1:
print("Detected end of header")
break
print("Not at end of header yet")
writer.write('hi, received your request')
loop = asyncio.get_event_loop()
coro = asyncio.start_unix_server(handle_request, path='/tmp/hi', loop=loop)
server = loop.run_until_complete(coro)
try:
loop.run_forever()
except:
pass
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
else:
addr = args.addr.split(':')
addr[1] = int(addr[1])
addr = tuple(addr)
print('serving on: {}'.format(addr))
if args.streams:
if args.proto:
print('cannot use --stream and --proto simultaneously')
exit(1)
print('using asyncio/streams')
if unix:
coro = asyncio.start_unix_server(echo_client_streams,
addr, loop=loop,
limit=1024 * 1024)
else:
coro = asyncio.start_server(echo_client_streams,
*addr, loop=loop,
limit=1024 * 1024)
srv = loop.run_until_complete(coro)
elif args.proto:
if args.streams:
print('cannot use --stream and --proto simultaneously')
exit(1)
print('using simple protocol')
if unix:
coro = loop.create_unix_server(EchoProtocol, addr)
else:
def start_callback(self):
start = asyncio.start_unix_server(self.handle_client_callback, path=self.path, loop=self.loop)
self.server = self.loop.run_until_complete(start)
def start(self):
self.server = self.loop.run_until_complete(
asyncio.start_unix_server(self.handle_client, path=self.path, loop=self.loop)
)
def accept_fdms_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
asyncio.Task(fdms.fdms_session(reader, writer), loop=loop).add_done_callback(lambda fut: writer.close())
def accept_site_net_client(reader, writer):
task = asyncio.Task(asyncio.open_unix_connection(path=UNIX_SOCKET_PATH))
asyncio.Task(fdms.site_net_session(reader, writer, task)).add_done_callback(lambda fut: writer.close())
# Start FDMS
if os.path.exists(UNIX_SOCKET_PATH):
os.remove(UNIX_SOCKET_PATH)
fdms.set_database_name('sqlite:///fdms.db')
f = asyncio.start_unix_server(accept_fdms_client, path=UNIX_SOCKET_PATH)
loop.run_until_complete(f)
pem_path = os.path.dirname(__file__)
pem_path = os.path.join(pem_path, 'cert.pem')
context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
context.load_cert_chain(pem_path)
f = asyncio.start_server(accept_site_net_client, port=8444, ssl=context)
loop.run_until_complete(f)
try:
loop.run_forever()
finally:
if os.path.exists(UNIX_SOCKET_PATH):
os.remove(UNIX_SOCKET_PATH)
yield from writer.drain()
finally:
parent_task.cancel()
except (OSError, asyncio.CancelledError):
return
if __name__ == '__main__':
if len(sys.argv) != 2:
print('Usage: %s <socket-path>' % sys.argv[0])
sys.exit(1)
loop = asyncio.get_event_loop()
s = Socks5Server()
server = loop.run_until_complete(
asyncio.start_unix_server(s.handle_proxy_conn, sys.argv[1], loop=loop))
ret = 0
try:
try:
loop.run_forever()
except KeyboardInterrupt:
pass
except:
ret = 1
finally:
server.close()
loop.run_until_complete(server.wait_closed())
loop.close()
os.unlink(sys.argv[1])
def test_create_unix_server_1(self):
CNT = 0 # number of clients that were successful
TOTAL_CNT = 100 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(4)
self.assertEqual(data, b'AAAA')
writer.write(b'OK')
data = await reader.readexactly(4)
self.assertEqual(data, b'BBBB')
writer.write(b'SPAM')
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
sock = socket.socket(socket.AF_UNIX)
with sock:
sock.setblocking(False)
await self.loop.sock_connect(sock, addr)
await self.loop.sock_sendall(sock, b'AAAA')
buf = b''
while len(buf) != 2:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'OK')
await self.loop.sock_sendall(sock, b'BBBB')
buf = b''
while len(buf) != 4:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'SPAM')
async def start_server():
nonlocal CNT
CNT = 0
with tempfile.TemporaryDirectory() as td:
sock_name = os.path.join(td, 'sock')
srv = await asyncio.start_unix_server(
handle_client,
sock_name,
loop=self.loop)
try:
srv_socks = srv.sockets
self.assertTrue(srv_socks)
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(sock_name))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
# asyncio doesn't cleanup the sock file
self.assertTrue(os.path.exists(sock_name))
async def start_server_sock(start_server):
nonlocal CNT
CNT = 0
with tempfile.TemporaryDirectory() as td:
sock_name = os.path.join(td, 'sock')
sock = socket.socket(socket.AF_UNIX)
sock.bind(sock_name)
srv = await start_server(sock)
try:
srv_socks = srv.sockets
self.assertTrue(srv_socks)
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(sock_name))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
# asyncio doesn't cleanup the sock file
self.assertTrue(os.path.exists(sock_name))
with self.subTest(func='start_unix_server(host, port)'):
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
with self.subTest(func='start_unix_server(sock)'):
self.loop.run_until_complete(start_server_sock(
lambda sock: asyncio.start_unix_server(
handle_client,
None,
loop=self.loop,
sock=sock)))
self.assertEqual(CNT, TOTAL_CNT)
with self.subTest(func='start_server(sock)'):
self.loop.run_until_complete(start_server_sock(
lambda sock: asyncio.start_server(
handle_client,
None, None,
loop=self.loop,
sock=sock)))
self.assertEqual(CNT, TOTAL_CNT)
os.remove(addr)
else:
addr = args.addr.split(':')
addr[1] = int(addr[1])
addr = tuple(addr)
print('serving on: {}'.format(addr))
if args.streams:
if args.proto:
print('cannot use --stream and --proto simultaneously')
exit(1)
print('using asyncio/streams')
if unix:
coro = asyncio.start_unix_server(echo_client_streams,
addr, loop=loop)
else:
coro = asyncio.start_server(echo_client_streams,
*addr, loop=loop)
srv = loop.run_until_complete(coro)
elif args.proto:
if args.streams:
print('cannot use --stream and --proto simultaneously')
exit(1)
print('using simple protocol')
if unix:
coro = loop.create_unix_server(EchoProtocol, addr)
else:
coro = loop.create_server(EchoProtocol, *addr)
srv = loop.run_until_complete(coro)
def _serve():
yield asyncio.async(asyncio.start_unix_server(self.on_client,
path=self.endpoint,
loop=self.loop))
yield self.event.wait()
