def send(self, request, expect_response=True):
if self._writer is None:
raise Errors.KafkaConnectionError(
"No connection to broker at {0}:{1}".format(
self._host, self._port))
correlation_id = self._next_correlation_id()
header = RequestHeader(request,
correlation_id=correlation_id,
client_id=self._client_id)
message = header.encode() + request.encode()
size = struct.pack(">i", len(message))
try:
self._writer.write(size + message)
except OSError as err:
self.close(reason=CloseReason.CONNECTION_BROKEN)
raise Errors.KafkaConnectionError(
"Connection at {0}:{1} broken: {2}".format(
self._host, self._port, err))
self.log.debug('%s Request %d: %s', self, correlation_id, request)
if not expect_response:
return self._writer.drain()
fut = self._loop.create_future()
self._requests.append((correlation_id, request.RESPONSE_TYPE, fut))
return asyncio.wait_for(fut, self._request_timeout)
def close(self, reason=None, exc=None):
self.log.debug("Closing connection at %s:%s", self._host, self._port)
if self._reader is not None:
self._writer.close()
self._writer = self._reader = None
if not self._read_task.done():
self._read_task.cancel()
self._read_task = None
for _, _, fut in self._requests:
if not fut.done():
error = Errors.KafkaConnectionError(
"Connection at {0}:{1} closed".format(
self._host, self._port))
if exc is not None:
error.__cause__ = exc
error.__context__ = exc
fut.set_exception(error)
self._requests = collections.deque()
if self._on_close_cb is not None:
self._on_close_cb(self, reason)
self._on_close_cb = None
if self._idle_handle is not None:
self._idle_handle.cancel()
# transport.close() will close socket, but not right ahead. Return
# a future in case we need to wait on it.
return self._closed_fut
def _send_sasl_token(self, payload, expect_response=True):
if self._writer is None:
raise Errors.KafkaConnectionError(
f"No connection to broker at {self._host}:{self._port}")
size = struct.pack(">i", len(payload))
try:
self._writer.write(size + payload)
except OSError as err:
self.close(reason=CloseReason.CONNECTION_BROKEN)
raise Errors.KafkaConnectionError(
f"Connection at {self._host}:{self._port} broken: {err}")
if not expect_response:
return self._writer.drain()
fut = self._loop.create_future()
self._requests.append((None, None, fut))
return asyncio.wait_for(fut, self._request_timeout)
