def __init__(self, stream, vat): self._stream = stream self._vat = vat self._queue = [] ruv.stashStream(stream._stream, (vat, self))
def __init__(self, stream, vat): # I hate C. self.stream = ruv.rffi.cast(ruv.stream_tp, stream) self.vat = vat self.bufs = [] # The initial stashing. ruv.stashStream(stream, (vat, self))
def listen(self, handler): vat = currentVat.get() uv_server = ruv.alloc_tcp(vat.uv_loop) try: ruv.tcpBind(uv_server, "0.0.0.0", self.port) except ruv.UVError as uve: raise userError(u"makeTCP4ServerEndpoint: Couldn't listen: %s" % uve.repr().decode("utf-8")) uv_stream = ruv.rffi.cast(ruv.stream_tp, uv_server) ruv.stashStream(uv_stream, (vat, handler)) # XXX hardcoded backlog of 42 ruv.listen(uv_stream, 42, connectionCB) return TCP4Server(uv_server)
def listenStream(self, handler): vat = currentVat.get() uv_server = ruv.alloc_tcp(vat.uv_loop) try: ruv.tcpBind(uv_server, "0.0.0.0", self.port) except ruv.UVError as uve: raise userError(u"listenStream/1: Couldn't listen: %s" % uve.repr().decode("utf-8")) uv_stream = ruv.rffi.cast(ruv.stream_tp, uv_server) ruv.stashStream(uv_stream, (vat, handler)) # XXX hardcoded backlog of 42 ruv.listen(uv_stream, 42, connectionStreamCB) return TCP4Server(uv_server)
def connect(self): vat = currentVat.get() stream = ruv.alloc_tcp(vat.uv_loop) fount, fountResolver = makePromise() drain, drainResolver = makePromise() # Ugh, the hax. resolvers = ConstList([fountResolver, drainResolver]) ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream), (vat, resolvers)) # Make the actual connection. ruv.tcpConnect(stream, self.host, self.port, connectCB) # Return the promises. return ConstList([fount, drain])
def run(self): uv_server = ruv.alloc_tcp(self.vat.uv_loop) try: if self.inet_type == 4: ruv.tcp4Bind(uv_server, "0.0.0.0", self.port) elif self.inet_type == 6: ruv.tcp6Bind(uv_server, "::", self.port) except ruv.UVError as uve: raise userError(u"listenStream/1: Couldn't listen: %s" % uve.repr().decode("utf-8")) uv_stream = ruv.rffi.cast(ruv.stream_tp, uv_server) ruv.stashStream(uv_stream, (self.vat, self.handler)) # XXX hardcoded backlog of 42 ruv.listen(uv_stream, 42, connectionStreamCB) self.r.resolve(TCPServer(uv_server))
def connectStream(self): vat = currentVat.get() stream = ruv.alloc_tcp(vat.uv_loop) source, sourceResolver = makePromise() sink, sinkResolver = makePromise() # Ugh, the hax. resolvers = wrapList([sourceResolver, sinkResolver]) ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream), (vat, resolvers)) # Make the actual connection. ruv.tcpConnect(stream, self.host, self.port, connectStreamCB) # Return the promises. return [source, sink]
def connect(self): vat = currentVat.get() stream = ruv.alloc_tcp(vat.uv_loop) fount, fountResolver = makePromise() drain, drainResolver = makePromise() # Ugh, the hax. resolvers = wrapList([fountResolver, drainResolver]) ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream), (vat, resolvers)) # Make the actual connection. ruv.tcpConnect(stream, self.host, self.port, connectCB) # Return the promises. return [fount, drain]
def listenStream(self, handler): vat = currentVat.get() uv_server = ruv.alloc_tcp(vat.uv_loop) try: if self.inet_type == 4: ruv.tcp4Bind(uv_server, "0.0.0.0", self.port) elif self.inet_type == 6: ruv.tcp6Bind(uv_server, "::", self.port) except ruv.UVError as uve: raise userError(u"listenStream/1: Couldn't listen: %s" % uve.repr().decode("utf-8")) uv_stream = ruv.rffi.cast(ruv.stream_tp, uv_server) ruv.stashStream(uv_stream, (vat, handler)) # XXX hardcoded backlog of 42 ruv.listen(uv_stream, 42, connectionStreamCB) return TCPServer(uv_server)
def connectStream(self): """ Connect this endpoint, returning a `[source, sink]` pair.of vows. """ vat = currentVat.get() stream = ruv.alloc_tcp(vat.uv_loop) source, sourceResolver = makePromise() sink, sinkResolver = makePromise() # Ugh, the hax. resolvers = wrapList([sourceResolver, sinkResolver]) ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream), (vat, resolvers)) vat.enqueueEvent(ConnectStreamIOEvent( vat, stream, self.host, self.port, self.inet_type)) # Return the promises. return [source, sink]
def readStreamCB(stream, status, buf): status = intmask(status) # We only restash in the success case, not the error cases. vat, source = ruv.unstashStream(stream) assert isinstance(source, StreamSource), "Implementation error" # Don't read any more. We'll call .readStart() when we're interested in # reading again. ruv.readStop(stream) with scopedVat(vat): if status > 0: # Restash required. ruv.stashStream(stream, (vat, source)) data = charpsize2str(buf.c_base, status) source.deliver(data) elif status == -4095: # EOF. source.complete() else: msg = ruv.formatError(status).decode("utf-8") source.abort(u"libuv error: %s" % msg)
def readCB(stream, status, buf): status = intmask(status) try: # We only restash in the success case, not the error cases. vat, fount = ruv.unstashStream(stream) assert isinstance(fount, StreamFount), "Implementation error" with scopedVat(vat): if status > 0: # Restash required. ruv.stashStream(stream, (vat, fount)) data = charpsize2str(buf.c_base, status) fount.receive(data) elif status == 0: # EOF. fount.stop(u"End of stream") else: msg = ruv.formatError(status).decode("utf-8") fount.abort(u"libuv error: %s" % msg) except: if not we_are_translated(): raise
def connectStream(self): """ Connect this endpoint, returning a `[source, sink]` pair.of vows. """ vat = currentVat.get() stream = ruv.alloc_tcp(vat.uv_loop) source, sourceResolver = makePromise() sink, sinkResolver = makePromise() # Ugh, the hax. resolvers = wrapList([sourceResolver, sinkResolver]) ruv.stashStream(ruv.rffi.cast(ruv.stream_tp, stream), (vat, resolvers)) # Make the actual connection. if self.inet_type == 4: ruv.tcp4Connect(stream, self.host, self.port, connectStreamCB) elif self.inet_type == 6: ruv.tcp6Connect(stream, self.host, self.port, connectStreamCB) # Return the promises. return [source, sink]