Пример #1
0
 def __init__(self, local_address, local_port, cmd_handler = None):
     self._cmd_handler = cmd_handler
     self._stream_server = StreamServer((local_address, local_port), self._accept, spawn = self._spawn_hook)
     self._stop = False
     self._ev_stop_getter, self._ev_stop_setter = socketpair()
     self._acceptors = []
     self._queries = {}
     self._socks = {}
Пример #2
0
def run_cmd(args, timeout=None):
    _init()
    args = list(args)
    for i, x in enumerate(args):
        if isinstance(x, unicode):
            args[i] = x.encode("utf-8")

    sp = socket.socketpair()
    pid = os.fork()
    if pid == 0:
        # client
        try:
            os.dup2(sp[1].fileno(), 1)
            os.dup2(sp[1].fileno(), 2)
            sp[0].close()
            sp[1].close()
            os.execvp(args[0], args)
        except:
            stderr = os.fdopen(2, "w", 0)
            os.write(2, "failed to exec child process: %r\nPATH=%r" % (args, os.environ.get('PATH')))
            traceback.print_exc(file=stderr)
        finally:
            os._exit(97)

    pid2status[pid] = event.AsyncResult()
    if not _nochild:

        def cb():
            pid2status[pid].set(child_watcher.rstatus)
            child_watcher.stop()

        child_watcher = get_hub().loop.child(pid)
        child_watcher.start(cb)

    sp[1].close()

    chunks = []

    # prevent loopexit. see test_run_cmd_trigger_loopexit in test_proc.py
    if timeout is None:
        timeout = 2 ** 30

    timeout = Timeout(timeout)
    timeout.start()
    try:
        while 1:
            chunk = sp[0].recv(4096)
            if not chunk:
                break
            chunks.append(chunk)

        st = pid2status[pid].get()
        del pid2status[pid]

        return st, "".join(chunks)
    except Timeout, t:
        if t is not timeout:
            raise
Пример #3
0
def test_rawconn_error():
    a, b = socketpair()
    def server_handler(stream):
        stream.close_with_error(NoRouteError())
    with RawConn(a, server_handler, True) as server:
        with RawConn(b) as client:
            with client.new_stream() as c:
                with pytest.raises(NoRouteError):
                    c.peek()
Пример #4
0
def test_rawconn():
    a, b = socketpair()
    def server_handler(stream):
        data = stream.recv(16)
        stream.write(data)
    with RawConn(a, server_handler, True) as server:
        with RawConn(b) as client:
            with client.new_stream() as c:
                c.write('foobar')
                data = c.recv(16)
                assert data == 'foobar'
Пример #5
0
 def _test_wait_read_invalid_switch(self, sleep):
     sock1, sock2 = socket.socketpair()
     try:
         p = gevent.spawn(util.wrap_errors(AssertionError, socket.wait_read), sock1.fileno())
         gevent.get_hub().loop.run_callback(switch_None, p)
         if sleep is not None:
             gevent.sleep(sleep)
         result = p.get()
         assert isinstance(result, AssertionError), result
         assert 'Invalid switch' in str(result), repr(str(result))
     finally:
         sock1.close()
         sock2.close()
Пример #6
0
 def _test_wait_read_invalid_switch(self, sleep):
     sock1, sock2 = socket.socketpair()
     try:
         p = gevent.spawn(util.wrap_errors(AssertionError, socket.wait_read), sock1.fileno())
         gevent.get_hub().loop.run_callback(switch_None, p)
         if sleep is not None:
             gevent.sleep(sleep)
         result = p.get()
         assert isinstance(result, AssertionError), result
         assert 'Invalid switch' in str(result), repr(str(result))
     finally:
         sock1.close()
         sock2.close()
Пример #7
0
    def test_select_many_sockets(self):
        try:
            AF_UNIX = socket.AF_UNIX
        except AttributeError:
            AF_UNIX = None

        pairs = [socket.socketpair() for _ in range(10)]

        try:
            server_sel = selectors.GeventSelector()
            client_sel = selectors.GeventSelector()
            for i, pair in enumerate(pairs):
                server, client = pair
                server_sel.register(server, selectors.EVENT_READ,
                                    self.read_from_ready_socket_and_reply)
                client_sel.register(client, selectors.EVENT_READ, i)
                # Prime them all to be ready at once.
                data = str(i).encode('ascii')
                client.send(data)

            # Read and reply to all the clients..
            # Everyone should be ready, so we ask not to block.
            # The call to gevent.idle() is there to make sure that
            # all event loop implementations (looking at you, libuv)
            # get a chance to poll for IO. Without it, libuv
            # doesn't find any results here.
            # Not blocking only works for AF_UNIX sockets, though.
            # If we got AF_INET (Windows) the data may need some time to
            # traverse through the layers.
            gevent.idle()
            self.run_selector_once(
                server_sel, timeout=-1 if pairs[0][0].family == AF_UNIX else 3)

            found = 0
            for key, _ in client_sel.select(timeout=3):
                expected = str(key.data).encode('ascii')
                data = key.fileobj.recv(50)
                self.assertEqual(data, expected)
                found += 1
            self.assertEqual(found, len(pairs))
        finally:
            server_sel.close()
            client_sel.close()
            for pair in pairs:
                for s in pair:
                    s.close()
Пример #8
0
 def _check_selector(self, sel):
     server, client = socket.socketpair()
     try:
         sel.register(server, selectors.EVENT_READ,
                      self.read_from_ready_socket_and_reply)
         glet = gevent.spawn(self.run_selector_once, sel)
         DATA = b'abcdef'
         client.send(DATA)
         data = client.recv(
             50)  # here is probably where we yield to the event loop
         self.assertEqual(data, DATA)
     finally:
         sel.close()
         server.close()
         client.close()
         glet.join(10)
     self.assertTrue(glet.ready())
Пример #9
0
def _socketpair(tmodel):
    if tmodel == ThreadingModel.THREADS:
        return tsocket.socketpair()
    elif tmodel == ThreadingModel.GEVENT:
        return gsocket.socketpair()
Пример #10
0
        for sb in self.subscribers:
            if sb.deliverer:
                sb.deliverer.kill(block=False)


_ws_refs = weakref.WeakValueDictionary()

# To generate new ids for websocket on worker (warps after trillons of years):
_ws_id_iterator = None

_worker_count = 1

_rpc_map = {}
_rpc_next_id = 0

(_call_endpoint, _handle_endpoint) = socket.socketpair(socket.AF_UNIX,
                                                       socket.SOCK_SEQPACKET)


def _ws_serialize(websocket):
    try:
        uid = websocket.environ['unique_id']
    except KeyError:
        uid = _ws_id_iterator.next()
        websocket.environ['unique_id'] = uid

    return (websocket.handler.socket.fileno(), uid)


def _ws_from_fd(fd):
    class PassiveWebSocket(WebSocket):
        __slots__ = ('__weakref__', 'unique_id')
Пример #11
0
def bench_gevent_forked_socketpair(loops):
    send, recv = gsocket.socketpair()
    return _do_sendall(loops, send, recv)
Пример #12
0
def bench_gevent_greenlet_default_socketpair(loops):
    send, recv = gsocket.socketpair()
    gevent.spawn(recvall, recv, None)
    return _sendall(loops, send, BIG_DATA)
Пример #13
0
    def force_stop(self):
        for sb in self.subscribers:
            if sb.deliverer:
                sb.deliverer.kill(block=False)

_ws_refs = weakref.WeakValueDictionary()

# To generate new ids for websocket on worker (warps after trillons of years):
_ws_id_iterator = None

_worker_count = 1

_rpc_map = {}
_rpc_next_id = 0

(_call_endpoint, _handle_endpoint) = socket.socketpair(socket.AF_UNIX, socket.SOCK_SEQPACKET)

def _ws_serialize(websocket):
    try:
        uid = websocket.environ['unique_id']
    except KeyError:
        uid = _ws_id_iterator.next()
        websocket.environ['unique_id'] = uid

    return (websocket.handler.socket.fileno(), uid)

def _ws_from_fd(fd):
    class PassiveWebSocket(WebSocket):
        __slots__ = ('__weakref__', 'unique_id')
        def __init__(self, *args, **kwargs):
            WebSocket.__init__(self, *args, **kwargs)