def __init__(self, loop, socket):
self.loop = loop
self.socket = socket
# shortcircuit some socket methods
self.bind = self.socket.bind
self.bind_to_random_port = self.socket.bind_to_random_port
self.connect = self.socket.connect
self.setsockopt = self.socket.setsockopt
self.getsockopt = self.socket.getsockopt
self.setsockopt_string = self.socket.setsockopt_string
self.getsockopt_string = self.socket.getsockopt_string
self.setsockopt_unicode = self.socket.setsockopt_unicode
self.getsockopt_unicode = self.socket.getsockopt_unicode
self.fd = socket.getsockopt(zmq.FD)
self._poll = pyuv.Poll(loop, self.fd)
self._poll.start(pyuv.UV_READABLE, self._on_events)
self._prepare_h = pyuv.Prepare(loop)
self._waker = pyuv.Idle(self.loop)
self._events = 0
self._send_queue = deque()
self._read_cb = None
self._read_copy = True
self._read_track = False
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 _publish(self, pattern, evtype, *args, **kwargs):
if pattern in self._events:
self._queue.append((pattern, evtype, args, kwargs))
idle = pyuv.Idle(self.loop)
idle.start(self._send)
self._triggered.append(idle)
def _publish_wildcards(self, evtype, *args, **kwargs):
if self._wildcards:
self._wqueue.append((evtype, args, kwargs))
idle = pyuv.Idle(self.loop)
idle.start(self._send_wildcards)
self._triggered.append(idle)
def setup_idle(self, exception=None):
def idle_cb(handle):
handle.stop()
handle.close()
if exception is not None:
raise exception
self.idle = pyuv.Idle(self.loop)
self.idle.start(idle_cb)
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 test_idle1(self):
self.idle_cb_called = 0
def idle_cb(idle):
self.idle_cb_called += 1
idle.stop()
idle.close()
idle = pyuv.Idle(self.loop)
idle.start(idle_cb)
self.loop.run()
self.assertEqual(self.idle_cb_called, 1)
def __init__(self, loop, max_size=10000):
self.loop = loop
self._events = {}
self._wildcards = set()
self._queue = deque(maxlen=max_size)
self._wqueue = deque(maxlen=max_size)
self._event_dispatcher = pyuv.Prepare(self.loop)
self._event_dispatcher.start(self._send)
self._event_dispatcher.unref()
self._spinner = pyuv.Idle(self.loop)
def add_callback(self, callback):
"""
Add a callback in the hub
:param timer:
:return:
"""
assert isinstance(callback, Callback)
eventcallback = pyuv.Idle(self.uv_loop)
eventcallback.data = callback
callback.implcallback = eventcallback
eventcallback.start(self._callback_triggered)
self.callbacks.add(callback)
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 test_multihandle1(self):
self.close_cb_called = 0
self.prepare_cb_called = 0
def close_cb(handle):
self.close_cb_called += 1
def prepare_cb(prepare):
self.prepare_cb_called += 1
prepare.stop()
prepare.close(close_cb)
self.idle_cb_called = 0
def idle_cb(idle):
self.idle_cb_called += 1
idle.stop()
idle.close(close_cb)
self.check_cb_called = 0
def check_cb(check):
self.check_cb_called += 1
check.stop()
check.close(close_cb)
self.timer_cb_called = 0
def timer_cb(timer):
self.timer_cb_called += 1
timer.stop()
timer.close(close_cb)
loop = pyuv.Loop.default_loop()
prepare = pyuv.Prepare(loop)
prepare.start(prepare_cb)
idle = pyuv.Idle(loop)
idle.start(idle_cb)
check = pyuv.Check(loop)
check.start(check_cb)
timer = pyuv.Timer(loop)
timer.start(timer_cb, 0.1, 0)
loop.run()
self.assertEqual(self.prepare_cb_called, 1)
self.assertEqual(self.idle_cb_called, 1)
self.assertEqual(self.check_cb_called, 1)
self.assertEqual(self.close_cb_called, 4)
def uv_idle(ref=True):
""" use the event loop for idling. This an alternative to our own
time events scheduler """
uv = uv_server()
c = channel()
def _sleep_cb(handle):
handle.stop()
c.send(True)
idle = pyuv.Idle(uv.loop)
idle.start(_sleep_cb)
if not ref:
idle.unref()
return c.receive()
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 __init__(self):
# main event loop
self.loop = pyuv.Loop.default_loop()
# set up Ctrl-C to exit
pyuv.Signal(self.loop).start(self.sigint_callback, signal.SIGINT)
self.ds4_init()
self.wheelchair_js_init()
self.drone_controller_init()
self.ds4_poll_handle = pyuv.Poll(self.loop, self.ds4.fd).start(
pyuv.UV_READABLE, self.ds4_callback)
self.wheelchair_js_poll_handle = pyuv.Poll(
self.loop,
self.wheelchair_js.fd).start(pyuv.UV_READABLE,
self.wheelchair_js_callback)
self.idle_handle = pyuv.Idle(self.loop).start(self.idle_callback)
# Start with PS4 controller (DualShock 4) overriding wheelchair joystick
self.override = True
# Assume wheelchair joystick starts off centered
self.wheelchair_X_centered = self.wheelchair_Y_centered = True
def __init__(self, loop, ref=True):
super(Idle, self).__init__(loop, ref)
self._handle = pyuv.Idle(self.loop._loop)
