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()