def select(cls, rlist, wlist, xlist, timeout=5): the_time = time.time() if timeout is not None: tstop = the_time + timeout else: tstop = 0 while timeout is None or the_time <= tstop: # we must always go around at least once rs = [] ws = [] for r in rlist: try: if r.recv_pipe.canread(): rs.append(r) except IOError: # raise a socket error raise select.error(errno.EPIPE, os.strerror(errno.EPIPE)) for w in wlist: try: if w.send_pipe.canwrite(): ws.append(w) except IOError: # raise a socket error raise select.error(errno.EPIPE, os.strerror(errno.EPIPE)) if rs or ws: return rs, ws, [] else: time.sleep(1) the_time = time.time() return [], [], []
def test_await_pg_notifications_failure(conn_string): expected_error_num = errno.ECONNREFUSED exceptions = [error(errno.EINTR, ""), error(expected_error_num, "")] with patch("dagster_postgres.pynotify.select") as mock_select: mock_select.select = MagicMock(side_effect=exceptions) mock_select.error = error with pytest.raises(error) as exc: for _ in await_pg_notifications( conn_string, channels=["foo"], yield_on_timeout=True, exit_event=Event() ): pass assert exc.value.errno == expected_error_num
def test_select_eintr(self): # EINTR is supposed to be ignored with mock.patch('pyftpdlib.ioloop.select.select', side_effect=select.error()) as m: m.side_effect.errno = errno.EINTR s, rd, wr = self.test_register() s.poll(0) # ...but just that with mock.patch('pyftpdlib.ioloop.select.select', side_effect=select.error()) as m: m.side_effect.errno = errno.EBADF s, rd, wr = self.test_register() self.assertRaises(select.error, s.poll, 0)
def test_invalidate_connection(slef, queued_pool): msg = Message.generate() with pytest.raises(select.error): with queued_pool.acquire() as cxn: fairy = cxn.fairy raise select.error(9, 'Bad file descriptor') assert fairy.cxn.is_closed
def serve_forever(self): while self.run: try: self.handle_request() except select.error(e): if e[0] != errno.EINTR: raise e
def select(self, *args, **kwargs): """Python3 raises `ValueError` if socket is closed, because fd == -1""" try: return super(PatroniSequentialThreadingHandler, self).select(*args, **kwargs) except ValueError as e: raise select.error(9, str(e))
def monitor_file() -> bool: # True if should restart monitoring fd = None kq = None try: fd = open(file) callback() kq = select.kqueue() kevent = select.kevent(fd.fileno(), filter=select.KQ_FILTER_VNODE, flags=select.KQ_EV_ADD | select.KQ_EV_CLEAR, fflags=select.KQ_NOTE_WRITE | select.KQ_NOTE_RENAME | select.KQ_NOTE_DELETE) renamed = False while True: revents = kq.control([kevent], 1, None) for evt in revents: if evt.flags & select.KQ_EV_ERROR == select.KQ_EV_ERROR: raise select.error(evt.data) if evt.fflags & select.KQ_NOTE_WRITE: callback() if evt.fflags & select.KQ_NOTE_RENAME: renamed = True if evt.fflags & select.KQ_NOTE_DELETE: return renamed finally: if kq is not None: kq.close() if fd is not None: fd.close()
def test_signal(self): """Tests behavior when signalled during wait.""" watcher = idirwatch.DirWatcher(self.root) mocked_pollobj = select.poll.return_value mocked_pollobj.poll.side_effect = select.error(errno.EINTR, '') self.assertFalse(watcher.wait_for_events())
def __call__(self, *args): self.called += 1 if self.called == 1: # raise the exception on first call raise select.error(errno.EINTR, os.strerror(errno.EINTR)) else: # Return real select value for consecutive calls return old_select(*args)
def test_nofailure_with_errno_EINTR(self): """checks no exception is raised if errno.EINTR is raised while it's selecting""" self.__call_count = 0 select.select = lambda r, w, x, t: self.__faked_select( select.error(errno.EINTR)) self.stats_httpd = MyStatsHttpd(get_availaddr()) self.stats_httpd.start() # shouldn't leak the exception self.assertFalse(self.stats_httpd.running) self.assertIsNone(self.stats_httpd.mccs)
def test_wait_interrupt(self): """Test that we actually select twice if the first one returns EINTR.""" utils.logging.debug.expect_any_call() bg_job = utils.BgJob('echo "hello world"') bg_job.result.exit_status = 0 self.god.stub_function(utils.select, 'select') utils.select.select.expect_any_call().and_raises( select.error(errno.EINTR, 'Select interrupted')) utils.logging.warning.expect_any_call() utils.select.select.expect_any_call().and_return( ([bg_job.sp.stdout, bg_job.sp.stderr], [], None)) utils.logging.warning.expect_any_call() self.assertFalse(utils._wait_for_commands([bg_job], time.time(), None))
def test_ppl(self, read_mock, select_mock): # Simulate the two files stdout = mock.Mock(name='pipe.stdout') stdout.fileno.return_value = 65 stderr = mock.Mock(name='pipe.stderr') stderr.fileno.return_value = 66 # Recipients for results out_list = [] err_list = [] # StreamLineProcessors out_proc = StreamLineProcessor(stdout, out_list.append) err_proc = StreamLineProcessor(stderr, err_list.append) # The select call always returns all the streams select_mock.side_effect = [ [[out_proc, err_proc], [], []], select.error(errno.EINTR), # Test interrupted system call [[out_proc, err_proc], [], []], [[out_proc, err_proc], [], []], ] # The read calls return out and err interleaved # Lines are split in various ways, to test all the code paths read_mock.side_effect = ['line1\nl'.encode('utf-8'), 'err'.encode('utf-8'), 'ine2'.encode('utf-8'), '1\nerr2\n'.encode('utf-8'), '', '', Exception] # Make sure it terminates command_wrappers.Command.pipe_processor_loop([out_proc, err_proc]) # Check the calls order and the output assert read_mock.mock_calls == [ mock.call(65, 4096), mock.call(66, 4096), mock.call(65, 4096), mock.call(66, 4096), mock.call(65, 4096), mock.call(66, 4096), ] assert out_list == ['line1', 'line2'] assert err_list == ['err1', 'err2', '']
def raise_eintr_once(*args): select_call.side_effect = None raise select.error(4, "Interrupted system call")
def test_ppl_select_failure(self, select_mock): # Test if select errors are passed through select_mock.side_effect = select.error('not good') with pytest.raises(select.error): command_wrappers.Command.pipe_processor_loop([None])
def select_that_throws_exception(*args, **kwargs): raise select.error('this is just a test')
def test_internal_utils(self): err = select.error(errno.EINTR, "interrupted") assert omcache._select_errno(err) == errno.EINTR
def raise_eintr_once(*args): select_call.side_effect = None raise select.error(4, 'Interrupted system call')
def select(self, r, w, x, timeout): import select if self.select_error: raise select.error(self.select_error) return self.select_result
def mock_select(*_): raise select.error('unittest')
def mock_select(*_): raise select.error(EINTR)
def test_read_select_err(self): '''Recovers from select errors''' with mock.patch('nsq.client.select.select') as mock_select: mock_select.side_effect = select.error(errno.EBADF) # This test passes if no exception is raised self.client.read()
def select(self, r, w, x, timeout): if self.error: raise select.error(self.error) return self.readables, self.writables, []
def raise_select_except(*args): raise select.error('dummy error')
class IOExceptionTests(TestFramework): def test_io_receive_raises_socket_error(self): connection = FakeConnection() io = IO(connection.parameters, exceptions=connection.exceptions) io.socket = mock.Mock(name='socket', spec=socket.socket) io.socket.recv.side_effect = socket.error('travis-ci') io._receive() self.assertRaisesRegexp(AMQPConnectionError, 'travis-ci', connection.check_for_errors) def test_io_receive_does_not_raise_on_block(self): connection = FakeConnection() io = IO(connection.parameters, exceptions=connection.exceptions) io.socket = mock.Mock(name='socket', spec=socket.socket) io.socket.recv.side_effect = socket.error(EWOULDBLOCK) io._receive() self.assertIsNone(connection.check_for_errors()) def test_io_receive_raises_socket_timeout(self): connection = FakeConnection() io = IO(connection.parameters) io.socket = mock.Mock(name='socket', spec=socket.socket) io.socket.recv.side_effect = socket.timeout('timeout') io._receive() def test_io_simple_send_with_error(self): connection = FakeConnection() io = IO(connection.parameters) io._exceptions = [] io.socket = mock.Mock(name='socket', spec=socket.socket) io.socket.send.side_effect = socket.error('error') io.write_to_socket(self.message) self.assertIsInstance(io._exceptions[0], AMQPConnectionError) def test_io_simple_send_with_recoverable_error(self): connection = FakeConnection() self.raised = False def custom_raise(*_): if self.raised: return 1 self.raised = True raise socket.error(EWOULDBLOCK) io = IO(connection.parameters) io._exceptions = [] io.socket = mock.Mock(name='socket', spec=socket.socket) io.socket.send.side_effect = custom_raise io.write_to_socket(self.message) self.assertTrue(self.raised) self.assertFalse(io._exceptions) def test_io_simple_send_with_timeout_error(self): connection = FakeConnection() self.raised = False def custom_raise(*_): if self.raised: return 1 self.raised = True raise socket.timeout() io = IO(connection.parameters) io._exceptions = [] io.socket = mock.Mock(name='socket', spec=socket.socket) io.socket.send.side_effect = custom_raise io.write_to_socket(self.message) self.assertTrue(self.raised) self.assertFalse(io._exceptions) def test_io_simple_send_with_io_error(self): connection = FakeConnection() io = IO(connection.parameters) io._exceptions = [] io.socket = None io.write_to_socket(self.message) self.assertTrue(io._exceptions) def test_io_ssl_connection_without_ssl_library(self): compatibility.SSL_SUPPORTED = False try: parameters = FakeConnection().parameters parameters['ssl'] = True io = IO(parameters) self.assertRaisesRegexp( AMQPConnectionError, 'Python not compiled with support for TLSv1 or higher', io.open) finally: compatibility.SSL_SUPPORTED = True @mock.patch('amqpstorm.compatibility.SSL_SUPPORTED', return_value=False) def test_io_normal_connection_without_ssl_library(self, _): connection = FakeConnection() connection.parameters['hostname'] = 'localhost' connection.parameters['port'] = 1234 parameters = connection.parameters io = IO(parameters) self.assertRaisesRegexp(AMQPConnectionError, 'Could not connect to localhost:1234', io.open) @mock.patch('socket.getaddrinfo', side_effect=socket.gaierror('could not connect')) def test_io_raises_gaierror(self, _): connection = FakeConnection() connection.parameters['hostname'] = 'localhost' connection.parameters['port'] = 1234 parameters = connection.parameters io = IO(parameters) self.assertRaisesRegexp(AMQPConnectionError, 'could not connect', io._get_socket_addresses) @mock.patch('amqpstorm.io.select.select', side_effect=select.error('travis-ci')) def test_io_poller_raises(self, _): exceptions = [] poller = Poller(0, exceptions, 30) self.assertFalse(poller.is_ready) self.assertTrue(exceptions) @mock.patch('amqpstorm.io.select.select', side_effect=select.error(EINTR)) def test_io_poller_eintr(self, _): exceptions = [] poller = Poller(0, exceptions, 30) self.assertFalse(poller.is_ready) self.assertFalse(exceptions) def test_io_simple_receive_when_socket_not_set(self): connection = FakeConnection() io = IO(connection.parameters, exceptions=connection.exceptions) self.assertFalse(io.use_ssl) self.assertEqual(io._receive(), bytes()) self.assertRaisesRegexp(AMQPConnectionError, 'connection/socket error', connection.check_for_errors)
def poll(self, timeout): if self.error: raise select.error(self.error) return self.result
def raise_eintr(): raise select.error(4, 'Interrupted system call')
def raise_eintr_once(*args): # @UnusedVariable select_call.side_effect = None raise select.error(4, 'Interrupted system call')