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