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 _adapter_connect(self):
"""Connect to the remote socket, adding the socket to the IOLoop if
connected
:rtype: bool
"""
LOGGER.debug('init io and signal watchers if any')
# reuse existing signal watchers, can only be declared for 1 ioloop
global global_sigint_watcher, global_sigterm_watcher
error = super(LibuvConnection, self)._adapter_connect()
if not error:
if self._on_signal_callback and not global_sigterm_watcher:
global_sigint_watcher = pyuv.Signal(self.ioloop)
if self._on_signal_callback and not global_sigint_watcher:
global_sigterm_watcher = pyuv.Signal(self.ioloop)
if not self._io_watcher:
self._io_watcher = pyuv.Poll(self.ioloop, self.socket.fileno())
self._io_watcher.fd = self.socket.fileno()
self. async = pyuv.Async(self.ioloop, self._noop_callable())
self. async .send()
if self._on_signal_callback:
global_sigterm_watcher.start(signal.SIGTERM,
self._handle_sigterm)
global_sigint_watcher.start(signal.SIGINT, self._handle_sigint)
self._io_watcher.start(self._PIKA_TO_LIBUV_ARRAY[self.event_state],
self._handle_events)
return error
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, loop=None):
# by default we run on the default loop
self.loop = loop or pyuv.Loop.default_loop()
# wakeup ev for internal signaling
self._wakeup_ev = pyuv.Async(self.loop, self._on_wakeup)
# initialize the emitter
self._emitter = EventEmitter(self.loop)
# initialize the process tracker
self._tracker = ProcessTracker(self.loop)
# initialize some values
self.apps = None
self.started = False
self._stop_ev = None
self.max_process_id = 0
self.processes = OrderedDict()
self.running = OrderedDict()
self.groups = {}
self.channel = deque()
self._updates = deque()
self._signals = []
self.stopping = False
self.stop_cb = None
self.restart_cb = None
self._lock = RLock()
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 test_async2(self):
self.prepare_cb_called = 0
self.check_cb_called = 0
def prepare_cb(prepare):
self.prepare_cb_called += 1
self.thread = threading.Thread(target=thread_cb)
self.thread.start()
def check_cb(check):
self.check_cb_called += 1
self.loop.stop()
def thread_cb():
time.sleep(0.01)
self. async .send()
self. async = pyuv.Async(self.loop)
self.prepare = pyuv.Prepare(self.loop)
self.prepare.start(prepare_cb)
self.check = pyuv.Check(self.loop)
self.check.start(check_cb)
self.loop.run()
self.assertEqual(self.prepare_cb_called, 1)
self.assertEqual(self.check_cb_called, 1)
def test_async1(self):
self.async_cb_called = 0
self.prepare_cb_called = 0
def async_cb(async):
with self.lock:
self.async_cb_called += 1
n = self.async_cb_called
if n == 3:
self.async.close()
self.prepare.close()
def prepare_cb(prepare):
if self.prepare_cb_called:
return
self.prepare_cb_called += 1
self.thread = threading.Thread(target=thread_cb)
self.thread.start()
def thread_cb():
while True:
with self.lock:
n = self.async_cb_called
if n == 3:
break
self.async.send()
self.async = pyuv.Async(self.loop, async_cb)
self.prepare = pyuv.Prepare(self.loop)
self.prepare.start(prepare_cb)
self.lock = threading.Lock()
self.loop.run()
self.assertEqual(self.async_cb_called, 3)
self.assertEqual(self.prepare_cb_called, 1)
def __init__(self):
self._loop = pyuv.Loop.default_loop()
self._running = False
self._stopped = False
self._callbacks = collections.deque()
self._callback_processor = pyuv.Check(self._loop)
self._callback_processor.start(self._process_callbacks)
self._waker = pyuv.Async(self._loop, lambda x: None)
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, loop):
self.loop = loop
self._queue = deque()
self._dispatcher = pyuv.Prepare(self.loop)
self._dispatcher.start(self._send)
if hasattr(self._dispatcher, 'unref'):
self._dispatcher.unref()
self._tick = pyuv.Async(loop, self._spin_up)
self._spinner = pyuv.Idle(self.loop)
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 wait(self):
"""Wait for signal or until set call."""
if self._flag:
return
self.start()
self._guard = pyuv.Async(self._loop, lambda h: None)
try:
self._loop.run()
finally:
self.stop()
def __init__(self, loop, pid, ref=True):
if not loop.default:
raise TypeError("child watchers are only allowed in the default loop")
super(Child, self).__init__(loop, ref)
loop.install_sigchld()
self._active = False
self._pid = pid
self.rpid = None
self.rstatus = None
self._handle = pyuv.Async(self.loop._loop, self._async_cb)
def __init__(self, address):
self.sock = socket.socket()
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(address)
self.sock.setblocking(0)
self.address = self.sock.getsockname()
self.loop = pyuv.Loop.default_loop()
self.poll_watcher = pyuv.Poll(self.loop, self.sock.fileno())
self.async = pyuv.Async(self.loop, self.async_cb)
self.conns = weakref.WeakValueDictionary()
self.signal_watchers = set()
def test_signal1(self):
self.async_cb_called = 0
self.signal_cb_called = 0
self. async = pyuv.Async(self.loop, self.async_cb)
self.signal_h = pyuv.Signal(self.loop)
self.signal_h.start(self.signal_cb, signal.SIGUSR1)
thread = threading.Thread(target=self.loop.run)
thread.start()
os.kill(os.getpid(), signal.SIGUSR1)
thread.join()
self.assertEqual(self.async_cb_called, 1)
self.assertEqual(self.signal_cb_called, 1)
def test_registry_events():
loop = pyuv.Loop.default_loop()
async = pyuv.Async(loop, lambda h: h.stop())
r = Registry(loop)
emitted = []
def cb(event, message):
emitted.append((event, copy.deepcopy(message)))
r.bind_all(cb)
c1 = object()
r.add_node(c1)
r.identify(c1, "c1", "broadcast", 1.0)
r.update(c1)
r.add_job(c1, "a.job1")
r.add_process(c1, "a.job1", 1)
r.remove_process(c1, "a.job1", 1)
r.remove_job(c1, "a.job1")
r.remove_node(c1)
t = pyuv.Timer(loop)
t.start(lambda h: async .close(), 0.2, 0.0)
loop.run()
assert len(emitted) == 7
actions = [line[0] for line in emitted]
assert list(actions) == [
'add_node', 'identify', 'add_job', 'add_process', 'remove_process',
'remove_job', 'remove_node'
]
assert isinstance(emitted[0][1], GafferNode)
assert isinstance(emitted[1][1], GafferNode)
assert isinstance(emitted[2][1], dict)
assert "job_name" in emitted[2][1]
assert emitted[2][1]['job_name'] == "a.job1"
assert isinstance(emitted[3][1], dict)
assert "job_name" in emitted[3][1]
assert emitted[3][1]['job_name'] == "a.job1"
assert "pid" in emitted[3][1]
assert emitted[3][1]['pid'] == 1
assert isinstance(emitted[4][1], dict)
assert "job_name" in emitted[4][1]
assert emitted[4][1]['job_name'] == "a.job1"
assert "pid" in emitted[4][1]
assert emitted[4][1]['pid'] == 1
assert isinstance(emitted[5][1], dict)
assert emitted[5][1]['job_name'] == "a.job1"
assert isinstance(emitted[6][1], GafferNode)
assert emitted[6][1].sessions == {}
def run_in_executor(self, callback):
# PosixEventLoop creates a thread function to call the callback and
# gives that to the executor... Apparently prompt_toolkit might rely
# on this so that it doesn't process autocompletions during paste in a
# heavy manner. TODO: Revisit this (they have a note about i/o vs cpu
# preferencing)
def wrapper(handle):
handle.close()
callback()
i = self.pending_async.index(handle)
del self.pending_async[i]
a = pyuv.Async(self.realloop, wrapper)
self.pending_async.append(a)
a.send()
def call_from_executor(self, callback, _max_postpone_until=None):
#TODO: Mess with max postpone? PosixEventLoop uses a pipe to schedule
# a callback for execution.
# We'll just call the function via pyuv Async and be done with it.
def wrapper(handle):
handle.close()
callback()
i = self.pending_async.index(handle)
del self.pending_async[i]
a = pyuv.Async(self.realloop, wrapper)
# If we don't store a somewhere ourselves, libuv never calls the
# callback. I suspect it is getting garbage collected if we don't keep
# a reference ourselves.
self.pending_async.append(a)
a.send()
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 __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 start(self, apps=[]):
""" start the manager. """
self.mapps = apps
self._waker = pyuv.Async(self.loop, self._wakeup)
# start the process tracker
self._tracker.start()
# manage processes
self.events.subscribe('exit', self._on_exit)
# start contollers
for mapp in self.mapps:
mapp.start(self.loop, self)
self.started = True
self.status = 0
def test_async1(self):
self.async_cb_called = 0
self.close_cb_called = 0
def close_cb(handle):
self.close_cb_called += 1
def async_cb(async):
self.async_cb_called += 1
async .close(close_cb)
loop = pyuv.Loop.default_loop()
thread = threading.Thread(target=loop.run)
async = pyuv.Async(loop)
thread.start()
async .send(async_cb)
thread.join()
self.assertEqual(self.async_cb_called, 1)
self.assertEqual(self.close_cb_called, 1)
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 __init__(self, loop, ref=True):
super(Async, self).__init__(loop, ref)
self._handle = pyuv.Async(self.loop._loop, self._async_cb)
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()
t.join()
def start_process(self):
self. async = pyuv.Async(self._loop, self._start_process_async)
self. async .send()
def __init__(self, reactor):
self._async = pyuv.Async(reactor._loop, lambda x: None)
self._async.unref()
def __init__(self, icommand, order_queue, event_queue):
try:
self.order_queue = order_queue # Messages from master thread
self.event_queue = event_queue # Messages to master thread
self.master_fd, self.slave_fd = pty.openpty()
pty_make_controlling_tty(self.slave_fd)
self.stream = pyte.Stream()
self.screen = pyte.Screen(icommand.width, icommand.height)
self.stream.attach(self.screen)
self.raw_byte_output = b''
self.timeout = icommand.timeout
self.task = None
self.loop = pyuv.Loop.default_loop()
self.tty_handle = pyuv.TTY(self.loop, self.master_fd, True)
self.tty_handle.start_read(self.on_tty_read)
self.sigterm_handle = pyuv.Signal(self.loop)
self.sigterm_handle.start(self.sigterm_callback, signal.SIGTERM)
self.sigint_handle = pyuv.Signal(self.loop)
self.sigint_handle.start(self.sigint_callback, signal.SIGINT)
self.process_handle = pyuv.Process.spawn(
self.loop,
args=icommand._command.arguments,
env=icommand._command.env,
cwd=icommand._command.directory,
exit_callback=self.on_exit,
stdio=[
pyuv.StdIO(
fd=self.slave_fd,
flags=pyuv.UV_INHERIT_FD,
),
pyuv.StdIO(
fd=self.slave_fd,
flags=pyuv.UV_INHERIT_FD,
),
pyuv.StdIO(
fd=self.slave_fd,
flags=pyuv.UV_INHERIT_FD,
),
],
flags=pyuv.UV_PROCESS_DETACHED,
)
self._pid = self.process_handle.pid
self.event_queue.put(
message.ProcessStartedMessage(
message.RunningProcess(self._pid, self.master_fd)))
self.async_handle = pyuv.Async(self.loop, self.on_thread_callback)
self.event_queue.put(
message.AsyncSendMethodMessage(self.async_handle.send))
self.timeout_handle = None
self.reset_timeout()
self.loop.run()
except Exception as error:
self.close_handles()
self.event_queue.put(message.ExceptionMessage(error))
def async_exit(async):
[c.close() for c in clients]
async .close()
signal_h.close()
server.close()
def signal_cb(handle, signum):
global async
async .send()
print("PyUV version %s" % pyuv.__version__)
loop = pyuv.Loop.default_loop()
async = pyuv.Async(loop, async_exit)
clients = []
server = pyuv.TCP(loop)
server.bind(("0.0.0.0", 1234))
server.listen(on_connection)
signal_h = pyuv.Signal(loop)
signal_h.start(signal_cb, signal.SIGINT)
loop.run()
print("Stopped!")
def __init__(self, loop):
self._async = pyuv.Async(loop, lambda x: None)
