import sys
import socket
from microactor.subsystems import Subsystem
from microactor.subsystems.net import NetSubsystem
from microactor.utils import reactive, rreturn, safe_import
from .transports import (ListeningSocketTransport, ConnectingSocketTransport,
SslHandshakingTransport, SslListeninglSocketTransport, DatagramSocketTransport,
PipeTransport, FileTransport)
import os
ssl = safe_import("ssl")
class PosixNetSubsystem(NetSubsystem):
@reactive
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)
@reactive
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)
import os
import socket
from microactor.subsystems import Subsystem
from microactor.subsystems.net import NetSubsystem
from microactor.utils import ReactorDeferred, reactive, rreturn, safe_import
from .transports import (SocketStreamTransport, ListeningSocketTransport,
PipeTransport, FileTransport, ConsoleInputTransport,
BlockingStreamTransport)
import threading
import sys
msvcrt = safe_import("msvcrt")
win32file = safe_import("win32file")
win32iocp = safe_import("microactor.arch.windows.iocp")
winconsole = safe_import("microactor.arch.windows.console")
class IocpNetSubsystem(NetSubsystem):
@reactive
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)
import sys
import socket
from microactor.subsystems import Subsystem
from microactor.subsystems.net import NetSubsystem
from microactor.utils import reactive, rreturn, safe_import
from .transports import (ListeningSocketTransport, ConnectingSocketTransport,
SslHandshakingTransport, SslListeninglSocketTransport,
DatagramSocketTransport, PipeTransport, FileTransport)
import os
ssl = safe_import("ssl")
class PosixNetSubsystem(NetSubsystem):
@reactive
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)
@reactive
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)
import socket
from microactor.utils import safe_import, ReactorDeferred, reactive, rreturn
from ..transports import ClosedFile, DetachedFile
from ..transports import TransportError, OverlappingRequestError
msvcrt = safe_import("msvcrt")
win32file = safe_import("win32file")
win32iocp = safe_import("microactor.arch.windows.iocp")
winsock = safe_import("microactor.arch.windows.winsock")
pywintypes = safe_import("pywintypes")
class BaseTransport(object):
__slots__ = ["reactor", "properties"]
def __init__(self, reactor):
self.reactor = reactor
self.properties = {}
def _register(self):
self.reactor.register_transport(self)
def detach(self):
raise NotImplementedError()
def close(self):
raise NotImplementedError()
def fileno(self):
raise NotImplementedError()
class StreamTransport(BaseTransport):
MAX_READ_SIZE = 32000
MAX_WRITE_SIZE = 32000
__slots__ = ["fileobj", "_ongoing_read", "_ongoing_write"]
import socket
from microactor.utils import safe_import, ReactorDeferred, reactive, rreturn
from ..transports import ClosedFile, DetachedFile
from ..transports import TransportError, OverlappingRequestError
msvcrt = safe_import("msvcrt")
win32file = safe_import("win32file")
win32iocp = safe_import("microactor.arch.windows.iocp")
winsock = safe_import("microactor.arch.windows.winsock")
pywintypes = safe_import("pywintypes")
class BaseTransport(object):
__slots__ = ["reactor", "properties"]
def __init__(self, reactor):
self.reactor = reactor
self.properties = {}
def _register(self):
self.reactor.register_transport(self)
def detach(self):
raise NotImplementedError()
def close(self):
raise NotImplementedError()
def fileno(self):
raise NotImplementedError()
from ..base import BaseReactor, ReactorError
from microactor.utils import safe_import
from .subsystems import IOCP_SUBSYSTEMS
win32iocp = safe_import("microactor.arch.windows.iocp")
win32file = safe_import("win32file")
class IocpReactor(BaseReactor):
SUBSYSTEMS = BaseReactor.SUBSYSTEMS + IOCP_SUBSYSTEMS
def __init__(self):
BaseReactor.__init__(self)
self._port = win32iocp.IOCP()
self._transports = {}
self._overlap_callbacks = {}
self._install_builtin_subsystems()
@classmethod
def supported(cls):
return bool(win32iocp)
def register_transport(self, transport):
fd = transport.fileno()
if fd in self._transports:
orig = self._transports[fd]
if transport is orig:
return
else:
try:
orig.fileno()
except EnvironmentError:
import os
import socket
from microactor.subsystems import Subsystem
from microactor.subsystems.net import NetSubsystem
from microactor.utils import ReactorDeferred, reactive, rreturn, safe_import
from .transports import (SocketStreamTransport, ListeningSocketTransport,
PipeTransport, FileTransport, ConsoleInputTransport, BlockingStreamTransport)
import threading
import sys
msvcrt = safe_import("msvcrt")
win32file = safe_import("win32file")
win32iocp = safe_import("microactor.arch.windows.iocp")
winconsole = safe_import("microactor.arch.windows.console")
class IocpNetSubsystem(NetSubsystem):
@reactive
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:
import os
import signal
import subprocess
from .base import Subsystem
from microactor.utils import ReactorDeferred, reactive, rreturn
from microactor.utils import BufferedTransport, safe_import
from microactor.protocols.remoting import RemotingClient
from microactor.utils.transports import DuplexStreamTransport
win32iocp = safe_import("microactor.arch.windows.iocp")
msvcrt = safe_import("msvcrt")
if win32iocp:
# praise monkey patching, for it pwnz
# we want the pipes to have FILE_FLAG_OVERLAPPED, that's all
import _subprocess
_subprocess.CreatePipe = lambda a, b: win32iocp.create_overlapped_pipe()
class ProcessExecutionError(Exception):
def __init__(self, msg, rc, stdout, stderr):
Exception.__init__(self, msg, rc, stdout, stderr)
self.rc = rc
self.stdout = stdout
self.stderr = stderr
@classmethod
@reactive
def from_proc(cls, msg, proc):
stdout = yield proc.stdout.read_all()
stderr = yield proc.stderr.read_all()
import os
import signal
import subprocess
from .base import Subsystem
from microactor.utils import ReactorDeferred, reactive, rreturn
from microactor.utils import BufferedTransport, safe_import
from microactor.protocols.remoting import RemotingClient
from microactor.utils.transports import DuplexStreamTransport
win32iocp = safe_import("microactor.arch.windows.iocp")
msvcrt = safe_import("msvcrt")
if win32iocp:
# praise monkey patching, for it pwnz
# we want the pipes to have FILE_FLAG_OVERLAPPED, that's all
import _subprocess
_subprocess.CreatePipe = lambda a, b: win32iocp.create_overlapped_pipe()
class ProcessExecutionError(Exception):
def __init__(self, msg, rc, stdout, stderr):
Exception.__init__(self, msg, rc, stdout, stderr)
self.rc = rc
self.stdout = stdout
self.stderr = stderr
@classmethod
@reactive
def from_proc(cls, msg, proc):
stdout = yield proc.stdout.read_all()
stderr = yield proc.stderr.read_all()
import sys
import os
import errno
import socket
from microactor.utils import ReactorDeferred, reactive, rreturn, safe_import
from ..transports import ClosedFile, DetachedFile
from ..transports import TransportError, ReadRequiresMoreData, OverlappingRequestError
fcntl = safe_import("fcntl")
ssl = safe_import("ssl")
#===============================================================================
# Base
#===============================================================================
class BaseTransport(object):
__slots__ = ["reactor", "properties"]
def __init__(self, reactor):
self.reactor = reactor
self.properties = {}
def fileno(self):
raise NotImplementedError()
def close(self):
raise NotImplementedError()
def detach(self):
raise NotImplementedError()
def _unregister(self):
self.reactor.unregister_read(self)
self.reactor.unregister_write(self)
def on_read(self):
pass
import sys
import os
import errno
import socket
from microactor.utils import ReactorDeferred, reactive, rreturn, safe_import
from ..transports import ClosedFile, DetachedFile
from ..transports import TransportError, ReadRequiresMoreData, OverlappingRequestError
fcntl = safe_import("fcntl")
ssl = safe_import("ssl")
#===============================================================================
# Base
#===============================================================================
class BaseTransport(object):
__slots__ = ["reactor", "properties"]
def __init__(self, reactor):
self.reactor = reactor
self.properties = {}
def fileno(self):
raise NotImplementedError()
def close(self):
raise NotImplementedError()
def detach(self):
raise NotImplementedError()
