def __init__(self, stream, vat):
self._stream = stream
self._vat = vat
self._queue = []
ruv.stashStream(stream._stream, (vat, self))
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 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]
