def got_app_error(topology, app_error):
server_address = common.partition_node(app_error['address'])
server = topology.get_server_by_address(server_address)
error_type = app_error['type']
generation = app_error.get('generation', server.pool.generation)
when = app_error['when']
max_wire_version = app_error['maxWireVersion']
# XXX: We could get better test coverage by mocking the errors on the
# Pool/SocketInfo.
try:
if error_type == 'command':
_check_command_response(app_error['response'])
elif error_type == 'network':
raise AutoReconnect('mock non-timeout network error')
elif error_type == 'timeout':
raise NetworkTimeout('mock network timeout error')
else:
raise AssertionError('unknown error type: %s' % (error_type, ))
assert False
except (AutoReconnect, NotMasterError, OperationFailure) as e:
if when == 'beforeHandshakeCompletes' and error_type == 'timeout':
raise unittest.SkipTest('PYTHON-2211')
topology.handle_error(server_address,
_ErrorContext(e, max_wire_version, generation))
def got_app_error(topology, app_error):
server_address = common.partition_node(app_error['address'])
server = topology.get_server_by_address(server_address)
error_type = app_error['type']
generation = app_error.get(
'generation', server.pool.gen.get_overall())
when = app_error['when']
max_wire_version = app_error['maxWireVersion']
# XXX: We could get better test coverage by mocking the errors on the
# Pool/SocketInfo.
try:
if error_type == 'command':
_check_command_response(app_error['response'], max_wire_version)
_check_write_command_response(app_error['response'])
elif error_type == 'network':
raise AutoReconnect('mock non-timeout network error')
elif error_type == 'timeout':
raise NetworkTimeout('mock network timeout error')
else:
raise AssertionError('unknown error type: %s' % (error_type,))
assert False
except (AutoReconnect, NotPrimaryError, OperationFailure) as e:
if when == 'beforeHandshakeCompletes':
completed_handshake = False
elif when == 'afterHandshakeCompletes':
completed_handshake = True
else:
assert False, 'Unknown when field %s' % (when,)
topology.handle_error(
server_address, _ErrorContext(e, max_wire_version, generation,
completed_handshake, None))
def _raise_connection_failure(address, error):
"""Convert a socket.error to ConnectionFailure and raise it."""
host, port = address
msg = '%s:%d: %s' % (host, port, error)
if isinstance(error, socket.timeout):
raise NetworkTimeout(msg)
else:
raise AutoReconnect(msg)
def mock_is_master(self, host):
"""Return mock ismaster response (a dict) and round trip time."""
if host in self.mock_wire_versions:
min_wire_version, max_wire_version = self.mock_wire_versions[host]
else:
min_wire_version = common.MIN_SUPPORTED_WIRE_VERSION
max_wire_version = common.MAX_SUPPORTED_WIRE_VERSION
max_write_batch_size = self.mock_max_write_batch_sizes.get(
host, common.MAX_WRITE_BATCH_SIZE)
rtt = self.mock_rtts.get(host, 0)
# host is like 'a:1'.
if host in self.mock_down_hosts:
raise NetworkTimeout('mock timeout')
elif host in self.mock_standalones:
response = {
'ok': 1,
'ismaster': True,
'minWireVersion': min_wire_version,
'maxWireVersion': max_wire_version,
'maxWriteBatchSize': max_write_batch_size
}
elif host in self.mock_members:
ismaster = (host == self.mock_primary)
# Simulate a replica set member.
response = {
'ok': 1,
'ismaster': ismaster,
'secondary': not ismaster,
'setName': 'rs',
'hosts': self.mock_ismaster_hosts,
'minWireVersion': min_wire_version,
'maxWireVersion': max_wire_version,
'maxWriteBatchSize': max_write_batch_size
}
if self.mock_primary:
response['primary'] = self.mock_primary
elif host in self.mock_mongoses:
response = {
'ok': 1,
'ismaster': True,
'minWireVersion': min_wire_version,
'maxWireVersion': max_wire_version,
'msg': 'isdbgrid',
'maxWriteBatchSize': max_write_batch_size
}
else:
# In test_internal_ips(), we try to connect to a host listed
# in ismaster['hosts'] but not publicly accessible.
raise AutoReconnect('Unknown host: %s' % host)
return response, rtt
def _raise_connection_failure(address, error):
"""Convert a socket.error to ConnectionFailure and raise it."""
host, port = address
# If connecting to a Unix socket, port will be None.
if port is not None:
msg = '%s:%d: %s' % (host, port, error)
else:
msg = '%s: %s' % (host, error)
if isinstance(error, socket.timeout):
raise NetworkTimeout(msg)
elif isinstance(error, SSLError) and 'timed out' in str(error):
# CPython 2.6, 2.7, PyPy 2.x, and PyPy3 do not distinguish network
# timeouts from other SSLErrors (https://bugs.python.org/issue10272).
# Luckily, we can work around this limitation because the phrase
# 'timed out' appears in all the timeout related SSLErrors raised
# on the above platforms. CPython >= 3.2 and PyPy3.3 correctly raise
# socket.timeout.
raise NetworkTimeout(msg)
else:
raise AutoReconnect(msg)
def g(arg1, counter=[0]):
if counter[0] == 0:
counter[0] += 1
print "NetworkTimeout"
raise NetworkTimeout("FOO")
elif counter[0] == 1:
counter[0] += 1
print "Connection Failure"
raise ConnectionFailure("BAR")
else:
return True
def _raise_connection_failure(address, error):
"""Convert a socket.error to ConnectionFailure and raise it."""
host, port = address
# If connecting to a Unix socket, port will be None.
if port is not None:
msg = '%s:%d: %s' % (host, port, error)
else:
msg = '%s: %s' % (host, error)
if isinstance(error, socket.timeout):
raise NetworkTimeout(msg)
else:
raise AutoReconnect(msg)
def test_set_upload_results_attached_raise_exc(self, get_collection):
collection = MagicMock()
collection.update_one.side_effect = NetworkTimeout()
get_collection.return_value = collection
args = ("one", 2, {3: 4, 5: 6})
result = set_upload_results_attached(*args)
collection.update_one.assert_called_once_with(
{'_id': args_to_uid(args)},
{"$set": {'attached': True}}
)
self.assertIs(result, None)
def test_save_upload_results_raise_exc(self, get_collection):
collection = MagicMock()
collection.insert.side_effect = NetworkTimeout()
get_collection.return_value = collection
file_data = {"data": 1, "meta": "hello"}
args = ("one", 2, [3, 4])
with patch("edr_bot.results_db.datetime") as datetime_mock:
datetime_mock.utcnow.return_value = datetime.utcnow()
result = save_upload_results(file_data, *args)
collection.insert.assert_called_once_with(
{
'_id': args_to_uid(args),
'file_data': file_data,
'createdAt': datetime_mock.utcnow.return_value
}
)
self.assertIs(result, None)
def test_save_upload_results_raise_exc(self, get_collection):
task = MagicMock()
task.name = "bot.some_task"
collection = MagicMock()
collection.insert_one.side_effect = NetworkTimeout()
get_collection.return_value = collection
file_data = {"data": 1, "meta": "hello"}
args = ("one", 2, [3, 4])
with patch("tasks_utils.results_db.datetime") as datetime_mock:
datetime_mock.utcnow.return_value = datetime.utcnow()
result = save_task_result(task, file_data, args)
collection.insert_one.assert_called_once_with({
'_id':
args_to_uid(("bot.some_task", ) + args),
'result':
file_data,
'createdAt':
datetime_mock.utcnow.return_value
})
self.assertIs(result, None)
