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 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_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_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 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 __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 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 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(self, r, w, x, timeout):
if self.error:
raise select.error(self.error)
return self.readables, self.writables, []
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')
def select(self, r, w, x, timeout):
import select
if self.select_error:
raise select.error(self.select_error)
return self.select_result
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 poll(self, timeout):
if self.error:
raise select.error(self.error)
return self.result
def raise_eintr_once(*args): # @UnusedVariable
select_call.side_effect = None
raise select.error(4, 'Interrupted system call')
