def __init__(self):
if self.parent is not None:
raise RuntimeError('Hub must be created in the root fiber')
super(Hub, self).__init__(target=self.run)
self.name = 'Hub'
self.context = ''
self._loop = pyuv.Loop()
self._loop.excepthook = self._uncaught_exception
self._data = {}
self._noswitch_depth = 0
self._callbacks = collections.deque()
# Thread IDs may be recycled when a thread exits. But as long as the
# hub is alive, it won't be recycled so in that case we can use just
# the ID as a check whether we are in the same thread or not.
self._thread = compat.get_thread_ident()
self._async = pyuv.Async(self._loop, lambda h: self._loop.stop())
self._sigint = pyuv.Signal(self._loop)
self._sigint.start(self._on_sigint, signal.SIGINT)
# Mark our own handles as "system handles". This allows the test suite
# to check that no active handles except these escape from tests.
self._async._system_handle = True
self._sigint._system_handle = True
self._log = logging.get_logger()
self._log.debug('new Hub for {.name}', threading.current_thread())
self._closing = False
self._error = None
def __init__(self):
global _tls
if getattr(_tls, 'loop', None) is not None:
raise RuntimeError('cannot instantiate more than one event loop per thread')
_tls.loop = self
self._loop = pyuv.Loop()
self._loop.excepthook = self._handle_error
self._loop.event_loop = self
self._default_executor = None
self._threadpool = ThreadPool(self)
self.tasklet = tasklet(self._run_loop)
self._started = False
self._fd_map = dict()
self._signals = dict()
self._timers = set()
self._ready = deque()
self._ready_processor = pyuv.Check(self._loop)
self._ready_processor.start(self._process_ready)
self._ready_processor.unref()
self._ticker = Ticker(self._loop)
self._waker = pyuv.Async(self._loop, self._ticker.tick)
self._waker.unref()
self._install_signal_checker()
def __init__(self, realloop=None):
# prompt_toolkit....PosixEventLoop never bothers to init its super, so maybe we
# shouldn't either?
if realloop is None:
realloop = pyuv.Loop()
self.realloop = realloop
self.pending_async = []
def __init__(self):
if getattr(_tls, 'loop', None) is not None:
raise RuntimeError(
'cannot instantiate more than one event loop per thread')
_tls.loop = self
self._loop = pyuv.Loop()
self._loop.excepthook = self._handle_error
self._loop.event_loop = self
self._threadpool = ThreadPool(self)
self.task = Fiber(self._run_loop)
self._destroyed = False
self._started = False
self._running = False
self._fd_map = dict()
self._signals = dict()
self._timers = set()
self._ready = deque()
self._ready_processor = pyuv.Idle(self._loop)
self._waker = pyuv.Async(self._loop, self._async_cb)
self._waker.unref()
self._install_signal_checker()
def __init__(self, address=None, port=None):
self._loop = pyuv.Loop()
self._error = None
self._data = None
self._written = True
self._connected = False
self._timed_out = False
self._timer = pyuv.Timer(self._loop)
self._timeout_cb = self._on_timeout.__get__(self, UvStream)
self._read_cb = self._on_read.__get__(self, UvStream)
self._write_cb = self._on_write.__get__(self, UvStream)
connect_cb = self._on_connect.__get__(self, UvStream)
# Select the type of handle
if port:
# tcp
self._stream = pyuv.TCP(self._loop)
self._stream.connect((address, port), connect_cb)
elif address:
# named pipe or unix socket
self._stream = pyuv.Pipe(self._loop)
self._stream.connect(address, connect_cb)
else:
# stdin/stdout
self._read_stream = pyuv.Pipe(self._loop)
self._read_stream.open(sys.stdin.fileno())
self._write_stream = pyuv.Pipe(self._loop)
self._write_stream.open(sys.stdout.fileno())
def __init__(self):
super(Manager, self).__init__()
self.loop = pyuv.Loop()
self.neighbors = {}
self.ports = {}
self.daemon = True
self.wake = pyuv.Async(self.loop, self.sync)
self.queue = Queue()
def __init__(self):
self.uv_loop = libuv.Loop()
self.future_tick_queue = event_loop.tick.FutureTickQueue()
self.timers = {}
self.read_streams = {}
self.write_streams = {}
self.running = False
self.signals = event_loop.signal.Signals()
self.signal_events = {}
def __init__(self, callback=None):
self._clients = []
self.callback = callback if callback is not None else lambda d: d
loop = self._loop = pyuv.Loop()
thread = self._thread = Thread(target=loop.run)
thread.daemon = True
self._guard = self._create_guard()
server = self._server = self._create_acceptor()
self.host, self.port = server.getsockname()
def __init__(self):
self.loop = pyuv.Loop()
self._async = pyuv.Async(self.loop, self._wakeloop)
self._async.unref()
self.fds = {}
self._lock = threading.RLock()
self.running = False
# start the server task
self._runtask = tasklet(self.run, "uv_server")()
def test_embed(self):
if poller is None:
self.skipTest("test disabled if no suitable poller method is found")
return
self.embed_timer_called = 0
self.embed_closed = False
self.external = pyuv.Loop()
self.embed_async = pyuv.Async(self.external, self.embed_cb)
self.loop = pyuv.Loop()
timer = pyuv.Timer(self.loop)
timer.start(self.timer_cb, 0.25, 0)
self.sem = pyuv.thread.Semaphore(0)
t = Thread(target=self.embed_runner)
t.start()
self.external.run()
t.join()
external = None
self.assertEqual(self.embed_timer_called, 1)
def test_weakref(self):
loop = pyuv.Loop()
refs = []
for type in self.handle_types:
klass = getattr(pyuv, type)
obj = klass(loop)
refs.append(weakref.ref(obj))
del obj
for ref in refs:
self.assertNotEqual(ref(), None)
loop.run()
for ref in refs:
self.assertEqual(ref(), None)
def initialize(self):
self._loop = pyuv.Loop().default_loop()
self._handlers = {}
self._callbacks = []
self._callback_lock = thread.allocate_lock()
self._timeouts = set()
self._stopped = False
self._closing = False
self._thread_ident = None
self._cb_handle = pyuv.Prepare(self._loop)
self._cb_handle.start(self._prepare_cb)
self._waker = Waker(self._loop)
self._fdwaker = FDWaker()
self._signal_checker = pyuv.util.SignalChecker(self._loop, self._fdwaker.reader.fileno())
def __init__(self):
super().__init__()
self._loop = pyuv.Loop()
self._loop._rose_loop = self
self._default_executor = None
self._last_exc = None
self._fd_map = {}
self._signal_handlers = {}
self._subprocesses = {}
self._ready = collections.deque()
self._timers = collections.deque()
self._waker = pyuv.Async(self._loop, self._async_cb)
self._ready_processor = pyuv.Idle(self._loop)
def node_setup(port, handler, call_interface=None, loop=None):
"""Starts up just the chorus communication handler."""
if not loop:
loop = pyuv.Loop()
if not call_interface:
call_interface = CallInterface(loop)
node = Node(loop, port, call_interface, handler)
signal_stop = pyuv.Signal(loop)
signal_stop.start(
partial(_unwind_loop, [call_interface, node], signal_stop),
signal.SIGINT,
)
return loop
def __init__(self):
self._loop = pyuv.Loop()
self._count = 0
self._signal_stop = pyuv.Signal(self._loop)
self._signal_stop.start(
self._unwind_loop,
signal.SIGINT,
)
self._timer = pyuv.Timer(self._loop)
self._timer.start(
self._print_count,
timeout=0,
repeat=1,
)
def __init__(self):
self._loop = pyuv.Loop()
self._async_handle = pyuv.Async(self._loop, self._async_cb)
self._async_handle_lock = threading.Lock()
self._async_callbacks = deque()
self._readers = {} # map of reader objects to fd
self._writers = {} # map of writer objects to fd
self._fds = {} # map of fd to a (reader, writer) tuple
self._delayedCalls = {}
self._poll_handles = {}
self._signal_fds = SocketPair()
self._signal_checker = pyuv.util.SignalChecker(
self._loop, self._signal_fds.reader_fileno())
self._signal_checker.unref()
self._signal_checker.start()
PosixReactorBase.__init__(self)
def __init__(self, impl=None, _loop=None):
if impl is not None:
raise RuntimeError(
'When using pyuv the poller implementation cannot be specifiedi'
)
self._loop = _loop or pyuv.Loop()
self._handlers = {}
self._callbacks = deque()
self._callback_lock = thread.allocate_lock()
self._timeouts = set()
self._running = False
self._stopped = False
self._thread_ident = None
self._cb_handle = pyuv.Prepare(self._loop)
self._waker = Waker(self._loop)
def __init__(self):
self._loop = pyuv.Loop()
"""
Is Event Loop running?
If not, and _active_count > 0 (i.e. some processes need loop to handle!)
Just create a thread execute `loop.run()`
"""
self.proc_pool = MCProcessPool()
self.callback = MCProcessCallback()
self.info_monitor = MCInstanceInfoMonitor(self._loop)
self._init_proc_pool()
self._signal_handle = pyuv.Signal(self._loop)
pass
def __init__(self, flags=None, default=True):
if default:
self._loop = pyuv.Loop.default_loop()
else:
self._loop = pyuv.Loop()
self._loop._poll_handles = {}
self._loop.excepthook = functools.partial(self.handle_error, None)
self._callback_watcher = pyuv.Prepare(self._loop)
self._callback_spinner = pyuv.Idle(self._loop)
self._callbacks = []
self._child_watchers = {}
self._watchers = set()
self._sigchld_handle = None
if _signal_check_rfd is not None:
self._signal_checker = pyuv.util.SignalChecker(self._loop, _signal_check_rfd)
self._signal_checker.start()
else:
self._signal_checker = None
def initialize(self, loop=None, **kwargs):
super(UVLoop, self).initialize(**kwargs)
self._loop = loop or pyuv.Loop()
self._handlers = {}
self._callbacks = []
self._callback_lock = thread.allocate_lock()
#TODO: handle timeouts better
self._timeouts = set()
self._stopped = False
self._running = False
self._closing = False
self._thread_ident = None
self._cb_handle = pyuv.Prepare(self._loop)
self._cb_handle.start(self._prepare_cb)
self._waker = Waker(self._loop)
self._fdwaker = FDWaker()
self._signal_checker = pyuv.util.SignalChecker(
self._loop, self._fdwaker.reader.fileno())
def standard_setup(my_id, port, store, allow_dangerous_debugging):
"""Sets up and return a pyuv loop to run as the main server.
Sets up signal handling in addition to the call interface and node
handler.
"""
loop = pyuv.Loop()
call_interface = CallInterface(loop)
handler = chain.Handler(
my_id,
store,
call_interface,
allow_dangerous_debugging,
)
return node_setup(port, handler, call_interface, loop)
handle.send(data + LINESEP, (ip, port))
def async_exit(async):
async .close()
signal_h.close()
server.close()
def signal_cb(sig, frame):
async .send(async_exit)
print("PyUV version %s" % pyuv.__version__)
loop = pyuv.Loop()
async = pyuv.Async(loop)
server = pyuv.UDP(loop)
server.bind(("0.0.0.0", 1234))
server.start_recv(on_read)
signal_h = pyuv.Signal(loop)
signal_h.start()
t = threading.Thread(target=loop.run)
t.start()
signal.signal(signal.SIGINT, signal_cb)
signal.pause()
def setUp(self):
super(EventLoopTest, self).setUp()
self.loop = pyuv.Loop()
self.errors = []
def pyuv_test():
loop = pyuv.Loop()
f = open(FN, 'r')
pyuv.fs.read(loop, f.fileno(), 1024 * 1000 * 590, 0)
loop.queue_work(lambda: factorial(FAC, 1), lambda e: e)
loop.run()
def __init__(self, uri, loop=None, **options):
self.loop = loop or pyuv.Loop()
self.uri = uri
self.options = options
self.client = HTTPClient(loop=loop)
def make_loop(self):
loop = pyuv.Loop()
loop.excepthook = None
return loop
def make_loop(self):
return pyuv.Loop()
def make_loop(self):
loop = pyuv.Loop()
loop.excepthook = self.excepthook_cb
return loop
def run_loop(self):
loop = pyuv.Loop()
pyuv.ThreadPool.run(loop, self.run_in_pool)
loop.run()
def run_loop(self):
loop = pyuv.Loop()
signal_h = pyuv.Signal(loop)
signal_h.start(self.signal_cb, signal.SIGUSR1)
loop.run()
