async def test_check_version(self): kafka_version = tuple(int(x) for x in self.kafka_version.split(".")) client = AIOKafkaClient(bootstrap_servers=self.hosts) await client.bootstrap() ver = await client.check_version() expected_version = kafka_version[:2] # No significant protocol changed, no way to differencieate if expected_version == (2, 2): expected_version = (2, 1) elif expected_version == (2, 4): expected_version = (2, 3) self.assertEqual(expected_version, ver[:2]) await self.wait_topic(client, 'some_test_topic') ver2 = await client.check_version() self.assertEqual(ver, ver2) ver2 = await client.check_version(client.get_random_node()) self.assertEqual(ver, ver2) with mock.patch.object(AIOKafkaConnection, 'send') as mocked: mocked.side_effect = KafkaError('mocked exception') with self.assertRaises(UnrecognizedBrokerVersion): await client.check_version(client.get_random_node()) async def _get_conn(*args: Any, **kw: Any): return None client._get_conn = _get_conn with self.assertRaises(KafkaConnectionError): await client.check_version() await client.close()
def test_send_request(self): client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts) yield from client.bootstrap() node_id = client.get_random_node() resp = yield from client.send(node_id, MetadataRequest([])) self.assertTrue(isinstance(resp, MetadataResponse)) yield from client.close()
async def test_send_request(self): client = AIOKafkaClient(bootstrap_servers=self.hosts) await client.bootstrap() node_id = client.get_random_node() resp = await client.send(node_id, MetadataRequest([])) self.assertTrue(isinstance(resp, MetadataResponse)) await client.close()
def test_no_concurrent_send_on_connection(self): client = AIOKafkaClient( loop=self.loop, bootstrap_servers=self.hosts, metadata_max_age_ms=10000) yield from client.bootstrap() self.add_cleanup(client.close) yield from self.wait_topic(client, self.topic) node_id = client.get_random_node() wait_request = FetchRequest_v0( -1, # replica_id 500, # max_wait_ms 1024 * 1024, # min_bytes [(self.topic, [(0, 0, 1024)] )]) vanila_request = MetadataRequest([]) send_time = self.loop.time() long_task = self.loop.create_task( client.send(node_id, wait_request) ) yield from asyncio.sleep(0.0001, loop=self.loop) self.assertFalse(long_task.done()) yield from client.send(node_id, vanila_request) resp_time = self.loop.time() fetch_resp = yield from long_task # Check error code like resp->topics[0]->partitions[0]->error_code self.assertEqual(fetch_resp.topics[0][1][0][1], 0) # Check that vanila request actually executed after wait request self.assertGreaterEqual(resp_time - send_time, 0.5)
async def test_no_concurrent_send_on_connection(self): client = AIOKafkaClient(bootstrap_servers=self.hosts, metadata_max_age_ms=10000) await client.bootstrap() self.add_cleanup(client.close) await self.wait_topic(client, self.topic) node_id = client.get_random_node() wait_request = FetchRequest_v0( -1, # replica_id 500, # max_wait_ms 1024 * 1024, # min_bytes [(self.topic, [(0, 0, 1024)])]) vanila_request = MetadataRequest([]) loop = get_running_loop() send_time = loop.time() long_task = create_task(client.send(node_id, wait_request)) await asyncio.sleep(0.0001) self.assertFalse(long_task.done()) await client.send(node_id, vanila_request) resp_time = loop.time() fetch_resp = await long_task # Check error code like resp->topics[0]->partitions[0]->error_code self.assertEqual(fetch_resp.topics[0][1][0][1], 0) # Check that vanila request actually executed after wait request self.assertGreaterEqual(resp_time - send_time, 0.5)
def test_concurrent_send_on_different_connection_groups(self): client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts, metadata_max_age_ms=10000) yield from client.bootstrap() self.add_cleanup(client.close) yield from self.wait_topic(client, self.topic) node_id = client.get_random_node() wait_request = FetchRequest_v0( -1, # replica_id 500, # max_wait_ms 1024 * 1024, # min_bytes [(self.topic, [(0, 0, 1024)])]) vanila_request = MetadataRequest([]) send_time = self.loop.time() long_task = self.loop.create_task(client.send(node_id, wait_request)) yield from asyncio.sleep(0.0001, loop=self.loop) self.assertFalse(long_task.done()) yield from client.send(node_id, vanila_request, group=ConnectionGroup.COORDINATION) resp_time = self.loop.time() self.assertFalse(long_task.done()) fetch_resp = yield from long_task # Check error code like resp->topics[0]->partitions[0]->error_code self.assertEqual(fetch_resp.topics[0][1][0][1], 0) # Check that vanila request actually executed after wait request self.assertLess(resp_time - send_time, 0.5)
def test_check_version(self): client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts) yield from client.bootstrap() ver = yield from client.check_version() self.assertTrue('0.' in ver) yield from self.wait_topic(client, 'some_test_topic') ver2 = yield from client.check_version() self.assertEqual(ver, ver2) ver2 = yield from client.check_version(client.get_random_node()) self.assertEqual(ver, ver2) with mock.patch.object(AIOKafkaConnection, 'send') as mocked: mocked.side_effect = KafkaError('mocked exception') with self.assertRaises(UnrecognizedBrokerVersion): yield from client.check_version(client.get_random_node()) client._get_conn = asyncio.coroutine(lambda _: None) with self.assertRaises(ConnectionError): yield from client.check_version()
def test_check_version(self): client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts) yield from client.bootstrap() ver = yield from client.check_version() self.assertTrue('0.' in ver) yield from self.wait_topic(client, 'some_test_topic') ver2 = yield from client.check_version() self.assertEqual(ver, ver2) ver2 = yield from client.check_version(client.get_random_node()) self.assertEqual(ver, ver2) with mock.patch.object( AIOKafkaConnection, 'send') as mocked: mocked.side_effect = KafkaError('mocked exception') with self.assertRaises(UnrecognizedBrokerVersion): yield from client.check_version(client.get_random_node()) client._get_conn = asyncio.coroutine(lambda _: None) with self.assertRaises(ConnectionError): yield from client.check_version()
def test_init_with_list(self): client = AIOKafkaClient( loop=self.loop, bootstrap_servers=['kafka01:9092', 'kafka02:9092', 'kafka03:9092']) self.assertEqual( '<AIOKafkaClient client_id=aiokafka-0.0.1>', client.__repr__()) self.assertEqual(sorted({'kafka01': 9092, 'kafka02': 9092, 'kafka03': 9092}.items()), sorted(client.hosts)) node = client.get_random_node() self.assertEqual(node, None) # unknown cluster metadata
async def test_check_version(self): kafka_version = tuple(int(x) for x in self.kafka_version.split(".")) client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts) await client.bootstrap() ver = await client.check_version() self.assertEqual(kafka_version[:2], ver[:2]) await self.wait_topic(client, 'some_test_topic') ver2 = await client.check_version() self.assertEqual(ver, ver2) ver2 = await client.check_version(client.get_random_node()) self.assertEqual(ver, ver2) with mock.patch.object(AIOKafkaConnection, 'send') as mocked: mocked.side_effect = KafkaError('mocked exception') with self.assertRaises(UnrecognizedBrokerVersion): await client.check_version(client.get_random_node()) client._get_conn = asyncio.coroutine(lambda _, **kw: None) with self.assertRaises(ConnectionError): await client.check_version() await client.close()
def test_init_with_list(self): client = AIOKafkaClient( loop=self.loop, bootstrap_servers=[ '127.0.0.1:9092', '127.0.0.2:9092', '127.0.0.3:9092']) self.assertEqual( '<AIOKafkaClient client_id=aiokafka-0.1.2>', client.__repr__()) self.assertEqual( sorted([('127.0.0.1', 9092, socket.AF_INET), ('127.0.0.2', 9092, socket.AF_INET), ('127.0.0.3', 9092, socket.AF_INET)]), sorted(client.hosts)) node = client.get_random_node() self.assertEqual(node, None) # unknown cluster metadata
async def test_init_with_list(self): client = AIOKafkaClient(bootstrap_servers=[ '127.0.0.1:9092', '127.0.0.2:9092', '127.0.0.3:9092' ]) self.assertEqual('<AIOKafkaClient client_id=aiokafka-0.6.1.dev0>', client.__repr__()) self.assertEqual( sorted([('127.0.0.1', 9092, socket.AF_INET), ('127.0.0.2', 9092, socket.AF_INET), ('127.0.0.3', 9092, socket.AF_INET)]), sorted(client.hosts)) node = client.get_random_node() self.assertEqual(node, None) # unknown cluster metadata
def test_different_connections_in_conn_groups(self): client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts, metadata_max_age_ms=10000) yield from client.bootstrap() self.add_cleanup(client.close) node_id = client.get_random_node() conn1 = yield from client._get_conn(node_id) conn2 = yield from client._get_conn(node_id, group=ConnectionGroup.COORDINATION) self.assertTrue(conn1 is not conn2) self.assertEqual((conn1.host, conn1.port), (conn2.host, conn2.port))
def test_check_version(self): kafka_version = tuple(int(x) for x in self.kafka_version.split(".")) client = AIOKafkaClient(loop=self.loop, bootstrap_servers=self.hosts) yield from client.bootstrap() ver = yield from client.check_version() self.assertEqual(kafka_version[:2], ver[:2]) yield from self.wait_topic(client, 'some_test_topic') ver2 = yield from client.check_version() self.assertEqual(ver, ver2) ver2 = yield from client.check_version(client.get_random_node()) self.assertEqual(ver, ver2) with mock.patch.object( AIOKafkaConnection, 'send') as mocked: mocked.side_effect = KafkaError('mocked exception') with self.assertRaises(UnrecognizedBrokerVersion): yield from client.check_version(client.get_random_node()) client._get_conn = asyncio.coroutine(lambda _, **kw: None) with self.assertRaises(ConnectionError): yield from client.check_version() yield from client.close()
def test_concurrent_send_on_different_connection_groups(self): client = AIOKafkaClient( loop=self.loop, bootstrap_servers=self.hosts, metadata_max_age_ms=10000) yield from client.bootstrap() self.add_cleanup(client.close) yield from self.wait_topic(client, self.topic) node_id = client.get_random_node() broker = client.cluster.broker_metadata(node_id) client.cluster.add_coordinator( node_id, broker.host, broker.port, rack=None, purpose=(CoordinationType.GROUP, "")) wait_request = FetchRequest_v0( -1, # replica_id 500, # max_wait_ms 1024 * 1024, # min_bytes [(self.topic, [(0, 0, 1024)] )]) vanila_request = MetadataRequest([]) send_time = self.loop.time() long_task = self.loop.create_task( client.send(node_id, wait_request) ) yield from asyncio.sleep(0.0001, loop=self.loop) self.assertFalse(long_task.done()) yield from client.send( node_id, vanila_request, group=ConnectionGroup.COORDINATION) resp_time = self.loop.time() self.assertFalse(long_task.done()) fetch_resp = yield from long_task # Check error code like resp->topics[0]->partitions[0]->error_code self.assertEqual(fetch_resp.topics[0][1][0][1], 0) # Check that vanila request actually executed after wait request self.assertLess(resp_time - send_time, 0.5)
async def test_different_connections_in_conn_groups(self): client = AIOKafkaClient(bootstrap_servers=self.hosts, metadata_max_age_ms=10000) await client.bootstrap() self.add_cleanup(client.close) node_id = client.get_random_node() broker = client.cluster.broker_metadata(node_id) client.cluster.add_coordinator(node_id, broker.host, broker.port, rack=None, purpose=(CoordinationType.GROUP, "")) conn1 = await client._get_conn(node_id) conn2 = await client._get_conn(node_id, group=ConnectionGroup.COORDINATION) self.assertTrue(conn1 is not conn2) self.assertEqual((conn1.host, conn1.port), (conn2.host, conn2.port))
def test_different_connections_in_conn_groups(self): client = AIOKafkaClient( loop=self.loop, bootstrap_servers=self.hosts, metadata_max_age_ms=10000) yield from client.bootstrap() self.add_cleanup(client.close) node_id = client.get_random_node() broker = client.cluster.broker_metadata(node_id) client.cluster.add_coordinator( node_id, broker.host, broker.port, rack=None, purpose=(CoordinationType.GROUP, "")) conn1 = yield from client._get_conn(node_id) conn2 = yield from client._get_conn( node_id, group=ConnectionGroup.COORDINATION) self.assertTrue(conn1 is not conn2) self.assertEqual((conn1.host, conn1.port), (conn2.host, conn2.port))
async def test_concurrent_send_on_different_connection_groups(self): client = AIOKafkaClient(bootstrap_servers=self.hosts, metadata_max_age_ms=10000) await client.bootstrap() self.add_cleanup(client.close) await self.wait_topic(client, self.topic) node_id = client.get_random_node() broker = client.cluster.broker_metadata(node_id) client.cluster.add_coordinator(node_id, broker.host, broker.port, rack=None, purpose=(CoordinationType.GROUP, "")) wait_request = FetchRequest_v0( -1, # replica_id 500, # max_wait_ms 1024 * 1024, # min_bytes [(self.topic, [(0, 0, 1024)])]) vanila_request = MetadataRequest([]) loop = get_running_loop() send_time = loop.time() long_task = create_task(client.send(node_id, wait_request)) await asyncio.sleep(0.0001) self.assertFalse(long_task.done()) await client.send(node_id, vanila_request, group=ConnectionGroup.COORDINATION) resp_time = loop.time() self.assertFalse(long_task.done()) fetch_resp = await long_task # Check error code like resp->topics[0]->partitions[0]->error_code self.assertEqual(fetch_resp.topics[0][1][0][1], 0) # Check that vanila request actually executed after wait request self.assertLess(resp_time - send_time, 0.5)
async def test_metadata_updated_on_socket_disconnect(self): # Related to issue 176. A disconnect means that either we lost # connection to the node, or we have a node failure. In both cases # there's a high probability that Leader distribution will also change. client = AIOKafkaClient(bootstrap_servers=self.hosts, metadata_max_age_ms=10000) await client.bootstrap() self.add_cleanup(client.close) # Init a clonnection node_id = client.get_random_node() assert node_id is not None req = MetadataRequest([]) await client.send(node_id, req) # No metadata update pending atm self.assertFalse(client._md_update_waiter.done()) # Connection disconnect should trigger an update conn = await client._get_conn(node_id) conn.close(reason=CloseReason.CONNECTION_BROKEN) self.assertTrue(client._md_update_waiter.done())
def test_metadata_updated_on_socket_disconnect(self): # Related to issue 176. A disconnect means that either we lost # connection to the node, or we have a node failure. In both cases # there's a high probability that Leader distribution will also change. client = AIOKafkaClient( loop=self.loop, bootstrap_servers=self.hosts, metadata_max_age_ms=10000) yield from client.bootstrap() self.add_cleanup(client.close) # Init a clonnection node_id = client.get_random_node() assert node_id is not None req = MetadataRequest([]) yield from client.send(node_id, req) # No metadata update pending atm self.assertFalse(client._md_update_waiter.done()) # Connection disconnect should trigger an update conn = yield from client._get_conn(node_id) conn.close(reason=CloseReason.CONNECTION_BROKEN) self.assertTrue(client._md_update_waiter.done())
class AIOKafkaProducer(object): """A Kafka client that publishes records to the Kafka cluster. The producer consists of a pool of buffer space that holds records that haven't yet been transmitted to the server as well as a background task that is responsible for turning these records into requests and transmitting them to the cluster. The send() method is asynchronous. When called it adds the record to a buffer of pending record sends and immediately returns. This allows the producer to batch together individual records for efficiency. The 'acks' config controls the criteria under which requests are considered complete. The "all" setting will result in waiting for all replicas to respond, the slowest but most durable setting. The key_serializer and value_serializer instruct how to turn the key and value objects the user provides into bytes. Arguments: bootstrap_servers: 'host[:port]' string (or list of 'host[:port]' strings) that the producer should contact to bootstrap initial cluster metadata. This does not have to be the full node list. It just needs to have at least one broker that will respond to a Metadata API Request. Default port is 9092. If no servers are specified, will default to localhost:9092. client_id (str): a name for this client. This string is passed in each request to servers and can be used to identify specific server-side log entries that correspond to this client. Default: 'aiokafka-producer-#' (appended with a unique number per instance) key_serializer (callable): used to convert user-supplied keys to bytes If not None, called as f(key), should return bytes. Default: None. value_serializer (callable): used to convert user-supplied message values to bytes. If not None, called as f(value), should return bytes. Default: None. acks (0, 1, 'all'): The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are common: 0: Producer will not wait for any acknowledgment from the server at all. The message will immediately be added to the socket buffer and considered sent. No guarantee can be made that the server has received the record in this case, and the retries configuration will not take effect (as the client won't generally know of any failures). The offset given back for each record will always be set to -1. 1: The broker leader will write the record to its local log but will respond without awaiting full acknowledgement from all followers. In this case should the leader fail immediately after acknowledging the record but before the followers have replicated it then the record will be lost. all: The broker leader will wait for the full set of in-sync replicas to acknowledge the record. This guarantees that the record will not be lost as long as at least one in-sync replica remains alive. This is the strongest available guarantee. If unset, defaults to *acks=1*. If ``enable_idempotence`` is ``True`` defaults to *acks=all* compression_type (str): The compression type for all data generated by the producer. Valid values are 'gzip', 'snappy', 'lz4', or None. Compression is of full batches of data, so the efficacy of batching will also impact the compression ratio (more batching means better compression). Default: None. max_batch_size (int): Maximum size of buffered data per partition. After this amount `send` coroutine will block until batch is drained. Default: 16384 linger_ms (int): The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay; that is, if first request is processed faster, than `linger_ms`, producer will wait `linger_ms - process_time`. This setting defaults to 0 (i.e. no delay). partitioner (callable): Callable used to determine which partition each message is assigned to. Called (after key serialization): partitioner(key_bytes, all_partitions, available_partitions). The default partitioner implementation hashes each non-None key using the same murmur2 algorithm as the Java client so that messages with the same key are assigned to the same partition. When a key is None, the message is delivered to a random partition (filtered to partitions with available leaders only, if possible). max_request_size (int): The maximum size of a request. This is also effectively a cap on the maximum record size. Note that the server has its own cap on record size which may be different from this. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. Default: 1048576. metadata_max_age_ms (int): The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions. Default: 300000 request_timeout_ms (int): Produce request timeout in milliseconds. As it's sent as part of ProduceRequest (it's a blocking call), maximum waiting time can be up to 2 * request_timeout_ms. Default: 40000. retry_backoff_ms (int): Milliseconds to backoff when retrying on errors. Default: 100. api_version (str): specify which kafka API version to use. If set to 'auto', will attempt to infer the broker version by probing various APIs. Default: auto security_protocol (str): Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL. Default: PLAINTEXT. ssl_context (ssl.SSLContext): pre-configured SSLContext for wrapping socket connections. Directly passed into asyncio's `create_connection`_. For more information see :ref:`ssl_auth`. Default: None. connections_max_idle_ms (int): Close idle connections after the number of milliseconds specified by this config. Specifying `None` will disable idle checks. Default: 540000 (9hours). enable_idempotence (bool): When set to ``True``, the producer will ensure that exactly one copy of each message is written in the stream. If ``False``, producer retries due to broker failures, etc., may write duplicates of the retried message in the stream. Note that enabling idempotence acks to set to 'all'. If it is not explicitly set by the user it will be chosen. If incompatible values are set, a ``ValueError`` will be thrown. New in version 0.5.0. Note: Many configuration parameters are taken from the Java client: https://kafka.apache.org/documentation.html#producerconfigs """ _PRODUCER_CLIENT_ID_SEQUENCE = 0 _COMPRESSORS = { 'gzip': (has_gzip, LegacyRecordBatchBuilder.CODEC_GZIP), 'snappy': (has_snappy, LegacyRecordBatchBuilder.CODEC_SNAPPY), 'lz4': (has_lz4, LegacyRecordBatchBuilder.CODEC_LZ4), } _transactional_id = None # XXX: For now no transactions available _transaction_timeout_ms = INTEGER_MAX_VALUE _closed = None # Serves as an uninitialized flag for __del__ _source_traceback = None def __init__(self, *, loop, bootstrap_servers='localhost', client_id=None, metadata_max_age_ms=300000, request_timeout_ms=40000, api_version='auto', acks=_missing, key_serializer=None, value_serializer=None, compression_type=None, max_batch_size=16384, partitioner=DefaultPartitioner(), max_request_size=1048576, linger_ms=0, send_backoff_ms=100, retry_backoff_ms=100, security_protocol="PLAINTEXT", ssl_context=None, connections_max_idle_ms=540000, enable_idempotence=False): if acks not in (0, 1, -1, 'all', _missing): raise ValueError("Invalid ACKS parameter") if compression_type not in ('gzip', 'snappy', 'lz4', None): raise ValueError("Invalid compression type!") if compression_type: checker, compression_attrs = self._COMPRESSORS[compression_type] if not checker(): raise RuntimeError( "Compression library for {} not found".format( compression_type)) else: compression_attrs = 0 if enable_idempotence: if acks is _missing: acks = -1 elif acks not in ('all', -1): raise ValueError( "acks={} not supported if enable_idempotence=True".format( acks)) self._txn_manager = TransactionManager() else: self._txn_manager = None if acks is _missing: acks = 1 elif acks == 'all': acks = -1 self._PRODUCER_CLIENT_ID_SEQUENCE += 1 if client_id is None: client_id = 'aiokafka-producer-%s' % \ self._PRODUCER_CLIENT_ID_SEQUENCE self._acks = acks self._key_serializer = key_serializer self._value_serializer = value_serializer self._compression_type = compression_type self._partitioner = partitioner self._max_request_size = max_request_size self._request_timeout_ms = request_timeout_ms self.client = AIOKafkaClient( loop=loop, bootstrap_servers=bootstrap_servers, client_id=client_id, metadata_max_age_ms=metadata_max_age_ms, request_timeout_ms=request_timeout_ms, retry_backoff_ms=retry_backoff_ms, api_version=api_version, security_protocol=security_protocol, ssl_context=ssl_context, connections_max_idle_ms=connections_max_idle_ms) self._metadata = self.client.cluster self._message_accumulator = MessageAccumulator( self._metadata, max_batch_size, compression_attrs, self._request_timeout_ms / 1000, txn_manager=self._txn_manager, loop=loop) self._sender_task = None self._in_flight = set() self._loop = loop self._retry_backoff = retry_backoff_ms / 1000 self._linger_time = linger_ms / 1000 self._producer_magic = 0 self._enable_idempotence = enable_idempotence if loop.get_debug(): self._source_traceback = traceback.extract_stack(sys._getframe(1)) self._closed = False if PY_341: # Warn if producer was not closed properly # We don't attempt to close the Consumer, as __del__ is synchronous def __del__(self, _warnings=warnings): if self._closed is False: if PY_36: kwargs = {'source': self} else: kwargs = {} _warnings.warn("Unclosed AIOKafkaProducer {!r}".format(self), ResourceWarning, **kwargs) context = { 'producer': self, 'message': 'Unclosed AIOKafkaProducer' } if self._source_traceback is not None: context['source_traceback'] = self._source_traceback self._loop.call_exception_handler(context) @asyncio.coroutine def start(self): """Connect to Kafka cluster and check server version""" log.debug("Starting the Kafka producer") # trace yield from self.client.bootstrap() if self._compression_type == 'lz4': assert self.client.api_version >= (0, 8, 2), \ 'LZ4 Requires >= Kafka 0.8.2 Brokers' if self._txn_manager is not None and self.client.api_version < (0, 11): raise UnsupportedVersionError( "Indempotent producer available only for Broker vesion 0.11" " and above") self._sender_task = ensure_future(self._sender_routine(), loop=self._loop) self._message_accumulator.set_api_version(self.client.api_version) self._producer_magic = 0 if self.client.api_version < (0, 10) else 1 log.debug("Kafka producer started") @asyncio.coroutine def flush(self): """Wait untill all batches are Delivered and futures resolved""" yield from self._message_accumulator.flush() @asyncio.coroutine def stop(self): """Flush all pending data and close all connections to kafka cluster""" if self._closed: return self._closed = True yield from self._message_accumulator.close() if self._sender_task: self._sender_task.cancel() yield from self._sender_task yield from self.client.close() log.debug("The Kafka producer has closed.") @asyncio.coroutine def partitions_for(self, topic): """Returns set of all known partitions for the topic.""" return (yield from self.client._wait_on_metadata(topic)) @asyncio.coroutine def send(self, topic, value=None, key=None, partition=None, timestamp_ms=None): """Publish a message to a topic. Arguments: topic (str): topic where the message will be published value (optional): message value. Must be type bytes, or be serializable to bytes via configured value_serializer. If value is None, key is required and message acts as a 'delete'. See kafka compaction documentation for more details: http://kafka.apache.org/documentation.html#compaction (compaction requires kafka >= 0.8.1) partition (int, optional): optionally specify a partition. If not set, the partition will be selected using the configured 'partitioner'. key (optional): a key to associate with the message. Can be used to determine which partition to send the message to. If partition is None (and producer's partitioner config is left as default), then messages with the same key will be delivered to the same partition (but if key is None, partition is chosen randomly). Must be type bytes, or be serializable to bytes via configured key_serializer. timestamp_ms (int, optional): epoch milliseconds (from Jan 1 1970 UTC) to use as the message timestamp. Defaults to current time. Returns: asyncio.Future: object that will be set when message is processed Raises: kafka.KafkaTimeoutError: if we can't schedule this record ( pending buffer is full) in up to `request_timeout_ms` milliseconds. Note: The returned future will wait based on `request_timeout_ms` setting. Cancelling the returned future **will not** stop event from being sent, but cancelling the ``send`` coroutine itself **will**. """ assert value is not None or self.client.api_version >= (0, 8, 1), ( 'Null messages require kafka >= 0.8.1') assert not (value is None and key is None), \ 'Need at least one: key or value' # first make sure the metadata for the topic is available yield from self.client._wait_on_metadata(topic) key_bytes, value_bytes = self._serialize(topic, key, value) partition = self._partition(topic, partition, key, value, key_bytes, value_bytes) tp = TopicPartition(topic, partition) log.debug("Sending (key=%s value=%s) to %s", key, value, tp) fut = yield from self._message_accumulator.add_message( tp, key_bytes, value_bytes, self._request_timeout_ms / 1000, timestamp_ms=timestamp_ms) return fut @asyncio.coroutine def send_and_wait(self, topic, value=None, key=None, partition=None, timestamp_ms=None): """Publish a message to a topic and wait the result""" future = yield from self.send(topic, value, key, partition, timestamp_ms) return (yield from future) @asyncio.coroutine def _sender_routine(self): """ Background task, that sends pending batches to leader nodes for batch's partition. This incapsulates same logic as Java's `Sender` background thread. Because we use asyncio this is more event based loop, rather than counting timeout till next possible even like in Java. The procedure: * Group pending batches by partition leaders (write nodes) * Ignore not ready (disconnected) and nodes, that already have a pending request. * If we have unknown leaders for partitions, we request a metadata update. * Wait for any event, that can change the above procedure, like new metadata or pending send is finished and a new one can be done. """ tasks = set() try: while True: # If indempotence or transactions are turned on we need to # have a valid PID to send requests yield from self._maybe_wait_for_pid() batches, unknown_leaders_exist = \ self._message_accumulator.drain_by_nodes( ignore_nodes=self._in_flight) # create produce task for every batch for node_id, batches in batches.items(): task = ensure_future(self._send_produce_req( node_id, batches), loop=self._loop) self._in_flight.add(node_id) tasks.add(task) if unknown_leaders_exist: # we have at least one unknown partition's leader, # try to update cluster metadata and wait backoff time fut = self.client.force_metadata_update() waiters = tasks.union([fut]) else: fut = self._message_accumulator.data_waiter() waiters = tasks.union([fut]) # wait when: # * At least one of produce task is finished # * Data for new partition arrived # * Metadata update if partition leader unknown done, _ = yield from asyncio.wait( waiters, return_when=asyncio.FIRST_COMPLETED, loop=self._loop) # done tasks should never produce errors, if they are it's a # bug for task in done: task.result() tasks -= done except asyncio.CancelledError: # done tasks should never produce errors, if they are it's a bug for task in tasks: yield from task except Exception: # pragma: no cover log.error("Unexpected error in sender routine", exc_info=True) @asyncio.coroutine def _maybe_wait_for_pid(self): if self._txn_manager is None or self._txn_manager.has_pid(): return while True: success = yield from self._do_init_pid() if not success: yield from self.force_metadata_update() yield from asyncio.sleep(self._retry_backoff, loop=self._loop) else: break @asyncio.coroutine def _do_init_pid(self): init_pid_req = InitProducerIdRequest[0]( transactional_id=self._transactional_id, transaction_timeout_ms=self._transaction_timeout_ms) node_id = self.client.get_random_node() try: resp = yield from self.client.send(node_id, init_pid_req) except KafkaError as err: log.debug("Could not send InitProducerIdRequest: %r", err) return False error = Errors.for_code(resp.error_code) if error is Errors.NoError: self._txn_manager.set_pid_and_epoch(resp.producer_id, resp.producer_epoch) # Just in case we got bad values from broker return self._txn_manager.has_pid() else: log.debug("Got an error for InitProducerIdRequest: %r", error) return False @asyncio.coroutine def _send_produce_req(self, node_id, batches): """ Create produce request to node If producer configured with `retries`>0 and produce response contain "failed" partitions produce request for this partition will try resend to broker `retries` times with `retry_timeout_ms` timeouts. Arguments: node_id (int): kafka broker identifier batches (dict): dictionary of {TopicPartition: MessageBatch} """ t0 = self._loop.time() topics = collections.defaultdict(list) for tp, batch in batches.items(): topics[tp.topic].append((tp.partition, batch.get_data_buffer())) if self.client.api_version >= (0, 11): version = 3 elif self.client.api_version >= (0, 10): version = 2 elif self.client.api_version == (0, 9): version = 1 else: version = 0 kwargs = {} if version >= 3: kwargs['transactional_id'] = self._transactional_id request = ProduceRequest[version](required_acks=self._acks, timeout=self._request_timeout_ms, topics=list(topics.items()), **kwargs) reenqueue = [] try: response = yield from self.client.send(node_id, request) except KafkaError as err: log.warning("Got error produce response: %s", err) if getattr(err, "invalid_metadata", False): self.client.force_metadata_update() for batch in batches.values(): if not self._can_retry(err, batch): batch.failure(exception=err) else: reenqueue.append(batch) else: # noacks, just mark batches as "done" if request.required_acks == 0: for batch in batches.values(): batch.done_noack() else: for topic, partitions in response.topics: for partition_info in partitions: if response.API_VERSION < 2: partition, error_code, offset = partition_info # Mimic CREATE_TIME to take user provided timestamp timestamp = -1 else: partition, error_code, offset, timestamp = \ partition_info tp = TopicPartition(topic, partition) error = Errors.for_code(error_code) batch = batches.pop(tp, None) if batch is None: continue if error is Errors.NoError: batch.done(offset, timestamp) elif not self._can_retry(error(), batch): batch.failure(exception=error()) else: log.warning( "Got error produce response on topic-partition" " %s, retrying. Error: %s", tp, error) # Ok, we can retry this batch if getattr(error, "invalid_metadata", False): self.client.force_metadata_update() reenqueue.append(batch) if reenqueue: # Wait backoff before reequeue yield from asyncio.sleep(self._retry_backoff, loop=self._loop) for batch in reenqueue: self._message_accumulator.reenqueue(batch) # If some error started metadata refresh we have to wait before # trying again yield from self.client._maybe_wait_metadata() # if batches for node is processed in less than a linger seconds # then waiting for the remaining time sleep_time = self._linger_time - (self._loop.time() - t0) if sleep_time > 0: yield from asyncio.sleep(sleep_time, loop=self._loop) self._in_flight.remove(node_id) def _can_retry(self, error, batch): # If indempotence is enabled we never expire batches, but retry until # we succeed. We can be sure, that no duplicates will be introduced # as long as we set proper sequence, pid and epoch. if self._txn_manager is None and batch.expired(): return False # XXX: remove unknown topic check as we fix # https://github.com/dpkp/kafka-python/issues/1155 if error.retriable or isinstance(error, UnknownTopicOrPartitionError)\ or error is UnknownTopicOrPartitionError: return True return False def _serialize(self, topic, key, value): if self._key_serializer: serialized_key = self._key_serializer(key) else: serialized_key = key if self._value_serializer: serialized_value = self._value_serializer(value) else: serialized_value = value message_size = LegacyRecordBatchBuilder.record_overhead( self._producer_magic) if serialized_key is not None: message_size += len(serialized_key) if serialized_value is not None: message_size += len(serialized_value) if message_size > self._max_request_size: raise MessageSizeTooLargeError( "The message is %d bytes when serialized which is larger than" " the maximum request size you have configured with the" " max_request_size configuration" % message_size) return serialized_key, serialized_value def _partition(self, topic, partition, key, value, serialized_key, serialized_value): if partition is not None: assert partition >= 0 assert partition in self._metadata.partitions_for_topic(topic), \ 'Unrecognized partition' return partition all_partitions = list(self._metadata.partitions_for_topic(topic)) available = list(self._metadata.available_partitions_for_topic(topic)) return self._partitioner(serialized_key, all_partitions, available) def create_batch(self): """Create and return an empty BatchBuilder. The batch is not queued for send until submission to ``send_batch``. Returns: BatchBuilder: empty batch to be filled and submitted by the caller. """ return self._message_accumulator.create_builder() @asyncio.coroutine def send_batch(self, batch, topic, *, partition): """Submit a BatchBuilder for publication. Arguments: batch (BatchBuilder): batch object to be published. topic (str): topic where the batch will be published. partition (int): partition where this batch will be published. Returns: asyncio.Future: object that will be set when the batch is delivered. """ partition = self._partition(topic, partition, None, None, None, None) tp = TopicPartition(topic, partition) log.debug("Sending batch to %s", tp) future = yield from self._message_accumulator.add_batch( batch, tp, self._request_timeout_ms / 1000) return future