def __call__(self,
request_iterator,
timeout=None,
metadata=None,
credentials=None):
deadline, deadline_timespec = _deadline(timeout)
state = _RPCState(_STREAM_STREAM_INITIAL_DUE, None, None, None, None)
channel = self._channel.get_channel()
call, drive_call = channel.managed_call(None, 0, self._method, None,
deadline_timespec)
if credentials is not None:
call.set_credentials(credentials._credentials)
event_handler = _event_handler(state, call,
self._response_deserializer)
with state.condition:
call.start_client_batch(
cygrpc.Operations(
(cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS),
)), event_handler)
operations = (
cygrpc.operation_send_initial_metadata(
_common.to_cygrpc_metadata(metadata), _EMPTY_FLAGS),
cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),
)
call_error = call.start_client_batch(cygrpc.Operations(operations),
event_handler)
if call_error != cygrpc.CallError.ok:
_call_error_set_RPCstate(state, call_error, metadata)
return _Rendezvous(state, None, None, deadline)
drive_call()
_consume_request_iterator(request_iterator, state, call,
self._request_serializer)
return _Rendezvous(state, call, self._response_deserializer, deadline)
def _make_grpc_error(self, status_code):
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
details = 'Some error details.'
exc_state = _RPCState((), None, None, status_code, details)
return _Rendezvous(exc_state, None, None, None)
def test_retry(adapter: PachydermAdapter):
from grpc._channel import _Rendezvous
from pachypy.adapter import retry
state = mock.MagicMock()
code = mock.MagicMock()
type(code).value = mock.PropertyMock(return_value=(None, 'unavailable'))
type(state).code = mock.PropertyMock(return_value=code)
func = mock.MagicMock(side_effect=_Rendezvous(
state=state,
call=mock.MagicMock(),
response_deserializer=mock.MagicMock(),
deadline=mock.MagicMock(),
))
adapter._max_retries = 3
with mock.patch('pachypy.adapter.PachydermAdapter.list_repos', func):
with mock.patch('pachypy.adapter.PachydermAdapter.check_connectivity', mock.MagicMock(return_value=True)):
with pytest.raises(PachydermError):
retry(adapter.list_repos)(adapter) # type: ignore
assert adapter._retries == adapter._max_retries
assert func.call_count == adapter._max_retries + 1
func.reset_mock()
adapter._retries = 0
with mock.patch('pachypy.adapter.PachydermAdapter.check_connectivity', mock.MagicMock(return_value=False)):
with pytest.raises(PachydermError):
retry(adapter.list_repos)(adapter) # type: ignore
assert adapter._retries == 0
assert func.call_count == 1
def _make_grpc_error(self, status_code):
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
details = 'Some error details.'
exc_state = _RPCState((), None, None, status_code, details)
return _Rendezvous(exc_state, None, None, None)
def test_commit_failure_cancelled(self):
from grpc import StatusCode
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
exc_state = _RPCState((), None, None, StatusCode.CANCELLED, None)
exc = _Rendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, _Rendezvous)
def test_commit_failure_cancelled(self):
from grpc import StatusCode
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
exc_state = _RPCState((), None, None, StatusCode.CANCELLED, None)
exc = _Rendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, _Rendezvous)
def _test_not_found(self):
error = _Rendezvous(_RPCState((), '', '', StatusCode.NOT_FOUND, ""),
None, None, None)
self.cdnskey_client.mock.side_effect = error
response = self.client.get(
reverse('webwhois:scan_results', kwargs={'handle': self.domain}))
self.assertContains(response, 'not found', status_code=404)
def test_with_stable(self):
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
from grpc import StatusCode
status_code = StatusCode.FAILED_PRECONDITION
exc_state = _RPCState((), None, None, status_code, None)
exc = _Rendezvous(exc_state, None, None, None)
result = self._callFUT(exc)
self.assertEqual(result, status_code)
def test_with_stable(self):
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
from grpc import StatusCode
status_code = StatusCode.FAILED_PRECONDITION
exc_state = _RPCState((), None, None, status_code, None)
exc = _Rendezvous(exc_state, None, None, None)
result = self._callFUT(exc)
self.assertEqual(result, status_code)
def test_commit_failure_aborted(self):
from grpc import StatusCode
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
from google.cloud.exceptions import Conflict
details = 'Bad things.'
exc_state = _RPCState((), None, None, StatusCode.ABORTED, details)
exc = _Rendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, Conflict)
def test_commit_failure_aborted(self):
from grpc import StatusCode
from grpc._channel import _Rendezvous
from grpc._channel import _RPCState
from gcloud.exceptions import Conflict
details = 'Bad things.'
exc_state = _RPCState((), None, None, StatusCode.ABORTED, details)
exc = _Rendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, Conflict)
def test_make_prediction_too_much_retrying(mocker):
mocker.patch('builtins.open')
mocker.patch('tensorflow_serving.apis.predict_pb2.PredictRequest')
predict_stub_mock = mocker.MagicMock()
grpc_exception = _Rendezvous(mocker.MagicMock(), None, None,
mocker.MagicMock())
mocker.patch.object(predict_stub_mock,
'Predict').side_effect = grpc_exception
with pytest.raises(_Rendezvous):
main.make_prediction(b'', predict_stub_mock)
def test_make_prediction_retrying(mocker):
mocker.patch('builtins.open')
mocker.patch('tensorflow_serving.apis.predict_pb2.PredictRequest')
predict_stub_mock = mocker.MagicMock()
grpc_exception = _Rendezvous(mocker.MagicMock(), None, None,
mocker.MagicMock())
mocker.patch.object(predict_stub_mock, 'Predict').side_effect = [
grpc_exception, grpc_exception,
mocker.MagicMock(SerializeToString=lambda: b'result')
]
result = main.make_prediction(b'', predict_stub_mock)
assert result == b'result'
def future(self, request, timeout=None, metadata=None, credentials=None):
state, operations, deadline, deadline_timespec, rendezvous = self._prepare(
request, timeout, metadata)
if rendezvous:
return rendezvous
else:
channel = self._channel.get_channel()
call, drive_call = channel.managed_call(None, 0, self._method,
None, deadline_timespec)
if credentials is not None:
call.set_credentials(credentials._credentials)
event_handler = _event_handler(state, call,
self._response_deserializer)
with state.condition:
call_error = call.start_client_batch(
cygrpc.Operations(operations), event_handler)
if call_error != cygrpc.CallError.ok:
_call_error_set_RPCstate(state, call_error, metadata)
return _Rendezvous(state, None, None, deadline)
drive_call()
return _Rendezvous(state, call, self._response_deserializer,
deadline)
def _test_raw_scan_results_error(self, status: StatusCode,
error_cls: Type[Exception],
error_msg: str) -> None:
domain = 'example.org'
error = _Rendezvous(_RPCState((), '', '', status, ""), None, None,
None)
self.client.mock.side_effect = error
with self.assertRaisesRegex(error_cls, error_msg):
self.client.raw_scan_results(domain)
request = RawScanResultsRequest()
request.domain_fqdn.value = domain
self.assertEqual(self.client.mock.mock_calls, [
call(request,
method='/CdnskeyProcessor.Api.Report.Report/raw_scan_results',
timeout=None)
])
