def connect_tcp(self, host, port, timeout = None):
yield self.reactor.started
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
hostaddr = yield self.resolve(host)
trns = ConnectingSocketTransport(self.reactor, sock, (hostaddr, port))
trns2 = yield trns.connect(timeout)
rreturn(trns2)
def connect_tcp(self, host, port, timeout=None):
yield self.reactor.started
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
hostaddr = yield self.resolve(host)
trns = ConnectingSocketTransport(self.reactor, sock, (hostaddr, port))
trns2 = yield trns.connect(timeout)
rreturn(trns2)
def connect_udp(self, host, port, broadcast=False):
yield self.reactor.started
sock = self._open_udp_sock("0.0.0.0", 0, broadcast)
hostaddr = yield self.resolve(host)
trns = ConnectingSocketTransport(self.reactor, sock, (hostaddr, port))
trns2 = yield trns.connect()
rreturn(trns2)
def listen_tcp(self, port, host="0.0.0.0", backlog=40):
yield self.reactor.started
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
sock.bind((host, port))
sock.listen(backlog)
rreturn(ListeningSocketTransport(self.reactor, sock))
def connect_udp(self, host, port, broadcast = False):
yield self.reactor.started
sock = self._open_udp_sock("0.0.0.0", 0, broadcast)
hostaddr = yield self.resolve(host)
trns = ConnectingSocketTransport(self.reactor, sock, (hostaddr, port))
trns2 = yield trns.connect()
rreturn(trns2)
def wrap_ssl_client(self,
transport,
keyfile=None,
certfile=None,
ca_certs=None,
cert_reqs=None,
ssl_version=None):
yield self.reactor.started
if ssl_version is None:
ssl_version = ssl.PROTOCOL_SSLv23
if cert_reqs is None:
cert_reqs = ssl.CERT_NONE
sslsock = ssl.wrap_socket(transport.fileobj,
keyfile=keyfile,
certfile=certfile,
ca_certs=ca_certs,
cert_reqs=cert_reqs,
ssl_version=ssl_version,
server_side=False,
do_handshake_on_connect=False,
suppress_ragged_eofs=True)
transport.detach()
handshaker = SslHandshakingTransport(self.reactor, sslsock)
ssltrns = yield handshaker.handshake()
rreturn(ssltrns)
def run(self,
args,
input=None,
retcodes=(0, ),
cwd=None,
env=None,
shell=False):
proc = yield self.spawn(args, cwd, env, shell)
if input:
@reactive
def write_all_stdin():
yield proc.stdin.write(input)
yield proc.stdin.close()
self.reactor.call(write_all_stdin)
else:
yield proc.stdin.close()
stdout_dfr = proc.stdout.read_all()
stderr_dfr = proc.stderr.read_all()
rc = yield proc.wait()
stdout_data = yield stdout_dfr
stderr_data = yield stderr_dfr
if retcodes and rc not in retcodes:
raise ProcessExecutionError("unexpected return code", rc,
stdout_data, stderr_data)
else:
rreturn((rc, stdout_data, stderr_data))
def listen_tcp(self, port, host = "0.0.0.0", backlog = 40):
yield self.reactor.started
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
sock.bind((host, port))
sock.listen(backlog)
rreturn(ListeningSocketTransport(self.reactor, sock))
def connect_ssl(self, host, port, timeout = None, keyfile = None,
certfile = None, ca_certs = None, cert_reqs = None, ssl_version = None):
trns = yield self.connect_tcp(host, port, timeout)
ssltrns = yield self.wrap_ssl_client(trns, keyfile = keyfile,
certfile = certfile, cert_reqs = cert_reqs, ca_certs = ca_certs,
ssl_version = ssl_version)
rreturn(ssltrns)
def pipe(self):
yield self.reactor.started
rfd, wfd = os.pipe()
rf = os.fdopen(rfd, "r")
wf = os.fdopen(wfd, "w")
rtrns = PipeTransport(self.reactor, rf, "r")
wtrns = PipeTransport(self.reactor, wf, "w")
rreturn((rtrns, wtrns))
def spawn(self, args, cwd = None, env = None, shell = False):
yield self.reactor.started
self._install_child_handler()
p = subprocess.Popen(args, stdin = subprocess.PIPE, stdout = subprocess.PIPE,
stderr = subprocess.PIPE, cwd = cwd, env = env, shell = shell)
proc = Process(self.reactor, p, args)
self.processes[proc.pid] = proc
rreturn(proc)
def pipe(self):
yield self.reactor.started
rfd, wfd = os.pipe()
rf = os.fdopen(rfd, "r")
wf = os.fdopen(wfd, "w")
rtrns = PipeTransport(self.reactor, rf, "r")
wtrns = PipeTransport(self.reactor, wf, "w")
rreturn((rtrns, wtrns))
def listen_tcp(self, port, host="0.0.0.0", backlog=40):
yield self.reactor.started
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if sys.platform != "win32":
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
sock.bind((host, port))
sock.listen(backlog)
trns = ListeningSocketTransport(self.reactor, sock)
rreturn(trns)
def listen_tcp(self, port, host = "0.0.0.0", backlog = 40):
yield self.reactor.started
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if sys.platform != "win32":
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
sock.bind((host, port))
sock.listen(backlog)
trns = ListeningSocketTransport(self.reactor, sock)
rreturn(trns)
def open(self, filename, mode="r"):
yield self.reactor.started
CONV = {
"r": "r",
"w": "w",
"a": "w",
"r+": "rw",
"w+": "rw",
"a+": "rw"
}
mode2 = CONV[mode.lower().replace("b", "").replace("t", "")]
fileobj = open(filename, mode, 0)
rreturn(FileTransport(self.reactor, fileobj, mode2))
def spawn(self, args, cwd=None, env=None, shell=False):
yield self.reactor.started
self._install_child_handler()
p = subprocess.Popen(args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=cwd,
env=env,
shell=shell)
proc = Process(self.reactor, p, args)
self.processes[proc.pid] = proc
rreturn(proc)
def wrap_ssl_server(self, transport, keyfile, certfile, ca_certs = None,
cert_reqs = None, ssl_version = None):
yield self.reactor.started
if ssl_version is None:
ssl_version = ssl.PROTOCOL_SSLv23
if cert_reqs is None:
cert_reqs = ssl.CERT_NONE
sslsock = ssl.wrap_socket(transport.fileobj, keyfile = keyfile,
certfile = certfile, ca_certs = ca_certs, cert_reqs = cert_reqs,
ssl_version = ssl_version, server_side = True, do_handshake_on_connect = False,
suppress_ragged_eofs = True)
transport.detach()
ssltrns = SslListeninglSocketTransport(self.reactor, sslsock)
rreturn(ssltrns)
def listen_ssl(self,
port,
host="0.0.0.0",
backlog=40,
keyfile=None,
certfile=None,
ca_certs=None,
cert_reqs=None,
ssl_version=None):
listener = yield self.listen_tcp(port, host, backlog)
ssl_listener = self.wrap_ssl_server(listener,
keyfile,
certfile,
ca_certs=ca_certs,
cert_reqs=cert_reqs,
ssl_version=ssl_version)
rreturn(ssl_listener)
def connect_ssl(self,
host,
port,
timeout=None,
keyfile=None,
certfile=None,
ca_certs=None,
cert_reqs=None,
ssl_version=None):
trns = yield self.connect_tcp(host, port, timeout)
ssltrns = yield self.wrap_ssl_client(trns,
keyfile=keyfile,
certfile=certfile,
cert_reqs=cert_reqs,
ca_certs=ca_certs,
ssl_version=ssl_version)
rreturn(ssltrns)
def connect_tcp(self, host, port, timeout = None):
def connect_finished(size, overlapped):
trns_dfr.set(trns)
yield self.reactor.started
hostaddr = yield self.resolve(host)
trns_dfr = ReactorDeferred(self.reactor)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
sock.bind(('0.0.0.0', 0)) # ConnectEx requires the socket to be bound
# this is required here to register the new socket with its IOCP
trns = SocketStreamTransport(self.reactor, sock)
overlapped = self.reactor._get_overlapped(connect_finished)
try:
win32file.ConnectEx(sock.fileno(), (hostaddr, port), overlapped)
except Exception:
self.reactor._discard_overlapped(overlapped)
raise
yield trns_dfr
rreturn(trns)
def connect_tcp(self, host, port, timeout=None):
def connect_finished(size, overlapped):
trns_dfr.set(trns)
yield self.reactor.started
hostaddr = yield self.resolve(host)
trns_dfr = ReactorDeferred(self.reactor)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setblocking(False)
sock.bind(('0.0.0.0', 0)) # ConnectEx requires the socket to be bound
# this is required here to register the new socket with its IOCP
trns = SocketStreamTransport(self.reactor, sock)
overlapped = self.reactor._get_overlapped(connect_finished)
try:
win32file.ConnectEx(sock.fileno(), (hostaddr, port), overlapped)
except Exception:
self.reactor._discard_overlapped(overlapped)
raise
yield trns_dfr
rreturn(trns)
def run(self, args, input = None, retcodes = (0,), cwd = None, env = None,
shell = False):
proc = yield self.spawn(args, cwd, env, shell)
if input:
@reactive
def write_all_stdin():
yield proc.stdin.write(input)
yield proc.stdin.close()
self.reactor.call(write_all_stdin)
else:
yield proc.stdin.close()
stdout_dfr = proc.stdout.read_all()
stderr_dfr = proc.stderr.read_all()
rc = yield proc.wait()
stdout_data = yield stdout_dfr
stderr_data = yield stderr_dfr
if retcodes and rc not in retcodes:
raise ProcessExecutionError("unexpected return code", rc, stdout_data, stderr_data)
else:
rreturn((rc, stdout_data, stderr_data))
def _get_process(self):
# find an empty worker
minimal_proc = None
for proc in self.processes:
if not proc.queue:
rreturn(proc)
if minimal_proc is None or minimal_proc.queue_size() > proc.queue_size():
minimal_proc = proc
# otherwise, see if we can spawn a new worker
if len(self.processes) < self.max_processes:
proc = yield self.process_factory()
proc2 = PooledProcess(proc)
self.processes.add(proc2)
self.reactor.call(self._collector, proc2)
rreturn(proc2)
# no, just return the minimal woker
rreturn(minimal_proc)
def _get_process(self):
# find an empty worker
minimal_proc = None
for proc in self.processes:
if not proc.queue:
rreturn(proc)
if minimal_proc is None or minimal_proc.queue_size(
) > proc.queue_size():
minimal_proc = proc
# otherwise, see if we can spawn a new worker
if len(self.processes) < self.max_processes:
proc = yield self.process_factory()
proc2 = PooledProcess(proc)
self.processes.add(proc2)
self.reactor.call(self._collector, proc2)
rreturn(proc2)
# no, just return the minimal woker
rreturn(minimal_proc)
def from_proc(cls, msg, proc):
stdout = yield proc.stdout.read_all()
stderr = yield proc.stderr.read_all()
rreturn(cls(msg, proc.returncode, stdout, stderr))
def joined(self, dfrlist):
reslist = []
for dfr in dfrlist:
res = yield dfr
reslist.append(res)
rreturn(reslist)
def resolve(self, hostname, family = socket.AF_INET):
res = yield self.getaddrinfo(hostname, family = family)
rreturn(res[0][4][0])
def open_udp(self, port, host = "0.0.0.0", broadcast = False):
yield self.reactor.started
sock = self._open_udp_sock(host, port, broadcast)
trns = DatagramSocketTransport(self.reactor, sock)
rreturn(trns)
def enqueue(self, func, args, kwargs):
dfr = yield self.client._call(func, args, kwargs)
dfr.register(lambda isexc, obj: self.queue.discard(dfr))
self.queue.add(dfr)
rreturn(dfr)
def _call(self, func, args, kwargs):
proc = yield self._get_process()
dfr = yield proc.enqueue(func, args, kwargs)
rreturn(dfr)
def from_proc(cls, msg, proc):
stdout = yield proc.stdout.read_all()
stderr = yield proc.stderr.read_all()
rreturn (cls(msg, proc.returncode, stdout, stderr))
def enqueue(self, func, args, kwargs):
dfr = yield self.client._call(func, args, kwargs)
dfr.register(lambda isexc, obj: self.queue.discard(dfr))
self.queue.add(dfr)
rreturn(dfr)
def open(self, filename, mode):
yield self.reactor.started
fobj, access = win32iocp.WinFile.open(filename, mode)
rreturn(FileTransport(self.reactor, fobj, access))
def accept(self):
handshaking_trns = yield ListeningSocketTransport.accept()
trns = yield handshaking_trns.handshake()
rreturn(trns)
def serve(self, handler_factory, port, host = "0.0.0.0", backlog = 40):
listener = yield self.listen_tcp(port, host, backlog)
server = SocketServer(self.reactor, handler_factory, listener)
self.reactor.call(server.start)
rreturn(server)
def open(self, filename, mode = "r"):
yield self.reactor.started
CONV = {"r" : "r", "w" : "w", "a" : "w", "r+" : "rw", "w+" : "rw", "a+" : "rw"}
mode2 = CONV[mode.lower().replace("b", "").replace("t", "")]
fileobj = open(filename, mode, 0)
rreturn(FileTransport(self.reactor, fileobj, mode2))
def call(self, func, *args, **kwargs):
dfr = yield self._call(func, args, kwargs)
res = yield dfr
rreturn(res)
def call(self, func, *args, **kwargs):
dfr = yield self._call(func, args, kwargs)
res = yield dfr
rreturn(res)
def _call(self, func, args, kwargs):
proc = yield self._get_process()
dfr = yield proc.enqueue(func, args, kwargs)
rreturn(dfr)
def open(self, filename, mode):
yield self.reactor.started
fobj, access = win32iocp.WinFile.open(filename, mode)
rreturn(FileTransport(self.reactor, fobj, access))
def listen_ssl(self, port, host = "0.0.0.0", backlog = 40, keyfile = None,
certfile = None, ca_certs = None, cert_reqs = None, ssl_version = None):
listener = yield self.listen_tcp(port, host, backlog)
ssl_listener = self.wrap_ssl_server(listener, keyfile, certfile,
ca_certs = ca_certs, cert_reqs = cert_reqs, ssl_version = ssl_version)
rreturn(ssl_listener)
def pipe(self):
yield self.reactor.started
rh, wh = win32iocp.create_overlapped_pipe()
rtrns = PipeTransport(self.reactor, win32iocp.WinFile(rh), "r")
wtrns = PipeTransport(self.reactor, win32iocp.WinFile(wh), "w")
rreturn((rtrns, wtrns))
def joined(self, dfrlist):
reslist = []
for dfr in dfrlist:
res = yield dfr
reslist.append(res)
rreturn(reslist)
def read(self, count):
data = yield PipeTransport.read(self, count)
if data:
self._rpos += len(data)
rreturn(data)
def pipe(self):
yield self.reactor.started
rh, wh = win32iocp.create_overlapped_pipe()
rtrns = PipeTransport(self.reactor, win32iocp.WinFile(rh), "r")
wtrns = PipeTransport(self.reactor, win32iocp.WinFile(wh), "w")
rreturn((rtrns, wtrns))
def read(self, count):
data = yield PipeTransport.read(self, count)
if data:
self._rpos += len(data)
rreturn(data)
def open_udp(self, port, host="0.0.0.0", broadcast=False):
yield self.reactor.started
sock = self._open_udp_sock(host, port, broadcast)
trns = DatagramSocketTransport(self.reactor, sock)
rreturn(trns)
def accept(self):
handshaking_trns = yield ListeningSocketTransport.accept()
trns = yield handshaking_trns.handshake()
rreturn(trns)
