def _blocking(self, request_iterator, timeout, metadata, credentials,
wait_for_ready, compression):
deadline = _deadline(timeout)
state = _RPCState(_STREAM_UNARY_INITIAL_DUE, None, None, None, None)
initial_metadata_flags = _InitialMetadataFlags().with_wait_for_ready(
wait_for_ready)
augmented_metadata = _compression.augment_metadata(
metadata, compression)
call = self._channel.segregated_call(
cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS, self._method,
None, _determine_deadline(deadline), augmented_metadata,
None if credentials is None else credentials._credentials,
_stream_unary_invocation_operationses_and_tags(
augmented_metadata, initial_metadata_flags), self._context)
_consume_request_iterator(request_iterator, state, call,
self._request_serializer, None)
while True:
event = call.next_event()
with state.condition:
_handle_event(event, state, self._response_deserializer)
state.condition.notify_all()
if not state.due:
break
return state, call
def __call__(self,
request_iterator,
timeout=None,
metadata=None,
credentials=None,
wait_for_ready=None,
compression=None):
deadline = _deadline(timeout)
state = _RPCState(_STREAM_STREAM_INITIAL_DUE, None, None, None, None)
initial_metadata_flags = _InitialMetadataFlags().with_wait_for_ready(
wait_for_ready)
augmented_metadata = _compression.augment_metadata(
metadata, compression)
operationses = (
(
cygrpc.SendInitialMetadataOperation(augmented_metadata,
initial_metadata_flags),
cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS),
),
(cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS), ),
)
event_handler = _event_handler(state, self._response_deserializer)
call = self._channel.managed_call(
cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS, self._method,
None, _determine_deadline(deadline), augmented_metadata,
None if credentials is None else credentials._credentials,
operationses, event_handler, self._context)
_consume_request_iterator(request_iterator, state, call,
self._request_serializer, event_handler)
return _MultiThreadedRendezvous(state, call,
self._response_deserializer, deadline)
def future(self,
request_iterator,
timeout=None,
metadata=None,
credentials=None,
wait_for_ready=None,
compression=None):
deadline = _deadline(timeout)
state = _RPCState(_STREAM_UNARY_INITIAL_DUE, None, None, None, None)
event_handler = _event_handler(state, self._response_deserializer)
initial_metadata_flags = _InitialMetadataFlags().with_wait_for_ready(
wait_for_ready)
augmented_metadata = _compression.augment_metadata(
metadata, compression)
call = self._channel.managed_call(
cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS, self._method,
None, deadline, augmented_metadata,
None if credentials is None else credentials._credentials,
_stream_unary_invocation_operationses(metadata,
initial_metadata_flags),
event_handler, self._context)
_consume_request_iterator(request_iterator, state, call,
self._request_serializer, event_handler)
return _MultiThreadedRendezvous(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 _make_grpc_error(status_code, trailing=None):
from grpc._channel import _RPCState
from google.cloud.exceptions import GrpcRendezvous
details = 'Some error details.'
exc_state = _RPCState((), None, trailing, status_code, details)
return GrpcRendezvous(exc_state, None, None, None)
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 __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 _blocking(self, channel, request_iterator, timeout, metadata,
credentials):
deadline, deadline_timespec = _deadline(timeout)
state = _RPCState(_STREAM_UNARY_INITIAL_DUE, None, None, None, None)
completion_queue = cygrpc.CompletionQueue()
call = channel.create_call(None, 0, completion_queue, self._method,
None, deadline_timespec)
if credentials is not None:
call.set_credentials(credentials._credentials)
with state.condition:
call.start_client_batch(
cygrpc.Operations(
(cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS),
)), None)
operations = (
cygrpc.operation_send_initial_metadata(
_common.to_cygrpc_metadata(metadata), _EMPTY_FLAGS),
cygrpc.operation_receive_message(_EMPTY_FLAGS),
cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),
)
call_error = call.start_client_batch(cygrpc.Operations(operations),
None)
_check_call_error(call_error, metadata)
_consume_request_iterator(request_iterator, state, call,
self._request_serializer)
while True:
event = completion_queue.poll()
with state.condition:
_handle_event(event, state, self._response_deserializer)
state.condition.notify_all()
if not state.due:
break
return state, call, deadline
def _make_grpc_error(self, status_code):
from grpc._channel import _RPCState
from google.cloud.exceptions import GrpcRendezvous
details = 'Some error details.'
exc_state = _RPCState((), None, None, status_code, details)
return GrpcRendezvous(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_commit_failure_cancelled(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import GrpcRendezvous
exc_state = _RPCState((), None, None, StatusCode.CANCELLED, None)
exc = GrpcRendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, GrpcRendezvous)
def test_commit_failure_cancelled(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import GrpcRendezvous
exc_state = _RPCState((), None, None, StatusCode.CANCELLED, None)
exc = GrpcRendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, GrpcRendezvous)
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_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_failure_cancelled(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import GrpcRendezvous
exc_state = _RPCState((), None, None, StatusCode.CANCELLED, None)
exc = GrpcRendezvous(exc_state, None, None, None)
with self.assertRaises(GrpcRendezvous):
with self._call_fut():
self._fake_method(exc)
def test_commit_failure_aborted(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import Conflict
from google.cloud.exceptions import GrpcRendezvous
details = 'Bad things.'
exc_state = _RPCState((), None, None, StatusCode.ABORTED, details)
exc = GrpcRendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, Conflict)
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_failure_cancelled(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import GrpcRendezvous
exc_state = _RPCState((), None, None, StatusCode.CANCELLED, None)
exc = GrpcRendezvous(exc_state, None, None, None)
with self.assertRaises(GrpcRendezvous):
with self._call_fut():
self._fake_method(exc)
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 _make_grpc_error(self, status_code=None):
from grpc._channel import _RPCState
from grpc import StatusCode
from google.cloud.exceptions import GrpcRendezvous
if status_code is None:
status_code = StatusCode.UNKNOWN
details = 'Some error details.'
exc_state = _RPCState((), None, None, status_code, details)
return GrpcRendezvous(exc_state, None, None, None)
def test_commit_failure_invalid_argument(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import BadRequest
from google.cloud.exceptions import GrpcRendezvous
details = 'Too long content.'
exc_state = _RPCState((), None, None, StatusCode.INVALID_ARGUMENT,
details)
exc = GrpcRendezvous(exc_state, None, None, None)
self._commit_failure_helper(exc, BadRequest)
def test_run_query_invalid_argument(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import BadRequest
from google.cloud.exceptions import GrpcRendezvous
details = ('Cannot have inequality filters on multiple '
'properties: [created, priority]')
exc_state = _RPCState((), None, None, StatusCode.INVALID_ARGUMENT,
details)
exc = GrpcRendezvous(exc_state, None, None, None)
self._run_query_failure_helper(exc, BadRequest)
def test_run_query_invalid_argument(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import BadRequest
from google.cloud.exceptions import GrpcRendezvous
details = ('Cannot have inequality filters on multiple '
'properties: [created, priority]')
exc_state = _RPCState((), None, None,
StatusCode.INVALID_ARGUMENT, details)
exc = GrpcRendezvous(exc_state, None, None, None)
self._run_query_failure_helper(exc, BadRequest)
def test_failure_aborted(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import Conflict
from google.cloud.exceptions import GrpcRendezvous
details = 'Bad things.'
exc_state = _RPCState((), None, None, StatusCode.ABORTED, details)
exc = GrpcRendezvous(exc_state, None, None, None)
with self.assertRaises(Conflict):
with self._call_fut():
self._fake_method(exc)
def test_failure_aborted(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import Conflict
from google.cloud.exceptions import GrpcRendezvous
details = 'Bad things.'
exc_state = _RPCState((), None, None, StatusCode.ABORTED, details)
exc = GrpcRendezvous(exc_state, None, None, None)
with self.assertRaises(Conflict):
with self._call_fut():
self._fake_method(exc)
def test_failure_invalid_argument(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import BadRequest
from google.cloud.exceptions import GrpcRendezvous
details = ('Cannot have inequality filters on multiple '
'properties: [created, priority]')
exc_state = _RPCState((), None, None, StatusCode.INVALID_ARGUMENT,
details)
exc = GrpcRendezvous(exc_state, None, None, None)
with self.assertRaises(BadRequest):
with self._call_fut():
self._fake_method(exc)
def test_failure_invalid_argument(self):
from grpc import StatusCode
from grpc._channel import _RPCState
from google.cloud.exceptions import BadRequest
from google.cloud.exceptions import GrpcRendezvous
details = ('Cannot have inequality filters on multiple '
'properties: [created, priority]')
exc_state = _RPCState((), None, None,
StatusCode.INVALID_ARGUMENT, details)
exc = GrpcRendezvous(exc_state, None, None, None)
with self.assertRaises(BadRequest):
with self._call_fut():
self._fake_method(exc)
def _prepare(self, request, timeout, metadata):
deadline, deadline_timespec, serialized_request, rendezvous = (
_start_unary_request(request, timeout, self._request_serializer))
if serialized_request is None:
return None, None, None, None, rendezvous
else:
state = _RPCState(_UNARY_UNARY_INITIAL_DUE, None, None, None, None)
operations = (
cygrpc.operation_send_initial_metadata(
_common.to_cygrpc_metadata(metadata), _EMPTY_FLAGS),
cygrpc.operation_send_message(serialized_request,
_EMPTY_FLAGS),
cygrpc.operation_send_close_from_client(_EMPTY_FLAGS),
cygrpc.operation_receive_initial_metadata(_EMPTY_FLAGS),
cygrpc.operation_receive_message(_EMPTY_FLAGS),
cygrpc.operation_receive_status_on_client(_EMPTY_FLAGS),
)
return state, operations, deadline, deadline_timespec, None
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)
])
def __call__(self,
request,
timeout=None,
metadata=None,
credentials=None,
wait_for_ready=None,
compression=None):
deadline, serialized_request, rendezvous = _start_unary_request(
request, timeout, self._request_serializer)
initial_metadata_flags = _InitialMetadataFlags().with_wait_for_ready(
wait_for_ready)
if serialized_request is None:
raise rendezvous
else:
augmented_metadata = _compression.augment_metadata(
metadata, compression)
state = _RPCState(_UNARY_STREAM_INITIAL_DUE, None, None, None,
None)
operationses = (
(
cygrpc.SendInitialMetadataOperation(
augmented_metadata, initial_metadata_flags),
cygrpc.SendMessageOperation(serialized_request,
_EMPTY_FLAGS),
cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS),
cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS),
),
(cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS), ),
)
call = self._channel.managed_call(
cygrpc.PropagationConstants.GRPC_PROPAGATE_DEFAULTS,
self._method, None, _determine_deadline(deadline), metadata,
None if credentials is None else credentials._credentials,
operationses, _event_handler(state,
self._response_deserializer),
self._context)
return _MultiThreadedRendezvous(state, call,
self._response_deserializer,
deadline)
def _prepare(self, request, timeout, metadata, wait_for_ready,
compression):
deadline, serialized_request, rendezvous = _start_unary_request(
request, timeout, self._request_serializer)
initial_metadata_flags = _InitialMetadataFlags().with_wait_for_ready(
wait_for_ready)
augmented_metadata = _compression.augment_metadata(
metadata, compression)
if serialized_request is None:
return None, None, None, rendezvous
else:
state = _RPCState(_UNARY_UNARY_INITIAL_DUE, None, None, None, None)
operations = (
cygrpc.SendInitialMetadataOperation(augmented_metadata,
initial_metadata_flags),
cygrpc.SendMessageOperation(serialized_request, _EMPTY_FLAGS),
cygrpc.SendCloseFromClientOperation(_EMPTY_FLAGS),
cygrpc.ReceiveInitialMetadataOperation(_EMPTY_FLAGS),
cygrpc.ReceiveMessageOperation(_EMPTY_FLAGS),
cygrpc.ReceiveStatusOnClientOperation(_EMPTY_FLAGS),
)
return state, operations, deadline, None
def _make_rendezvous(status_code, details):
from grpc import _channel
from google.cloud import exceptions
exc_state = _channel._RPCState((), None, None, status_code, details)
return exceptions.GrpcRendezvous(exc_state, None, None, None)
def _make_rendezvous(status_code, details):
from grpc._channel import _RPCState
from google.cloud.exceptions import GrpcRendezvous
exc_state = _RPCState((), None, None, status_code, details)
return GrpcRendezvous(exc_state, None, None, None)
