Add files using upload-large-folder tool

testbed/dpkp__kafka-python/.covrc

@@ -0,0 +1,3 @@
+[run]
+omit =
+    kafka/vendor/*

testbed/dpkp__kafka-python/.gitignore

@@ -0,0 +1,17 @@
+*.egg-info
+*.pyc
+.tox
+build
+dist
+MANIFEST
+env
+servers/*/kafka-bin*
+servers/*/resources/ssl*
+.coverage*
+.noseids
+docs/_build
+.cache*
+.idea/
+integration-test/
+tests-env/
+.pytest_cache/

testbed/dpkp__kafka-python/.travis.yml

@@ -0,0 +1,46 @@
+language: python
+
+dist: xenial
+
+python:
+    - 2.7
+    - 3.4
+    - 3.7
+    - 3.8
+    - pypy2.7-6.0
+
+env:
+    - KAFKA_VERSION=0.8.2.2
+    - KAFKA_VERSION=0.9.0.1
+    - KAFKA_VERSION=0.10.2.2
+    - KAFKA_VERSION=0.11.0.3
+    - KAFKA_VERSION=1.1.1
+    - KAFKA_VERSION=2.4.0
+    - KAFKA_VERSION=2.5.0
+    - KAFKA_VERSION=2.6.0
+
+addons:
+  apt:
+    packages:
+      - libsnappy-dev
+      - libzstd-dev
+      - openjdk-8-jdk
+
+cache:
+  directories:
+    - $HOME/.cache/pip
+    - servers/dist
+
+before_install:
+    - source travis_java_install.sh
+    - ./build_integration.sh
+
+install:
+    - pip install tox coveralls
+    - pip install .
+
+script:
+  - tox -e `if [ "$TRAVIS_PYTHON_VERSION" == "pypy2.7-6.0" ]; then echo pypy; else echo py${TRAVIS_PYTHON_VERSION/./}; fi`
+
+after_success:
+  - coveralls

testbed/dpkp__kafka-python/AUTHORS.md

@@ -0,0 +1,51 @@
+# Current Maintainer
+* Dana Powers, [@dpkp](https://github.com/dpkp)
+
+# Original Author and First Commit
+* David Arthur, [@mumrah](https://github.com/mumrah)
+
+# Contributors - 2015 (alpha by username)
+* Alex Couture-Beil, [@alexcb](https://github.com/alexcb)
+* Ali-Akber Saifee, [@alisaifee](https://github.com/alisaifee)
+* Christophe-Marie Duquesne, [@chmduquesne](https://github.com/chmduquesne)
+* Thomas Dimson, [@cosbynator](https://github.com/cosbynator)
+* Kasper Jacobsen, [@Dinoshauer](https://github.com/Dinoshauer)
+* Ross Duggan, [@duggan](https://github.com/duggan)
+* Enrico Canzonieri, [@ecanzonieri](https://github.com/ecanzonieri)
+* haosdent, [@haosdent](https://github.com/haosdent)
+* Arturo Filastò, [@hellais](https://github.com/hellais)
+* Job Evers‐Meltzer, [@jobevers](https://github.com/jobevers)
+* Martin Olveyra, [@kalessin](https://github.com/kalessin)
+* Kubilay Kocak, [@koobs](https://github.com/koobs)
+* Matthew L Daniel <mdaniel@gmail.com>
+* Eric Hewitt, [@meandthewallaby](https://github.com/meandthewallaby)
+* Oliver Jowett [@mutability](https://github.com/mutability)
+* Shaolei Zhou, [@reAsOn2010](https://github.com/reAsOn2010)
+* Oskari Saarenmaa, [@saaros](https://github.com/saaros)
+* John Anderson, [@sontek](https://github.com/sontek)
+* Eduard Iskandarov, [@toidi](https://github.com/toidi)
+* Todd Palino, [@toddpalino](https://github.com/toddpalino)
+* trbs, [@trbs](https://github.com/trbs)
+* Viktor Shlapakov, [@vshlapakov](https://github.com/vshlapakov)
+* Will Daly, [@wedaly](https://github.com/wedaly)
+* Warren Kiser, [@wkiser](https://github.com/wkiser)
+* William Ting, [@wting](https://github.com/wting)
+* Zack Dever, [@zackdever](https://github.com/zackdever)
+
+# More Contributors
+* Bruno Renié, [@brutasse](https://github.com/brutasse)
+* Thomas Dimson, [@cosbynator](https://github.com/cosbynator)
+* Jesse Myers, [@jessemyers](https://github.com/jessemyers)
+* Mahendra M, [@mahendra](https://github.com/mahendra)
+* Miguel Eduardo Gil Biraud, [@mgilbir](https://github.com/mgilbir)
+* Marc Labbé, [@mrtheb](https://github.com/mrtheb)
+* Patrick Lucas, [@patricklucas](https://github.com/patricklucas)
+* Omar Ghishan, [@rdiomar](https://github.com/rdiomar) - RIP, Omar. 2014
+* Ivan Pouzyrevsky, [@sandello](https://github.com/sandello)
+* Lou Marvin Caraig, [@se7entyse7en](https://github.com/se7entyse7en)
+* waliaashish85, [@waliaashish85](https://github.com/waliaashish85)
+* Mark Roberts, [@wizzat](https://github.com/wizzat)
+* Christophe Lecointe [@christophelec](https://github.com/christophelec)
+* Mohamed Helmi Hichri [@hellich](https://github.com/hellich)
+
+Thanks to all who have contributed!

testbed/dpkp__kafka-python/CHANGES.md

@@ -0,0 +1,1204 @@
+# 2.0.2 (Sep 29, 2020)
+
+Consumer
+* KIP-54: Implement sticky partition assignment strategy (aynroot / PR #2057)
+* Fix consumer deadlock when heartbeat thread request timeout (huangcuiyang / PR #2064)
+
+Compatibility
+* Python 3.8 support (Photonios / PR #2088)
+
+Cleanups
+* Bump dev requirements (jeffwidman / PR #2129)
+* Fix crc32c deprecation warning (crc32c==2.1) (jeffwidman / PR #2128)
+* Lint cleanup (jeffwidman / PR #2126)
+* Fix initialization order in KafkaClient (pecalleja / PR #2119)
+* Allow installing crc32c via extras (mishas / PR #2069)
+* Remove unused imports (jameslamb / PR #2046)
+
+Admin Client
+* Merge _find_coordinator_id methods (jeffwidman / PR #2127)
+* Feature: delete consumergroups (swenzel / PR #2040)
+* Allow configurable timeouts in admin client check version (sunnyakaxd / PR #2107)
+* Enhancement for Kafka Admin Client's "Describe Consumer Group" (Apurva007 / PR #2035)
+
+Protocol
+* Add support for zstd compression (gabriel-tincu / PR #2021)
+* Add protocol support for brokers 1.1.0 - 2.5.0 (gabriel-tincu / PR #2038)
+* Add ProduceRequest/ProduceResponse v6/v7/v8 (gabriel-tincu / PR #2020)
+* Fix parsing NULL header values (kvfi / PR #2024)
+
+Tests
+* Add 2.5.0 to automated CI tests (gabriel-tincu / PR #2038)
+* Add 2.1.1 to build_integration (gabriel-tincu / PR #2019)
+
+Documentation / Logging / Errors
+* Disable logging during producer object gc (gioele / PR #2043)
+* Update example.py; use threading instead of multiprocessing (Mostafa-Elmenbawy / PR #2081)
+* Fix typo in exception message (haracejacob / PR #2096)
+* Add kafka.structs docstrings (Mostafa-Elmenbawy / PR #2080)
+* Fix broken compatibility page link (anuragrana / PR #2045)
+* Rename README to README.md (qhzxc0015 / PR #2055)
+* Fix docs by adding SASL mention (jeffwidman / #1990)
+
+# 2.0.1 (Feb 19, 2020)
+
+Admin Client
+* KAFKA-8962: Use least_loaded_node() for AdminClient.describe_topics() (jeffwidman / PR #2000)
+* Fix AdminClient topic error parsing in MetadataResponse (jtribble / PR #1997)
+
+# 2.0.0 (Feb 10, 2020)
+
+This release includes breaking changes for any application code that has not
+migrated from older Simple-style classes to newer Kafka-style classes.
+
+Deprecation
+* Remove deprecated SimpleClient, Producer, Consumer, Unittest (jeffwidman / PR #1196)
+
+Admin Client
+* Use the controller for topic metadata requests (TylerLubeck / PR #1995)
+* Implement list_topics, describe_topics, and describe_cluster (TylerLubeck / PR #1993)
+* Implement __eq__ and __hash__ for ACL objects (TylerLubeck / PR #1955)
+* Fixes KafkaAdminClient returning `IncompatibleBrokerVersion` when passing an `api_version` (ian28223 / PR #1953)
+* Admin protocol updates (TylerLubeck / PR #1948)
+* Fix describe config for multi-broker clusters (jlandersen  / PR #1869)
+
+Miscellaneous Bugfixes / Improvements
+* Enable SCRAM-SHA-256 and SCRAM-SHA-512 for sasl (swenzel / PR #1918)
+* Fix slots usage and use more slots (carsonip / PR #1987)
+* Optionally return OffsetAndMetadata from consumer.committed(tp) (dpkp / PR #1979)
+* Reset conn configs on exception in conn.check_version() (dpkp / PR #1977)
+* Do not block on sender thread join after timeout in producer.close() (dpkp / PR #1974)
+* Implement methods to convert a Struct object to a pythonic object (TylerLubeck / PR #1951)
+
+Test Infrastructure / Documentation / Maintenance
+* Update 2.4.0 resource files for sasl integration (dpkp)
+* Add kafka 2.4.0 to CI testing (vvuibert / PR #1972)
+* convert test_admin_integration to pytest (ulrikjohansson / PR #1923)
+* xfail test_describe_configs_topic_resource_returns_configs (dpkp / Issue #1929)
+* Add crc32c to README and docs (dpkp)
+* Improve docs for reconnect_backoff_max_ms (dpkp / PR #1976)
+* Fix simple typo: managementment -> management (timgates42 / PR #1966)
+* Fix typos (carsonip / PR #1938)
+* Fix doc import paths (jeffwidman / PR #1933)
+* Update docstring to match conn.py's (dabcoder / PR #1921)
+* Do not log topic-specific errors in full metadata fetch (dpkp / PR #1980)
+* Raise AssertionError if consumer closed in poll() (dpkp / PR #1978)
+* Log retriable coordinator NodeNotReady, TooManyInFlightRequests as debug not error (dpkp / PR #1975)
+* Remove unused import (jeffwidman)
+* Remove some dead code (jeffwidman)
+* Fix a benchmark to Use print() function in both Python 2 and Python 3 (cclauss / PR #1983)
+* Fix a test to use ==/!= to compare str, bytes, and int literals (cclauss / PR #1984)
+* Fix benchmarks to use pyperf (carsonip / PR #1986)
+* Remove unused/empty .gitsubmodules file (jeffwidman / PR #1928)
+* Remove deprecated `ConnectionError` (jeffwidman / PR #1816)
+
+
+# 1.4.7 (Sep 30, 2019)
+
+This is a minor release focused on KafkaConsumer performance, Admin Client
+improvements, and Client concurrency. The KafkaConsumer iterator implementation
+has been greatly simplified so that it just wraps consumer.poll(). The prior
+implementation will remain available for a few more releases using the optional
+KafkaConsumer config: `legacy_iterator=True` . This is expected to improve
+consumer throughput substantially and help reduce heartbeat failures / group
+rebalancing.
+
+Client
+* Send socket data via non-blocking IO with send buffer (dpkp / PR #1912)
+* Rely on socket selector to detect completed connection attempts (dpkp / PR #1909)
+* Improve connection lock handling; always use context manager (melor,dpkp / PR #1895)
+* Reduce client poll timeout when there are no in-flight requests (dpkp / PR #1823)
+
+KafkaConsumer
+* Do not use wakeup when sending fetch requests from consumer (dpkp / PR #1911)
+* Wrap `consumer.poll()` for KafkaConsumer iteration (dpkp / PR #1902)
+* Allow the coordinator to auto-commit on old brokers (justecorruptio / PR #1832)
+* Reduce internal client poll timeout for (legacy) consumer iterator interface (dpkp / PR #1824)
+* Use dedicated connection for group coordinator (dpkp / PR #1822)
+* Change coordinator lock acquisition order (dpkp / PR #1821)
+* Make `partitions_for_topic` a read-through cache (Baisang / PR #1781,#1809)
+* Fix consumer hanging indefinitely on topic deletion while rebalancing (commanderdishwasher / PR #1782)
+
+Miscellaneous Bugfixes / Improvements
+* Fix crc32c avilability on non-intel architectures (ossdev07 / PR #1904)
+* Load system default SSL CAs if `ssl_cafile` is not provided (iAnomaly / PR #1883)
+* Catch py3 TimeoutError in BrokerConnection send/recv (dpkp / PR #1820)
+* Added a function to determine if bootstrap is successfully connected (Wayde2014 / PR #1876)
+
+Admin Client
+* Add ACL api support to KafkaAdminClient (ulrikjohansson / PR #1833)
+* Add `sasl_kerberos_domain_name` config to KafkaAdminClient (jeffwidman / PR #1852)
+* Update `security_protocol` config documentation for KafkaAdminClient (cardy31 / PR #1849)
+* Break FindCoordinator into request/response methods in KafkaAdminClient (jeffwidman / PR #1871)
+* Break consumer operations into request / response methods in KafkaAdminClient (jeffwidman / PR #1845)
+* Parallelize calls to `_send_request_to_node()` in KafkaAdminClient (davidheitman / PR #1807)
+
+Test Infrastructure / Documentation / Maintenance
+* Add Kafka 2.3.0 to test matrix and compatibility docs (dpkp / PR #1915)
+* Convert remaining `KafkaConsumer` tests to `pytest` (jeffwidman / PR #1886)
+* Bump integration tests to 0.10.2.2 and 0.11.0.3 (jeffwidman / #1890)
+* Cleanup handling of `KAFKA_VERSION` env var in tests (jeffwidman / PR #1887)
+* Minor test cleanup (jeffwidman / PR #1885)
+* Use `socket.SOCK_STREAM` in test assertions (iv-m / PR #1879)
+* Sanity test for `consumer.topics()` and `consumer.partitions_for_topic()` (Baisang / PR #1829)
+* Cleanup seconds conversion in client poll timeout calculation (jeffwidman / PR #1825)
+* Remove unused imports (jeffwidman / PR #1808)
+* Cleanup python nits in RangePartitionAssignor (jeffwidman / PR #1805)
+* Update links to kafka consumer config docs (jeffwidman)
+* Fix minor documentation typos (carsonip / PR #1865)
+* Remove unused/weird comment line (jeffwidman / PR #1813)
+* Update docs for `api_version_auto_timeout_ms` (jeffwidman / PR #1812)
+
+
+# 1.4.6 (Apr 2, 2019)
+
+This is a patch release primarily focused on bugs related to concurrency,
+SSL connections and testing, and SASL authentication:
+
+Client Concurrency Issues (Race Conditions / Deadlocks)
+* Fix race condition in `protocol.send_bytes` (isamaru / PR #1752)
+* Do not call `state_change_callback` with lock (dpkp / PR #1775)
+* Additional BrokerConnection locks to synchronize protocol/IFR state (dpkp / PR #1768)
+* Send pending requests before waiting for responses (dpkp / PR #1762)
+* Avoid race condition on `client._conns` in send() (dpkp / PR #1772)
+* Hold lock during `client.check_version` (dpkp / PR #1771)
+
+Producer Wakeup / TimeoutError
+* Dont wakeup during `maybe_refresh_metadata` -- it is only called by poll() (dpkp / PR #1769)
+* Dont do client wakeup when sending from sender thread (dpkp / PR #1761)
+
+SSL - Python3.7 Support / Bootstrap Hostname Verification / Testing
+* Wrap SSL sockets after connecting for python3.7 compatibility (dpkp / PR #1754)
+* Allow configuration of SSL Ciphers (dpkp / PR #1755)
+* Maintain shadow cluster metadata for bootstrapping (dpkp / PR #1753)
+* Generate SSL certificates for local testing (dpkp / PR #1756)
+* Rename ssl.keystore.location and ssl.truststore.location config files (dpkp)
+* Reset reconnect backoff on SSL connection (dpkp / PR #1777)
+
+SASL - OAuthBearer support / api version bugfix
+* Fix 0.8.2 protocol quick detection / fix SASL version check (dpkp / PR #1763)
+* Update sasl configuration docstrings to include supported mechanisms (dpkp)
+* Support SASL OAuthBearer Authentication (pt2pham / PR #1750)
+
+Miscellaneous Bugfixes
+* Dont force metadata refresh when closing unneeded bootstrap connections (dpkp / PR #1773)
+* Fix possible AttributeError during conn._close_socket (dpkp / PR #1776)
+* Return connection state explicitly after close in connect() (dpkp / PR #1778)
+* Fix flaky conn tests that use time.time (dpkp / PR #1758)
+* Add py to requirements-dev (dpkp)
+* Fixups to benchmark scripts for py3 / new KafkaFixture interface (dpkp)
+
+
+# 1.4.5 (Mar 14, 2019)
+
+This release is primarily focused on addressing lock contention
+and other coordination issues between the KafkaConsumer and the
+background heartbeat thread that was introduced in the 1.4 release.
+
+Consumer
+* connections_max_idle_ms must be larger than request_timeout_ms (jeffwidman / PR #1688)
+* Avoid race condition during close() / join heartbeat thread (dpkp / PR #1735)
+* Use last offset from fetch v4 if available to avoid getting stuck in compacted topic (keithks / PR #1724)
+* Synchronize puts to KafkaConsumer protocol buffer during async sends (dpkp / PR #1733)
+* Improve KafkaConsumer join group / only enable Heartbeat Thread during stable group (dpkp / PR #1695)
+* Remove unused `skip_double_compressed_messages` (jeffwidman / PR #1677)
+* Fix commit_offsets_async() callback (Faqa / PR #1712)
+
+Client
+* Retry bootstrapping after backoff when necessary (dpkp / PR #1736)
+* Recheck connecting nodes sooner when refreshing metadata (dpkp / PR #1737)
+* Avoid probing broker versions twice on newer brokers (dpkp / PR #1738)
+* Move all network connections and writes to KafkaClient.poll() (dpkp / PR #1729)
+* Do not require client lock for read-only operations (dpkp / PR #1730)
+* Timeout all unconnected conns (incl SSL) after request_timeout_ms (dpkp / PR #1696)
+
+Admin Client
+* Fix AttributeError in response topic error codes checking (jeffwidman)
+* Fix response error checking in KafkaAdminClient send_to_controller (jeffwidman)
+* Fix NotControllerError check (jeffwidman)
+
+Core/Protocol
+* Fix default protocol parser version / 0.8.2 version probe (dpkp / PR #1740)
+* Make NotEnoughReplicasError/NotEnoughReplicasAfterAppendError retriable (le-linh / PR #1722)
+
+Bugfixes
+* Use copy() in metrics() to avoid thread safety issues (emeric254 / PR #1682)
+
+Test Infrastructure
+* Mock dns lookups in test_conn (dpkp / PR #1739)
+* Use test.fixtures.version not test.conftest.version to avoid warnings (dpkp / PR #1731)
+* Fix test_legacy_correct_metadata_response on x86 arch (stanislavlevin / PR #1718)
+* Travis CI: 'sudo' tag is now deprecated in Travis (cclauss / PR #1698)
+* Use Popen.communicate() instead of Popen.wait() (Baisang / PR #1689)
+
+Compatibility
+* Catch thrown OSError by python 3.7 when creating a connection (danjo133 / PR #1694)
+* Update travis test coverage: 2.7, 3.4, 3.7, pypy2.7 (jeffwidman, dpkp / PR #1614)
+* Drop dependency on sphinxcontrib-napoleon (stanislavlevin / PR #1715)
+* Remove unused import from kafka/producer/record_accumulator.py (jeffwidman / PR #1705)
+* Fix SSL connection testing in Python 3.7 (seanthegeek, silentben / PR #1669)
+
+
+# 1.4.4 (Nov 20, 2018)
+
+Bugfixes
+* (Attempt to) Fix deadlock between consumer and heartbeat (zhgjun / dpkp #1628)
+* Fix Metrics dict memory leak (kishorenc #1569)
+
+Client
+* Support Kafka record headers (hnousiainen #1574)
+* Set socket timeout for the write-side of wake socketpair (Fleurer #1577)
+* Add kerberos domain name config for gssapi sasl mechanism handshake (the-sea #1542)
+* Support smaller topic metadata fetch during bootstrap (andyxning #1541)
+* Use TypeError for invalid timeout type (jeffwidman #1636)
+* Break poll if closed (dpkp)
+
+Admin Client
+* Add KafkaAdminClient class (llamahunter #1540)
+* Fix list_consumer_groups() to query all brokers (jeffwidman #1635)
+* Stop using broker-errors for client-side problems (jeffwidman #1639)
+* Fix send to controller (jeffwidman #1640)
+* Add group coordinator lookup (jeffwidman #1641)
+* Fix describe_groups (jeffwidman #1642)
+* Add list_consumer_group_offsets() (jeffwidman #1643)
+* Remove support for api versions as strings from KafkaAdminClient (jeffwidman #1644)
+* Set a clear default value for `validate_only`/`include_synonyms` (jeffwidman #1645)
+* Bugfix: Always set this_groups_coordinator_id (jeffwidman #1650)
+
+Consumer
+* Fix linter warning on import of ConsumerRebalanceListener (ben-harack #1591)
+* Remove ConsumerTimeout (emord #1587)
+* Return future from commit_offsets_async() (ekimekim #1560)
+
+Core / Protocol
+* Add protocol structs for {Describe,Create,Delete} Acls (ulrikjohansson #1646/partial)
+* Pre-compile pack/unpack function calls (billyevans / jeffwidman #1619)
+* Don't use `kafka.common` internally (jeffwidman #1509)
+* Be explicit with tuples for %s formatting (jeffwidman #1634)
+
+Documentation
+* Document connections_max_idle_ms (jeffwidman #1531)
+* Fix sphinx url (jeffwidman #1610)
+* Update remote urls: snappy, https, etc (jeffwidman #1603)
+* Minor cleanup of testing doc (jeffwidman #1613)
+* Various docstring / pep8 / code hygiene cleanups (jeffwidman #1647)
+
+Test Infrastructure
+* Stop pinning `pylint` (jeffwidman #1611)
+* (partial) Migrate from `Unittest` to `pytest` (jeffwidman #1620)
+* Minor aesthetic cleanup of partitioner tests (jeffwidman #1618)
+* Cleanup fixture imports (jeffwidman #1616)
+* Fix typo in test file name (jeffwidman)
+* Remove unused ivy_root variable (jeffwidman)
+* Add test fixtures for kafka versions 1.0.2 -> 2.0.1 (dpkp)
+* Bump travis test for 1.x brokers to 1.1.1 (dpkp)
+
+Logging / Error Messages
+* raising logging level on messages signalling data loss (sibiryakov #1553)
+* Stop using deprecated log.warn() (jeffwidman #1615)
+* Fix typo in logging message (jeffwidman)
+
+Compatibility
+* Vendor enum34 (jeffwidman #1604)
+* Bump vendored `six` to `1.11.0` (jeffwidman #1602)
+* Vendor `six` consistently (jeffwidman #1605)
+* Prevent `pylint` import errors on `six.moves` (jeffwidman #1609)
+
+
+# 1.4.3 (May 26, 2018)
+
+Compatibility
+* Fix for python 3.7 support: remove 'async' keyword from SimpleProducer (dpkp #1454)
+
+Client
+* Improve BrokerConnection initialization time (romulorosa #1475)
+* Ignore MetadataResponses with empty broker list (dpkp #1506)
+* Improve connection handling when bootstrap list is invalid (dpkp #1507)
+
+Consumer
+* Check for immediate failure when looking up coordinator in heartbeat thread (dpkp #1457)
+
+Core / Protocol
+* Always acquire client lock before coordinator lock to avoid deadlocks (dpkp #1464)
+* Added AlterConfigs and DescribeConfigs apis (StephenSorriaux #1472)
+* Fix CreatePartitionsRequest_v0 (StephenSorriaux #1469)
+* Add codec validators to record parser and builder for all formats (tvoinarovskyi #1447)
+* Fix MemoryRecord bugs re error handling and add test coverage (tvoinarovskyi #1448)
+* Force lz4 to disable Kafka-unsupported block linking when encoding (mnito #1476)
+* Stop shadowing `ConnectionError` (jeffwidman #1492)
+
+Documentation
+* Document methods that return None (jeffwidman #1504)
+* Minor doc capitalization cleanup (jeffwidman)
+* Adds add_callback/add_errback example to docs (Berkodev #1441)
+* Fix KafkaConsumer docstring for request_timeout_ms default (dpkp #1459)
+
+Test Infrastructure
+* Skip flakey SimpleProducer test (dpkp)
+* Fix skipped integration tests if KAFKA_VERSION unset (dpkp #1453)
+
+Logging / Error Messages
+* Stop using deprecated log.warn() (jeffwidman)
+* Change levels for some heartbeat thread logging (dpkp #1456)
+* Log Heartbeat thread start / close for debugging (dpkp)
+
+
+# 1.4.2 (Mar 10, 2018)
+
+Bugfixes
+* Close leaked selector in version check (dpkp #1425)
+* Fix `BrokerConnection.connection_delay()` to return milliseconds (dpkp #1414)
+* Use local copies in `Fetcher._fetchable_partitions` to avoid mutation errors (dpkp #1400)
+* Fix error var name in `_unpack` (j2gg0s #1403)
+* Fix KafkaConsumer compacted offset handling (dpkp #1397)
+* Fix byte size estimation with kafka producer (blakeembrey #1393)
+* Fix coordinator timeout in consumer poll interface (braedon #1384)
+
+Client
+* Add `BrokerConnection.connect_blocking()` to improve bootstrap to multi-address hostnames (dpkp #1411)
+* Short-circuit `BrokerConnection.close()` if already disconnected (dpkp #1424)
+* Only increase reconnect backoff if all addrinfos have been tried (dpkp #1423)
+* Make BrokerConnection .host / .port / .afi immutable to avoid incorrect 'metadata changed' checks (dpkp #1422)
+* Connect with sockaddrs to support non-zero ipv6 scope ids (dpkp #1433)
+* Check timeout type in KafkaClient constructor (asdaraujo #1293)
+* Update string representation of SimpleClient (asdaraujo #1293)
+* Do not validate `api_version` against known versions (dpkp #1434)
+
+Consumer
+* Avoid tight poll loop in consumer when brokers are down (dpkp #1415)
+* Validate `max_records` in KafkaConsumer.poll (dpkp #1398)
+* KAFKA-5512: Awake heartbeat thread when it is time to poll (dpkp #1439)
+
+Producer
+* Validate that serializers generate bytes-like (or None) data (dpkp #1420)
+
+Core / Protocol
+* Support alternative lz4 package: lz4framed (everpcpc #1395)
+* Use hardware accelerated CRC32C function if available (tvoinarovskyi #1389)
+* Add Admin CreatePartitions API call (alexef #1386)
+
+Test Infrastructure
+* Close KafkaConsumer instances during tests (dpkp #1410)
+* Introduce new fixtures to prepare for migration to pytest (asdaraujo #1293)
+* Removed pytest-catchlog dependency (asdaraujo #1380)
+* Fixes racing condition when message is sent to broker before topic logs are created (asdaraujo #1293)
+* Add kafka 1.0.1 release to test fixtures (dpkp #1437)
+
+Logging / Error Messages
+* Re-enable logging during broker version check (dpkp #1430)
+* Connection logging cleanups (dpkp #1432)
+* Remove old CommitFailed error message from coordinator (dpkp #1436)
+
+
+# 1.4.1 (Feb 9, 2018)
+
+Bugfixes
+* Fix consumer poll stuck error when no available partition (ckyoog #1375)
+* Increase some integration test timeouts (dpkp #1374)
+* Use raw in case string overriden (jeffwidman #1373)
+* Fix pending completion IndexError bug caused by multiple threads (dpkp #1372)
+
+
+# 1.4.0 (Feb 6, 2018)
+
+This is a substantial release. Although there are no known 'showstopper' bugs as of release,
+we do recommend you test any planned upgrade to your application prior to running in production.
+
+Some of the major changes include:
+* We have officially dropped python 2.6 support
+* The KafkaConsumer now includes a background thread to handle coordinator heartbeats
+* API protocol handling has been separated from networking code into a new class, KafkaProtocol
+* Added support for kafka message format v2
+* Refactored DNS lookups during kafka broker connections
+* SASL authentication is working (we think)
+* Removed several circular references to improve gc on close()
+
+Thanks to all contributors -- the state of the kafka-python community is strong!
+
+Detailed changelog are listed below:
+
+Client
+* Fixes for SASL support
+  * Refactor SASL/gssapi support (dpkp #1248 #1249 #1257 #1262 #1280)
+  * Add security layer negotiation to the GSSAPI authentication (asdaraujo #1283)
+  * Fix overriding sasl_kerberos_service_name in KafkaConsumer / KafkaProducer (natedogs911 #1264)
+  * Fix typo in _try_authenticate_plain (everpcpc #1333)
+  * Fix for Python 3 byte string handling in SASL auth (christophelec #1353)
+* Move callback processing from BrokerConnection to KafkaClient (dpkp #1258)
+* Use socket timeout of request_timeout_ms to prevent blocking forever on send (dpkp #1281)
+* Refactor dns lookup in BrokerConnection (dpkp #1312)
+* Read all available socket bytes (dpkp #1332)
+* Honor reconnect_backoff in conn.connect() (dpkp #1342)
+
+Consumer
+* KAFKA-3977: Defer fetch parsing for space efficiency, and to raise exceptions to user (dpkp #1245)
+* KAFKA-4034: Avoid unnecessary consumer coordinator lookup (dpkp #1254)
+* Handle lookup_coordinator send failures (dpkp #1279)
+* KAFKA-3888 Use background thread to process consumer heartbeats (dpkp #1266)
+* Improve KafkaConsumer cleanup (dpkp #1339)
+* Fix coordinator join_future race condition (dpkp #1338)
+* Avoid KeyError when filtering fetchable partitions (dpkp #1344)
+* Name heartbeat thread with group_id; use backoff when polling (dpkp #1345)
+* KAFKA-3949: Avoid race condition when subscription changes during rebalance (dpkp #1364)
+* Fix #1239 regression to avoid consuming duplicate compressed messages from mid-batch (dpkp #1367)
+
+Producer
+* Fix timestamp not passed to RecordMetadata (tvoinarovskyi #1273)
+* Raise non-API exceptions (jeffwidman #1316)
+* Fix reconnect_backoff_max_ms default config bug in KafkaProducer (YaoC #1352)
+
+Core / Protocol
+* Add kafka.protocol.parser.KafkaProtocol w/ receive and send (dpkp #1230)
+* Refactor MessageSet and Message into LegacyRecordBatch to later support v2 message format (tvoinarovskyi #1252)
+* Add DefaultRecordBatch implementation aka V2 message format parser/builder. (tvoinarovskyi #1185)
+* optimize util.crc32 (ofek #1304)
+* Raise better struct pack/unpack errors (jeffwidman #1320)
+* Add Request/Response structs for kafka broker 1.0.0 (dpkp #1368)
+
+Bugfixes
+* use python standard max value (lukekingbru #1303)
+* changed for to use enumerate() (TheAtomicOption #1301)
+* Explicitly check for None rather than falsey (jeffwidman #1269)
+* Minor Exception cleanup (jeffwidman #1317)
+* Use non-deprecated exception handling (jeffwidman a699f6a)
+* Remove assertion with side effect in client.wakeup() (bgedik #1348)
+* use absolute imports everywhere (kevinkjt2000 #1362)
+
+Test Infrastructure
+* Use 0.11.0.2 kafka broker for integration testing (dpkp #1357 #1244)
+* Add a Makefile to help build the project, generate docs, and run tests (tvoinarovskyi #1247)
+* Add fixture support for 1.0.0 broker (dpkp #1275)
+* Add kafka 1.0.0 to travis integration tests (dpkp #1365)
+* Change fixture default host to localhost (asdaraujo #1305)
+* Minor test cleanups (dpkp #1343)
+* Use latest pytest 3.4.0, but drop pytest-sugar due to incompatibility (dpkp #1361)
+
+Documentation
+* Expand metrics docs (jeffwidman #1243)
+* Fix docstring (jeffwidman #1261)
+* Added controlled thread shutdown to example.py (TheAtomicOption #1268)
+* Add license to wheel (jeffwidman #1286)
+* Use correct casing for MB (jeffwidman #1298)
+
+Logging / Error Messages
+* Fix two bugs in printing bytes instance (jeffwidman #1296)
+
+
+# 1.3.5 (Oct 7, 2017)
+
+Bugfixes
+* Fix partition assignment race condition (jeffwidman #1240)
+* Fix consumer bug when seeking / resetting to the middle of a compressed messageset (dpkp #1239)
+* Fix traceback sent to stderr not logging (dbgasaway #1221)
+* Stop using mutable types for default arg values (jeffwidman #1213)
+* Remove a few unused imports (jameslamb #1188)
+
+Client
+* Refactor BrokerConnection to use asynchronous receive_bytes pipe (dpkp #1032)
+
+Consumer
+* Drop unused sleep kwarg to poll (dpkp #1177)
+* Enable KafkaConsumer beginning_offsets() and end_offsets() with older broker versions (buptljy #1200)
+* Validate consumer subscription topic strings (nikeee #1238)
+
+Documentation
+* Small fixes to SASL documentation and logging; validate security_protocol (dpkp #1231)
+* Various typo and grammar fixes (jeffwidman)
+
+
+# 1.3.4 (Aug 13, 2017)
+
+Bugfixes
+* Avoid multiple connection attempts when refreshing metadata (dpkp #1067)
+* Catch socket.errors when sending / recving bytes on wake socketpair (dpkp #1069)
+* Deal with brokers that reappear with different IP address (originsmike #1085)
+* Fix join-time-max and sync-time-max metrics to use Max() measure function (billyevans #1146)
+* Raise AssertionError when decompression unsupported (bts-webber #1159)
+* Catch ssl.EOFErrors on Python3.3 so we close the failing conn (Ormod #1162)
+* Select on sockets to avoid busy polling during bootstrap (dpkp #1175)
+* Initialize metadata_snapshot in group coordinator to avoid unnecessary rebalance (dpkp #1174)
+
+Client
+* Timeout idle connections via connections_max_idle_ms (dpkp #1068)
+* Warn, dont raise, on DNS lookup failures (dpkp #1091)
+* Support exponential backoff for broker reconnections -- KIP-144 (dpkp #1124)
+* Add gssapi support (Kerberos) for SASL (Harald-Berghoff #1152)
+* Add private map of api key -> min/max versions to BrokerConnection (dpkp #1169)
+
+Consumer
+* Backoff on unavailable group coordinator retry (dpkp #1125)
+* Only change_subscription on pattern subscription when topics change (Artimi #1132)
+* Add offsets_for_times, beginning_offsets and end_offsets APIs (tvoinarovskyi #1161)
+
+Producer
+* Raise KafkaTimeoutError when flush times out (infecto)
+* Set producer atexit timeout to 0 to match del (Ormod #1126)
+
+Core / Protocol
+* 0.11.0.0 protocol updates (only - no client support yet) (dpkp #1127)
+* Make UnknownTopicOrPartitionError retriable error (tvoinarovskyi)
+
+Test Infrastructure
+* pylint 1.7.0+ supports python 3.6 and merge py36 into common testenv (jianbin-wei #1095)
+* Add kafka 0.10.2.1 into integration testing version (jianbin-wei #1096)
+* Disable automated tests for python 2.6 and kafka 0.8.0 and 0.8.1.1 (jianbin-wei #1096)
+* Support manual py26 testing; dont advertise 3.3 support (dpkp)
+* Add 0.11.0.0 server resources, fix tests for 0.11 brokers (dpkp)
+* Use fixture hostname, dont assume localhost (dpkp)
+* Add 0.11.0.0 to travis test matrix, remove 0.10.1.1; use scala 2.11 artifacts (dpkp #1176)
+
+Logging / Error Messages
+* Improve error message when expiring batches in KafkaProducer (dpkp #1077)
+* Update producer.send docstring -- raises KafkaTimeoutError (infecto)
+* Use logging's built-in string interpolation (jeffwidman)
+* Fix produce timeout message (melor #1151)
+* Fix producer batch expiry messages to use seconds (dnwe)
+
+Documentation
+* Fix typo in KafkaClient docstring (jeffwidman #1054)
+* Update README: Prefer python-lz4 over lz4tools (kiri11 #1057)
+* Fix poll() hyperlink in KafkaClient (jeffwidman)
+* Update RTD links with https / .io (jeffwidman #1074)
+* Describe consumer thread-safety (ecksun)
+* Fix typo in consumer integration test (jeffwidman)
+* Note max_in_flight_requests_per_connection > 1 may change order of messages (tvoinarovskyi #1149)
+
+
+# 1.3.3 (Mar 14, 2017)
+
+Core / Protocol
+* Derive all api classes from Request / Response base classes (dpkp 1030)
+* Prefer python-lz4 if available (dpkp 1024)
+* Fix kwarg handing in kafka.protocol.struct.Struct (dpkp 1025)
+* Fixed couple of "leaks" when gc is disabled (Mephius 979)
+* Added `max_bytes` option and FetchRequest_v3 usage. (Drizzt1991 962)
+* CreateTopicsRequest / Response v1 (dpkp 1012)
+* Add MetadataRequest_v2 and MetadataResponse_v2 structures for KIP-78 (Drizzt1991 974)
+* KIP-88 / KAFKA-3853: OffsetFetch v2 structs (jeffwidman 971)
+* DRY-up the MetadataRequest_v1 struct (jeffwidman 966)
+* Add JoinGroup v1 structs (jeffwidman 965)
+* DRY-up the OffsetCommitResponse Structs (jeffwidman 970)
+* DRY-up the OffsetFetch structs (jeffwidman 964)
+* time --> timestamp to match Java API (jeffwidman 969)
+* Add support for offsetRequestV1 messages (jlafaye 951)
+* Add FetchRequest/Response_v3 structs (jeffwidman 943)
+* Add CreateTopics / DeleteTopics Structs (jeffwidman 944)
+
+Test Infrastructure
+* Add python3.6 to travis test suite, drop python3.3 (exponea 992)
+* Update to 0.10.1.1 for integration testing (dpkp 953)
+* Update vendored berkerpeksag/selectors34 to ff61b82 (Mephius 979)
+* Remove dead code (jeffwidman 967)
+* Update pytest fixtures to new yield syntax (jeffwidman 919)
+
+Consumer
+* Avoid re-encoding message for crc check (dpkp 1027)
+* Optionally skip auto-commit during consumer.close (dpkp 1031)
+* Return copy of consumer subscription set (dpkp 1029)
+* Short-circuit group coordinator requests when NodeNotReady (dpkp 995)
+* Avoid unknown coordinator after client poll (dpkp 1023)
+* No longer configure a default consumer group (dpkp 1016)
+* Dont refresh metadata on failed group coordinator request unless needed (dpkp 1006)
+* Fail-fast on timeout constraint violations during KafkaConsumer creation (harelba 986)
+* Default max_poll_records to Java default of 500 (jeffwidman 947)
+* For 0.8.2, only attempt connection to coordinator if least_loaded_node succeeds (dpkp)
+
+Producer
+* change default timeout of KafkaProducer.close() to threading.TIMEOUT_MAX on py3 (mmyjona 991)
+
+Client
+* Add optional kwarg to ready/is_ready to disable metadata-priority logic (dpkp 1017)
+* When closing a broker connection without error, fail in-flight-requests with Cancelled (dpkp 1010)
+* Catch socket errors during ssl handshake (dpkp 1007)
+* Drop old brokers when rebuilding broker metadata (dpkp 1005)
+* Drop bad disconnect test -- just use the mocked-socket test (dpkp 982)
+* Add support for Python built without ssl (minagawa-sho 954)
+* Do not re-close a disconnected connection (dpkp)
+* Drop unused last_failure time from BrokerConnection (dpkp)
+* Use connection state functions where possible (dpkp)
+* Pass error to BrokerConnection.close() (dpkp)
+
+Bugfixes
+* Free lz4 decompression context to avoid leak (dpkp 1024)
+* Fix sasl reconnect bug: auth future must be reset on close (dpkp 1003)
+* Fix raise exception from SubscriptionState.assign_from_subscribed (qntln 960)
+* Fix blackout calculation: mark last_attempt time during connection close (dpkp 1008)
+* Fix buffer pool reallocation after raising timeout (dpkp 999)
+
+Logging / Error Messages
+* Add client info logging re bootstrap; log connection attempts to balance with close (dpkp)
+* Minor additional logging for consumer coordinator (dpkp)
+* Add more debug-level connection logging (dpkp)
+* Do not need str(self) when formatting to %s (dpkp)
+* Add new broker response errors (dpkp)
+* Small style fixes in kafka.errors (dpkp)
+* Include the node id in BrokerConnection logging (dpkp 1009)
+* Replace %s with %r in producer debug log message (chekunkov 973)
+
+Documentation
+* Sphinx documentation updates (jeffwidman 1019)
+* Add sphinx formatting to hyperlink methods (jeffwidman 898)
+* Fix BrokerConnection api_version docs default (jeffwidman 909)
+* PEP-8: Spacing & removed unused imports (jeffwidman 899)
+* Move BrokerConnection docstring to class (jeffwidman 968)
+* Move docstring so it shows up in Sphinx/RTD (jeffwidman 952)
+* Remove non-pip install instructions (jeffwidman 940)
+* Spelling and grammar changes (melissacrawford396 923)
+* Fix typo: coorelation --> correlation (jeffwidman 929)
+* Make SSL warning list the correct Python versions (jeffwidman 924)
+* Fixup comment reference to _maybe_connect (dpkp)
+* Add ClusterMetadata sphinx documentation (dpkp)
+
+Legacy Client
+* Add send_list_offset_request for searching offset by timestamp (charsyam 1001)
+* Use select to poll sockets for read to reduce CPU usage (jianbin-wei 958)
+* Use select.select without instance bounding (adamwen829 949)
+
+
+# 1.3.2 (Dec 28, 2016)
+
+Core
+* Add kafka.serializer interfaces (dpkp 912)
+* from kafka import ConsumerRebalanceListener, OffsetAndMetadata
+* Use 0.10.0.1 for integration tests (dpkp 803)
+
+Consumer
+* KAFKA-3007: KafkaConsumer max_poll_records (dpkp 831)
+* Raise exception if given a non-str topic (ssaamm 824)
+* Immediately update metadata for pattern subscription (laz2 915)
+
+Producer
+* Update Partitioners for use with KafkaProducer (barrotsteindev 827)
+* Sort partitions before calling partitioner (ms7s 905)
+* Added ssl_password config option to KafkaProducer class (kierkegaard13 830)
+
+Client
+* Always check for request timeouts (dpkp 887)
+* When hostname lookup is necessary, do every connect (benauthor 812)
+
+Bugfixes
+* Fix errorcode check when socket.connect_ex raises an exception (guojh 907)
+* Fix fetcher bug when processing offset out of range (sibiryakov 860)
+* Fix possible request draining in ensure_active_group (dpkp 896)
+* Fix metadata refresh handling with 0.10+ brokers when topic list is empty (sibiryakov 867)
+* KafkaProducer should set timestamp in Message if provided (Drizzt1991 875)
+* Fix murmur2 bug handling python2 bytes that do not ascii encode (dpkp 815)
+* Monkeypatch max_in_flight_requests_per_connection when checking broker version (dpkp 834)
+* Fix message timestamp_type (qix 828)
+
+Logging / Error Messages
+* Always include an error for logging when the coordinator is marked dead (dpkp 890)
+* Only string-ify BrokerResponseError args if provided (dpkp 889)
+* Update warning re advertised.listeners / advertised.host.name (jeffwidman 878)
+* Fix unrecognized sasl_mechanism error message (sharego 883)
+
+Documentation
+* Add docstring for max_records (jeffwidman 897)
+* Fixup doc references to max_in_flight_requests_per_connection
+* Fix typo: passowrd --> password (jeffwidman 901)
+* Fix documentation typo 'Defualt' -> 'Default'. (rolando 895)
+* Added doc for `max_poll_records` option (Drizzt1991 881)
+* Remove old design notes from Kafka 8 era (jeffwidman 876)
+* Fix documentation typos (jeffwidman 874)
+* Fix quota violation exception message (dpkp 809)
+* Add comment for round robin partitioner with different subscriptions
+* Improve KafkaProducer docstring for retries configuration
+
+
+# 1.3.1 (Aug 8, 2016)
+
+Bugfixes
+* Fix AttributeError in BrokerConnectionMetrics after reconnecting
+
+
+# 1.3.0 (Aug 4, 2016)
+
+Incompatible Changes
+* Delete KafkaConnection class (dpkp 769)
+* Rename partition_assignment -> assignment in MemberMetadata for consistency
+* Move selectors34 and socketpair to kafka.vendor (dpkp 785)
+* Change api_version config to tuple; deprecate str with warning (dpkp 761)
+* Rename _DEFAULT_CONFIG -> DEFAULT_CONFIG in KafkaProducer (dpkp 788)
+
+Improvements
+* Vendor six 1.10.0 to eliminate runtime dependency (dpkp 785)
+* Add KafkaProducer and KafkaConsumer.metrics() with instrumentation similar to java client (dpkp 754 / 772 / 794)
+* Support Sasl PLAIN authentication (larsjsol PR 779)
+* Add checksum and size to RecordMetadata and ConsumerRecord (KAFKA-3196 / 770 / 594)
+* Use MetadataRequest v1 for 0.10+ api_version (dpkp 762)
+* Fix KafkaConsumer autocommit for 0.8 brokers (dpkp 756 / 706)
+* Improve error logging (dpkp 760 / 759)
+* Adapt benchmark scripts from https://github.com/mrafayaleem/kafka-jython (dpkp 754)
+* Add api_version config to KafkaClient (dpkp 761)
+* New Metadata method with_partitions() (dpkp 787)
+* Use socket_options configuration to setsockopts(). Default TCP_NODELAY (dpkp 783)
+* Expose selector type as config option (dpkp 764)
+* Drain pending requests to the coordinator before initiating group rejoin (dpkp 798)
+* Send combined size and payload bytes to socket to avoid potentially split packets with TCP_NODELAY (dpkp 797)
+
+Bugfixes
+* Ignore socket.error when checking for protocol out of sync prior to socket close (dpkp 792)
+* Fix offset fetch when partitions are manually assigned (KAFKA-3960 / 786)
+* Change pickle_method to use python3 special attributes (jpaulodit 777)
+* Fix ProduceResponse v2 throttle_time_ms
+* Always encode size with MessageSet (#771)
+* Avoid buffer overread when compressing messageset in KafkaProducer
+* Explicit format string argument indices for python 2.6 compatibility
+* Simplify RecordMetadata; short circuit callbacks (#768)
+* Fix autocommit when partitions assigned manually (KAFKA-3486 / #767 / #626)
+* Handle metadata updates during consumer rebalance (KAFKA-3117 / #766 / #701)
+* Add a consumer config option to exclude internal topics (KAFKA-2832 / #765)
+* Protect writes to wakeup socket with threading lock (#763 / #709)
+* Fetcher spending unnecessary time during metrics recording (KAFKA-3785)
+* Always use absolute_import (dpkp)
+
+Test / Fixtures
+* Catch select errors while capturing test fixture logs
+* Fix consumer group test race condition (dpkp 795)
+* Retry fixture failures on a different port (dpkp 796)
+* Dump fixture logs on failure
+
+Documentation
+* Fix misspelling of password (ssaamm 793)
+* Document the ssl_password config option (ssaamm 780)
+* Fix typo in KafkaConsumer documentation (ssaamm 775)
+* Expand consumer.fetcher inline comments
+* Update kafka configuration links -> 0.10.0.0 docs
+* Fixup metrics_sample_window_ms docstring in consumer
+
+
+# 1.2.5 (July 15, 2016)
+
+Bugfixes
+* Fix bug causing KafkaProducer to double-compress message batches on retry
+* Check for double-compressed messages in KafkaConsumer, log warning and optionally skip
+* Drop recursion in _unpack_message_set; only decompress once
+
+
+# 1.2.4 (July 8, 2016)
+
+Bugfixes
+* Update consumer_timeout_ms docstring - KafkaConsumer raises StopIteration, no longer ConsumerTimeout
+* Use explicit subscription state flag to handle seek() during message iteration
+* Fix consumer iteration on compacted topics (dpkp PR 752)
+* Support ssl_password config when loading cert chains (amckemie PR 750)
+
+
+# 1.2.3 (July 2, 2016)
+
+Patch Improvements
+* Fix gc error log: avoid AttributeError in _unregister_cleanup (dpkp PR 747)
+* Wakeup socket optimizations (dpkp PR 740)
+* Assert will be disabled by "python -O" (tyronecai PR 736)
+* Randomize order of topics/partitions processed by fetcher to improve balance (dpkp PR 732)
+* Allow client.check_version timeout to be set in Producer and Consumer constructors (eastlondoner PR 647)
+
+
+# 1.2.2 (June 21, 2016)
+
+Bugfixes
+* Clarify timeout unit in KafkaProducer close and flush (ms7s PR 734)
+* Avoid busy poll during metadata refresh failure with retry_backoff_ms (dpkp PR 733)
+* Check_version should scan nodes until version found or timeout (dpkp PR 731)
+* Fix bug which could cause least_loaded_node to always return the same unavailable node (dpkp PR 730)
+* Fix producer garbage collection with weakref in atexit handler (dpkp PR 728)
+* Close client selector to fix fd leak (msmith PR 729)
+* Tweak spelling mistake in error const (steve8918 PR 719)
+* Rearrange connection tests to separate legacy KafkaConnection
+
+
+# 1.2.1 (June 1, 2016)
+
+Bugfixes
+* Fix regression in MessageSet decoding wrt PartialMessages (#716)
+* Catch response decode errors and log details (#715)
+* Fix Legacy support url (#712 - JonasGroeger)
+* Update sphinx docs re 0.10 broker support
+
+
+# 1.2.0 (May 24, 2016)
+
+This release officially adds support for Kafka 0.10
+* Add protocol support for ApiVersionRequest (dpkp PR 678)
+* KAFKA-3025: Message v1 -- add timetamp and relative offsets (dpkp PR 693)
+* Use Fetch/Produce API v2 for brokers >= 0.10 (uses message format v1) (dpkp PR 694)
+* Use standard LZ4 framing for v1 messages / kafka 0.10 (dpkp PR 695)
+
+Consumers
+* Update SimpleConsumer / legacy protocol to handle compressed messages (paulcavallaro PR 684)
+
+Producers
+* KAFKA-3388: Fix expiration of batches sitting in the accumulator (dpkp PR 699)
+* KAFKA-3197: when max.in.flight.request.per.connection = 1, attempt to guarantee ordering (dpkp PR 698)
+* Don't use soon-to-be-reserved keyword await as function name (FutureProduceResult) (dpkp PR 697)
+
+Clients
+* Fix socket leaks in KafkaClient (dpkp PR 696)
+
+Documentation
+<none>
+
+Internals
+* Support SSL CRL [requires python 2.7.9+ / 3.4+] (vincentbernat PR 683)
+* Use original hostname for SSL checks (vincentbernat PR 682)
+* Always pass encoded message bytes to MessageSet.encode()
+* Raise ValueError on protocol encode/decode errors
+* Supplement socket.gaierror exception in BrokerConnection.connect() (erikbeebe PR 687)
+* BrokerConnection check_version: expect 0.9 to fail with CorrelationIdError
+* Fix small bug in Sensor (zackdever PR 679)
+
+
+# 1.1.1 (Apr 26, 2016)
+
+quick bugfixes
+* fix throttle_time_ms sensor handling (zackdever pr 667)
+* improve handling of disconnected sockets (easypost pr 666 / dpkp)
+* disable standard metadata refresh triggers during bootstrap (dpkp)
+* more predictable future callback/errback exceptions (zackdever pr 670)
+* avoid some exceptions in coordinator.__del__ (dpkp pr 668)
+
+
+# 1.1.0 (Apr 25, 2016)
+
+Consumers
+* Avoid resending FetchRequests that are pending on internal queue
+* Log debug messages when skipping fetched messages due to offset checks
+* KAFKA-3013: Include topic-partition in exception for expired batches
+* KAFKA-3318: clean up consumer logging and error messages
+* Improve unknown coordinator error handling
+* Improve auto-commit error handling when group_id is None
+* Add paused() API (zackdever PR 602)
+* Add default_offset_commit_callback to KafkaConsumer DEFAULT_CONFIGS
+
+Producers
+<none>
+
+Clients
+* Support SSL connections
+* Use selectors module for non-blocking IO
+* Refactor KafkaClient connection management
+* Fix AttributeError in __del__
+* SimpleClient: catch errors thrown by _get_leader_for_partition (zackdever PR 606)
+
+Documentation
+* Fix serializer/deserializer examples in README
+* Update max.block.ms docstring
+* Remove errant next(consumer) from consumer documentation
+* Add producer.flush() to usage docs
+
+Internals
+* Add initial metrics implementation (zackdever PR 637)
+* KAFKA-2136: support Fetch and Produce v1 (throttle_time_ms)
+* Use version-indexed lists for request/response protocol structs (dpkp PR 630)
+* Split kafka.common into kafka.structs and kafka.errors
+* Handle partial socket send() (dpkp PR 611)
+* Fix windows support (dpkp PR 603)
+* IPv6 support (TimEvens PR 615; Roguelazer PR 642)
+
+
+# 1.0.2 (Mar 14, 2016)
+
+Consumers
+* Improve KafkaConsumer Heartbeat handling (dpkp PR 583)
+* Fix KafkaConsumer.position bug (stefanth PR 578)
+* Raise TypeError when partition is not a TopicPartition (dpkp PR 587)
+* KafkaConsumer.poll should sleep to prevent tight-loops (dpkp PR 597)
+
+Producers
+* Fix producer threading bug that can crash sender (dpkp PR 590)
+* Fix bug in producer buffer pool reallocation (dpkp PR 585)
+* Remove spurious warnings when closing sync SimpleProducer (twm PR 567)
+* Fix FutureProduceResult.await() on python2.6 (dpkp)
+* Add optional timeout parameter to KafkaProducer.flush() (dpkp)
+* KafkaProducer Optimizations (zackdever PR 598)
+
+Clients
+* Improve error handling in SimpleClient.load_metadata_for_topics (dpkp)
+* Improve handling of KafkaClient.least_loaded_node failure (dpkp PR 588)
+
+Documentation
+* Fix KafkaError import error in docs (shichao-an PR 564)
+* Fix serializer / deserializer examples (scribu PR 573)
+
+Internals
+* Update to Kafka 0.9.0.1 for integration testing
+* Fix ifr.future.failure in conn.py (mortenlj PR 566)
+* Improve Zookeeper / Kafka Fixture management (dpkp)
+
+
+# 1.0.1 (Feb 19, 2016)
+
+Consumers
+* Add RangePartitionAssignor (and use as default); add assignor tests (dpkp PR 550)
+* Make sure all consumers are in same generation before stopping group test
+* Verify node ready before sending offset fetch request from coordinator
+* Improve warning when offset fetch request returns unknown topic / partition
+
+Producers
+* Warn if pending batches failed during flush
+* Fix concurrency bug in RecordAccumulator.ready()
+* Fix bug in SimpleBufferPool memory condition waiting / timeout
+* Support batch_size = 0 in producer buffers (dpkp PR 558)
+* Catch duplicate batch.done() calls [e.g., maybe_expire then a response errback]
+
+Clients
+
+Documentation
+* Improve kafka.cluster docstrings
+* Migrate load_example.py to KafkaProducer / KafkaConsumer
+
+Internals
+* Don't override system rcvbuf or sndbuf unless configured explicitly (dpkp PR 557)
+* Some attributes may not exist in __del__ if we failed assertions
+* Break up some circular references and close client wake pipes on __del__ (aisch PR 554)
+
+
+# 1.0.0 (Feb 15, 2016)
+
+This release includes significant code changes. Users of older kafka-python
+versions are encouraged to test upgrades before deploying to production as
+some interfaces and configuration options have changed.
+
+Users of SimpleConsumer / SimpleProducer / SimpleClient (formerly KafkaClient)
+from prior releases should migrate to KafkaConsumer / KafkaProducer. Low-level
+APIs (Simple*) are no longer being actively maintained and will be removed in a
+future release.
+
+For comprehensive API documentation, please see python help() / docstrings,
+kafka-python.readthedocs.org, or run `tox -e docs` from source to build
+documentation locally.
+
+Consumers
+* KafkaConsumer re-written to emulate the new 0.9 kafka consumer (java client)
+  and support coordinated consumer groups (feature requires >= 0.9.0.0 brokers)
+
+  * Methods no longer available:
+
+    * configure [initialize a new consumer instead]
+    * set_topic_partitions [use subscribe() or assign()]
+    * fetch_messages [use poll() or iterator interface]
+    * get_partition_offsets
+    * offsets [use committed(partition)]
+    * task_done [handled internally by auto-commit; or commit offsets manually]
+
+  * Configuration changes (consistent with updated java client):
+
+    * lots of new configuration parameters -- see docs for details
+    * auto_offset_reset: previously values were 'smallest' or 'largest', now
+      values are 'earliest' or 'latest'
+    * fetch_wait_max_ms is now fetch_max_wait_ms
+    * max_partition_fetch_bytes is now max_partition_fetch_bytes
+    * deserializer_class is now value_deserializer and key_deserializer
+    * auto_commit_enable is now enable_auto_commit
+    * auto_commit_interval_messages was removed
+    * socket_timeout_ms was removed
+    * refresh_leader_backoff_ms was removed
+
+* SimpleConsumer and MultiProcessConsumer are now deprecated and will be removed
+  in a future release. Users are encouraged to migrate to KafkaConsumer.
+
+Producers
+* new producer class: KafkaProducer. Exposes the same interface as official java client.
+  Async by default; returned future.get() can be called for synchronous blocking
+* SimpleProducer is now deprecated and will be removed in a future release. Users are
+  encouraged to migrate to KafkaProducer.
+
+Clients
+* synchronous KafkaClient renamed to SimpleClient. For backwards compatibility, you
+  will get a SimpleClient via `from kafka import KafkaClient`. This will change in
+  a future release.
+* All client calls use non-blocking IO under the hood.
+* Add probe method check_version() to infer broker versions.
+
+Documentation
+* Updated README and sphinx documentation to address new classes.
+* Docstring improvements to make python help() easier to use.
+
+Internals
+* Old protocol stack is deprecated. It has been moved to kafka.protocol.legacy
+  and may be removed in a future release.
+* Protocol layer re-written using Type classes, Schemas and Structs (modeled on
+  the java client).
+* Add support for LZ4 compression (including broken framing header checksum).
+
+
+# 0.9.5 (Dec 6, 2015)
+
+Consumers
+* Initial support for consumer coordinator: offsets only (toddpalino PR 420)
+* Allow blocking until some messages are received in SimpleConsumer (saaros PR 457)
+* Support subclass config changes in KafkaConsumer (zackdever PR 446)
+* Support retry semantics in MultiProcessConsumer (barricadeio PR 456)
+* Support partition_info in MultiProcessConsumer (scrapinghub PR 418)
+* Enable seek() to an absolute offset in SimpleConsumer (haosdent PR 412)
+* Add KafkaConsumer.close() (ucarion PR 426)
+
+Producers
+* Catch client.reinit() exceptions in async producer (dpkp)
+* Producer.stop() now blocks until async thread completes (dpkp PR 485)
+* Catch errors during load_metadata_for_topics in async producer (bschopman PR 467)
+* Add compression-level support for codecs that support it (trbs PR 454)
+* Fix translation of Java murmur2 code, fix byte encoding for Python 3 (chrischamberlin PR 439)
+* Only call stop() on not-stopped producer objects (docker-hub PR 435)
+* Allow null payload for deletion feature (scrapinghub PR 409)
+
+Clients
+* Use non-blocking io for broker aware requests (ecanzonieri PR 473)
+* Use debug logging level for metadata request (ecanzonieri PR 415)
+* Catch KafkaUnavailableError in _send_broker_aware_request (mutability PR 436)
+* Lower logging level on replica not available and commit (ecanzonieri PR 415)
+
+Documentation
+* Update docs and links wrt maintainer change (mumrah -> dpkp)
+
+Internals
+* Add py35 to tox testing
+* Update travis config to use container infrastructure
+* Add 0.8.2.2 and 0.9.0.0 resources for integration tests; update default official releases
+* new pylint disables for pylint 1.5.1 (zackdever PR 481)
+* Fix python3 / python2 comments re queue/Queue (dpkp)
+* Add Murmur2Partitioner to kafka __all__ imports (dpkp Issue 471)
+* Include LICENSE in PyPI sdist (koobs PR 441)
+
+# 0.9.4 (June 11, 2015)
+
+Consumers
+* Refactor SimpleConsumer internal fetch handling (dpkp PR 399)
+* Handle exceptions in SimpleConsumer commit() and reset_partition_offset() (dpkp PR 404)
+* Improve FailedPayloadsError handling in KafkaConsumer (dpkp PR 398)
+* KafkaConsumer: avoid raising KeyError in task_done (dpkp PR 389)
+* MultiProcessConsumer -- support configured partitions list (dpkp PR 380)
+* Fix SimpleConsumer leadership change handling (dpkp PR 393) 
+* Fix SimpleConsumer connection error handling (reAsOn2010 PR 392)
+* Improve Consumer handling of 'falsy' partition values (wting PR 342)
+* Fix _offsets call error in KafkaConsumer (hellais PR 376)
+* Fix str/bytes bug in KafkaConsumer (dpkp PR 365)
+* Register atexit handlers for consumer and producer thread/multiprocess cleanup (dpkp PR 360)
+* Always fetch commit offsets in base consumer unless group is None (dpkp PR 356)
+* Stop consumer threads on delete (dpkp PR 357)
+* Deprecate metadata_broker_list in favor of bootstrap_servers in KafkaConsumer (dpkp PR 340)
+* Support pass-through parameters in multiprocess consumer (scrapinghub PR 336)
+* Enable offset commit on SimpleConsumer.seek (ecanzonieri PR 350)
+* Improve multiprocess consumer partition distribution (scrapinghub PR 335)
+* Ignore messages with offset less than requested (wkiser PR 328)
+* Handle OffsetOutOfRange in SimpleConsumer (ecanzonieri PR 296)
+
+Producers
+* Add Murmur2Partitioner (dpkp PR 378)
+* Log error types in SimpleProducer and SimpleConsumer (dpkp PR 405)
+* SimpleProducer support configuration of fail_on_error (dpkp PR 396)
+* Deprecate KeyedProducer.send() (dpkp PR 379)
+* Further improvements to async producer code (dpkp PR 388)
+* Add more configuration parameters for async producer (dpkp)
+* Deprecate SimpleProducer batch_send=True in favor of async (dpkp)
+* Improve async producer error handling and retry logic (vshlapakov PR 331)
+* Support message keys in async producer (vshlapakov PR 329)
+* Use threading instead of multiprocessing for Async Producer (vshlapakov PR 330)
+* Stop threads on __del__ (chmduquesne PR 324)
+* Fix leadership failover handling in KeyedProducer (dpkp PR 314)
+
+KafkaClient
+* Add .topics property for list of known topics (dpkp)
+* Fix request / response order guarantee bug in KafkaClient (dpkp PR 403)
+* Improve KafkaClient handling of connection failures in _get_conn (dpkp)
+* Client clears local metadata cache before updating from server (dpkp PR 367)
+* KafkaClient should return a response or error for each request - enable better retry handling (dpkp PR 366)
+* Improve str/bytes conversion in KafkaClient and KafkaConsumer (dpkp PR 332)
+* Always return sorted partition ids in client.get_partition_ids_for_topic() (dpkp PR 315)
+
+Documentation
+* Cleanup Usage Documentation
+* Improve KafkaConsumer documentation (dpkp PR 341)
+* Update consumer documentation (sontek PR 317)
+* Add doc configuration for tox (sontek PR 316)
+* Switch to .rst doc format (sontek PR 321)
+* Fixup google groups link in README (sontek PR 320)
+* Automate documentation at kafka-python.readthedocs.org
+
+Internals
+* Switch integration testing from 0.8.2.0 to 0.8.2.1 (dpkp PR 402)
+* Fix most flaky tests, improve debug logging, improve fixture handling (dpkp)
+* General style cleanups (dpkp PR 394)
+* Raise error on duplicate topic-partition payloads in protocol grouping (dpkp)
+* Use module-level loggers instead of simply 'kafka' (dpkp)
+* Remove pkg_resources check for __version__ at runtime (dpkp PR 387)
+* Make external API consistently support python3 strings for topic (kecaps PR 361)
+* Fix correlation id overflow (dpkp PR 355)
+* Cleanup kafka/common structs (dpkp PR 338)
+* Use context managers in gzip_encode / gzip_decode (dpkp PR 337)
+* Save failed request as FailedPayloadsError attribute (jobevers PR 302)
+* Remove unused kafka.queue (mumrah)
+
+# 0.9.3 (Feb 3, 2015)
+
+* Add coveralls.io support (sontek PR 307)
+* Fix python2.6 threading.Event bug in ReentrantTimer (dpkp PR 312)
+* Add kafka 0.8.2.0 to travis integration tests (dpkp PR 310)
+* Auto-convert topics to utf-8 bytes in Producer (sontek PR 306)
+* Fix reference cycle between SimpleConsumer and ReentrantTimer (zhaopengzp PR 309)
+* Add Sphinx API docs (wedaly PR 282)
+* Handle additional error cases exposed by 0.8.2.0 kafka server (dpkp PR 295)
+* Refactor error class management (alexcb PR 289)
+* Expose KafkaConsumer in __all__ for easy imports (Dinoshauer PR 286)
+* SimpleProducer starts on random partition by default (alexcb PR 288)
+* Add keys to compressed messages (meandthewallaby PR 281)
+* Add new high-level KafkaConsumer class based on java client api (dpkp PR 234)
+* Add KeyedProducer.send_messages api (pubnub PR 277)
+* Fix consumer pending() method (jettify PR 276)
+* Update low-level demo in README (sunisdown PR 274)
+* Include key in KeyedProducer messages (se7entyse7en PR 268)
+* Fix SimpleConsumer timeout behavior in get_messages (dpkp PR 238)
+* Fix error in consumer.py test against max_buffer_size (rthille/wizzat PR 225/242)
+* Improve string concat performance on pypy / py3 (dpkp PR 233)
+* Reorg directory layout for consumer/producer/partitioners (dpkp/wizzat PR 232/243)
+* Add OffsetCommitContext (locationlabs PR 217)
+* Metadata Refactor (dpkp  PR 223)
+* Add Python 3 support (brutasse/wizzat - PR 227)
+* Minor cleanups - imports / README / PyPI classifiers (dpkp - PR 221)
+* Fix socket test (dpkp - PR 222)
+* Fix exception catching bug in test_failover_integration (zever - PR 216)
+
+# 0.9.2 (Aug 26, 2014)
+
+* Warn users that async producer does not reliably handle failures (dpkp - PR 213)
+* Fix spurious ConsumerFetchSizeTooSmall error in consumer (DataDog - PR 136)
+* Use PyLint for static error checking (dpkp - PR 208)
+* Strictly enforce str message type in producer.send_messages (dpkp - PR 211)
+* Add test timers via nose-timer plugin; list 10 slowest timings by default (dpkp)
+* Move fetching last known offset logic to a stand alone function (zever - PR 177)
+* Improve KafkaConnection and add more tests (dpkp - PR 196)
+* Raise TypeError if necessary when encoding strings (mdaniel - PR 204) 
+* Use Travis-CI to publish tagged releases to pypi (tkuhlman / mumrah)
+* Use official binary tarballs for integration tests and parallelize travis tests (dpkp - PR 193)
+* Improve new-topic creation handling (wizzat - PR 174)
+
+# 0.9.1 (Aug 10, 2014)
+
+* Add codec parameter to Producers to enable compression (patricklucas - PR 166)
+* Support IPv6 hosts and network (snaury - PR 169)
+* Remove dependency on distribute (patricklucas - PR 163)
+* Fix connection error timeout and improve tests (wizzat - PR 158)
+* SimpleProducer randomization of initial round robin ordering (alexcb - PR 139)
+* Fix connection timeout in KafkaClient and KafkaConnection (maciejkula - PR 161)
+* Fix seek + commit behavior (wizzat - PR 148) 
+
+
+# 0.9.0 (Mar 21, 2014)
+
+* Connection refactor and test fixes (wizzat - PR 134)
+* Fix when partition has no leader (mrtheb - PR 109)
+* Change Producer API to take topic as send argument, not as instance variable (rdiomar - PR 111)
+* Substantial refactor and Test Fixing (rdiomar - PR 88)
+* Fix Multiprocess Consumer on windows (mahendra - PR 62)
+* Improve fault tolerance; add integration tests (jimjh)
+* PEP8 / Flakes / Style cleanups (Vetoshkin Nikita; mrtheb - PR 59)
+* Setup Travis CI (jimjh - PR 53/54)
+* Fix import of BufferUnderflowError (jimjh - PR 49)
+* Fix code examples in README (StevenLeRoux - PR 47/48)
+
+# 0.8.0
+
+* Changing auto_commit to False in [SimpleConsumer](kafka/consumer.py), until 0.8.1 is release offset commits are unsupported
+* Adding fetch_size_bytes to SimpleConsumer constructor to allow for user-configurable fetch sizes
+* Allow SimpleConsumer to automatically increase the fetch size if a partial message is read and no other messages were read during that fetch request. The increase factor is 1.5
+* Exception classes moved to kafka.common

testbed/dpkp__kafka-python/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2015 David Arthur
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

testbed/dpkp__kafka-python/MANIFEST.in

@@ -0,0 +1,5 @@
+recursive-include kafka *.py
+include README.rst
+include LICENSE
+include AUTHORS.md
+include CHANGES.md

testbed/dpkp__kafka-python/Makefile

@@ -0,0 +1,59 @@
+# Some simple testing tasks (sorry, UNIX only).
+
+FLAGS=
+KAFKA_VERSION=0.11.0.2
+SCALA_VERSION=2.12
+
+setup:
+	pip install -r requirements-dev.txt
+	pip install -Ue .
+
+servers/$(KAFKA_VERSION)/kafka-bin:
+	KAFKA_VERSION=$(KAFKA_VERSION) SCALA_VERSION=$(SCALA_VERSION) ./build_integration.sh
+
+build-integration: servers/$(KAFKA_VERSION)/kafka-bin
+
+# Test and produce coverage using tox. This is the same as is run on Travis
+test37: build-integration
+	KAFKA_VERSION=$(KAFKA_VERSION) SCALA_VERSION=$(SCALA_VERSION) tox -e py37 -- $(FLAGS)
+
+test27: build-integration
+	KAFKA_VERSION=$(KAFKA_VERSION) SCALA_VERSION=$(SCALA_VERSION) tox -e py27 -- $(FLAGS)
+
+# Test using py.test directly if you want to use local python. Useful for other
+# platforms that require manual installation for C libraries, ie. Windows.
+test-local: build-integration
+	KAFKA_VERSION=$(KAFKA_VERSION) SCALA_VERSION=$(SCALA_VERSION) py.test \
+		--pylint --pylint-rcfile=pylint.rc --pylint-error-types=EF $(FLAGS) kafka test
+
+cov-local: build-integration
+	KAFKA_VERSION=$(KAFKA_VERSION) SCALA_VERSION=$(SCALA_VERSION) py.test \
+		--pylint --pylint-rcfile=pylint.rc --pylint-error-types=EF --cov=kafka \
+		--cov-config=.covrc --cov-report html $(FLAGS) kafka test
+	@echo "open file://`pwd`/htmlcov/index.html"
+
+# Check the readme for syntax errors, which can lead to invalid formatting on
+# PyPi homepage (https://pypi.python.org/pypi/kafka-python)
+check-readme:
+	python setup.py check -rms
+
+clean:
+	rm -rf `find . -name __pycache__`
+	rm -f `find . -type f -name '*.py[co]' `
+	rm -f `find . -type f -name '*~' `
+	rm -f `find . -type f -name '.*~' `
+	rm -f `find . -type f -name '@*' `
+	rm -f `find . -type f -name '#*#' `
+	rm -f `find . -type f -name '*.orig' `
+	rm -f `find . -type f -name '*.rej' `
+	rm -f .coverage
+	rm -rf htmlcov
+	rm -rf docs/_build/
+	rm -rf cover
+	rm -rf dist
+
+doc:
+	make -C docs html
+	@echo "open file://`pwd`/docs/_build/html/index.html"
+
+.PHONY: all test37 test27 test-local cov-local clean doc

testbed/dpkp__kafka-python/README.rst

@@ -0,0 +1,172 @@
+Kafka Python client
+------------------------
+
+.. image:: https://img.shields.io/badge/kafka-2.6%2C%202.5%2C%202.4%2C%202.3%2C%202.2%2C%202.1%2C%202.0%2C%201.1%2C%201.0%2C%200.11%2C%200.10%2C%200.9%2C%200.8-brightgreen.svg
+    :target: https://kafka-python.readthedocs.io/en/master/compatibility.html
+.. image:: https://img.shields.io/pypi/pyversions/kafka-python.svg
+    :target: https://pypi.python.org/pypi/kafka-python
+.. image:: https://coveralls.io/repos/dpkp/kafka-python/badge.svg?branch=master&service=github
+    :target: https://coveralls.io/github/dpkp/kafka-python?branch=master
+.. image:: https://travis-ci.org/dpkp/kafka-python.svg?branch=master
+    :target: https://travis-ci.org/dpkp/kafka-python
+.. image:: https://img.shields.io/badge/license-Apache%202-blue.svg
+    :target: https://github.com/dpkp/kafka-python/blob/master/LICENSE
+
+Python client for the Apache Kafka distributed stream processing system.
+kafka-python is designed to function much like the official java client, with a
+sprinkling of pythonic interfaces (e.g., consumer iterators).
+
+kafka-python is best used with newer brokers (0.9+), but is backwards-compatible with
+older versions (to 0.8.0). Some features will only be enabled on newer brokers.
+For example, fully coordinated consumer groups -- i.e., dynamic partition
+assignment to multiple consumers in the same group -- requires use of 0.9+ kafka
+brokers. Supporting this feature for earlier broker releases would require
+writing and maintaining custom leadership election and membership / health
+check code (perhaps using zookeeper or consul). For older brokers, you can
+achieve something similar by manually assigning different partitions to each
+consumer instance with config management tools like chef, ansible, etc. This
+approach will work fine, though it does not support rebalancing on failures.
+See <https://kafka-python.readthedocs.io/en/master/compatibility.html>
+for more details.
+
+Please note that the master branch may contain unreleased features. For release
+documentation, please see readthedocs and/or python's inline help.
+
+>>> pip install kafka-python
+
+
+KafkaConsumer
+*************
+
+KafkaConsumer is a high-level message consumer, intended to operate as similarly
+as possible to the official java client. Full support for coordinated
+consumer groups requires use of kafka brokers that support the Group APIs: kafka v0.9+.
+
+See <https://kafka-python.readthedocs.io/en/master/apidoc/KafkaConsumer.html>
+for API and configuration details.
+
+The consumer iterator returns ConsumerRecords, which are simple namedtuples
+that expose basic message attributes: topic, partition, offset, key, and value:
+
+>>> from kafka import KafkaConsumer
+>>> consumer = KafkaConsumer('my_favorite_topic')
+>>> for msg in consumer:
+...     print (msg)
+
+>>> # join a consumer group for dynamic partition assignment and offset commits
+>>> from kafka import KafkaConsumer
+>>> consumer = KafkaConsumer('my_favorite_topic', group_id='my_favorite_group')
+>>> for msg in consumer:
+...     print (msg)
+
+>>> # manually assign the partition list for the consumer
+>>> from kafka import TopicPartition
+>>> consumer = KafkaConsumer(bootstrap_servers='localhost:1234')
+>>> consumer.assign([TopicPartition('foobar', 2)])
+>>> msg = next(consumer)
+
+>>> # Deserialize msgpack-encoded values
+>>> consumer = KafkaConsumer(value_deserializer=msgpack.loads)
+>>> consumer.subscribe(['msgpackfoo'])
+>>> for msg in consumer:
+...     assert isinstance(msg.value, dict)
+
+>>> # Access record headers. The returned value is a list of tuples
+>>> # with str, bytes for key and value
+>>> for msg in consumer:
+...     print (msg.headers)
+
+>>> # Get consumer metrics
+>>> metrics = consumer.metrics()
+
+
+KafkaProducer
+*************
+
+KafkaProducer is a high-level, asynchronous message producer. The class is
+intended to operate as similarly as possible to the official java client.
+See <https://kafka-python.readthedocs.io/en/master/apidoc/KafkaProducer.html>
+for more details.
+
+>>> from kafka import KafkaProducer
+>>> producer = KafkaProducer(bootstrap_servers='localhost:1234')
+>>> for _ in range(100):
+...     producer.send('foobar', b'some_message_bytes')
+
+>>> # Block until a single message is sent (or timeout)
+>>> future = producer.send('foobar', b'another_message')
+>>> result = future.get(timeout=60)
+
+>>> # Block until all pending messages are at least put on the network
+>>> # NOTE: This does not guarantee delivery or success! It is really
+>>> # only useful if you configure internal batching using linger_ms
+>>> producer.flush()
+
+>>> # Use a key for hashed-partitioning
+>>> producer.send('foobar', key=b'foo', value=b'bar')
+
+>>> # Serialize json messages
+>>> import json
+>>> producer = KafkaProducer(value_serializer=lambda v: json.dumps(v).encode('utf-8'))
+>>> producer.send('fizzbuzz', {'foo': 'bar'})
+
+>>> # Serialize string keys
+>>> producer = KafkaProducer(key_serializer=str.encode)
+>>> producer.send('flipflap', key='ping', value=b'1234')
+
+>>> # Compress messages
+>>> producer = KafkaProducer(compression_type='gzip')
+>>> for i in range(1000):
+...     producer.send('foobar', b'msg %d' % i)
+
+>>> # Include record headers. The format is list of tuples with string key
+>>> # and bytes value.
+>>> producer.send('foobar', value=b'c29tZSB2YWx1ZQ==', headers=[('content-encoding', b'base64')])
+
+>>> # Get producer performance metrics
+>>> metrics = producer.metrics()
+
+
+Thread safety
+*************
+
+The KafkaProducer can be used across threads without issue, unlike the
+KafkaConsumer which cannot.
+
+While it is possible to use the KafkaConsumer in a thread-local manner,
+multiprocessing is recommended.
+
+
+Compression
+***********
+
+kafka-python supports the following compression formats:
+
+- gzip
+- LZ4
+- Snappy
+- Zstandard (zstd)
+
+gzip is supported natively, the others require installing additional libraries.
+See <https://kafka-python.readthedocs.io/en/master/install.html> for more information.
+
+
+Optimized CRC32 Validation
+**************************
+
+Kafka uses CRC32 checksums to validate messages. kafka-python includes a pure
+python implementation for compatibility. To improve performance for high-throughput
+applications, kafka-python will use `crc32c` for optimized native code if installed.
+See <https://kafka-python.readthedocs.io/en/master/install.html> for installation instructions.
+See https://pypi.org/project/crc32c/ for details on the underlying crc32c lib.
+
+
+Protocol
+********
+
+A secondary goal of kafka-python is to provide an easy-to-use protocol layer
+for interacting with kafka brokers via the python repl. This is useful for
+testing, probing, and general experimentation. The protocol support is
+leveraged to enable a KafkaClient.check_version() method that
+probes a kafka broker and attempts to identify which version it is running
+(0.8.0 to 2.6+).

testbed/dpkp__kafka-python/benchmarks/README.md

@@ -0,0 +1,4 @@
+The `record_batch_*` benchmarks in this section are written using
+``pyperf`` library, created by Victor Stinner. For more information on
+how to get reliable results of test runs please consult
+https://pyperf.readthedocs.io/en/latest/run_benchmark.html.

testbed/dpkp__kafka-python/benchmarks/consumer_performance.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+# Adapted from https://github.com/mrafayaleem/kafka-jython
+
+from __future__ import absolute_import, print_function
+
+import argparse
+import logging
+import pprint
+import sys
+import threading
+import traceback
+
+from kafka.vendor.six.moves import range
+
+from kafka import KafkaConsumer, KafkaProducer
+from test.fixtures import KafkaFixture, ZookeeperFixture
+
+logging.basicConfig(level=logging.ERROR)
+
+
+def start_brokers(n):
+    print('Starting {0} {1}-node cluster...'.format(KafkaFixture.kafka_version, n))
+    print('-> 1 Zookeeper')
+    zk = ZookeeperFixture.instance()
+    print('---> {0}:{1}'.format(zk.host, zk.port))
+    print()
+
+    partitions = min(n, 3)
+    replicas = min(n, 3)
+    print('-> {0} Brokers [{1} partitions / {2} replicas]'.format(n, partitions, replicas))
+    brokers = [
+        KafkaFixture.instance(i, zk, zk_chroot='',
+                              partitions=partitions, replicas=replicas)
+        for i in range(n)
+    ]
+    for broker in brokers:
+        print('---> {0}:{1}'.format(broker.host, broker.port))
+    print()
+    return brokers
+
+
+class ConsumerPerformance(object):
+
+    @staticmethod
+    def run(args):
+        try:
+            props = {}
+            for prop in args.consumer_config:
+                k, v = prop.split('=')
+                try:
+                    v = int(v)
+                except ValueError:
+                    pass
+                if v == 'None':
+                    v = None
+                props[k] = v
+
+            if args.brokers:
+                brokers = start_brokers(args.brokers)
+                props['bootstrap_servers'] = ['{0}:{1}'.format(broker.host, broker.port)
+                                              for broker in brokers]
+                print('---> bootstrap_servers={0}'.format(props['bootstrap_servers']))
+                print()
+
+                print('-> Producing records')
+                record = bytes(bytearray(args.record_size))
+                producer = KafkaProducer(compression_type=args.fixture_compression,
+                                         **props)
+                for i in range(args.num_records):
+                    producer.send(topic=args.topic, value=record)
+                producer.flush()
+                producer.close()
+                print('-> OK!')
+                print()
+
+            print('Initializing Consumer...')
+            props['auto_offset_reset'] = 'earliest'
+            if 'consumer_timeout_ms' not in props:
+                props['consumer_timeout_ms'] = 10000
+            props['metrics_sample_window_ms'] = args.stats_interval * 1000
+            for k, v in props.items():
+                print('---> {0}={1}'.format(k, v))
+            consumer = KafkaConsumer(args.topic, **props)
+            print('---> group_id={0}'.format(consumer.config['group_id']))
+            print('---> report stats every {0} secs'.format(args.stats_interval))
+            print('---> raw metrics? {0}'.format(args.raw_metrics))
+            timer_stop = threading.Event()
+            timer = StatsReporter(args.stats_interval, consumer,
+                                  event=timer_stop,
+                                  raw_metrics=args.raw_metrics)
+            timer.start()
+            print('-> OK!')
+            print()
+
+            records = 0
+            for msg in consumer:
+                records += 1
+                if records >= args.num_records:
+                    break
+            print('Consumed {0} records'.format(records))
+
+            timer_stop.set()
+
+        except Exception:
+            exc_info = sys.exc_info()
+            traceback.print_exception(*exc_info)
+            sys.exit(1)
+
+
+class StatsReporter(threading.Thread):
+    def __init__(self, interval, consumer, event=None, raw_metrics=False):
+        super(StatsReporter, self).__init__()
+        self.interval = interval
+        self.consumer = consumer
+        self.event = event
+        self.raw_metrics = raw_metrics
+
+    def print_stats(self):
+        metrics = self.consumer.metrics()
+        if self.raw_metrics:
+            pprint.pprint(metrics)
+        else:
+            print('{records-consumed-rate} records/sec ({bytes-consumed-rate} B/sec),'
+                  ' {fetch-latency-avg} latency,'
+                  ' {fetch-rate} fetch/s,'
+                  ' {fetch-size-avg} fetch size,'
+                  ' {records-lag-max} max record lag,'
+                  ' {records-per-request-avg} records/req'
+                  .format(**metrics['consumer-fetch-manager-metrics']))
+
+
+    def print_final(self):
+        self.print_stats()
+
+    def run(self):
+        while self.event and not self.event.wait(self.interval):
+            self.print_stats()
+        else:
+            self.print_final()
+
+
+def get_args_parser():
+    parser = argparse.ArgumentParser(
+        description='This tool is used to verify the consumer performance.')
+
+    parser.add_argument(
+        '--topic', type=str,
+        help='Topic for consumer test',
+        default='kafka-python-benchmark-test')
+    parser.add_argument(
+        '--num-records', type=int,
+        help='number of messages to consume',
+        default=1000000)
+    parser.add_argument(
+        '--record-size', type=int,
+        help='message size in bytes',
+        default=100)
+    parser.add_argument(
+        '--consumer-config', type=str, nargs='+', default=(),
+        help='kafka consumer related configuration properties like '
+             'bootstrap_servers,client_id etc..')
+    parser.add_argument(
+        '--fixture-compression', type=str,
+        help='specify a compression type for use with broker fixtures / producer')
+    parser.add_argument(
+        '--brokers', type=int,
+        help='Number of kafka brokers to start',
+        default=0)
+    parser.add_argument(
+        '--stats-interval', type=int,
+        help='Interval in seconds for stats reporting to console',
+        default=5)
+    parser.add_argument(
+        '--raw-metrics', action='store_true',
+        help='Enable this flag to print full metrics dict on each interval')
+    return parser
+
+
+if __name__ == '__main__':
+    args = get_args_parser().parse_args()
+    ConsumerPerformance.run(args)

testbed/dpkp__kafka-python/benchmarks/load_example.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import threading, logging, time
+
+from kafka import KafkaConsumer, KafkaProducer
+
+msg_size = 524288
+
+producer_stop = threading.Event()
+consumer_stop = threading.Event()
+
+class Producer(threading.Thread):
+    big_msg = b'1' * msg_size
+
+    def run(self):
+        producer = KafkaProducer(bootstrap_servers='localhost:9092')
+        self.sent = 0
+
+        while not producer_stop.is_set():
+            producer.send('my-topic', self.big_msg)
+            self.sent += 1
+        producer.flush()
+
+
+class Consumer(threading.Thread):
+
+    def run(self):
+        consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
+                                 auto_offset_reset='earliest')
+        consumer.subscribe(['my-topic'])
+        self.valid = 0
+        self.invalid = 0
+
+        for message in consumer:
+            if len(message.value) == msg_size:
+                self.valid += 1
+            else:
+                self.invalid += 1
+
+            if consumer_stop.is_set():
+                break
+
+        consumer.close()
+
+def main():
+    threads = [
+        Producer(),
+        Consumer()
+    ]
+
+    for t in threads:
+        t.start()
+
+    time.sleep(10)
+    producer_stop.set()
+    consumer_stop.set()
+    print('Messages sent: %d' % threads[0].sent)
+    print('Messages recvd: %d' % threads[1].valid)
+    print('Messages invalid: %d' % threads[1].invalid)
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        format='%(asctime)s.%(msecs)s:%(name)s:%(thread)d:%(levelname)s:%(process)d:%(message)s',
+        level=logging.INFO
+        )
+    main()

testbed/dpkp__kafka-python/benchmarks/producer_performance.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python
+# Adapted from https://github.com/mrafayaleem/kafka-jython
+
+from __future__ import absolute_import, print_function
+
+import argparse
+import pprint
+import sys
+import threading
+import traceback
+
+from kafka.vendor.six.moves import range
+
+from kafka import KafkaProducer
+from test.fixtures import KafkaFixture, ZookeeperFixture
+
+
+def start_brokers(n):
+    print('Starting {0} {1}-node cluster...'.format(KafkaFixture.kafka_version, n))
+    print('-> 1 Zookeeper')
+    zk = ZookeeperFixture.instance()
+    print('---> {0}:{1}'.format(zk.host, zk.port))
+    print()
+
+    partitions = min(n, 3)
+    replicas = min(n, 3)
+    print('-> {0} Brokers [{1} partitions / {2} replicas]'.format(n, partitions, replicas))
+    brokers = [
+        KafkaFixture.instance(i, zk, zk_chroot='',
+                              partitions=partitions, replicas=replicas)
+        for i in range(n)
+    ]
+    for broker in brokers:
+        print('---> {0}:{1}'.format(broker.host, broker.port))
+    print()
+    return brokers
+
+
+class ProducerPerformance(object):
+
+    @staticmethod
+    def run(args):
+        try:
+            props = {}
+            for prop in args.producer_config:
+                k, v = prop.split('=')
+                try:
+                    v = int(v)
+                except ValueError:
+                    pass
+                if v == 'None':
+                    v = None
+                props[k] = v
+
+            if args.brokers:
+                brokers = start_brokers(args.brokers)
+                props['bootstrap_servers'] = ['{0}:{1}'.format(broker.host, broker.port)
+                                              for broker in brokers]
+                print("---> bootstrap_servers={0}".format(props['bootstrap_servers']))
+                print()
+                print('-> OK!')
+                print()
+
+            print('Initializing producer...')
+            record = bytes(bytearray(args.record_size))
+            props['metrics_sample_window_ms'] = args.stats_interval * 1000
+
+            producer = KafkaProducer(**props)
+            for k, v in props.items():
+                print('---> {0}={1}'.format(k, v))
+            print('---> send {0} byte records'.format(args.record_size))
+            print('---> report stats every {0} secs'.format(args.stats_interval))
+            print('---> raw metrics? {0}'.format(args.raw_metrics))
+            timer_stop = threading.Event()
+            timer = StatsReporter(args.stats_interval, producer,
+                                  event=timer_stop,
+                                  raw_metrics=args.raw_metrics)
+            timer.start()
+            print('-> OK!')
+            print()
+
+            for i in range(args.num_records):
+                producer.send(topic=args.topic, value=record)
+            producer.flush()
+
+            timer_stop.set()
+
+        except Exception:
+            exc_info = sys.exc_info()
+            traceback.print_exception(*exc_info)
+            sys.exit(1)
+
+
+class StatsReporter(threading.Thread):
+    def __init__(self, interval, producer, event=None, raw_metrics=False):
+        super(StatsReporter, self).__init__()
+        self.interval = interval
+        self.producer = producer
+        self.event = event
+        self.raw_metrics = raw_metrics
+
+    def print_stats(self):
+        metrics = self.producer.metrics()
+        if self.raw_metrics:
+            pprint.pprint(metrics)
+        else:
+            print('{record-send-rate} records/sec ({byte-rate} B/sec),'
+                  ' {request-latency-avg} latency,'
+                  ' {record-size-avg} record size,'
+                  ' {batch-size-avg} batch size,'
+                  ' {records-per-request-avg} records/req'
+                  .format(**metrics['producer-metrics']))
+
+    def print_final(self):
+        self.print_stats()
+
+    def run(self):
+        while self.event and not self.event.wait(self.interval):
+            self.print_stats()
+        else:
+            self.print_final()
+
+
+def get_args_parser():
+    parser = argparse.ArgumentParser(
+        description='This tool is used to verify the producer performance.')
+
+    parser.add_argument(
+        '--topic', type=str,
+        help='Topic name for test',
+        default='kafka-python-benchmark-test')
+    parser.add_argument(
+        '--num-records', type=int,
+        help='number of messages to produce',
+        default=1000000)
+    parser.add_argument(
+        '--record-size', type=int,
+        help='message size in bytes',
+        default=100)
+    parser.add_argument(
+        '--producer-config', type=str, nargs='+', default=(),
+        help='kafka producer related configuaration properties like '
+             'bootstrap_servers,client_id etc..')
+    parser.add_argument(
+        '--brokers', type=int,
+        help='Number of kafka brokers to start',
+        default=0)
+    parser.add_argument(
+        '--stats-interval', type=int,
+        help='Interval in seconds for stats reporting to console',
+        default=5)
+    parser.add_argument(
+        '--raw-metrics', action='store_true',
+        help='Enable this flag to print full metrics dict on each interval')
+    return parser
+
+
+if __name__ == '__main__':
+    args = get_args_parser().parse_args()
+    ProducerPerformance.run(args)

testbed/dpkp__kafka-python/benchmarks/record_batch_compose.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+from __future__ import print_function
+import hashlib
+import itertools
+import os
+import random
+
+import pyperf
+
+from kafka.record.memory_records import MemoryRecordsBuilder
+
+
+DEFAULT_BATCH_SIZE = 1600 * 1024
+KEY_SIZE = 6
+VALUE_SIZE = 60
+TIMESTAMP_RANGE = [1505824130000, 1505824140000]
+
+# With values above v1 record is 100 bytes, so 10 000 bytes for 100 messages
+MESSAGES_PER_BATCH = 100
+
+
+def random_bytes(length):
+    buffer = bytearray(length)
+    for i in range(length):
+        buffer[i] = random.randint(0, 255)
+    return bytes(buffer)
+
+
+def prepare():
+    return iter(itertools.cycle([
+        (random_bytes(KEY_SIZE),
+         random_bytes(VALUE_SIZE),
+         random.randint(*TIMESTAMP_RANGE)
+         )
+        for _ in range(int(MESSAGES_PER_BATCH * 1.94))
+    ]))
+
+
+def finalize(results):
+    # Just some strange code to make sure PyPy does execute the main code
+    # properly, without optimizing it away
+    hash_val = hashlib.md5()
+    for buf in results:
+        hash_val.update(buf)
+    print(hash_val, file=open(os.devnull, "w"))
+
+
+def func(loops, magic):
+    # Jit can optimize out the whole function if the result is the same each
+    # time, so we need some randomized input data )
+    precomputed_samples = prepare()
+    results = []
+
+    # Main benchmark code.
+    t0 = pyperf.perf_counter()
+    for _ in range(loops):
+        batch = MemoryRecordsBuilder(
+            magic, batch_size=DEFAULT_BATCH_SIZE, compression_type=0)
+        for _ in range(MESSAGES_PER_BATCH):
+            key, value, timestamp = next(precomputed_samples)
+            size = batch.append(
+                timestamp=timestamp, key=key, value=value)
+            assert size
+        batch.close()
+        results.append(batch.buffer())
+
+    res = pyperf.perf_counter() - t0
+
+    finalize(results)
+
+    return res
+
+
+runner = pyperf.Runner()
+runner.bench_time_func('batch_append_v0', func, 0)
+runner.bench_time_func('batch_append_v1', func, 1)
+runner.bench_time_func('batch_append_v2', func, 2)

testbed/dpkp__kafka-python/benchmarks/record_batch_read.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import hashlib
+import itertools
+import os
+import random
+
+import pyperf
+
+from kafka.record.memory_records import MemoryRecords, MemoryRecordsBuilder
+
+
+DEFAULT_BATCH_SIZE = 1600 * 1024
+KEY_SIZE = 6
+VALUE_SIZE = 60
+TIMESTAMP_RANGE = [1505824130000, 1505824140000]
+
+BATCH_SAMPLES = 5
+MESSAGES_PER_BATCH = 100
+
+
+def random_bytes(length):
+    buffer = bytearray(length)
+    for i in range(length):
+        buffer[i] = random.randint(0, 255)
+    return bytes(buffer)
+
+
+def prepare(magic):
+    samples = []
+    for _ in range(BATCH_SAMPLES):
+        batch = MemoryRecordsBuilder(
+            magic, batch_size=DEFAULT_BATCH_SIZE, compression_type=0)
+        for _ in range(MESSAGES_PER_BATCH):
+            size = batch.append(
+                random.randint(*TIMESTAMP_RANGE),
+                random_bytes(KEY_SIZE),
+                random_bytes(VALUE_SIZE),
+                headers=[])
+            assert size
+        batch.close()
+        samples.append(bytes(batch.buffer()))
+
+    return iter(itertools.cycle(samples))
+
+
+def finalize(results):
+    # Just some strange code to make sure PyPy does execute the code above
+    # properly
+    hash_val = hashlib.md5()
+    for buf in results:
+        hash_val.update(buf)
+    print(hash_val, file=open(os.devnull, "w"))
+
+
+def func(loops, magic):
+    # Jit can optimize out the whole function if the result is the same each
+    # time, so we need some randomized input data )
+    precomputed_samples = prepare(magic)
+    results = []
+
+    # Main benchmark code.
+    batch_data = next(precomputed_samples)
+    t0 = pyperf.perf_counter()
+    for _ in range(loops):
+        records = MemoryRecords(batch_data)
+        while records.has_next():
+            batch = records.next_batch()
+            batch.validate_crc()
+            for record in batch:
+                results.append(record.value)
+
+    res = pyperf.perf_counter() - t0
+    finalize(results)
+
+    return res
+
+
+runner = pyperf.Runner()
+runner.bench_time_func('batch_read_v0', func, 0)
+runner.bench_time_func('batch_read_v1', func, 1)
+runner.bench_time_func('batch_read_v2', func, 2)

testbed/dpkp__kafka-python/benchmarks/varint_speed.py

@@ -0,0 +1,443 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import pyperf
+from kafka.vendor import six
+
+
+test_data = [
+    (b"\x00", 0),
+    (b"\x01", -1),
+    (b"\x02", 1),
+    (b"\x7E", 63),
+    (b"\x7F", -64),
+    (b"\x80\x01", 64),
+    (b"\x81\x01", -65),
+    (b"\xFE\x7F", 8191),
+    (b"\xFF\x7F", -8192),
+    (b"\x80\x80\x01", 8192),
+    (b"\x81\x80\x01", -8193),
+    (b"\xFE\xFF\x7F", 1048575),
+    (b"\xFF\xFF\x7F", -1048576),
+    (b"\x80\x80\x80\x01", 1048576),
+    (b"\x81\x80\x80\x01", -1048577),
+    (b"\xFE\xFF\xFF\x7F", 134217727),
+    (b"\xFF\xFF\xFF\x7F", -134217728),
+    (b"\x80\x80\x80\x80\x01", 134217728),
+    (b"\x81\x80\x80\x80\x01", -134217729),
+    (b"\xFE\xFF\xFF\xFF\x7F", 17179869183),
+    (b"\xFF\xFF\xFF\xFF\x7F", -17179869184),
+    (b"\x80\x80\x80\x80\x80\x01", 17179869184),
+    (b"\x81\x80\x80\x80\x80\x01", -17179869185),
+    (b"\xFE\xFF\xFF\xFF\xFF\x7F", 2199023255551),
+    (b"\xFF\xFF\xFF\xFF\xFF\x7F", -2199023255552),
+    (b"\x80\x80\x80\x80\x80\x80\x01", 2199023255552),
+    (b"\x81\x80\x80\x80\x80\x80\x01", -2199023255553),
+    (b"\xFE\xFF\xFF\xFF\xFF\xFF\x7F", 281474976710655),
+    (b"\xFF\xFF\xFF\xFF\xFF\xFF\x7F", -281474976710656),
+    (b"\x80\x80\x80\x80\x80\x80\x80\x01", 281474976710656),
+    (b"\x81\x80\x80\x80\x80\x80\x80\x01", -281474976710657),
+    (b"\xFE\xFF\xFF\xFF\xFF\xFF\xFF\x7F", 36028797018963967),
+    (b"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F", -36028797018963968),
+    (b"\x80\x80\x80\x80\x80\x80\x80\x80\x01", 36028797018963968),
+    (b"\x81\x80\x80\x80\x80\x80\x80\x80\x01", -36028797018963969),
+    (b"\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F", 4611686018427387903),
+    (b"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F", -4611686018427387904),
+    (b"\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01", 4611686018427387904),
+    (b"\x81\x80\x80\x80\x80\x80\x80\x80\x80\x01", -4611686018427387905),
+]
+
+
+BENCH_VALUES_ENC = [
+    60,  # 1 byte
+    -8192,  # 2 bytes
+    1048575,  # 3 bytes
+    134217727,  # 4 bytes
+    -17179869184,  # 5 bytes
+    2199023255551,  # 6 bytes
+]
+
+BENCH_VALUES_DEC = [
+    b"\x7E",  # 1 byte
+    b"\xFF\x7F",  # 2 bytes
+    b"\xFE\xFF\x7F",  # 3 bytes
+    b"\xFF\xFF\xFF\x7F",  # 4 bytes
+    b"\x80\x80\x80\x80\x01",  # 5 bytes
+    b"\xFE\xFF\xFF\xFF\xFF\x7F",  # 6 bytes
+]
+BENCH_VALUES_DEC = list(map(bytearray, BENCH_VALUES_DEC))
+
+
+def _assert_valid_enc(enc_func):
+    for encoded, decoded in test_data:
+        assert enc_func(decoded) == encoded, decoded
+
+
+def _assert_valid_dec(dec_func):
+    for encoded, decoded in test_data:
+        res, pos = dec_func(bytearray(encoded))
+        assert res == decoded, (decoded, res)
+        assert pos == len(encoded), (decoded, pos)
+
+
+def _assert_valid_size(size_func):
+    for encoded, decoded in test_data:
+        assert size_func(decoded) == len(encoded), decoded
+
+
+def encode_varint_1(num):
+    """ Encode an integer to a varint presentation. See
+    https://developers.google.com/protocol-buffers/docs/encoding?csw=1#varints
+    on how those can be produced.
+
+        Arguments:
+            num (int): Value to encode
+
+        Returns:
+            bytearray: Encoded presentation of integer with length from 1 to 10
+                 bytes
+    """
+    # Shift sign to the end of number
+    num = (num << 1) ^ (num >> 63)
+    # Max 10 bytes. We assert those are allocated
+    buf = bytearray(10)
+
+    for i in range(10):
+        # 7 lowest bits from the number and set 8th if we still have pending
+        # bits left to encode
+        buf[i] = num & 0x7f | (0x80 if num > 0x7f else 0)
+        num = num >> 7
+        if num == 0:
+            break
+    else:
+        # Max size of endcoded double is 10 bytes for unsigned values
+        raise ValueError("Out of double range")
+    return buf[:i + 1]
+
+_assert_valid_enc(encode_varint_1)
+
+
+def encode_varint_2(value, int2byte=six.int2byte):
+    value = (value << 1) ^ (value >> 63)
+
+    bits = value & 0x7f
+    value >>= 7
+    res = b""
+    while value:
+        res += int2byte(0x80 | bits)
+        bits = value & 0x7f
+        value >>= 7
+    return res + int2byte(bits)
+
+_assert_valid_enc(encode_varint_2)
+
+
+def encode_varint_3(value, buf):
+    append = buf.append
+    value = (value << 1) ^ (value >> 63)
+
+    bits = value & 0x7f
+    value >>= 7
+    while value:
+        append(0x80 | bits)
+        bits = value & 0x7f
+        value >>= 7
+    append(bits)
+    return value
+
+
+for encoded, decoded in test_data:
+    res = bytearray()
+    encode_varint_3(decoded, res)
+    assert res == encoded
+
+
+def encode_varint_4(value, int2byte=six.int2byte):
+    value = (value << 1) ^ (value >> 63)
+
+    if value <= 0x7f:  # 1 byte
+        return int2byte(value)
+    if value <= 0x3fff:  # 2 bytes
+        return int2byte(0x80 | (value & 0x7f)) + int2byte(value >> 7)
+    if value <= 0x1fffff:  # 3 bytes
+        return int2byte(0x80 | (value & 0x7f)) + \
+            int2byte(0x80 | ((value >> 7) & 0x7f)) + \
+            int2byte(value >> 14)
+    if value <= 0xfffffff:  # 4 bytes
+        return int2byte(0x80 | (value & 0x7f)) + \
+            int2byte(0x80 | ((value >> 7) & 0x7f)) + \
+            int2byte(0x80 | ((value >> 14) & 0x7f)) + \
+            int2byte(value >> 21)
+    if value <= 0x7ffffffff:  # 5 bytes
+        return int2byte(0x80 | (value & 0x7f)) + \
+            int2byte(0x80 | ((value >> 7) & 0x7f)) + \
+            int2byte(0x80 | ((value >> 14) & 0x7f)) + \
+            int2byte(0x80 | ((value >> 21) & 0x7f)) + \
+            int2byte(value >> 28)
+    else:
+        # Return to general algorithm
+        bits = value & 0x7f
+        value >>= 7
+        res = b""
+        while value:
+            res += int2byte(0x80 | bits)
+            bits = value & 0x7f
+            value >>= 7
+        return res + int2byte(bits)
+
+
+_assert_valid_enc(encode_varint_4)
+
+# import dis
+# dis.dis(encode_varint_4)
+
+
+def encode_varint_5(value, buf, pos=0):
+    value = (value << 1) ^ (value >> 63)
+
+    bits = value & 0x7f
+    value >>= 7
+    while value:
+        buf[pos] = 0x80 | bits
+        bits = value & 0x7f
+        value >>= 7
+        pos += 1
+    buf[pos] = bits
+    return pos + 1
+
+for encoded, decoded in test_data:
+    res = bytearray(10)
+    written = encode_varint_5(decoded, res)
+    assert res[:written] == encoded
+
+
+def encode_varint_6(value, buf):
+    append = buf.append
+    value = (value << 1) ^ (value >> 63)
+
+    if value <= 0x7f:  # 1 byte
+        append(value)
+        return 1
+    if value <= 0x3fff:  # 2 bytes
+        append(0x80 | (value & 0x7f))
+        append(value >> 7)
+        return 2
+    if value <= 0x1fffff:  # 3 bytes
+        append(0x80 | (value & 0x7f))
+        append(0x80 | ((value >> 7) & 0x7f))
+        append(value >> 14)
+        return 3
+    if value <= 0xfffffff:  # 4 bytes
+        append(0x80 | (value & 0x7f))
+        append(0x80 | ((value >> 7) & 0x7f))
+        append(0x80 | ((value >> 14) & 0x7f))
+        append(value >> 21)
+        return 4
+    if value <= 0x7ffffffff:  # 5 bytes
+        append(0x80 | (value & 0x7f))
+        append(0x80 | ((value >> 7) & 0x7f))
+        append(0x80 | ((value >> 14) & 0x7f))
+        append(0x80 | ((value >> 21) & 0x7f))
+        append(value >> 28)
+        return 5
+    else:
+        # Return to general algorithm
+        bits = value & 0x7f
+        value >>= 7
+        i = 0
+        while value:
+            append(0x80 | bits)
+            bits = value & 0x7f
+            value >>= 7
+            i += 1
+    append(bits)
+    return i
+
+
+for encoded, decoded in test_data:
+    res = bytearray()
+    encode_varint_6(decoded, res)
+    assert res == encoded
+
+
+def size_of_varint_1(value):
+    """ Number of bytes needed to encode an integer in variable-length format.
+    """
+    value = (value << 1) ^ (value >> 63)
+    res = 0
+    while True:
+        res += 1
+        value = value >> 7
+        if value == 0:
+            break
+    return res
+
+_assert_valid_size(size_of_varint_1)
+
+
+def size_of_varint_2(value):
+    """ Number of bytes needed to encode an integer in variable-length format.
+    """
+    value = (value << 1) ^ (value >> 63)
+    if value <= 0x7f:
+        return 1
+    if value <= 0x3fff:
+        return 2
+    if value <= 0x1fffff:
+        return 3
+    if value <= 0xfffffff:
+        return 4
+    if value <= 0x7ffffffff:
+        return 5
+    if value <= 0x3ffffffffff:
+        return 6
+    if value <= 0x1ffffffffffff:
+        return 7
+    if value <= 0xffffffffffffff:
+        return 8
+    if value <= 0x7fffffffffffffff:
+        return 9
+    return 10
+
+_assert_valid_size(size_of_varint_2)
+
+
+if six.PY3:
+    def _read_byte(memview, pos):
+        """ Read a byte from memoryview as an integer
+
+            Raises:
+                IndexError: if position is out of bounds
+        """
+        return memview[pos]
+else:
+    def _read_byte(memview, pos):
+        """ Read a byte from memoryview as an integer
+
+            Raises:
+                IndexError: if position is out of bounds
+        """
+        return ord(memview[pos])
+
+
+def decode_varint_1(buffer, pos=0):
+    """ Decode an integer from a varint presentation. See
+    https://developers.google.com/protocol-buffers/docs/encoding?csw=1#varints
+    on how those can be produced.
+
+        Arguments:
+            buffer (bytes-like): any object acceptable by ``memoryview``
+            pos (int): optional position to read from
+
+        Returns:
+            (int, int): Decoded int value and next read position
+    """
+    value = 0
+    shift = 0
+    memview = memoryview(buffer)
+    for i in range(pos, pos + 10):
+        try:
+            byte = _read_byte(memview, i)
+        except IndexError:
+            raise ValueError("End of byte stream")
+        if byte & 0x80 != 0:
+            value |= (byte & 0x7f) << shift
+            shift += 7
+        else:
+            value |= byte << shift
+            break
+    else:
+        # Max size of endcoded double is 10 bytes for unsigned values
+        raise ValueError("Out of double range")
+    # Normalize sign
+    return (value >> 1) ^ -(value & 1), i + 1
+
+_assert_valid_dec(decode_varint_1)
+
+
+def decode_varint_2(buffer, pos=0):
+    result = 0
+    shift = 0
+    while 1:
+        b = buffer[pos]
+        result |= ((b & 0x7f) << shift)
+        pos += 1
+        if not (b & 0x80):
+            # result = result_type(() & mask)
+            return ((result >> 1) ^ -(result & 1), pos)
+        shift += 7
+        if shift >= 64:
+            raise ValueError("Out of int64 range")
+
+
+_assert_valid_dec(decode_varint_2)
+
+
+def decode_varint_3(buffer, pos=0):
+    result = buffer[pos]
+    if not (result & 0x81):
+        return (result >> 1), pos + 1
+    if not (result & 0x80):
+        return (result >> 1) ^ (~0), pos + 1
+
+    result &= 0x7f
+    pos += 1
+    shift = 7
+    while 1:
+        b = buffer[pos]
+        result |= ((b & 0x7f) << shift)
+        pos += 1
+        if not (b & 0x80):
+            return ((result >> 1) ^ -(result & 1), pos)
+        shift += 7
+        if shift >= 64:
+            raise ValueError("Out of int64 range")
+
+
+_assert_valid_dec(decode_varint_3)
+
+# import dis
+# dis.dis(decode_varint_3)
+
+runner = pyperf.Runner()
+# Encode algorithms returning a bytes result
+for bench_func in [
+        encode_varint_1,
+        encode_varint_2,
+        encode_varint_4]:
+    for i, value in enumerate(BENCH_VALUES_ENC):
+        runner.bench_func(
+            '{}_{}byte'.format(bench_func.__name__, i + 1),
+            bench_func, value)
+
+# Encode algorithms writing to the buffer
+for bench_func in [
+        encode_varint_3,
+        encode_varint_5,
+        encode_varint_6]:
+    for i, value in enumerate(BENCH_VALUES_ENC):
+        fname = bench_func.__name__
+        runner.timeit(
+            '{}_{}byte'.format(fname, i + 1),
+            stmt="{}({}, buffer)".format(fname, value),
+            setup="from __main__ import {}; buffer = bytearray(10)".format(
+                fname)
+        )
+
+# Size algorithms
+for bench_func in [
+        size_of_varint_1,
+        size_of_varint_2]:
+    for i, value in enumerate(BENCH_VALUES_ENC):
+        runner.bench_func(
+            '{}_{}byte'.format(bench_func.__name__, i + 1),
+            bench_func, value)
+
+# Decode algorithms
+for bench_func in [
+        decode_varint_1,
+        decode_varint_2,
+        decode_varint_3]:
+    for i, value in enumerate(BENCH_VALUES_DEC):
+        runner.bench_func(
+            '{}_{}byte'.format(bench_func.__name__, i + 1),
+            bench_func, value)

testbed/dpkp__kafka-python/build_integration.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+
+: ${ALL_RELEASES:="0.8.2.2 0.9.0.1 0.10.1.1 0.10.2.2 0.11.0.3 1.0.2 1.1.1 2.0.1 2.1.1 2.2.1 2.3.0 2.4.0 2.5.0"}
+: ${SCALA_VERSION:=2.11}
+: ${DIST_BASE_URL:=https://archive.apache.org/dist/kafka/}
+: ${KAFKA_SRC_GIT:=https://github.com/apache/kafka.git}
+
+# On travis CI, empty KAFKA_VERSION means skip integration tests
+# so we don't try to get binaries
+# Otherwise it means test all official releases, so we get all of them!
+if [ -z "$KAFKA_VERSION" -a -z "$TRAVIS" ]; then
+  KAFKA_VERSION=$ALL_RELEASES
+fi
+
+pushd servers
+  mkdir -p dist
+  pushd dist
+    for kafka in $KAFKA_VERSION; do
+      if [ "$kafka" == "trunk" ]; then
+        if [ ! -d "$kafka" ]; then
+          git clone $KAFKA_SRC_GIT $kafka
+        fi
+        pushd $kafka
+          git pull
+          ./gradlew -PscalaVersion=$SCALA_VERSION -Pversion=$kafka releaseTarGz -x signArchives
+        popd
+        # Not sure how to construct the .tgz name accurately, so use a wildcard (ugh)
+        tar xzvf $kafka/core/build/distributions/kafka_*.tgz -C ../$kafka/
+        rm $kafka/core/build/distributions/kafka_*.tgz
+        rm -rf ../$kafka/kafka-bin
+        mv ../$kafka/kafka_* ../$kafka/kafka-bin
+      else
+        echo "-------------------------------------"
+        echo "Checking kafka binaries for ${kafka}"
+        echo
+        if [ "$kafka" == "0.8.0" ]; then
+          KAFKA_ARTIFACT="kafka_2.8.0-${kafka}.tar.gz"
+        else if [ "$kafka" \> "2.4.0" ]; then
+          KAFKA_ARTIFACT="kafka_2.12-${kafka}.tgz"
+        else
+          KAFKA_ARTIFACT="kafka_${SCALA_VERSION}-${kafka}.tgz"
+        fi
+        fi
+        if [ ! -f "../$kafka/kafka-bin/bin/kafka-run-class.sh" ]; then
+          if [ -f "${KAFKA_ARTIFACT}" ]; then
+            echo "Using cached artifact: ${KAFKA_ARTIFACT}"
+          else
+            echo "Downloading kafka ${kafka} tarball"
+            TARBALL=${DIST_BASE_URL}${kafka}/${KAFKA_ARTIFACT}
+            if command -v wget 2>/dev/null; then
+              wget -N $TARBALL
+            else
+              echo "wget not found... using curl"
+              curl -f $TARBALL -o ${KAFKA_ARTIFACT}
+            fi
+          fi
+          echo
+          echo "Extracting kafka ${kafka} binaries"
+          tar xzvf ${KAFKA_ARTIFACT} -C ../$kafka/
+          rm -rf ../$kafka/kafka-bin
+          mv ../$kafka/${KAFKA_ARTIFACT/%.t*/} ../$kafka/kafka-bin
+          if [ ! -f "../$kafka/kafka-bin/bin/kafka-run-class.sh" ]; then
+            echo "Extraction Failed ($kafka/kafka-bin/bin/kafka-run-class.sh does not exist)!"
+            exit 1
+          fi
+        else
+          echo "$kafka is already installed in servers/$kafka/ -- skipping"
+        fi
+      fi
+      echo
+    done
+  popd
+popd

testbed/dpkp__kafka-python/example.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+import threading, time
+
+from kafka import KafkaAdminClient, KafkaConsumer, KafkaProducer
+from kafka.admin import NewTopic
+
+
+class Producer(threading.Thread):
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.stop_event = threading.Event()
+
+    def stop(self):
+        self.stop_event.set()
+
+    def run(self):
+        producer = KafkaProducer(bootstrap_servers='localhost:9092')
+
+        while not self.stop_event.is_set():
+            producer.send('my-topic', b"test")
+            producer.send('my-topic', b"\xc2Hola, mundo!")
+            time.sleep(1)
+
+        producer.close()
+
+
+class Consumer(threading.Thread):
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.stop_event = threading.Event()
+
+    def stop(self):
+        self.stop_event.set()
+
+    def run(self):
+        consumer = KafkaConsumer(bootstrap_servers='localhost:9092',
+                                 auto_offset_reset='earliest',
+                                 consumer_timeout_ms=1000)
+        consumer.subscribe(['my-topic'])
+
+        while not self.stop_event.is_set():
+            for message in consumer:
+                print(message)
+                if self.stop_event.is_set():
+                    break
+
+        consumer.close()
+
+
+def main():
+    # Create 'my-topic' Kafka topic
+    try:
+        admin = KafkaAdminClient(bootstrap_servers='localhost:9092')
+
+        topic = NewTopic(name='my-topic',
+                         num_partitions=1,
+                         replication_factor=1)
+        admin.create_topics([topic])
+    except Exception:
+        pass
+
+    tasks = [
+        Producer(),
+        Consumer()
+    ]
+
+    # Start threads of a publisher/producer and a subscriber/consumer to 'my-topic' Kafka topic
+    for t in tasks:
+        t.start()
+
+    time.sleep(10)
+
+    # Stop threads
+    for task in tasks:
+        task.stop()
+
+    for task in tasks:
+        task.join()
+
+
+if __name__ == "__main__":
+    main()

testbed/dpkp__kafka-python/kafka/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import absolute_import
+
+__title__ = 'kafka'
+from kafka.version import __version__
+__author__ = 'Dana Powers'
+__license__ = 'Apache License 2.0'
+__copyright__ = 'Copyright 2016 Dana Powers, David Arthur, and Contributors'
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+try:  # Python 2.7+
+    from logging import NullHandler
+except ImportError:
+    class NullHandler(logging.Handler):
+        def emit(self, record):
+            pass
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+
+from kafka.admin import KafkaAdminClient
+from kafka.client_async import KafkaClient
+from kafka.consumer import KafkaConsumer
+from kafka.consumer.subscription_state import ConsumerRebalanceListener
+from kafka.producer import KafkaProducer
+from kafka.conn import BrokerConnection
+from kafka.serializer import Serializer, Deserializer
+from kafka.structs import TopicPartition, OffsetAndMetadata
+
+
+__all__ = [
+    'BrokerConnection', 'ConsumerRebalanceListener', 'KafkaAdminClient',
+    'KafkaClient', 'KafkaConsumer', 'KafkaProducer',
+]

testbed/dpkp__kafka-python/kafka/admin/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import absolute_import
+
+from kafka.admin.config_resource import ConfigResource, ConfigResourceType
+from kafka.admin.client import KafkaAdminClient
+from kafka.admin.acl_resource import (ACL, ACLFilter, ResourcePattern, ResourcePatternFilter, ACLOperation,
+                                      ResourceType, ACLPermissionType, ACLResourcePatternType)
+from kafka.admin.new_topic import NewTopic
+from kafka.admin.new_partitions import NewPartitions
+
+__all__ = [
+    'ConfigResource', 'ConfigResourceType', 'KafkaAdminClient', 'NewTopic', 'NewPartitions', 'ACL', 'ACLFilter',
+    'ResourcePattern', 'ResourcePatternFilter', 'ACLOperation', 'ResourceType', 'ACLPermissionType',
+    'ACLResourcePatternType'
+]

testbed/dpkp__kafka-python/kafka/admin/acl_resource.py

@@ -0,0 +1,244 @@
+from __future__ import absolute_import
+from kafka.errors import IllegalArgumentError
+
+# enum in stdlib as of py3.4
+try:
+    from enum import IntEnum  # pylint: disable=import-error
+except ImportError:
+    # vendored backport module
+    from kafka.vendor.enum34 import IntEnum
+
+
+class ResourceType(IntEnum):
+    """Type of kafka resource to set ACL for
+
+    The ANY value is only valid in a filter context
+    """
+
+    UNKNOWN = 0,
+    ANY = 1,
+    CLUSTER = 4,
+    DELEGATION_TOKEN = 6,
+    GROUP = 3,
+    TOPIC = 2,
+    TRANSACTIONAL_ID = 5
+
+
+class ACLOperation(IntEnum):
+    """Type of operation
+
+    The ANY value is only valid in a filter context
+    """
+
+    ANY = 1,
+    ALL = 2,
+    READ = 3,
+    WRITE = 4,
+    CREATE = 5,
+    DELETE = 6,
+    ALTER = 7,
+    DESCRIBE = 8,
+    CLUSTER_ACTION = 9,
+    DESCRIBE_CONFIGS = 10,
+    ALTER_CONFIGS = 11,
+    IDEMPOTENT_WRITE = 12
+
+
+class ACLPermissionType(IntEnum):
+    """An enumerated type of permissions
+
+    The ANY value is only valid in a filter context
+    """
+
+    ANY = 1,
+    DENY = 2,
+    ALLOW = 3
+
+
+class ACLResourcePatternType(IntEnum):
+    """An enumerated type of resource patterns
+
+    More details on the pattern types and how they work
+    can be found in KIP-290 (Support for prefixed ACLs)
+    https://cwiki.apache.org/confluence/display/KAFKA/KIP-290%3A+Support+for+Prefixed+ACLs
+    """
+
+    ANY = 1,
+    MATCH = 2,
+    LITERAL = 3,
+    PREFIXED = 4
+
+
+class ACLFilter(object):
+    """Represents a filter to use with describing and deleting ACLs
+
+    The difference between this class and the ACL class is mainly that
+    we allow using ANY with the operation, permission, and resource type objects
+    to fetch ALCs matching any of the properties.
+
+    To make a filter matching any principal, set principal to None
+    """
+
+    def __init__(
+        self,
+        principal,
+        host,
+        operation,
+        permission_type,
+        resource_pattern
+    ):
+        self.principal = principal
+        self.host = host
+        self.operation = operation
+        self.permission_type = permission_type
+        self.resource_pattern = resource_pattern
+
+        self.validate()
+
+    def validate(self):
+        if not isinstance(self.operation, ACLOperation):
+            raise IllegalArgumentError("operation must be an ACLOperation object, and cannot be ANY")
+        if not isinstance(self.permission_type, ACLPermissionType):
+            raise IllegalArgumentError("permission_type must be an ACLPermissionType object, and cannot be ANY")
+        if not isinstance(self.resource_pattern, ResourcePatternFilter):
+            raise IllegalArgumentError("resource_pattern must be a ResourcePatternFilter object")
+
+    def __repr__(self):
+        return "<ACL principal={principal}, resource={resource}, operation={operation}, type={type}, host={host}>".format(
+            principal=self.principal,
+            host=self.host,
+            operation=self.operation.name,
+            type=self.permission_type.name,
+            resource=self.resource_pattern
+        )
+
+    def __eq__(self, other):
+        return all((
+            self.principal == other.principal,
+            self.host == other.host,
+            self.operation == other.operation,
+            self.permission_type == other.permission_type,
+            self.resource_pattern == other.resource_pattern
+        ))
+
+    def __hash__(self):
+        return hash((
+            self.principal,
+            self.host,
+            self.operation,
+            self.permission_type,
+            self.resource_pattern,
+        ))
+
+
+class ACL(ACLFilter):
+    """Represents a concrete ACL for a specific ResourcePattern
+
+    In kafka an ACL is a 4-tuple of (principal, host, operation, permission_type)
+    that limits who can do what on a specific resource (or since KIP-290 a resource pattern)
+
+    Terminology:
+    Principal -> This is the identifier for the user. Depending on the authorization method used (SSL, SASL etc)
+        the principal will look different. See http://kafka.apache.org/documentation/#security_authz for details.
+        The principal must be on the format "User:<name>" or kafka will treat it as invalid. It's possible to use
+        other principal types than "User" if using a custom authorizer for the cluster.
+    Host -> This must currently be an IP address. It cannot be a range, and it cannot be a domain name.
+        It can be set to "*", which is special cased in kafka to mean "any host"
+    Operation -> Which client operation this ACL refers to. Has different meaning depending
+        on the resource type the ACL refers to. See https://docs.confluent.io/current/kafka/authorization.html#acl-format
+        for a list of which combinations of resource/operation that unlocks which kafka APIs
+    Permission Type: Whether this ACL is allowing or denying access
+    Resource Pattern -> This is a representation of the resource or resource pattern that the ACL
+        refers to. See the ResourcePattern class for details.
+
+    """
+
+    def __init__(
+            self,
+            principal,
+            host,
+            operation,
+            permission_type,
+            resource_pattern
+    ):
+        super(ACL, self).__init__(principal, host, operation, permission_type, resource_pattern)
+        self.validate()
+
+    def validate(self):
+        if self.operation == ACLOperation.ANY:
+            raise IllegalArgumentError("operation cannot be ANY")
+        if self.permission_type == ACLPermissionType.ANY:
+            raise IllegalArgumentError("permission_type cannot be ANY")
+        if not isinstance(self.resource_pattern, ResourcePattern):
+            raise IllegalArgumentError("resource_pattern must be a ResourcePattern object")
+
+
+class ResourcePatternFilter(object):
+    def __init__(
+            self,
+            resource_type,
+            resource_name,
+            pattern_type
+    ):
+        self.resource_type = resource_type
+        self.resource_name = resource_name
+        self.pattern_type = pattern_type
+
+        self.validate()
+
+    def validate(self):
+        if not isinstance(self.resource_type, ResourceType):
+            raise IllegalArgumentError("resource_type must be a ResourceType object")
+        if not isinstance(self.pattern_type, ACLResourcePatternType):
+            raise IllegalArgumentError("pattern_type must be an ACLResourcePatternType object")
+
+    def __repr__(self):
+        return "<ResourcePattern type={}, name={}, pattern={}>".format(
+            self.resource_type.name,
+            self.resource_name,
+            self.pattern_type.name
+        )
+
+    def __eq__(self, other):
+        return all((
+            self.resource_type == other.resource_type,
+            self.resource_name == other.resource_name,
+            self.pattern_type == other.pattern_type,
+        ))
+
+    def __hash__(self):
+        return hash((
+            self.resource_type,
+            self.resource_name,
+            self.pattern_type
+        ))
+
+
+class ResourcePattern(ResourcePatternFilter):
+    """A resource pattern to apply the ACL to
+
+    Resource patterns are used to be able to specify which resources an ACL
+    describes in a more flexible way than just pointing to a literal topic name for example.
+    Since KIP-290 (kafka 2.0) it's possible to set an ACL for a prefixed resource name, which
+    can cut down considerably on the number of ACLs needed when the number of topics and
+    consumer groups start to grow.
+    The default pattern_type is LITERAL, and it describes a specific resource. This is also how
+    ACLs worked before the introduction of prefixed ACLs
+    """
+
+    def __init__(
+            self,
+            resource_type,
+            resource_name,
+            pattern_type=ACLResourcePatternType.LITERAL
+    ):
+        super(ResourcePattern, self).__init__(resource_type, resource_name, pattern_type)
+        self.validate()
+
+    def validate(self):
+        if self.resource_type == ResourceType.ANY:
+            raise IllegalArgumentError("resource_type cannot be ANY")
+        if self.pattern_type in [ACLResourcePatternType.ANY, ACLResourcePatternType.MATCH]:
+            raise IllegalArgumentError(
+                "pattern_type cannot be {} on a concrete ResourcePattern".format(self.pattern_type.name)
+            )

testbed/dpkp__kafka-python/kafka/admin/client.py

@@ -0,0 +1,1342 @@
+from __future__ import absolute_import
+
+from collections import defaultdict
+import copy
+import logging
+import socket
+
+from . import ConfigResourceType
+from kafka.vendor import six
+
+from kafka.admin.acl_resource import ACLOperation, ACLPermissionType, ACLFilter, ACL, ResourcePattern, ResourceType, \
+    ACLResourcePatternType
+from kafka.client_async import KafkaClient, selectors
+from kafka.coordinator.protocol import ConsumerProtocolMemberMetadata, ConsumerProtocolMemberAssignment, ConsumerProtocol
+import kafka.errors as Errors
+from kafka.errors import (
+    IncompatibleBrokerVersion, KafkaConfigurationError, NotControllerError,
+    UnrecognizedBrokerVersion, IllegalArgumentError)
+from kafka.metrics import MetricConfig, Metrics
+from kafka.protocol.admin import (
+    CreateTopicsRequest, DeleteTopicsRequest, DescribeConfigsRequest, AlterConfigsRequest, CreatePartitionsRequest,
+    ListGroupsRequest, DescribeGroupsRequest, DescribeAclsRequest, CreateAclsRequest, DeleteAclsRequest,
+    DeleteGroupsRequest
+)
+from kafka.protocol.commit import GroupCoordinatorRequest, OffsetFetchRequest
+from kafka.protocol.metadata import MetadataRequest
+from kafka.protocol.types import Array
+from kafka.structs import TopicPartition, OffsetAndMetadata, MemberInformation, GroupInformation
+from kafka.version import __version__
+
+
+log = logging.getLogger(__name__)
+
+
+class KafkaAdminClient(object):
+    """A class for administering the Kafka cluster.
+
+    Warning:
+        This is an unstable interface that was recently added and is subject to
+        change without warning. In particular, many methods currently return
+        raw protocol tuples. In future releases, we plan to make these into
+        nicer, more pythonic objects. Unfortunately, this will likely break
+        those interfaces.
+
+    The KafkaAdminClient class will negotiate for the latest version of each message
+    protocol format supported by both the kafka-python client library and the
+    Kafka broker. Usage of optional fields from protocol versions that are not
+    supported by the broker will result in IncompatibleBrokerVersion exceptions.
+
+    Use of this class requires a minimum broker version >= 0.10.0.0.
+
+    Keyword Arguments:
+        bootstrap_servers: 'host[:port]' string (or list of 'host[:port]'
+            strings) that the consumer 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. Also
+            submitted to GroupCoordinator for logging with respect to
+            consumer group administration. Default: 'kafka-python-{version}'
+        reconnect_backoff_ms (int): The amount of time in milliseconds to
+            wait before attempting to reconnect to a given host.
+            Default: 50.
+        reconnect_backoff_max_ms (int): The maximum amount of time in
+            milliseconds to backoff/wait when reconnecting to a broker that has
+            repeatedly failed to connect. If provided, the backoff per host
+            will increase exponentially for each consecutive connection
+            failure, up to this maximum. Once the maximum is reached,
+            reconnection attempts will continue periodically with this fixed
+            rate. To avoid connection storms, a randomization factor of 0.2
+            will be applied to the backoff resulting in a random range between
+            20% below and 20% above the computed value. Default: 1000.
+        request_timeout_ms (int): Client request timeout in milliseconds.
+            Default: 30000.
+        connections_max_idle_ms: Close idle connections after the number of
+            milliseconds specified by this config. The broker closes idle
+            connections after connections.max.idle.ms, so this avoids hitting
+            unexpected socket disconnected errors on the client.
+            Default: 540000
+        retry_backoff_ms (int): Milliseconds to backoff when retrying on
+            errors. Default: 100.
+        max_in_flight_requests_per_connection (int): Requests are pipelined
+            to kafka brokers up to this number of maximum requests per
+            broker connection. Default: 5.
+        receive_buffer_bytes (int): The size of the TCP receive buffer
+            (SO_RCVBUF) to use when reading data. Default: None (relies on
+            system defaults). Java client defaults to 32768.
+        send_buffer_bytes (int): The size of the TCP send buffer
+            (SO_SNDBUF) to use when sending data. Default: None (relies on
+            system defaults). Java client defaults to 131072.
+        socket_options (list): List of tuple-arguments to socket.setsockopt
+            to apply to broker connection sockets. Default:
+            [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]
+        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
+        security_protocol (str): Protocol used to communicate with brokers.
+            Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL.
+            Default: PLAINTEXT.
+        ssl_context (ssl.SSLContext): Pre-configured SSLContext for wrapping
+            socket connections. If provided, all other ssl_* configurations
+            will be ignored. Default: None.
+        ssl_check_hostname (bool): Flag to configure whether SSL handshake
+            should verify that the certificate matches the broker's hostname.
+            Default: True.
+        ssl_cafile (str): Optional filename of CA file to use in certificate
+            verification. Default: None.
+        ssl_certfile (str): Optional filename of file in PEM format containing
+            the client certificate, as well as any CA certificates needed to
+            establish the certificate's authenticity. Default: None.
+        ssl_keyfile (str): Optional filename containing the client private key.
+            Default: None.
+        ssl_password (str): Optional password to be used when loading the
+            certificate chain. Default: None.
+        ssl_crlfile (str): Optional filename containing the CRL to check for
+            certificate expiration. By default, no CRL check is done. When
+            providing a file, only the leaf certificate will be checked against
+            this CRL. The CRL can only be checked with Python 3.4+ or 2.7.9+.
+            Default: None.
+        api_version (tuple): Specify which Kafka API version to use. If set
+            to None, KafkaClient will attempt to infer the broker version by
+            probing various APIs. Example: (0, 10, 2). Default: None
+        api_version_auto_timeout_ms (int): number of milliseconds to throw a
+            timeout exception from the constructor when checking the broker
+            api version. Only applies if api_version is None
+        selector (selectors.BaseSelector): Provide a specific selector
+            implementation to use for I/O multiplexing.
+            Default: selectors.DefaultSelector
+        metrics (kafka.metrics.Metrics): Optionally provide a metrics
+            instance for capturing network IO stats. Default: None.
+        metric_group_prefix (str): Prefix for metric names. Default: ''
+        sasl_mechanism (str): Authentication mechanism when security_protocol
+            is configured for SASL_PLAINTEXT or SASL_SSL. Valid values are:
+            PLAIN, GSSAPI, OAUTHBEARER, SCRAM-SHA-256, SCRAM-SHA-512.
+        sasl_plain_username (str): username for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_plain_password (str): password for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_kerberos_service_name (str): Service name to include in GSSAPI
+            sasl mechanism handshake. Default: 'kafka'
+        sasl_kerberos_domain_name (str): kerberos domain name to use in GSSAPI
+            sasl mechanism handshake. Default: one of bootstrap servers
+        sasl_oauth_token_provider (AbstractTokenProvider): OAuthBearer token provider
+            instance. (See kafka.oauth.abstract). Default: None
+
+    """
+    DEFAULT_CONFIG = {
+        # client configs
+        'bootstrap_servers': 'localhost',
+        'client_id': 'kafka-python-' + __version__,
+        'request_timeout_ms': 30000,
+        'connections_max_idle_ms': 9 * 60 * 1000,
+        'reconnect_backoff_ms': 50,
+        'reconnect_backoff_max_ms': 1000,
+        'max_in_flight_requests_per_connection': 5,
+        'receive_buffer_bytes': None,
+        'send_buffer_bytes': None,
+        'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],
+        'sock_chunk_bytes': 4096,  # undocumented experimental option
+        'sock_chunk_buffer_count': 1000,  # undocumented experimental option
+        'retry_backoff_ms': 100,
+        'metadata_max_age_ms': 300000,
+        'security_protocol': 'PLAINTEXT',
+        'ssl_context': None,
+        'ssl_check_hostname': True,
+        'ssl_cafile': None,
+        'ssl_certfile': None,
+        'ssl_keyfile': None,
+        'ssl_password': None,
+        'ssl_crlfile': None,
+        'api_version': None,
+        'api_version_auto_timeout_ms': 2000,
+        'selector': selectors.DefaultSelector,
+        'sasl_mechanism': None,
+        'sasl_plain_username': None,
+        'sasl_plain_password': None,
+        'sasl_kerberos_service_name': 'kafka',
+        'sasl_kerberos_domain_name': None,
+        'sasl_oauth_token_provider': None,
+
+        # metrics configs
+        'metric_reporters': [],
+        'metrics_num_samples': 2,
+        'metrics_sample_window_ms': 30000,
+    }
+
+    def __init__(self, **configs):
+        log.debug("Starting KafkaAdminClient with configuration: %s", configs)
+        extra_configs = set(configs).difference(self.DEFAULT_CONFIG)
+        if extra_configs:
+            raise KafkaConfigurationError("Unrecognized configs: {}".format(extra_configs))
+
+        self.config = copy.copy(self.DEFAULT_CONFIG)
+        self.config.update(configs)
+
+        # Configure metrics
+        metrics_tags = {'client-id': self.config['client_id']}
+        metric_config = MetricConfig(samples=self.config['metrics_num_samples'],
+                                     time_window_ms=self.config['metrics_sample_window_ms'],
+                                     tags=metrics_tags)
+        reporters = [reporter() for reporter in self.config['metric_reporters']]
+        self._metrics = Metrics(metric_config, reporters)
+
+        self._client = KafkaClient(metrics=self._metrics,
+                                   metric_group_prefix='admin',
+                                   **self.config)
+        self._client.check_version(timeout=(self.config['api_version_auto_timeout_ms'] / 1000))
+
+        # Get auto-discovered version from client if necessary
+        if self.config['api_version'] is None:
+            self.config['api_version'] = self._client.config['api_version']
+
+        self._closed = False
+        self._refresh_controller_id()
+        log.debug("KafkaAdminClient started.")
+
+    def close(self):
+        """Close the KafkaAdminClient connection to the Kafka broker."""
+        if not hasattr(self, '_closed') or self._closed:
+            log.info("KafkaAdminClient already closed.")
+            return
+
+        self._metrics.close()
+        self._client.close()
+        self._closed = True
+        log.debug("KafkaAdminClient is now closed.")
+
+    def _matching_api_version(self, operation):
+        """Find the latest version of the protocol operation supported by both
+        this library and the broker.
+
+        This resolves to the lesser of either the latest api version this
+        library supports, or the max version supported by the broker.
+
+        :param operation: A list of protocol operation versions from kafka.protocol.
+        :return: The max matching version number between client and broker.
+        """
+        broker_api_versions = self._client.get_api_versions()
+        api_key = operation[0].API_KEY
+        if broker_api_versions is None or api_key not in broker_api_versions:
+            raise IncompatibleBrokerVersion(
+                "Kafka broker does not support the '{}' Kafka protocol."
+                .format(operation[0].__name__))
+        min_version, max_version = broker_api_versions[api_key]
+        version = min(len(operation) - 1, max_version)
+        if version < min_version:
+            # max library version is less than min broker version. Currently,
+            # no Kafka versions specify a min msg version. Maybe in the future?
+            raise IncompatibleBrokerVersion(
+                "No version of the '{}' Kafka protocol is supported by both the client and broker."
+                .format(operation[0].__name__))
+        return version
+
+    def _validate_timeout(self, timeout_ms):
+        """Validate the timeout is set or use the configuration default.
+
+        :param timeout_ms: The timeout provided by api call, in milliseconds.
+        :return: The timeout to use for the operation.
+        """
+        return timeout_ms or self.config['request_timeout_ms']
+
+    def _refresh_controller_id(self):
+        """Determine the Kafka cluster controller."""
+        version = self._matching_api_version(MetadataRequest)
+        if 1 <= version <= 6:
+            request = MetadataRequest[version]()
+            future = self._send_request_to_node(self._client.least_loaded_node(), request)
+
+            self._wait_for_futures([future])
+
+            response = future.value
+            controller_id = response.controller_id
+            # verify the controller is new enough to support our requests
+            controller_version = self._client.check_version(controller_id, timeout=(self.config['api_version_auto_timeout_ms'] / 1000))
+            if controller_version < (0, 10, 0):
+                raise IncompatibleBrokerVersion(
+                    "The controller appears to be running Kafka {}. KafkaAdminClient requires brokers >= 0.10.0.0."
+                    .format(controller_version))
+            self._controller_id = controller_id
+        else:
+            raise UnrecognizedBrokerVersion(
+                "Kafka Admin interface cannot determine the controller using MetadataRequest_v{}."
+                .format(version))
+
+    def _find_coordinator_id_send_request(self, group_id):
+        """Send a FindCoordinatorRequest to a broker.
+
+        :param group_id: The consumer group ID. This is typically the group
+            name as a string.
+        :return: A message future
+        """
+        # TODO add support for dynamically picking version of
+        # GroupCoordinatorRequest which was renamed to FindCoordinatorRequest.
+        # When I experimented with this, the coordinator value returned in
+        # GroupCoordinatorResponse_v1 didn't match the value returned by
+        # GroupCoordinatorResponse_v0 and I couldn't figure out why.
+        version = 0
+        # version = self._matching_api_version(GroupCoordinatorRequest)
+        if version <= 0:
+            request = GroupCoordinatorRequest[version](group_id)
+        else:
+            raise NotImplementedError(
+                "Support for GroupCoordinatorRequest_v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        return self._send_request_to_node(self._client.least_loaded_node(), request)
+
+    def _find_coordinator_id_process_response(self, response):
+        """Process a FindCoordinatorResponse.
+
+        :param response: a FindCoordinatorResponse.
+        :return: The node_id of the broker that is the coordinator.
+        """
+        if response.API_VERSION <= 0:
+            error_type = Errors.for_code(response.error_code)
+            if error_type is not Errors.NoError:
+                # Note: When error_type.retriable, Java will retry... see
+                # KafkaAdminClient's handleFindCoordinatorError method
+                raise error_type(
+                    "FindCoordinatorRequest failed with response '{}'."
+                    .format(response))
+        else:
+            raise NotImplementedError(
+                "Support for FindCoordinatorRequest_v{} has not yet been added to KafkaAdminClient."
+                .format(response.API_VERSION))
+        return response.coordinator_id
+
+    def _find_coordinator_ids(self, group_ids):
+        """Find the broker node_ids of the coordinators of the given groups.
+
+        Sends a FindCoordinatorRequest message to the cluster for each group_id.
+        Will block until the FindCoordinatorResponse is received for all groups.
+        Any errors are immediately raised.
+
+        :param group_ids: A list of consumer group IDs. This is typically the group
+            name as a string.
+        :return: A dict of {group_id: node_id} where node_id is the id of the
+            broker that is the coordinator for the corresponding group.
+        """
+        groups_futures = {
+            group_id: self._find_coordinator_id_send_request(group_id)
+            for group_id in group_ids
+        }
+        self._wait_for_futures(groups_futures.values())
+        groups_coordinators = {
+            group_id: self._find_coordinator_id_process_response(future.value)
+            for group_id, future in groups_futures.items()
+        }
+        return groups_coordinators
+
+    def _send_request_to_node(self, node_id, request):
+        """Send a Kafka protocol message to a specific broker.
+
+        Returns a future that may be polled for status and results.
+
+        :param node_id: The broker id to which to send the message.
+        :param request: The message to send.
+        :return: A future object that may be polled for status and results.
+        :exception: The exception if the message could not be sent.
+        """
+        while not self._client.ready(node_id):
+            # poll until the connection to broker is ready, otherwise send()
+            # will fail with NodeNotReadyError
+            self._client.poll()
+        return self._client.send(node_id, request)
+
+    def _send_request_to_controller(self, request):
+        """Send a Kafka protocol message to the cluster controller.
+
+        Will block until the message result is received.
+
+        :param request: The message to send.
+        :return: The Kafka protocol response for the message.
+        """
+        tries = 2  # in case our cached self._controller_id is outdated
+        while tries:
+            tries -= 1
+            future = self._send_request_to_node(self._controller_id, request)
+
+            self._wait_for_futures([future])
+
+            response = future.value
+            # In Java, the error field name is inconsistent:
+            #  - CreateTopicsResponse / CreatePartitionsResponse uses topic_errors
+            #  - DeleteTopicsResponse uses topic_error_codes
+            # So this is a little brittle in that it assumes all responses have
+            # one of these attributes and that they always unpack into
+            # (topic, error_code) tuples.
+            topic_error_tuples = (response.topic_errors if hasattr(response, 'topic_errors')
+                    else response.topic_error_codes)
+            # Also small py2/py3 compatibility -- py3 can ignore extra values
+            # during unpack via: for x, y, *rest in list_of_values. py2 cannot.
+            # So for now we have to map across the list and explicitly drop any
+            # extra values (usually the error_message)
+            for topic, error_code in map(lambda e: e[:2], topic_error_tuples):
+                error_type = Errors.for_code(error_code)
+                if tries and error_type is NotControllerError:
+                    # No need to inspect the rest of the errors for
+                    # non-retriable errors because NotControllerError should
+                    # either be thrown for all errors or no errors.
+                    self._refresh_controller_id()
+                    break
+                elif error_type is not Errors.NoError:
+                    raise error_type(
+                        "Request '{}' failed with response '{}'."
+                        .format(request, response))
+            else:
+                return response
+        raise RuntimeError("This should never happen, please file a bug with full stacktrace if encountered")
+
+    @staticmethod
+    def _convert_new_topic_request(new_topic):
+        return (
+            new_topic.name,
+            new_topic.num_partitions,
+            new_topic.replication_factor,
+            [
+                (partition_id, replicas) for partition_id, replicas in new_topic.replica_assignments.items()
+            ],
+            [
+                (config_key, config_value) for config_key, config_value in new_topic.topic_configs.items()
+            ]
+        )
+
+    def create_topics(self, new_topics, timeout_ms=None, validate_only=False):
+        """Create new topics in the cluster.
+
+        :param new_topics: A list of NewTopic objects.
+        :param timeout_ms: Milliseconds to wait for new topics to be created
+            before the broker returns.
+        :param validate_only: If True, don't actually create new topics.
+            Not supported by all versions. Default: False
+        :return: Appropriate version of CreateTopicResponse class.
+        """
+        version = self._matching_api_version(CreateTopicsRequest)
+        timeout_ms = self._validate_timeout(timeout_ms)
+        if version == 0:
+            if validate_only:
+                raise IncompatibleBrokerVersion(
+                    "validate_only requires CreateTopicsRequest >= v1, which is not supported by Kafka {}."
+                    .format(self.config['api_version']))
+            request = CreateTopicsRequest[version](
+                create_topic_requests=[self._convert_new_topic_request(new_topic) for new_topic in new_topics],
+                timeout=timeout_ms
+            )
+        elif version <= 3:
+            request = CreateTopicsRequest[version](
+                create_topic_requests=[self._convert_new_topic_request(new_topic) for new_topic in new_topics],
+                timeout=timeout_ms,
+                validate_only=validate_only
+            )
+        else:
+            raise NotImplementedError(
+                "Support for CreateTopics v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        # TODO convert structs to a more pythonic interface
+        # TODO raise exceptions if errors
+        return self._send_request_to_controller(request)
+
+    def delete_topics(self, topics, timeout_ms=None):
+        """Delete topics from the cluster.
+
+        :param topics: A list of topic name strings.
+        :param timeout_ms: Milliseconds to wait for topics to be deleted
+            before the broker returns.
+        :return: Appropriate version of DeleteTopicsResponse class.
+        """
+        version = self._matching_api_version(DeleteTopicsRequest)
+        timeout_ms = self._validate_timeout(timeout_ms)
+        if version <= 3:
+            request = DeleteTopicsRequest[version](
+                topics=topics,
+                timeout=timeout_ms
+            )
+            response = self._send_request_to_controller(request)
+        else:
+            raise NotImplementedError(
+                "Support for DeleteTopics v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        return response
+
+
+    def _get_cluster_metadata(self, topics=None, auto_topic_creation=False):
+        """
+        topics == None means "get all topics"
+        """
+        version = self._matching_api_version(MetadataRequest)
+        if version <= 3:
+            if auto_topic_creation:
+                raise IncompatibleBrokerVersion(
+                    "auto_topic_creation requires MetadataRequest >= v4, which"
+                    " is not supported by Kafka {}"
+                    .format(self.config['api_version']))
+
+            request = MetadataRequest[version](topics=topics)
+        elif version <= 5:
+            request = MetadataRequest[version](
+                topics=topics,
+                allow_auto_topic_creation=auto_topic_creation
+            )
+
+        future = self._send_request_to_node(
+            self._client.least_loaded_node(),
+            request
+        )
+        self._wait_for_futures([future])
+        return future.value
+
+    def list_topics(self):
+        metadata = self._get_cluster_metadata(topics=None)
+        obj = metadata.to_object()
+        return [t['topic'] for t in obj['topics']]
+
+    def describe_topics(self, topics=None):
+        metadata = self._get_cluster_metadata(topics=topics)
+        obj = metadata.to_object()
+        return obj['topics']
+
+    def describe_cluster(self):
+        metadata = self._get_cluster_metadata()
+        obj = metadata.to_object()
+        obj.pop('topics')  # We have 'describe_topics' for this
+        return obj
+
+    @staticmethod
+    def _convert_describe_acls_response_to_acls(describe_response):
+        version = describe_response.API_VERSION
+
+        error = Errors.for_code(describe_response.error_code)
+        acl_list = []
+        for resources in describe_response.resources:
+            if version == 0:
+                resource_type, resource_name, acls = resources
+                resource_pattern_type = ACLResourcePatternType.LITERAL.value
+            elif version <= 1:
+                resource_type, resource_name, resource_pattern_type, acls = resources
+            else:
+                raise NotImplementedError(
+                    "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin."
+                        .format(version)
+                )
+            for acl in acls:
+                principal, host, operation, permission_type = acl
+                conv_acl = ACL(
+                    principal=principal,
+                    host=host,
+                    operation=ACLOperation(operation),
+                    permission_type=ACLPermissionType(permission_type),
+                    resource_pattern=ResourcePattern(
+                        ResourceType(resource_type),
+                        resource_name,
+                        ACLResourcePatternType(resource_pattern_type)
+                    )
+                )
+                acl_list.append(conv_acl)
+
+        return (acl_list, error,)
+
+    def describe_acls(self, acl_filter):
+        """Describe a set of ACLs
+
+        Used to return a set of ACLs matching the supplied ACLFilter.
+        The cluster must be configured with an authorizer for this to work, or
+        you will get a SecurityDisabledError
+
+        :param acl_filter: an ACLFilter object
+        :return: tuple of a list of matching ACL objects and a KafkaError (NoError if successful)
+        """
+
+        version = self._matching_api_version(DescribeAclsRequest)
+        if version == 0:
+            request = DescribeAclsRequest[version](
+                resource_type=acl_filter.resource_pattern.resource_type,
+                resource_name=acl_filter.resource_pattern.resource_name,
+                principal=acl_filter.principal,
+                host=acl_filter.host,
+                operation=acl_filter.operation,
+                permission_type=acl_filter.permission_type
+            )
+        elif version <= 1:
+            request = DescribeAclsRequest[version](
+                resource_type=acl_filter.resource_pattern.resource_type,
+                resource_name=acl_filter.resource_pattern.resource_name,
+                resource_pattern_type_filter=acl_filter.resource_pattern.pattern_type,
+                principal=acl_filter.principal,
+                host=acl_filter.host,
+                operation=acl_filter.operation,
+                permission_type=acl_filter.permission_type
+
+            )
+        else:
+            raise NotImplementedError(
+                "Support for DescribeAcls v{} has not yet been added to KafkaAdmin."
+                    .format(version)
+            )
+
+        future = self._send_request_to_node(self._client.least_loaded_node(), request)
+        self._wait_for_futures([future])
+        response = future.value
+
+        error_type = Errors.for_code(response.error_code)
+        if error_type is not Errors.NoError:
+            # optionally we could retry if error_type.retriable
+            raise error_type(
+                "Request '{}' failed with response '{}'."
+                    .format(request, response))
+
+        return self._convert_describe_acls_response_to_acls(response)
+
+    @staticmethod
+    def _convert_create_acls_resource_request_v0(acl):
+
+        return (
+            acl.resource_pattern.resource_type,
+            acl.resource_pattern.resource_name,
+            acl.principal,
+            acl.host,
+            acl.operation,
+            acl.permission_type
+        )
+
+    @staticmethod
+    def _convert_create_acls_resource_request_v1(acl):
+
+        return (
+            acl.resource_pattern.resource_type,
+            acl.resource_pattern.resource_name,
+            acl.resource_pattern.pattern_type,
+            acl.principal,
+            acl.host,
+            acl.operation,
+            acl.permission_type
+        )
+
+    @staticmethod
+    def _convert_create_acls_response_to_acls(acls, create_response):
+        version = create_response.API_VERSION
+
+        creations_error = []
+        creations_success = []
+        for i, creations in enumerate(create_response.creation_responses):
+            if version <= 1:
+                error_code, error_message = creations
+                acl = acls[i]
+                error = Errors.for_code(error_code)
+            else:
+                raise NotImplementedError(
+                    "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin."
+                        .format(version)
+                )
+
+            if error is Errors.NoError:
+                creations_success.append(acl)
+            else:
+                creations_error.append((acl, error,))
+
+        return {"succeeded": creations_success, "failed": creations_error}
+
+    def create_acls(self, acls):
+        """Create a list of ACLs
+
+        This endpoint only accepts a list of concrete ACL objects, no ACLFilters.
+        Throws TopicAlreadyExistsError if topic is already present.
+
+        :param acls: a list of ACL objects
+        :return: dict of successes and failures
+        """
+
+        for acl in acls:
+            if not isinstance(acl, ACL):
+                raise IllegalArgumentError("acls must contain ACL objects")
+
+        version = self._matching_api_version(CreateAclsRequest)
+        if version == 0:
+            request = CreateAclsRequest[version](
+                creations=[self._convert_create_acls_resource_request_v0(acl) for acl in acls]
+            )
+        elif version <= 1:
+            request = CreateAclsRequest[version](
+                creations=[self._convert_create_acls_resource_request_v1(acl) for acl in acls]
+            )
+        else:
+            raise NotImplementedError(
+                "Support for CreateAcls v{} has not yet been added to KafkaAdmin."
+                    .format(version)
+            )
+
+        future = self._send_request_to_node(self._client.least_loaded_node(), request)
+        self._wait_for_futures([future])
+        response = future.value
+
+        return self._convert_create_acls_response_to_acls(acls, response)
+
+    @staticmethod
+    def _convert_delete_acls_resource_request_v0(acl):
+        return (
+            acl.resource_pattern.resource_type,
+            acl.resource_pattern.resource_name,
+            acl.principal,
+            acl.host,
+            acl.operation,
+            acl.permission_type
+        )
+
+    @staticmethod
+    def _convert_delete_acls_resource_request_v1(acl):
+        return (
+            acl.resource_pattern.resource_type,
+            acl.resource_pattern.resource_name,
+            acl.resource_pattern.pattern_type,
+            acl.principal,
+            acl.host,
+            acl.operation,
+            acl.permission_type
+        )
+
+    @staticmethod
+    def _convert_delete_acls_response_to_matching_acls(acl_filters, delete_response):
+        version = delete_response.API_VERSION
+        filter_result_list = []
+        for i, filter_responses in enumerate(delete_response.filter_responses):
+            filter_error_code, filter_error_message, matching_acls = filter_responses
+            filter_error = Errors.for_code(filter_error_code)
+            acl_result_list = []
+            for acl in matching_acls:
+                if version == 0:
+                    error_code, error_message, resource_type, resource_name, principal, host, operation, permission_type = acl
+                    resource_pattern_type = ACLResourcePatternType.LITERAL.value
+                elif version == 1:
+                    error_code, error_message, resource_type, resource_name, resource_pattern_type, principal, host, operation, permission_type = acl
+                else:
+                    raise NotImplementedError(
+                        "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin."
+                            .format(version)
+                    )
+                acl_error = Errors.for_code(error_code)
+                conv_acl = ACL(
+                    principal=principal,
+                    host=host,
+                    operation=ACLOperation(operation),
+                    permission_type=ACLPermissionType(permission_type),
+                    resource_pattern=ResourcePattern(
+                        ResourceType(resource_type),
+                        resource_name,
+                        ACLResourcePatternType(resource_pattern_type)
+                    )
+                )
+                acl_result_list.append((conv_acl, acl_error,))
+            filter_result_list.append((acl_filters[i], acl_result_list, filter_error,))
+        return filter_result_list
+
+    def delete_acls(self, acl_filters):
+        """Delete a set of ACLs
+
+        Deletes all ACLs matching the list of input ACLFilter
+
+        :param acl_filters: a list of ACLFilter
+        :return: a list of 3-tuples corresponding to the list of input filters.
+                 The tuples hold (the input ACLFilter, list of affected ACLs, KafkaError instance)
+        """
+
+        for acl in acl_filters:
+            if not isinstance(acl, ACLFilter):
+                raise IllegalArgumentError("acl_filters must contain ACLFilter type objects")
+
+        version = self._matching_api_version(DeleteAclsRequest)
+
+        if version == 0:
+            request = DeleteAclsRequest[version](
+                filters=[self._convert_delete_acls_resource_request_v0(acl) for acl in acl_filters]
+            )
+        elif version <= 1:
+            request = DeleteAclsRequest[version](
+                filters=[self._convert_delete_acls_resource_request_v1(acl) for acl in acl_filters]
+            )
+        else:
+            raise NotImplementedError(
+                "Support for DeleteAcls v{} has not yet been added to KafkaAdmin."
+                    .format(version)
+            )
+
+        future = self._send_request_to_node(self._client.least_loaded_node(), request)
+        self._wait_for_futures([future])
+        response = future.value
+
+        return self._convert_delete_acls_response_to_matching_acls(acl_filters, response)
+
+    @staticmethod
+    def _convert_describe_config_resource_request(config_resource):
+        return (
+            config_resource.resource_type,
+            config_resource.name,
+            [
+                config_key for config_key, config_value in config_resource.configs.items()
+            ] if config_resource.configs else None
+        )
+
+    def describe_configs(self, config_resources, include_synonyms=False):
+        """Fetch configuration parameters for one or more Kafka resources.
+
+        :param config_resources: An list of ConfigResource objects.
+            Any keys in ConfigResource.configs dict will be used to filter the
+            result. Setting the configs dict to None will get all values. An
+            empty dict will get zero values (as per Kafka protocol).
+        :param include_synonyms: If True, return synonyms in response. Not
+            supported by all versions. Default: False.
+        :return: Appropriate version of DescribeConfigsResponse class.
+        """
+
+        # Break up requests by type - a broker config request must be sent to the specific broker.
+        # All other (currently just topic resources) can be sent to any broker.
+        broker_resources = []
+        topic_resources = []
+
+        for config_resource in config_resources:
+            if config_resource.resource_type == ConfigResourceType.BROKER:
+                broker_resources.append(self._convert_describe_config_resource_request(config_resource))
+            else:
+                topic_resources.append(self._convert_describe_config_resource_request(config_resource))
+
+        futures = []
+        version = self._matching_api_version(DescribeConfigsRequest)
+        if version == 0:
+            if include_synonyms:
+                raise IncompatibleBrokerVersion(
+                    "include_synonyms requires DescribeConfigsRequest >= v1, which is not supported by Kafka {}."
+                        .format(self.config['api_version']))
+
+            if len(broker_resources) > 0:
+                for broker_resource in broker_resources:
+                    try:
+                        broker_id = int(broker_resource[1])
+                    except ValueError:
+                        raise ValueError("Broker resource names must be an integer or a string represented integer")
+
+                    futures.append(self._send_request_to_node(
+                        broker_id,
+                        DescribeConfigsRequest[version](resources=[broker_resource])
+                    ))
+
+            if len(topic_resources) > 0:
+                futures.append(self._send_request_to_node(
+                    self._client.least_loaded_node(),
+                    DescribeConfigsRequest[version](resources=topic_resources)
+                ))
+
+        elif version <= 2:
+            if len(broker_resources) > 0:
+                for broker_resource in broker_resources:
+                    try:
+                        broker_id = int(broker_resource[1])
+                    except ValueError:
+                        raise ValueError("Broker resource names must be an integer or a string represented integer")
+
+                    futures.append(self._send_request_to_node(
+                        broker_id,
+                        DescribeConfigsRequest[version](
+                            resources=[broker_resource],
+                            include_synonyms=include_synonyms)
+                    ))
+
+            if len(topic_resources) > 0:
+                futures.append(self._send_request_to_node(
+                    self._client.least_loaded_node(),
+                    DescribeConfigsRequest[version](resources=topic_resources, include_synonyms=include_synonyms)
+                ))
+        else:
+            raise NotImplementedError(
+                "Support for DescribeConfigs v{} has not yet been added to KafkaAdminClient.".format(version))
+
+        self._wait_for_futures(futures)
+        return [f.value for f in futures]
+
+    @staticmethod
+    def _convert_alter_config_resource_request(config_resource):
+        return (
+            config_resource.resource_type,
+            config_resource.name,
+            [
+                (config_key, config_value) for config_key, config_value in config_resource.configs.items()
+            ]
+        )
+
+    def alter_configs(self, config_resources):
+        """Alter configuration parameters of one or more Kafka resources.
+
+        Warning:
+            This is currently broken for BROKER resources because those must be
+            sent to that specific broker, versus this always picks the
+            least-loaded node. See the comment in the source code for details.
+            We would happily accept a PR fixing this.
+
+        :param config_resources: A list of ConfigResource objects.
+        :return: Appropriate version of AlterConfigsResponse class.
+        """
+        version = self._matching_api_version(AlterConfigsRequest)
+        if version <= 1:
+            request = AlterConfigsRequest[version](
+                resources=[self._convert_alter_config_resource_request(config_resource) for config_resource in config_resources]
+            )
+        else:
+            raise NotImplementedError(
+                "Support for AlterConfigs v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        # TODO the Java client has the note:
+        # // We must make a separate AlterConfigs request for every BROKER resource we want to alter
+        # // and send the request to that specific broker. Other resources are grouped together into
+        # // a single request that may be sent to any broker.
+        #
+        # So this is currently broken as it always sends to the least_loaded_node()
+        future = self._send_request_to_node(self._client.least_loaded_node(), request)
+
+        self._wait_for_futures([future])
+        response = future.value
+        return response
+
+    # alter replica logs dir protocol not yet implemented
+    # Note: have to lookup the broker with the replica assignment and send the request to that broker
+
+    # describe log dirs protocol not yet implemented
+    # Note: have to lookup the broker with the replica assignment and send the request to that broker
+
+    @staticmethod
+    def _convert_create_partitions_request(topic_name, new_partitions):
+        return (
+            topic_name,
+            (
+                new_partitions.total_count,
+                new_partitions.new_assignments
+            )
+        )
+
+    def create_partitions(self, topic_partitions, timeout_ms=None, validate_only=False):
+        """Create additional partitions for an existing topic.
+
+        :param topic_partitions: A map of topic name strings to NewPartition objects.
+        :param timeout_ms: Milliseconds to wait for new partitions to be
+            created before the broker returns.
+        :param validate_only: If True, don't actually create new partitions.
+            Default: False
+        :return: Appropriate version of CreatePartitionsResponse class.
+        """
+        version = self._matching_api_version(CreatePartitionsRequest)
+        timeout_ms = self._validate_timeout(timeout_ms)
+        if version <= 1:
+            request = CreatePartitionsRequest[version](
+                topic_partitions=[self._convert_create_partitions_request(topic_name, new_partitions) for topic_name, new_partitions in topic_partitions.items()],
+                timeout=timeout_ms,
+                validate_only=validate_only
+            )
+        else:
+            raise NotImplementedError(
+                "Support for CreatePartitions v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        return self._send_request_to_controller(request)
+
+    # delete records protocol not yet implemented
+    # Note: send the request to the partition leaders
+
+    # create delegation token protocol not yet implemented
+    # Note: send the request to the least_loaded_node()
+
+    # renew delegation token protocol not yet implemented
+    # Note: send the request to the least_loaded_node()
+
+    # expire delegation_token protocol not yet implemented
+    # Note: send the request to the least_loaded_node()
+
+    # describe delegation_token protocol not yet implemented
+    # Note: send the request to the least_loaded_node()
+
+    def _describe_consumer_groups_send_request(self, group_id, group_coordinator_id, include_authorized_operations=False):
+        """Send a DescribeGroupsRequest to the group's coordinator.
+
+        :param group_id: The group name as a string
+        :param group_coordinator_id: The node_id of the groups' coordinator
+            broker.
+        :return: A message future.
+        """
+        version = self._matching_api_version(DescribeGroupsRequest)
+        if version <= 2:
+            if include_authorized_operations:
+                raise IncompatibleBrokerVersion(
+                    "include_authorized_operations requests "
+                    "DescribeGroupsRequest >= v3, which is not "
+                    "supported by Kafka {}".format(version)
+                )
+            # Note: KAFKA-6788 A potential optimization is to group the
+            # request per coordinator and send one request with a list of
+            # all consumer groups. Java still hasn't implemented this
+            # because the error checking is hard to get right when some
+            # groups error and others don't.
+            request = DescribeGroupsRequest[version](groups=(group_id,))
+        elif version <= 3:
+            request = DescribeGroupsRequest[version](
+                groups=(group_id,),
+                include_authorized_operations=include_authorized_operations
+            )
+        else:
+            raise NotImplementedError(
+                "Support for DescribeGroupsRequest_v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        return self._send_request_to_node(group_coordinator_id, request)
+
+    def _describe_consumer_groups_process_response(self, response):
+        """Process a DescribeGroupsResponse into a group description."""
+        if response.API_VERSION <= 3:
+            assert len(response.groups) == 1
+            for response_field, response_name in zip(response.SCHEMA.fields, response.SCHEMA.names):
+                if isinstance(response_field, Array):
+                    described_groups_field_schema = response_field.array_of
+                    described_group = response.__dict__[response_name][0]
+                    described_group_information_list = []
+                    protocol_type_is_consumer = False
+                    for (described_group_information, group_information_name, group_information_field) in zip(described_group, described_groups_field_schema.names, described_groups_field_schema.fields):
+                        if group_information_name == 'protocol_type':
+                            protocol_type = described_group_information
+                            protocol_type_is_consumer = (protocol_type == ConsumerProtocol.PROTOCOL_TYPE or not protocol_type)
+                        if isinstance(group_information_field, Array):
+                            member_information_list = []
+                            member_schema = group_information_field.array_of
+                            for members in described_group_information:
+                                member_information = []
+                                for (member, member_field, member_name)  in zip(members, member_schema.fields, member_schema.names):
+                                    if protocol_type_is_consumer:
+                                        if member_name == 'member_metadata' and member:
+                                            member_information.append(ConsumerProtocolMemberMetadata.decode(member))
+                                        elif member_name == 'member_assignment' and member:
+                                            member_information.append(ConsumerProtocolMemberAssignment.decode(member))
+                                        else:
+                                            member_information.append(member)
+                                member_info_tuple = MemberInformation._make(member_information)
+                                member_information_list.append(member_info_tuple)
+                            described_group_information_list.append(member_information_list)
+                        else:
+                            described_group_information_list.append(described_group_information)
+                    # Version 3 of the DescribeGroups API introduced the "authorized_operations" field.
+                    # This will cause the namedtuple to fail.
+                    # Therefore, appending a placeholder of None in it.
+                    if response.API_VERSION <=2:
+                        described_group_information_list.append(None)
+                    group_description = GroupInformation._make(described_group_information_list)
+            error_code = group_description.error_code
+            error_type = Errors.for_code(error_code)
+            # Java has the note: KAFKA-6789, we can retry based on the error code
+            if error_type is not Errors.NoError:
+                raise error_type(
+                    "DescribeGroupsResponse failed with response '{}'."
+                    .format(response))
+        else:
+            raise NotImplementedError(
+                "Support for DescribeGroupsResponse_v{} has not yet been added to KafkaAdminClient."
+                .format(response.API_VERSION))
+        return group_description
+
+    def describe_consumer_groups(self, group_ids, group_coordinator_id=None, include_authorized_operations=False):
+        """Describe a set of consumer groups.
+
+        Any errors are immediately raised.
+
+        :param group_ids: A list of consumer group IDs. These are typically the
+            group names as strings.
+        :param group_coordinator_id: The node_id of the groups' coordinator
+            broker. If set to None, it will query the cluster for each group to
+            find that group's coordinator. Explicitly specifying this can be
+            useful for avoiding extra network round trips if you already know
+            the group coordinator. This is only useful when all the group_ids
+            have the same coordinator, otherwise it will error. Default: None.
+        :param include_authorized_operations: Whether or not to include
+            information about the operations a group is allowed to perform.
+            Only supported on API version >= v3. Default: False.
+        :return: A list of group descriptions. For now the group descriptions
+            are the raw results from the DescribeGroupsResponse. Long-term, we
+            plan to change this to return namedtuples as well as decoding the
+            partition assignments.
+        """
+        group_descriptions = []
+
+        if group_coordinator_id is not None:
+            groups_coordinators = {group_id: group_coordinator_id for group_id in group_ids}
+        else:
+            groups_coordinators = self._find_coordinator_ids(group_ids)
+
+        futures = [
+            self._describe_consumer_groups_send_request(
+                group_id,
+                coordinator_id,
+                include_authorized_operations)
+            for group_id, coordinator_id in groups_coordinators.items()
+        ]
+        self._wait_for_futures(futures)
+
+        for future in futures:
+            response = future.value
+            group_description = self._describe_consumer_groups_process_response(response)
+            group_descriptions.append(group_description)
+
+        return group_descriptions
+
+    def _list_consumer_groups_send_request(self, broker_id):
+        """Send a ListGroupsRequest to a broker.
+
+        :param broker_id: The broker's node_id.
+        :return: A message future
+        """
+        version = self._matching_api_version(ListGroupsRequest)
+        if version <= 2:
+            request = ListGroupsRequest[version]()
+        else:
+            raise NotImplementedError(
+                "Support for ListGroupsRequest_v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        return self._send_request_to_node(broker_id, request)
+
+    def _list_consumer_groups_process_response(self, response):
+        """Process a ListGroupsResponse into a list of groups."""
+        if response.API_VERSION <= 2:
+            error_type = Errors.for_code(response.error_code)
+            if error_type is not Errors.NoError:
+                raise error_type(
+                    "ListGroupsRequest failed with response '{}'."
+                    .format(response))
+        else:
+            raise NotImplementedError(
+                "Support for ListGroupsResponse_v{} has not yet been added to KafkaAdminClient."
+                .format(response.API_VERSION))
+        return response.groups
+
+    def list_consumer_groups(self, broker_ids=None):
+        """List all consumer groups known to the cluster.
+
+        This returns a list of Consumer Group tuples. The tuples are
+        composed of the consumer group name and the consumer group protocol
+        type.
+
+        Only consumer groups that store their offsets in Kafka are returned.
+        The protocol type will be an empty string for groups created using
+        Kafka < 0.9 APIs because, although they store their offsets in Kafka,
+        they don't use Kafka for group coordination. For groups created using
+        Kafka >= 0.9, the protocol type will typically be "consumer".
+
+        As soon as any error is encountered, it is immediately raised.
+
+        :param broker_ids: A list of broker node_ids to query for consumer
+            groups. If set to None, will query all brokers in the cluster.
+            Explicitly specifying broker(s) can be useful for determining which
+            consumer groups are coordinated by those broker(s). Default: None
+        :return list: List of tuples of Consumer Groups.
+        :exception GroupCoordinatorNotAvailableError: The coordinator is not
+            available, so cannot process requests.
+        :exception GroupLoadInProgressError: The coordinator is loading and
+            hence can't process requests.
+        """
+        # While we return a list, internally use a set to prevent duplicates
+        # because if a group coordinator fails after being queried, and its
+        # consumer groups move to new brokers that haven't yet been queried,
+        # then the same group could be returned by multiple brokers.
+        consumer_groups = set()
+        if broker_ids is None:
+            broker_ids = [broker.nodeId for broker in self._client.cluster.brokers()]
+        futures = [self._list_consumer_groups_send_request(b) for b in broker_ids]
+        self._wait_for_futures(futures)
+        for f in futures:
+            response = f.value
+            consumer_groups.update(self._list_consumer_groups_process_response(response))
+        return list(consumer_groups)
+
+    def _list_consumer_group_offsets_send_request(self, group_id,
+                group_coordinator_id, partitions=None):
+        """Send an OffsetFetchRequest to a broker.
+
+        :param group_id: The consumer group id name for which to fetch offsets.
+        :param group_coordinator_id: The node_id of the group's coordinator
+            broker.
+        :return: A message future
+        """
+        version = self._matching_api_version(OffsetFetchRequest)
+        if version <= 3:
+            if partitions is None:
+                if version <= 1:
+                    raise ValueError(
+                        """OffsetFetchRequest_v{} requires specifying the
+                        partitions for which to fetch offsets. Omitting the
+                        partitions is only supported on brokers >= 0.10.2.
+                        For details, see KIP-88.""".format(version))
+                topics_partitions = None
+            else:
+                # transform from [TopicPartition("t1", 1), TopicPartition("t1", 2)] to [("t1", [1, 2])]
+                topics_partitions_dict = defaultdict(set)
+                for topic, partition in partitions:
+                    topics_partitions_dict[topic].add(partition)
+                topics_partitions = list(six.iteritems(topics_partitions_dict))
+            request = OffsetFetchRequest[version](group_id, topics_partitions)
+        else:
+            raise NotImplementedError(
+                "Support for OffsetFetchRequest_v{} has not yet been added to KafkaAdminClient."
+                .format(version))
+        return self._send_request_to_node(group_coordinator_id, request)
+
+    def _list_consumer_group_offsets_process_response(self, response):
+        """Process an OffsetFetchResponse.
+
+        :param response: an OffsetFetchResponse.
+        :return: A dictionary composed of TopicPartition keys and
+            OffsetAndMetada values.
+        """
+        if response.API_VERSION <= 3:
+
+            # OffsetFetchResponse_v1 lacks a top-level error_code
+            if response.API_VERSION > 1:
+                error_type = Errors.for_code(response.error_code)
+                if error_type is not Errors.NoError:
+                    # optionally we could retry if error_type.retriable
+                    raise error_type(
+                        "OffsetFetchResponse failed with response '{}'."
+                        .format(response))
+
+            # transform response into a dictionary with TopicPartition keys and
+            # OffsetAndMetada values--this is what the Java AdminClient returns
+            offsets = {}
+            for topic, partitions in response.topics:
+                for partition, offset, metadata, error_code in partitions:
+                    error_type = Errors.for_code(error_code)
+                    if error_type is not Errors.NoError:
+                        raise error_type(
+                            "Unable to fetch consumer group offsets for topic {}, partition {}"
+                            .format(topic, partition))
+                    offsets[TopicPartition(topic, partition)] = OffsetAndMetadata(offset, metadata)
+        else:
+            raise NotImplementedError(
+                "Support for OffsetFetchResponse_v{} has not yet been added to KafkaAdminClient."
+                .format(response.API_VERSION))
+        return offsets
+
+    def list_consumer_group_offsets(self, group_id, group_coordinator_id=None,
+                                    partitions=None):
+        """Fetch Consumer Offsets for a single consumer group.
+
+        Note:
+        This does not verify that the group_id or partitions actually exist
+        in the cluster.
+
+        As soon as any error is encountered, it is immediately raised.
+
+        :param group_id: The consumer group id name for which to fetch offsets.
+        :param group_coordinator_id: The node_id of the group's coordinator
+            broker. If set to None, will query the cluster to find the group
+            coordinator. Explicitly specifying this can be useful to prevent
+            that extra network round trip if you already know the group
+            coordinator. Default: None.
+        :param partitions: A list of TopicPartitions for which to fetch
+            offsets. On brokers >= 0.10.2, this can be set to None to fetch all
+            known offsets for the consumer group. Default: None.
+        :return dictionary: A dictionary with TopicPartition keys and
+            OffsetAndMetada values. Partitions that are not specified and for
+            which the group_id does not have a recorded offset are omitted. An
+            offset value of `-1` indicates the group_id has no offset for that
+            TopicPartition. A `-1` can only happen for partitions that are
+            explicitly specified.
+        """
+        if group_coordinator_id is None:
+            group_coordinator_id = self._find_coordinator_ids([group_id])[group_id]
+        future = self._list_consumer_group_offsets_send_request(
+                                    group_id, group_coordinator_id, partitions)
+        self._wait_for_futures([future])
+        response = future.value
+        return self._list_consumer_group_offsets_process_response(response)
+
+    def delete_consumer_groups(self, group_ids, group_coordinator_id=None):
+        """Delete Consumer Group Offsets for given consumer groups.
+
+        Note:
+        This does not verify that the group ids actually exist and
+        group_coordinator_id is the correct coordinator for all these groups.
+
+        The result needs checking for potential errors.
+
+        :param group_ids: The consumer group ids of the groups which are to be deleted.
+        :param group_coordinator_id: The node_id of the broker which is the coordinator for
+            all the groups. Use only if all groups are coordinated by the same broker.
+            If set to None, will query the cluster to find the coordinator for every single group.
+            Explicitly specifying this can be useful to prevent
+            that extra network round trips if you already know the group
+            coordinator. Default: None.
+        :return: A list of tuples (group_id, KafkaError)
+        """
+        if group_coordinator_id is not None:
+            futures = [self._delete_consumer_groups_send_request(group_ids, group_coordinator_id)]
+        else:
+            coordinators_groups = defaultdict(list)
+            for group_id, coordinator_id in self._find_coordinator_ids(group_ids).items():
+                coordinators_groups[coordinator_id].append(group_id)
+            futures = [
+                self._delete_consumer_groups_send_request(group_ids, coordinator_id)
+                for coordinator_id, group_ids in coordinators_groups.items()
+            ]
+
+        self._wait_for_futures(futures)
+
+        results = []
+        for f in futures:
+            results.extend(self._convert_delete_groups_response(f.value))
+        return results
+
+    def _convert_delete_groups_response(self, response):
+        if response.API_VERSION <= 1:
+            results = []
+            for group_id, error_code in response.results:
+                results.append((group_id, Errors.for_code(error_code)))
+            return results
+        else:
+            raise NotImplementedError(
+                "Support for DeleteGroupsResponse_v{} has not yet been added to KafkaAdminClient."
+                    .format(response.API_VERSION))
+
+    def _delete_consumer_groups_send_request(self, group_ids, group_coordinator_id):
+        """Send a DeleteGroups request to a broker.
+
+        :param group_ids: The consumer group ids of the groups which are to be deleted.
+        :param group_coordinator_id: The node_id of the broker which is the coordinator for
+            all the groups.
+        :return: A message future
+        """
+        version = self._matching_api_version(DeleteGroupsRequest)
+        if version <= 1:
+            request = DeleteGroupsRequest[version](group_ids)
+        else:
+            raise NotImplementedError(
+                "Support for DeleteGroupsRequest_v{} has not yet been added to KafkaAdminClient."
+                    .format(version))
+        return self._send_request_to_node(group_coordinator_id, request)
+
+    def _wait_for_futures(self, futures):
+        while not all(future.succeeded() for future in futures):
+            for future in futures:
+                self._client.poll(future=future)
+
+                if future.failed():
+                    raise future.exception  # pylint: disable-msg=raising-bad-type

testbed/dpkp__kafka-python/kafka/admin/config_resource.py

@@ -0,0 +1,36 @@
+from __future__ import absolute_import
+
+# enum in stdlib as of py3.4
+try:
+    from enum import IntEnum  # pylint: disable=import-error
+except ImportError:
+    # vendored backport module
+    from kafka.vendor.enum34 import IntEnum
+
+
+class ConfigResourceType(IntEnum):
+    """An enumerated type of config resources"""
+
+    BROKER = 4,
+    TOPIC = 2
+
+
+class ConfigResource(object):
+    """A class for specifying config resources.
+    Arguments:
+        resource_type (ConfigResourceType): the type of kafka resource
+        name (string): The name of the kafka resource
+        configs ({key : value}): A  maps of config keys to values.
+    """
+
+    def __init__(
+            self,
+            resource_type,
+            name,
+            configs=None
+    ):
+        if not isinstance(resource_type, (ConfigResourceType)):
+            resource_type = ConfigResourceType[str(resource_type).upper()] # pylint: disable-msg=unsubscriptable-object
+        self.resource_type = resource_type
+        self.name = name
+        self.configs = configs

testbed/dpkp__kafka-python/kafka/admin/new_partitions.py

@@ -0,0 +1,19 @@
+from __future__ import absolute_import
+
+
+class NewPartitions(object):
+    """A class for new partition creation on existing topics.  Note that the length of new_assignments, if specified,
+    must be the difference between the new total number of partitions and the existing number of partitions.
+    Arguments:
+        total_count (int): the total number of partitions that should exist on the topic
+        new_assignments ([[int]]): an array of arrays of replica assignments for new partitions.
+            If not set, broker assigns replicas per an internal algorithm.
+    """
+
+    def __init__(
+        self,
+        total_count,
+        new_assignments=None
+    ):
+        self.total_count = total_count
+        self.new_assignments = new_assignments

testbed/dpkp__kafka-python/kafka/admin/new_topic.py

@@ -0,0 +1,34 @@
+from __future__ import absolute_import
+
+from kafka.errors import IllegalArgumentError
+
+
+class NewTopic(object):
+    """ A class for new topic creation
+    Arguments:
+        name (string): name of the topic
+        num_partitions (int): number of partitions
+            or -1 if replica_assignment has been specified
+        replication_factor (int): replication factor or -1 if
+            replica assignment is specified
+        replica_assignment (dict of int: [int]): A mapping containing
+            partition id and replicas to assign to it.
+        topic_configs (dict of str: str): A mapping of config key
+            and value for the topic.
+    """
+
+    def __init__(
+            self,
+            name,
+            num_partitions,
+            replication_factor,
+            replica_assignments=None,
+            topic_configs=None,
+    ):
+        if not (num_partitions == -1 or replication_factor == -1) ^ (replica_assignments is None):
+            raise IllegalArgumentError('either num_partitions/replication_factor or replica_assignment must be specified')
+        self.name = name
+        self.num_partitions = num_partitions
+        self.replication_factor = replication_factor
+        self.replica_assignments = replica_assignments or {}
+        self.topic_configs = topic_configs or {}

testbed/dpkp__kafka-python/kafka/client_async.py

@@ -0,0 +1,1077 @@
+from __future__ import absolute_import, division
+
+import collections
+import copy
+import logging
+import random
+import socket
+import threading
+import time
+import weakref
+
+# selectors in stdlib as of py3.4
+try:
+    import selectors  # pylint: disable=import-error
+except ImportError:
+    # vendored backport module
+    from kafka.vendor import selectors34 as selectors
+
+from kafka.vendor import six
+
+from kafka.cluster import ClusterMetadata
+from kafka.conn import BrokerConnection, ConnectionStates, collect_hosts, get_ip_port_afi
+from kafka import errors as Errors
+from kafka.future import Future
+from kafka.metrics import AnonMeasurable
+from kafka.metrics.stats import Avg, Count, Rate
+from kafka.metrics.stats.rate import TimeUnit
+from kafka.protocol.metadata import MetadataRequest
+from kafka.util import Dict, WeakMethod
+# Although this looks unused, it actually monkey-patches socket.socketpair()
+# and should be left in as long as we're using socket.socketpair() in this file
+from kafka.vendor import socketpair
+from kafka.version import __version__
+
+if six.PY2:
+    ConnectionError = None
+
+
+log = logging.getLogger('kafka.client')
+
+
+class KafkaClient(object):
+    """
+    A network client for asynchronous request/response network I/O.
+
+    This is an internal class used to implement the user-facing producer and
+    consumer clients.
+
+    This class is not thread-safe!
+
+    Attributes:
+        cluster (:any:`ClusterMetadata`): Local cache of cluster metadata, retrieved
+            via MetadataRequests during :meth:`~kafka.KafkaClient.poll`.
+
+    Keyword Arguments:
+        bootstrap_servers: 'host[:port]' string (or list of 'host[:port]'
+            strings) that the client 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. Also
+            submitted to GroupCoordinator for logging with respect to
+            consumer group administration. Default: 'kafka-python-{version}'
+        reconnect_backoff_ms (int): The amount of time in milliseconds to
+            wait before attempting to reconnect to a given host.
+            Default: 50.
+        reconnect_backoff_max_ms (int): The maximum amount of time in
+            milliseconds to backoff/wait when reconnecting to a broker that has
+            repeatedly failed to connect. If provided, the backoff per host
+            will increase exponentially for each consecutive connection
+            failure, up to this maximum. Once the maximum is reached,
+            reconnection attempts will continue periodically with this fixed
+            rate. To avoid connection storms, a randomization factor of 0.2
+            will be applied to the backoff resulting in a random range between
+            20% below and 20% above the computed value. Default: 1000.
+        request_timeout_ms (int): Client request timeout in milliseconds.
+            Default: 30000.
+        connections_max_idle_ms: Close idle connections after the number of
+            milliseconds specified by this config. The broker closes idle
+            connections after connections.max.idle.ms, so this avoids hitting
+            unexpected socket disconnected errors on the client.
+            Default: 540000
+        retry_backoff_ms (int): Milliseconds to backoff when retrying on
+            errors. Default: 100.
+        max_in_flight_requests_per_connection (int): Requests are pipelined
+            to kafka brokers up to this number of maximum requests per
+            broker connection. Default: 5.
+        receive_buffer_bytes (int): The size of the TCP receive buffer
+            (SO_RCVBUF) to use when reading data. Default: None (relies on
+            system defaults). Java client defaults to 32768.
+        send_buffer_bytes (int): The size of the TCP send buffer
+            (SO_SNDBUF) to use when sending data. Default: None (relies on
+            system defaults). Java client defaults to 131072.
+        socket_options (list): List of tuple-arguments to socket.setsockopt
+            to apply to broker connection sockets. Default:
+            [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]
+        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
+        security_protocol (str): Protocol used to communicate with brokers.
+            Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL.
+            Default: PLAINTEXT.
+        ssl_context (ssl.SSLContext): Pre-configured SSLContext for wrapping
+            socket connections. If provided, all other ssl_* configurations
+            will be ignored. Default: None.
+        ssl_check_hostname (bool): Flag to configure whether SSL handshake
+            should verify that the certificate matches the broker's hostname.
+            Default: True.
+        ssl_cafile (str): Optional filename of CA file to use in certificate
+            verification. Default: None.
+        ssl_certfile (str): Optional filename of file in PEM format containing
+            the client certificate, as well as any CA certificates needed to
+            establish the certificate's authenticity. Default: None.
+        ssl_keyfile (str): Optional filename containing the client private key.
+            Default: None.
+        ssl_password (str): Optional password to be used when loading the
+            certificate chain. Default: None.
+        ssl_crlfile (str): Optional filename containing the CRL to check for
+            certificate expiration. By default, no CRL check is done. When
+            providing a file, only the leaf certificate will be checked against
+            this CRL. The CRL can only be checked with Python 3.4+ or 2.7.9+.
+            Default: None.
+        ssl_ciphers (str): optionally set the available ciphers for ssl
+            connections. It should be a string in the OpenSSL cipher list
+            format. If no cipher can be selected (because compile-time options
+            or other configuration forbids use of all the specified ciphers),
+            an ssl.SSLError will be raised. See ssl.SSLContext.set_ciphers
+        api_version (tuple): Specify which Kafka API version to use. If set
+            to None, KafkaClient will attempt to infer the broker version by
+            probing various APIs. Example: (0, 10, 2). Default: None
+        api_version_auto_timeout_ms (int): number of milliseconds to throw a
+            timeout exception from the constructor when checking the broker
+            api version. Only applies if api_version is None
+        selector (selectors.BaseSelector): Provide a specific selector
+            implementation to use for I/O multiplexing.
+            Default: selectors.DefaultSelector
+        metrics (kafka.metrics.Metrics): Optionally provide a metrics
+            instance for capturing network IO stats. Default: None.
+        metric_group_prefix (str): Prefix for metric names. Default: ''
+        sasl_mechanism (str): Authentication mechanism when security_protocol
+            is configured for SASL_PLAINTEXT or SASL_SSL. Valid values are:
+            PLAIN, GSSAPI, OAUTHBEARER, SCRAM-SHA-256, SCRAM-SHA-512.
+        sasl_plain_username (str): username for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_plain_password (str): password for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_kerberos_service_name (str): Service name to include in GSSAPI
+            sasl mechanism handshake. Default: 'kafka'
+        sasl_kerberos_domain_name (str): kerberos domain name to use in GSSAPI
+            sasl mechanism handshake. Default: one of bootstrap servers
+        sasl_oauth_token_provider (AbstractTokenProvider): OAuthBearer token provider
+            instance. (See kafka.oauth.abstract). Default: None
+    """
+
+    DEFAULT_CONFIG = {
+        'bootstrap_servers': 'localhost',
+        'bootstrap_topics_filter': set(),
+        'client_id': 'kafka-python-' + __version__,
+        'request_timeout_ms': 30000,
+        'wakeup_timeout_ms': 3000,
+        'connections_max_idle_ms': 9 * 60 * 1000,
+        'reconnect_backoff_ms': 50,
+        'reconnect_backoff_max_ms': 1000,
+        'max_in_flight_requests_per_connection': 5,
+        'receive_buffer_bytes': None,
+        'send_buffer_bytes': None,
+        'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],
+        'sock_chunk_bytes': 4096,  # undocumented experimental option
+        'sock_chunk_buffer_count': 1000,  # undocumented experimental option
+        'retry_backoff_ms': 100,
+        'metadata_max_age_ms': 300000,
+        'security_protocol': 'PLAINTEXT',
+        'ssl_context': None,
+        'ssl_check_hostname': True,
+        'ssl_cafile': None,
+        'ssl_certfile': None,
+        'ssl_keyfile': None,
+        'ssl_password': None,
+        'ssl_crlfile': None,
+        'ssl_ciphers': None,
+        'api_version': None,
+        'api_version_auto_timeout_ms': 2000,
+        'selector': selectors.DefaultSelector,
+        'metrics': None,
+        'metric_group_prefix': '',
+        'sasl_mechanism': None,
+        'sasl_plain_username': None,
+        'sasl_plain_password': None,
+        'sasl_kerberos_service_name': 'kafka',
+        'sasl_kerberos_domain_name': None,
+        'sasl_oauth_token_provider': None
+    }
+
+    def __init__(self, **configs):
+        self.config = copy.copy(self.DEFAULT_CONFIG)
+        for key in self.config:
+            if key in configs:
+                self.config[key] = configs[key]
+
+        # these properties need to be set on top of the initialization pipeline
+        # because they are used when __del__ method is called
+        self._closed = False
+        self._wake_r, self._wake_w = socket.socketpair()
+        self._selector = self.config['selector']()
+
+        self.cluster = ClusterMetadata(**self.config)
+        self._topics = set()  # empty set will fetch all topic metadata
+        self._metadata_refresh_in_progress = False
+        self._conns = Dict()  # object to support weakrefs
+        self._api_versions = None
+        self._connecting = set()
+        self._sending = set()
+        self._refresh_on_disconnects = True
+        self._last_bootstrap = 0
+        self._bootstrap_fails = 0
+        self._wake_r.setblocking(False)
+        self._wake_w.settimeout(self.config['wakeup_timeout_ms'] / 1000.0)
+        self._wake_lock = threading.Lock()
+
+        self._lock = threading.RLock()
+
+        # when requests complete, they are transferred to this queue prior to
+        # invocation. The purpose is to avoid invoking them while holding the
+        # lock above.
+        self._pending_completion = collections.deque()
+
+        self._selector.register(self._wake_r, selectors.EVENT_READ)
+        self._idle_expiry_manager = IdleConnectionManager(self.config['connections_max_idle_ms'])
+        self._sensors = None
+        if self.config['metrics']:
+            self._sensors = KafkaClientMetrics(self.config['metrics'],
+                                               self.config['metric_group_prefix'],
+                                               weakref.proxy(self._conns))
+
+        self._num_bootstrap_hosts = len(collect_hosts(self.config['bootstrap_servers']))
+
+        # Check Broker Version if not set explicitly
+        if self.config['api_version'] is None:
+            check_timeout = self.config['api_version_auto_timeout_ms'] / 1000
+            self.config['api_version'] = self.check_version(timeout=check_timeout)
+
+    def _can_bootstrap(self):
+        effective_failures = self._bootstrap_fails // self._num_bootstrap_hosts
+        backoff_factor = 2 ** effective_failures
+        backoff_ms = min(self.config['reconnect_backoff_ms'] * backoff_factor,
+                         self.config['reconnect_backoff_max_ms'])
+
+        backoff_ms *= random.uniform(0.8, 1.2)
+
+        next_at = self._last_bootstrap + backoff_ms / 1000.0
+        now = time.time()
+        if next_at > now:
+            return False
+        return True
+
+    def _can_connect(self, node_id):
+        if node_id not in self._conns:
+            if self.cluster.broker_metadata(node_id):
+                return True
+            return False
+        conn = self._conns[node_id]
+        return conn.disconnected() and not conn.blacked_out()
+
+    def _conn_state_change(self, node_id, sock, conn):
+        with self._lock:
+            if conn.connecting():
+                # SSL connections can enter this state 2x (second during Handshake)
+                if node_id not in self._connecting:
+                    self._connecting.add(node_id)
+                try:
+                    self._selector.register(sock, selectors.EVENT_WRITE, conn)
+                except KeyError:
+                    self._selector.modify(sock, selectors.EVENT_WRITE, conn)
+
+                if self.cluster.is_bootstrap(node_id):
+                    self._last_bootstrap = time.time()
+
+            elif conn.connected():
+                log.debug("Node %s connected", node_id)
+                if node_id in self._connecting:
+                    self._connecting.remove(node_id)
+
+                try:
+                    self._selector.modify(sock, selectors.EVENT_READ, conn)
+                except KeyError:
+                    self._selector.register(sock, selectors.EVENT_READ, conn)
+
+                if self._sensors:
+                    self._sensors.connection_created.record()
+
+                self._idle_expiry_manager.update(node_id)
+
+                if self.cluster.is_bootstrap(node_id):
+                    self._bootstrap_fails = 0
+
+                else:
+                    for node_id in list(self._conns.keys()):
+                        if self.cluster.is_bootstrap(node_id):
+                            self._conns.pop(node_id).close()
+
+            # Connection failures imply that our metadata is stale, so let's refresh
+            elif conn.state is ConnectionStates.DISCONNECTED:
+                if node_id in self._connecting:
+                    self._connecting.remove(node_id)
+                try:
+                    self._selector.unregister(sock)
+                except KeyError:
+                    pass
+
+                if self._sensors:
+                    self._sensors.connection_closed.record()
+
+                idle_disconnect = False
+                if self._idle_expiry_manager.is_expired(node_id):
+                    idle_disconnect = True
+                self._idle_expiry_manager.remove(node_id)
+
+                # If the connection has already by popped from self._conns,
+                # we can assume the disconnect was intentional and not a failure
+                if node_id not in self._conns:
+                    pass
+
+                elif self.cluster.is_bootstrap(node_id):
+                    self._bootstrap_fails += 1
+
+                elif self._refresh_on_disconnects and not self._closed and not idle_disconnect:
+                    log.warning("Node %s connection failed -- refreshing metadata", node_id)
+                    self.cluster.request_update()
+
+    def maybe_connect(self, node_id, wakeup=True):
+        """Queues a node for asynchronous connection during the next .poll()"""
+        if self._can_connect(node_id):
+            self._connecting.add(node_id)
+            # Wakeup signal is useful in case another thread is
+            # blocked waiting for incoming network traffic while holding
+            # the client lock in poll().
+            if wakeup:
+                self.wakeup()
+            return True
+        return False
+
+    def _should_recycle_connection(self, conn):
+        # Never recycle unless disconnected
+        if not conn.disconnected():
+            return False
+
+        # Otherwise, only recycle when broker metadata has changed
+        broker = self.cluster.broker_metadata(conn.node_id)
+        if broker is None:
+            return False
+
+        host, _, afi = get_ip_port_afi(broker.host)
+        if conn.host != host or conn.port != broker.port:
+            log.info("Broker metadata change detected for node %s"
+                     " from %s:%s to %s:%s", conn.node_id, conn.host, conn.port,
+                     broker.host, broker.port)
+            return True
+
+        return False
+
+    def _maybe_connect(self, node_id):
+        """Idempotent non-blocking connection attempt to the given node id."""
+        with self._lock:
+            conn = self._conns.get(node_id)
+
+            if conn is None:
+                broker = self.cluster.broker_metadata(node_id)
+                assert broker, 'Broker id %s not in current metadata' % (node_id,)
+
+                log.debug("Initiating connection to node %s at %s:%s",
+                          node_id, broker.host, broker.port)
+                host, port, afi = get_ip_port_afi(broker.host)
+                cb = WeakMethod(self._conn_state_change)
+                conn = BrokerConnection(host, broker.port, afi,
+                                        state_change_callback=cb,
+                                        node_id=node_id,
+                                        **self.config)
+                self._conns[node_id] = conn
+
+            # Check if existing connection should be recreated because host/port changed
+            elif self._should_recycle_connection(conn):
+                self._conns.pop(node_id)
+                return False
+
+            elif conn.connected():
+                return True
+
+            conn.connect()
+            return conn.connected()
+
+    def ready(self, node_id, metadata_priority=True):
+        """Check whether a node is connected and ok to send more requests.
+
+        Arguments:
+            node_id (int): the id of the node to check
+            metadata_priority (bool): Mark node as not-ready if a metadata
+                refresh is required. Default: True
+
+        Returns:
+            bool: True if we are ready to send to the given node
+        """
+        self.maybe_connect(node_id)
+        return self.is_ready(node_id, metadata_priority=metadata_priority)
+
+    def connected(self, node_id):
+        """Return True iff the node_id is connected."""
+        conn = self._conns.get(node_id)
+        if conn is None:
+            return False
+        return conn.connected()
+
+    def _close(self):
+        if not self._closed:
+            self._closed = True
+            self._wake_r.close()
+            self._wake_w.close()
+            self._selector.close()
+
+    def close(self, node_id=None):
+        """Close one or all broker connections.
+
+        Arguments:
+            node_id (int, optional): the id of the node to close
+        """
+        with self._lock:
+            if node_id is None:
+                self._close()
+                conns = list(self._conns.values())
+                self._conns.clear()
+                for conn in conns:
+                    conn.close()
+            elif node_id in self._conns:
+                self._conns.pop(node_id).close()
+            else:
+                log.warning("Node %s not found in current connection list; skipping", node_id)
+                return
+
+    def __del__(self):
+        self._close()
+
+    def is_disconnected(self, node_id):
+        """Check whether the node connection has been disconnected or failed.
+
+        A disconnected node has either been closed or has failed. Connection
+        failures are usually transient and can be resumed in the next ready()
+        call, but there are cases where transient failures need to be caught
+        and re-acted upon.
+
+        Arguments:
+            node_id (int): the id of the node to check
+
+        Returns:
+            bool: True iff the node exists and is disconnected
+        """
+        conn = self._conns.get(node_id)
+        if conn is None:
+            return False
+        return conn.disconnected()
+
+    def connection_delay(self, node_id):
+        """
+        Return the number of milliseconds to wait, based on the connection
+        state, before attempting to send data. When disconnected, this respects
+        the reconnect backoff time. When connecting, returns 0 to allow
+        non-blocking connect to finish. When connected, returns a very large
+        number to handle slow/stalled connections.
+
+        Arguments:
+            node_id (int): The id of the node to check
+
+        Returns:
+            int: The number of milliseconds to wait.
+        """
+        conn = self._conns.get(node_id)
+        if conn is None:
+            return 0
+        return conn.connection_delay()
+
+    def is_ready(self, node_id, metadata_priority=True):
+        """Check whether a node is ready to send more requests.
+
+        In addition to connection-level checks, this method also is used to
+        block additional requests from being sent during a metadata refresh.
+
+        Arguments:
+            node_id (int): id of the node to check
+            metadata_priority (bool): Mark node as not-ready if a metadata
+                refresh is required. Default: True
+
+        Returns:
+            bool: True if the node is ready and metadata is not refreshing
+        """
+        if not self._can_send_request(node_id):
+            return False
+
+        # if we need to update our metadata now declare all requests unready to
+        # make metadata requests first priority
+        if metadata_priority:
+            if self._metadata_refresh_in_progress:
+                return False
+            if self.cluster.ttl() == 0:
+                return False
+        return True
+
+    def _can_send_request(self, node_id):
+        conn = self._conns.get(node_id)
+        if not conn:
+            return False
+        return conn.connected() and conn.can_send_more()
+
+    def send(self, node_id, request, wakeup=True):
+        """Send a request to a specific node. Bytes are placed on an
+        internal per-connection send-queue. Actual network I/O will be
+        triggered in a subsequent call to .poll()
+
+        Arguments:
+            node_id (int): destination node
+            request (Struct): request object (not-encoded)
+            wakeup (bool): optional flag to disable thread-wakeup
+
+        Raises:
+            AssertionError: if node_id is not in current cluster metadata
+
+        Returns:
+            Future: resolves to Response struct or Error
+        """
+        conn = self._conns.get(node_id)
+        if not conn or not self._can_send_request(node_id):
+            self.maybe_connect(node_id, wakeup=wakeup)
+            return Future().failure(Errors.NodeNotReadyError(node_id))
+
+        # conn.send will queue the request internally
+        # we will need to call send_pending_requests()
+        # to trigger network I/O
+        future = conn.send(request, blocking=False)
+        self._sending.add(conn)
+
+        # Wakeup signal is useful in case another thread is
+        # blocked waiting for incoming network traffic while holding
+        # the client lock in poll().
+        if wakeup:
+            self.wakeup()
+
+        return future
+
+    def poll(self, timeout_ms=None, future=None):
+        """Try to read and write to sockets.
+
+        This method will also attempt to complete node connections, refresh
+        stale metadata, and run previously-scheduled tasks.
+
+        Arguments:
+            timeout_ms (int, optional): maximum amount of time to wait (in ms)
+                for at least one response. Must be non-negative. The actual
+                timeout will be the minimum of timeout, request timeout and
+                metadata timeout. Default: request_timeout_ms
+            future (Future, optional): if provided, blocks until future.is_done
+
+        Returns:
+            list: responses received (can be empty)
+        """
+        if future is not None:
+            timeout_ms = 100
+        elif timeout_ms is None:
+            timeout_ms = self.config['request_timeout_ms']
+        elif not isinstance(timeout_ms, (int, float)):
+            raise TypeError('Invalid type for timeout: %s' % type(timeout_ms))
+
+        # Loop for futures, break after first loop if None
+        responses = []
+        while True:
+            with self._lock:
+                if self._closed:
+                    break
+
+                # Attempt to complete pending connections
+                for node_id in list(self._connecting):
+                    self._maybe_connect(node_id)
+
+                # Send a metadata request if needed
+                metadata_timeout_ms = self._maybe_refresh_metadata()
+
+                # If we got a future that is already done, don't block in _poll
+                if future is not None and future.is_done:
+                    timeout = 0
+                else:
+                    idle_connection_timeout_ms = self._idle_expiry_manager.next_check_ms()
+                    timeout = min(
+                        timeout_ms,
+                        metadata_timeout_ms,
+                        idle_connection_timeout_ms,
+                        self.config['request_timeout_ms'])
+                    # if there are no requests in flight, do not block longer than the retry backoff
+                    if self.in_flight_request_count() == 0:
+                        timeout = min(timeout, self.config['retry_backoff_ms'])
+                    timeout = max(0, timeout)  # avoid negative timeouts
+
+                self._poll(timeout / 1000)
+
+            # called without the lock to avoid deadlock potential
+            # if handlers need to acquire locks
+            responses.extend(self._fire_pending_completed_requests())
+
+            # If all we had was a timeout (future is None) - only do one poll
+            # If we do have a future, we keep looping until it is done
+            if future is None or future.is_done:
+                break
+
+        return responses
+
+    def _register_send_sockets(self):
+        while self._sending:
+            conn = self._sending.pop()
+            try:
+                key = self._selector.get_key(conn._sock)
+                events = key.events | selectors.EVENT_WRITE
+                self._selector.modify(key.fileobj, events, key.data)
+            except KeyError:
+                self._selector.register(conn._sock, selectors.EVENT_WRITE, conn)
+
+    def _poll(self, timeout):
+        # This needs to be locked, but since it is only called from within the
+        # locked section of poll(), there is no additional lock acquisition here
+        processed = set()
+
+        # Send pending requests first, before polling for responses
+        self._register_send_sockets()
+
+        start_select = time.time()
+        ready = self._selector.select(timeout)
+        end_select = time.time()
+        if self._sensors:
+            self._sensors.select_time.record((end_select - start_select) * 1000000000)
+
+        for key, events in ready:
+            if key.fileobj is self._wake_r:
+                self._clear_wake_fd()
+                continue
+
+            # Send pending requests if socket is ready to write
+            if events & selectors.EVENT_WRITE:
+                conn = key.data
+                if conn.connecting():
+                    conn.connect()
+                else:
+                    if conn.send_pending_requests_v2():
+                        # If send is complete, we dont need to track write readiness
+                        # for this socket anymore
+                        if key.events ^ selectors.EVENT_WRITE:
+                            self._selector.modify(
+                                key.fileobj,
+                                key.events ^ selectors.EVENT_WRITE,
+                                key.data)
+                        else:
+                            self._selector.unregister(key.fileobj)
+
+            if not (events & selectors.EVENT_READ):
+                continue
+            conn = key.data
+            processed.add(conn)
+
+            if not conn.in_flight_requests:
+                # if we got an EVENT_READ but there were no in-flight requests, one of
+                # two things has happened:
+                #
+                # 1. The remote end closed the connection (because it died, or because
+                #    a firewall timed out, or whatever)
+                # 2. The protocol is out of sync.
+                #
+                # either way, we can no longer safely use this connection
+                #
+                # Do a 1-byte read to check protocol didnt get out of sync, and then close the conn
+                try:
+                    unexpected_data = key.fileobj.recv(1)
+                    if unexpected_data:  # anything other than a 0-byte read means protocol issues
+                        log.warning('Protocol out of sync on %r, closing', conn)
+                except socket.error:
+                    pass
+                conn.close(Errors.KafkaConnectionError('Socket EVENT_READ without in-flight-requests'))
+                continue
+
+            self._idle_expiry_manager.update(conn.node_id)
+            self._pending_completion.extend(conn.recv())
+
+        # Check for additional pending SSL bytes
+        if self.config['security_protocol'] in ('SSL', 'SASL_SSL'):
+            # TODO: optimize
+            for conn in self._conns.values():
+                if conn not in processed and conn.connected() and conn._sock.pending():
+                    self._pending_completion.extend(conn.recv())
+
+        for conn in six.itervalues(self._conns):
+            if conn.requests_timed_out():
+                log.warning('%s timed out after %s ms. Closing connection.',
+                            conn, conn.config['request_timeout_ms'])
+                conn.close(error=Errors.RequestTimedOutError(
+                    'Request timed out after %s ms' %
+                    conn.config['request_timeout_ms']))
+
+        if self._sensors:
+            self._sensors.io_time.record((time.time() - end_select) * 1000000000)
+
+        self._maybe_close_oldest_connection()
+
+    def in_flight_request_count(self, node_id=None):
+        """Get the number of in-flight requests for a node or all nodes.
+
+        Arguments:
+            node_id (int, optional): a specific node to check. If unspecified,
+                return the total for all nodes
+
+        Returns:
+            int: pending in-flight requests for the node, or all nodes if None
+        """
+        if node_id is not None:
+            conn = self._conns.get(node_id)
+            if conn is None:
+                return 0
+            return len(conn.in_flight_requests)
+        else:
+            return sum([len(conn.in_flight_requests)
+                        for conn in list(self._conns.values())])
+
+    def _fire_pending_completed_requests(self):
+        responses = []
+        while True:
+            try:
+                # We rely on deque.popleft remaining threadsafe
+                # to allow both the heartbeat thread and the main thread
+                # to process responses
+                response, future = self._pending_completion.popleft()
+            except IndexError:
+                break
+            future.success(response)
+            responses.append(response)
+        return responses
+
+    def least_loaded_node(self):
+        """Choose the node with fewest outstanding requests, with fallbacks.
+
+        This method will prefer a node with an existing connection and no
+        in-flight-requests. If no such node is found, a node will be chosen
+        randomly from disconnected nodes that are not "blacked out" (i.e.,
+        are not subject to a reconnect backoff). If no node metadata has been
+        obtained, will return a bootstrap node (subject to exponential backoff).
+
+        Returns:
+            node_id or None if no suitable node was found
+        """
+        nodes = [broker.nodeId for broker in self.cluster.brokers()]
+        random.shuffle(nodes)
+
+        inflight = float('inf')
+        found = None
+        for node_id in nodes:
+            conn = self._conns.get(node_id)
+            connected = conn is not None and conn.connected()
+            blacked_out = conn is not None and conn.blacked_out()
+            curr_inflight = len(conn.in_flight_requests) if conn is not None else 0
+            if connected and curr_inflight == 0:
+                # if we find an established connection
+                # with no in-flight requests, we can stop right away
+                return node_id
+            elif not blacked_out and curr_inflight < inflight:
+                # otherwise if this is the best we have found so far, record that
+                inflight = curr_inflight
+                found = node_id
+
+        return found
+
+    def set_topics(self, topics):
+        """Set specific topics to track for metadata.
+
+        Arguments:
+            topics (list of str): topics to check for metadata
+
+        Returns:
+            Future: resolves after metadata request/response
+        """
+        if set(topics).difference(self._topics):
+            future = self.cluster.request_update()
+        else:
+            future = Future().success(set(topics))
+        self._topics = set(topics)
+        return future
+
+    def add_topic(self, topic):
+        """Add a topic to the list of topics tracked via metadata.
+
+        Arguments:
+            topic (str): topic to track
+
+        Returns:
+            Future: resolves after metadata request/response
+        """
+        if topic in self._topics:
+            return Future().success(set(self._topics))
+
+        self._topics.add(topic)
+        return self.cluster.request_update()
+
+    # This method should be locked when running multi-threaded
+    def _maybe_refresh_metadata(self, wakeup=False):
+        """Send a metadata request if needed.
+
+        Returns:
+            int: milliseconds until next refresh
+        """
+        ttl = self.cluster.ttl()
+        wait_for_in_progress_ms = self.config['request_timeout_ms'] if self._metadata_refresh_in_progress else 0
+        metadata_timeout = max(ttl, wait_for_in_progress_ms)
+
+        if metadata_timeout > 0:
+            return metadata_timeout
+
+        # Beware that the behavior of this method and the computation of
+        # timeouts for poll() are highly dependent on the behavior of
+        # least_loaded_node()
+        node_id = self.least_loaded_node()
+        if node_id is None:
+            log.debug("Give up sending metadata request since no node is available");
+            return self.config['reconnect_backoff_ms']
+
+        if self._can_send_request(node_id):
+            topics = list(self._topics)
+            if not topics and self.cluster.is_bootstrap(node_id):
+                topics = list(self.config['bootstrap_topics_filter'])
+
+            if self.cluster.need_all_topic_metadata or not topics:
+                topics = [] if self.config['api_version'] < (0, 10) else None
+            api_version = 0 if self.config['api_version'] < (0, 10) else 1
+            request = MetadataRequest[api_version](topics)
+            log.debug("Sending metadata request %s to node %s", request, node_id)
+            future = self.send(node_id, request, wakeup=wakeup)
+            future.add_callback(self.cluster.update_metadata)
+            future.add_errback(self.cluster.failed_update)
+
+            self._metadata_refresh_in_progress = True
+            def refresh_done(val_or_error):
+                self._metadata_refresh_in_progress = False
+            future.add_callback(refresh_done)
+            future.add_errback(refresh_done)
+            return self.config['request_timeout_ms']
+
+        # If there's any connection establishment underway, wait until it completes. This prevents
+        # the client from unnecessarily connecting to additional nodes while a previous connection
+        # attempt has not been completed.
+        if self._connecting:
+            return self.config['reconnect_backoff_ms']
+
+        if self.maybe_connect(node_id, wakeup=wakeup):
+            log.debug("Initializing connection to node %s for metadata request", node_id)
+            return self.config['reconnect_backoff_ms']
+
+        # connected but can't send more, OR connecting
+        # In either case we just need to wait for a network event
+        # to let us know the selected connection might be usable again.
+        return float('inf')
+
+    def get_api_versions(self):
+        """Return the ApiVersions map, if available.
+
+        Note: A call to check_version must previously have succeeded and returned
+        version 0.10.0 or later
+
+        Returns: a map of dict mapping {api_key : (min_version, max_version)},
+        or None if ApiVersion is not supported by the kafka cluster.
+        """
+        return self._api_versions
+
+    def check_version(self, node_id=None, timeout=2, strict=False):
+        """Attempt to guess the version of a Kafka broker.
+
+        Note: It is possible that this method blocks longer than the
+            specified timeout. This can happen if the entire cluster
+            is down and the client enters a bootstrap backoff sleep.
+            This is only possible if node_id is None.
+
+        Returns: version tuple, i.e. (0, 10), (0, 9), (0, 8, 2), ...
+
+        Raises:
+            NodeNotReadyError (if node_id is provided)
+            NoBrokersAvailable (if node_id is None)
+            UnrecognizedBrokerVersion: please file bug if seen!
+            AssertionError (if strict=True): please file bug if seen!
+        """
+        self._lock.acquire()
+        end = time.time() + timeout
+        while time.time() < end:
+
+            # It is possible that least_loaded_node falls back to bootstrap,
+            # which can block for an increasing backoff period
+            try_node = node_id or self.least_loaded_node()
+            if try_node is None:
+                self._lock.release()
+                raise Errors.NoBrokersAvailable()
+            self._maybe_connect(try_node)
+            conn = self._conns[try_node]
+
+            # We will intentionally cause socket failures
+            # These should not trigger metadata refresh
+            self._refresh_on_disconnects = False
+            try:
+                remaining = end - time.time()
+                version = conn.check_version(timeout=remaining, strict=strict, topics=list(self.config['bootstrap_topics_filter']))
+                if version >= (0, 10, 0):
+                    # cache the api versions map if it's available (starting
+                    # in 0.10 cluster version)
+                    self._api_versions = conn.get_api_versions()
+                self._lock.release()
+                return version
+            except Errors.NodeNotReadyError:
+                # Only raise to user if this is a node-specific request
+                if node_id is not None:
+                    self._lock.release()
+                    raise
+            finally:
+                self._refresh_on_disconnects = True
+
+        # Timeout
+        else:
+            self._lock.release()
+            raise Errors.NoBrokersAvailable()
+
+    def wakeup(self):
+        with self._wake_lock:
+            try:
+                self._wake_w.sendall(b'x')
+            except socket.timeout:
+                log.warning('Timeout to send to wakeup socket!')
+                raise Errors.KafkaTimeoutError()
+            except socket.error:
+                log.warning('Unable to send to wakeup socket!')
+
+    def _clear_wake_fd(self):
+        # reading from wake socket should only happen in a single thread
+        while True:
+            try:
+                self._wake_r.recv(1024)
+            except socket.error:
+                break
+
+    def _maybe_close_oldest_connection(self):
+        expired_connection = self._idle_expiry_manager.poll_expired_connection()
+        if expired_connection:
+            conn_id, ts = expired_connection
+            idle_ms = (time.time() - ts) * 1000
+            log.info('Closing idle connection %s, last active %d ms ago', conn_id, idle_ms)
+            self.close(node_id=conn_id)
+
+    def bootstrap_connected(self):
+        """Return True if a bootstrap node is connected"""
+        for node_id in self._conns:
+            if not self.cluster.is_bootstrap(node_id):
+                continue
+            if self._conns[node_id].connected():
+                return True
+        else:
+            return False
+
+
+# OrderedDict requires python2.7+
+try:
+    from collections import OrderedDict
+except ImportError:
+    # If we dont have OrderedDict, we'll fallback to dict with O(n) priority reads
+    OrderedDict = dict
+
+
+class IdleConnectionManager(object):
+    def __init__(self, connections_max_idle_ms):
+        if connections_max_idle_ms > 0:
+            self.connections_max_idle = connections_max_idle_ms / 1000
+        else:
+            self.connections_max_idle = float('inf')
+        self.next_idle_close_check_time = None
+        self.update_next_idle_close_check_time(time.time())
+        self.lru_connections = OrderedDict()
+
+    def update(self, conn_id):
+        # order should reflect last-update
+        if conn_id in self.lru_connections:
+            del self.lru_connections[conn_id]
+        self.lru_connections[conn_id] = time.time()
+
+    def remove(self, conn_id):
+        if conn_id in self.lru_connections:
+            del self.lru_connections[conn_id]
+
+    def is_expired(self, conn_id):
+        if conn_id not in self.lru_connections:
+            return None
+        return time.time() >= self.lru_connections[conn_id] + self.connections_max_idle
+
+    def next_check_ms(self):
+        now = time.time()
+        if not self.lru_connections:
+            return float('inf')
+        elif self.next_idle_close_check_time <= now:
+            return 0
+        else:
+            return int((self.next_idle_close_check_time - now) * 1000)
+
+    def update_next_idle_close_check_time(self, ts):
+        self.next_idle_close_check_time = ts + self.connections_max_idle
+
+    def poll_expired_connection(self):
+        if time.time() < self.next_idle_close_check_time:
+            return None
+
+        if not len(self.lru_connections):
+            return None
+
+        oldest_conn_id = None
+        oldest_ts = None
+        if OrderedDict is dict:
+            for conn_id, ts in self.lru_connections.items():
+                if oldest_conn_id is None or ts < oldest_ts:
+                    oldest_conn_id = conn_id
+                    oldest_ts = ts
+        else:
+            (oldest_conn_id, oldest_ts) = next(iter(self.lru_connections.items()))
+
+        self.update_next_idle_close_check_time(oldest_ts)
+
+        if time.time() >= oldest_ts + self.connections_max_idle:
+            return (oldest_conn_id, oldest_ts)
+        else:
+            return None
+
+
+class KafkaClientMetrics(object):
+    def __init__(self, metrics, metric_group_prefix, conns):
+        self.metrics = metrics
+        self.metric_group_name = metric_group_prefix + '-metrics'
+
+        self.connection_closed = metrics.sensor('connections-closed')
+        self.connection_closed.add(metrics.metric_name(
+            'connection-close-rate', self.metric_group_name,
+            'Connections closed per second in the window.'), Rate())
+        self.connection_created = metrics.sensor('connections-created')
+        self.connection_created.add(metrics.metric_name(
+            'connection-creation-rate', self.metric_group_name,
+            'New connections established per second in the window.'), Rate())
+
+        self.select_time = metrics.sensor('select-time')
+        self.select_time.add(metrics.metric_name(
+            'select-rate', self.metric_group_name,
+            'Number of times the I/O layer checked for new I/O to perform per'
+            ' second'), Rate(sampled_stat=Count()))
+        self.select_time.add(metrics.metric_name(
+            'io-wait-time-ns-avg', self.metric_group_name,
+            'The average length of time the I/O thread spent waiting for a'
+            ' socket ready for reads or writes in nanoseconds.'), Avg())
+        self.select_time.add(metrics.metric_name(
+            'io-wait-ratio', self.metric_group_name,
+            'The fraction of time the I/O thread spent waiting.'),
+            Rate(time_unit=TimeUnit.NANOSECONDS))
+
+        self.io_time = metrics.sensor('io-time')
+        self.io_time.add(metrics.metric_name(
+            'io-time-ns-avg', self.metric_group_name,
+            'The average length of time for I/O per select call in nanoseconds.'),
+            Avg())
+        self.io_time.add(metrics.metric_name(
+            'io-ratio', self.metric_group_name,
+            'The fraction of time the I/O thread spent doing I/O'),
+            Rate(time_unit=TimeUnit.NANOSECONDS))
+
+        metrics.add_metric(metrics.metric_name(
+            'connection-count', self.metric_group_name,
+            'The current number of active connections.'), AnonMeasurable(
+                lambda config, now: len(conns)))

testbed/dpkp__kafka-python/kafka/cluster.py

@@ -0,0 +1,397 @@
+from __future__ import absolute_import
+
+import collections
+import copy
+import logging
+import threading
+import time
+
+from kafka.vendor import six
+
+from kafka import errors as Errors
+from kafka.conn import collect_hosts
+from kafka.future import Future
+from kafka.structs import BrokerMetadata, PartitionMetadata, TopicPartition
+
+log = logging.getLogger(__name__)
+
+
+class ClusterMetadata(object):
+    """
+    A class to manage kafka cluster metadata.
+
+    This class does not perform any IO. It simply updates internal state
+    given API responses (MetadataResponse, GroupCoordinatorResponse).
+
+    Keyword Arguments:
+        retry_backoff_ms (int): Milliseconds to backoff when retrying on
+            errors. Default: 100.
+        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
+        bootstrap_servers: 'host[:port]' string (or list of 'host[:port]'
+            strings) that the client 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.
+    """
+    DEFAULT_CONFIG = {
+        'retry_backoff_ms': 100,
+        'metadata_max_age_ms': 300000,
+        'bootstrap_servers': [],
+    }
+
+    def __init__(self, **configs):
+        self._brokers = {}  # node_id -> BrokerMetadata
+        self._partitions = {}  # topic -> partition -> PartitionMetadata
+        self._broker_partitions = collections.defaultdict(set)  # node_id -> {TopicPartition...}
+        self._groups = {}  # group_name -> node_id
+        self._last_refresh_ms = 0
+        self._last_successful_refresh_ms = 0
+        self._need_update = True
+        self._future = None
+        self._listeners = set()
+        self._lock = threading.Lock()
+        self.need_all_topic_metadata = False
+        self.unauthorized_topics = set()
+        self.internal_topics = set()
+        self.controller = None
+
+        self.config = copy.copy(self.DEFAULT_CONFIG)
+        for key in self.config:
+            if key in configs:
+                self.config[key] = configs[key]
+
+        self._bootstrap_brokers = self._generate_bootstrap_brokers()
+        self._coordinator_brokers = {}
+
+    def _generate_bootstrap_brokers(self):
+        # collect_hosts does not perform DNS, so we should be fine to re-use
+        bootstrap_hosts = collect_hosts(self.config['bootstrap_servers'])
+
+        brokers = {}
+        for i, (host, port, _) in enumerate(bootstrap_hosts):
+            node_id = 'bootstrap-%s' % i
+            brokers[node_id] = BrokerMetadata(node_id, host, port, None)
+        return brokers
+
+    def is_bootstrap(self, node_id):
+        return node_id in self._bootstrap_brokers
+
+    def brokers(self):
+        """Get all BrokerMetadata
+
+        Returns:
+            set: {BrokerMetadata, ...}
+        """
+        return set(self._brokers.values()) or set(self._bootstrap_brokers.values())
+
+    def broker_metadata(self, broker_id):
+        """Get BrokerMetadata
+
+        Arguments:
+            broker_id (int): node_id for a broker to check
+
+        Returns:
+            BrokerMetadata or None if not found
+        """
+        return (
+            self._brokers.get(broker_id) or
+            self._bootstrap_brokers.get(broker_id) or
+            self._coordinator_brokers.get(broker_id)
+        )
+
+    def partitions_for_topic(self, topic):
+        """Return set of all partitions for topic (whether available or not)
+
+        Arguments:
+            topic (str): topic to check for partitions
+
+        Returns:
+            set: {partition (int), ...}
+        """
+        if topic not in self._partitions:
+            return None
+        return set(self._partitions[topic].keys())
+
+    def available_partitions_for_topic(self, topic):
+        """Return set of partitions with known leaders
+
+        Arguments:
+            topic (str): topic to check for partitions
+
+        Returns:
+            set: {partition (int), ...}
+            None if topic not found.
+        """
+        if topic not in self._partitions:
+            return None
+        return set([partition for partition, metadata
+                              in six.iteritems(self._partitions[topic])
+                              if metadata.leader != -1])
+
+    def leader_for_partition(self, partition):
+        """Return node_id of leader, -1 unavailable, None if unknown."""
+        if partition.topic not in self._partitions:
+            return None
+        elif partition.partition not in self._partitions[partition.topic]:
+            return None
+        return self._partitions[partition.topic][partition.partition].leader
+
+    def partitions_for_broker(self, broker_id):
+        """Return TopicPartitions for which the broker is a leader.
+
+        Arguments:
+            broker_id (int): node id for a broker
+
+        Returns:
+            set: {TopicPartition, ...}
+            None if the broker either has no partitions or does not exist.
+        """
+        return self._broker_partitions.get(broker_id)
+
+    def coordinator_for_group(self, group):
+        """Return node_id of group coordinator.
+
+        Arguments:
+            group (str): name of consumer group
+
+        Returns:
+            int: node_id for group coordinator
+            None if the group does not exist.
+        """
+        return self._groups.get(group)
+
+    def ttl(self):
+        """Milliseconds until metadata should be refreshed"""
+        now = time.time() * 1000
+        if self._need_update:
+            ttl = 0
+        else:
+            metadata_age = now - self._last_successful_refresh_ms
+            ttl = self.config['metadata_max_age_ms'] - metadata_age
+
+        retry_age = now - self._last_refresh_ms
+        next_retry = self.config['retry_backoff_ms'] - retry_age
+
+        return max(ttl, next_retry, 0)
+
+    def refresh_backoff(self):
+        """Return milliseconds to wait before attempting to retry after failure"""
+        return self.config['retry_backoff_ms']
+
+    def request_update(self):
+        """Flags metadata for update, return Future()
+
+        Actual update must be handled separately. This method will only
+        change the reported ttl()
+
+        Returns:
+            kafka.future.Future (value will be the cluster object after update)
+        """
+        with self._lock:
+            self._need_update = True
+            if not self._future or self._future.is_done:
+                self._future = Future()
+            return self._future
+
+    def topics(self, exclude_internal_topics=True):
+        """Get set of known topics.
+
+        Arguments:
+            exclude_internal_topics (bool): Whether records from internal topics
+                (such as offsets) should be exposed to the consumer. If set to
+                True the only way to receive records from an internal topic is
+                subscribing to it. Default True
+
+        Returns:
+            set: {topic (str), ...}
+        """
+        topics = set(self._partitions.keys())
+        if exclude_internal_topics:
+            return topics - self.internal_topics
+        else:
+            return topics
+
+    def failed_update(self, exception):
+        """Update cluster state given a failed MetadataRequest."""
+        f = None
+        with self._lock:
+            if self._future:
+                f = self._future
+                self._future = None
+        if f:
+            f.failure(exception)
+        self._last_refresh_ms = time.time() * 1000
+
+    def update_metadata(self, metadata):
+        """Update cluster state given a MetadataResponse.
+
+        Arguments:
+            metadata (MetadataResponse): broker response to a metadata request
+
+        Returns: None
+        """
+        # In the common case where we ask for a single topic and get back an
+        # error, we should fail the future
+        if len(metadata.topics) == 1 and metadata.topics[0][0] != 0:
+            error_code, topic = metadata.topics[0][:2]
+            error = Errors.for_code(error_code)(topic)
+            return self.failed_update(error)
+
+        if not metadata.brokers:
+            log.warning("No broker metadata found in MetadataResponse -- ignoring.")
+            return self.failed_update(Errors.MetadataEmptyBrokerList(metadata))
+
+        _new_brokers = {}
+        for broker in metadata.brokers:
+            if metadata.API_VERSION == 0:
+                node_id, host, port = broker
+                rack = None
+            else:
+                node_id, host, port, rack = broker
+            _new_brokers.update({
+                node_id: BrokerMetadata(node_id, host, port, rack)
+            })
+
+        if metadata.API_VERSION == 0:
+            _new_controller = None
+        else:
+            _new_controller = _new_brokers.get(metadata.controller_id)
+
+        _new_partitions = {}
+        _new_broker_partitions = collections.defaultdict(set)
+        _new_unauthorized_topics = set()
+        _new_internal_topics = set()
+
+        for topic_data in metadata.topics:
+            if metadata.API_VERSION == 0:
+                error_code, topic, partitions = topic_data
+                is_internal = False
+            else:
+                error_code, topic, is_internal, partitions = topic_data
+            if is_internal:
+                _new_internal_topics.add(topic)
+            error_type = Errors.for_code(error_code)
+            if error_type is Errors.NoError:
+                _new_partitions[topic] = {}
+                for p_error, partition, leader, replicas, isr in partitions:
+                    _new_partitions[topic][partition] = PartitionMetadata(
+                        topic=topic, partition=partition, leader=leader,
+                        replicas=replicas, isr=isr, error=p_error)
+                    if leader != -1:
+                        _new_broker_partitions[leader].add(
+                            TopicPartition(topic, partition))
+
+            # Specific topic errors can be ignored if this is a full metadata fetch
+            elif self.need_all_topic_metadata:
+                continue
+
+            elif error_type is Errors.LeaderNotAvailableError:
+                log.warning("Topic %s is not available during auto-create"
+                            " initialization", topic)
+            elif error_type is Errors.UnknownTopicOrPartitionError:
+                log.error("Topic %s not found in cluster metadata", topic)
+            elif error_type is Errors.TopicAuthorizationFailedError:
+                log.error("Topic %s is not authorized for this client", topic)
+                _new_unauthorized_topics.add(topic)
+            elif error_type is Errors.InvalidTopicError:
+                log.error("'%s' is not a valid topic name", topic)
+            else:
+                log.error("Error fetching metadata for topic %s: %s",
+                          topic, error_type)
+
+        with self._lock:
+            self._brokers = _new_brokers
+            self.controller = _new_controller
+            self._partitions = _new_partitions
+            self._broker_partitions = _new_broker_partitions
+            self.unauthorized_topics = _new_unauthorized_topics
+            self.internal_topics = _new_internal_topics
+            f = None
+            if self._future:
+                f = self._future
+            self._future = None
+            self._need_update = False
+
+        now = time.time() * 1000
+        self._last_refresh_ms = now
+        self._last_successful_refresh_ms = now
+
+        if f:
+            f.success(self)
+        log.debug("Updated cluster metadata to %s", self)
+
+        for listener in self._listeners:
+            listener(self)
+
+        if self.need_all_topic_metadata:
+            # the listener may change the interested topics,
+            # which could cause another metadata refresh.
+            # If we have already fetched all topics, however,
+            # another fetch should be unnecessary.
+            self._need_update = False
+
+    def add_listener(self, listener):
+        """Add a callback function to be called on each metadata update"""
+        self._listeners.add(listener)
+
+    def remove_listener(self, listener):
+        """Remove a previously added listener callback"""
+        self._listeners.remove(listener)
+
+    def add_group_coordinator(self, group, response):
+        """Update with metadata for a group coordinator
+
+        Arguments:
+            group (str): name of group from GroupCoordinatorRequest
+            response (GroupCoordinatorResponse): broker response
+
+        Returns:
+            string: coordinator node_id if metadata is updated, None on error
+        """
+        log.debug("Updating coordinator for %s: %s", group, response)
+        error_type = Errors.for_code(response.error_code)
+        if error_type is not Errors.NoError:
+            log.error("GroupCoordinatorResponse error: %s", error_type)
+            self._groups[group] = -1
+            return
+
+        # Use a coordinator-specific node id so that group requests
+        # get a dedicated connection
+        node_id = 'coordinator-{}'.format(response.coordinator_id)
+        coordinator = BrokerMetadata(
+            node_id,
+            response.host,
+            response.port,
+            None)
+
+        log.info("Group coordinator for %s is %s", group, coordinator)
+        self._coordinator_brokers[node_id] = coordinator
+        self._groups[group] = node_id
+        return node_id
+
+    def with_partitions(self, partitions_to_add):
+        """Returns a copy of cluster metadata with partitions added"""
+        new_metadata = ClusterMetadata(**self.config)
+        new_metadata._brokers = copy.deepcopy(self._brokers)
+        new_metadata._partitions = copy.deepcopy(self._partitions)
+        new_metadata._broker_partitions = copy.deepcopy(self._broker_partitions)
+        new_metadata._groups = copy.deepcopy(self._groups)
+        new_metadata.internal_topics = copy.deepcopy(self.internal_topics)
+        new_metadata.unauthorized_topics = copy.deepcopy(self.unauthorized_topics)
+
+        for partition in partitions_to_add:
+            new_metadata._partitions[partition.topic][partition.partition] = partition
+
+            if partition.leader is not None and partition.leader != -1:
+                new_metadata._broker_partitions[partition.leader].add(
+                    TopicPartition(partition.topic, partition.partition))
+
+        return new_metadata
+
+    def __str__(self):
+        return 'ClusterMetadata(brokers: %d, topics: %d, groups: %d)' % \
+               (len(self._brokers), len(self._partitions), len(self._groups))

testbed/dpkp__kafka-python/kafka/codec.py

@@ -0,0 +1,326 @@
+from __future__ import absolute_import
+
+import gzip
+import io
+import platform
+import struct
+
+from kafka.vendor import six
+from kafka.vendor.six.moves import range
+
+_XERIAL_V1_HEADER = (-126, b'S', b'N', b'A', b'P', b'P', b'Y', 0, 1, 1)
+_XERIAL_V1_FORMAT = 'bccccccBii'
+ZSTD_MAX_OUTPUT_SIZE = 1024 * 1024
+
+try:
+    import snappy
+except ImportError:
+    snappy = None
+
+try:
+    import zstandard as zstd
+except ImportError:
+    zstd = None
+
+try:
+    import lz4.frame as lz4
+
+    def _lz4_compress(payload, **kwargs):
+        # Kafka does not support LZ4 dependent blocks
+        try:
+            # For lz4>=0.12.0
+            kwargs.pop('block_linked', None)
+            return lz4.compress(payload, block_linked=False, **kwargs)
+        except TypeError:
+            # For earlier versions of lz4
+            kwargs.pop('block_mode', None)
+            return lz4.compress(payload, block_mode=1, **kwargs)
+
+except ImportError:
+    lz4 = None
+
+try:
+    import lz4f
+except ImportError:
+    lz4f = None
+
+try:
+    import lz4framed
+except ImportError:
+    lz4framed = None
+
+try:
+    import xxhash
+except ImportError:
+    xxhash = None
+
+PYPY = bool(platform.python_implementation() == 'PyPy')
+
+def has_gzip():
+    return True
+
+
+def has_snappy():
+    return snappy is not None
+
+
+def has_zstd():
+    return zstd is not None
+
+
+def has_lz4():
+    if lz4 is not None:
+        return True
+    if lz4f is not None:
+        return True
+    if lz4framed is not None:
+        return True
+    return False
+
+
+def gzip_encode(payload, compresslevel=None):
+    if not compresslevel:
+        compresslevel = 9
+
+    buf = io.BytesIO()
+
+    # Gzip context manager introduced in python 2.7
+    # so old-fashioned way until we decide to not support 2.6
+    gzipper = gzip.GzipFile(fileobj=buf, mode="w", compresslevel=compresslevel)
+    try:
+        gzipper.write(payload)
+    finally:
+        gzipper.close()
+
+    return buf.getvalue()
+
+
+def gzip_decode(payload):
+    buf = io.BytesIO(payload)
+
+    # Gzip context manager introduced in python 2.7
+    # so old-fashioned way until we decide to not support 2.6
+    gzipper = gzip.GzipFile(fileobj=buf, mode='r')
+    try:
+        return gzipper.read()
+    finally:
+        gzipper.close()
+
+
+def snappy_encode(payload, xerial_compatible=True, xerial_blocksize=32*1024):
+    """Encodes the given data with snappy compression.
+
+    If xerial_compatible is set then the stream is encoded in a fashion
+    compatible with the xerial snappy library.
+
+    The block size (xerial_blocksize) controls how frequent the blocking occurs
+    32k is the default in the xerial library.
+
+    The format winds up being:
+
+
+        +-------------+------------+--------------+------------+--------------+
+        |   Header    | Block1 len | Block1 data  | Blockn len | Blockn data  |
+        +-------------+------------+--------------+------------+--------------+
+        |  16 bytes   |  BE int32  | snappy bytes |  BE int32  | snappy bytes |
+        +-------------+------------+--------------+------------+--------------+
+
+
+    It is important to note that the blocksize is the amount of uncompressed
+    data presented to snappy at each block, whereas the blocklen is the number
+    of bytes that will be present in the stream; so the length will always be
+    <= blocksize.
+
+    """
+
+    if not has_snappy():
+        raise NotImplementedError("Snappy codec is not available")
+
+    if not xerial_compatible:
+        return snappy.compress(payload)
+
+    out = io.BytesIO()
+    for fmt, dat in zip(_XERIAL_V1_FORMAT, _XERIAL_V1_HEADER):
+        out.write(struct.pack('!' + fmt, dat))
+
+    # Chunk through buffers to avoid creating intermediate slice copies
+    if PYPY:
+        # on pypy, snappy.compress() on a sliced buffer consumes the entire
+        # buffer... likely a python-snappy bug, so just use a slice copy
+        chunker = lambda payload, i, size: payload[i:size+i]
+
+    elif six.PY2:
+        # Sliced buffer avoids additional copies
+        # pylint: disable-msg=undefined-variable
+        chunker = lambda payload, i, size: buffer(payload, i, size)
+    else:
+        # snappy.compress does not like raw memoryviews, so we have to convert
+        # tobytes, which is a copy... oh well. it's the thought that counts.
+        # pylint: disable-msg=undefined-variable
+        chunker = lambda payload, i, size: memoryview(payload)[i:size+i].tobytes()
+
+    for chunk in (chunker(payload, i, xerial_blocksize)
+                  for i in range(0, len(payload), xerial_blocksize)):
+
+        block = snappy.compress(chunk)
+        block_size = len(block)
+        out.write(struct.pack('!i', block_size))
+        out.write(block)
+
+    return out.getvalue()
+
+
+def _detect_xerial_stream(payload):
+    """Detects if the data given might have been encoded with the blocking mode
+        of the xerial snappy library.
+
+        This mode writes a magic header of the format:
+            +--------+--------------+------------+---------+--------+
+            | Marker | Magic String | Null / Pad | Version | Compat |
+            +--------+--------------+------------+---------+--------+
+            |  byte  |   c-string   |    byte    |  int32  | int32  |
+            +--------+--------------+------------+---------+--------+
+            |  -126  |   'SNAPPY'   |     \0     |         |        |
+            +--------+--------------+------------+---------+--------+
+
+        The pad appears to be to ensure that SNAPPY is a valid cstring
+        The version is the version of this format as written by xerial,
+        in the wild this is currently 1 as such we only support v1.
+
+        Compat is there to claim the miniumum supported version that
+        can read a xerial block stream, presently in the wild this is
+        1.
+    """
+
+    if len(payload) > 16:
+        header = struct.unpack('!' + _XERIAL_V1_FORMAT, bytes(payload)[:16])
+        return header == _XERIAL_V1_HEADER
+    return False
+
+
+def snappy_decode(payload):
+    if not has_snappy():
+        raise NotImplementedError("Snappy codec is not available")
+
+    if _detect_xerial_stream(payload):
+        # TODO ? Should become a fileobj ?
+        out = io.BytesIO()
+        byt = payload[16:]
+        length = len(byt)
+        cursor = 0
+
+        while cursor < length:
+            block_size = struct.unpack_from('!i', byt[cursor:])[0]
+            # Skip the block size
+            cursor += 4
+            end = cursor + block_size
+            out.write(snappy.decompress(byt[cursor:end]))
+            cursor = end
+
+        out.seek(0)
+        return out.read()
+    else:
+        return snappy.decompress(payload)
+
+
+if lz4:
+    lz4_encode = _lz4_compress # pylint: disable-msg=no-member
+elif lz4f:
+    lz4_encode = lz4f.compressFrame # pylint: disable-msg=no-member
+elif lz4framed:
+    lz4_encode = lz4framed.compress # pylint: disable-msg=no-member
+else:
+    lz4_encode = None
+
+
+def lz4f_decode(payload):
+    """Decode payload using interoperable LZ4 framing. Requires Kafka >= 0.10"""
+    # pylint: disable-msg=no-member
+    ctx = lz4f.createDecompContext()
+    data = lz4f.decompressFrame(payload, ctx)
+    lz4f.freeDecompContext(ctx)
+
+    # lz4f python module does not expose how much of the payload was
+    # actually read if the decompression was only partial.
+    if data['next'] != 0:
+        raise RuntimeError('lz4f unable to decompress full payload')
+    return data['decomp']
+
+
+if lz4:
+    lz4_decode = lz4.decompress # pylint: disable-msg=no-member
+elif lz4f:
+    lz4_decode = lz4f_decode
+elif lz4framed:
+    lz4_decode = lz4framed.decompress # pylint: disable-msg=no-member
+else:
+    lz4_decode = None
+
+
+def lz4_encode_old_kafka(payload):
+    """Encode payload for 0.8/0.9 brokers -- requires an incorrect header checksum."""
+    assert xxhash is not None
+    data = lz4_encode(payload)
+    header_size = 7
+    flg = data[4]
+    if not isinstance(flg, int):
+        flg = ord(flg)
+
+    content_size_bit = ((flg >> 3) & 1)
+    if content_size_bit:
+        # Old kafka does not accept the content-size field
+        # so we need to discard it and reset the header flag
+        flg -= 8
+        data = bytearray(data)
+        data[4] = flg
+        data = bytes(data)
+        payload = data[header_size+8:]
+    else:
+        payload = data[header_size:]
+
+    # This is the incorrect hc
+    hc = xxhash.xxh32(data[0:header_size-1]).digest()[-2:-1]  # pylint: disable-msg=no-member
+
+    return b''.join([
+        data[0:header_size-1],
+        hc,
+        payload
+    ])
+
+
+def lz4_decode_old_kafka(payload):
+    assert xxhash is not None
+    # Kafka's LZ4 code has a bug in its header checksum implementation
+    header_size = 7
+    if isinstance(payload[4], int):
+        flg = payload[4]
+    else:
+        flg = ord(payload[4])
+    content_size_bit = ((flg >> 3) & 1)
+    if content_size_bit:
+        header_size += 8
+
+    # This should be the correct hc
+    hc = xxhash.xxh32(payload[4:header_size-1]).digest()[-2:-1]  # pylint: disable-msg=no-member
+
+    munged_payload = b''.join([
+        payload[0:header_size-1],
+        hc,
+        payload[header_size:]
+    ])
+    return lz4_decode(munged_payload)
+
+
+def zstd_encode(payload):
+    if not zstd:
+        raise NotImplementedError("Zstd codec is not available")
+    return zstd.ZstdCompressor().compress(payload)
+
+
+def zstd_decode(payload):
+    if not zstd:
+        raise NotImplementedError("Zstd codec is not available")
+    try:
+        return zstd.ZstdDecompressor().decompress(payload)
+    except zstd.ZstdError:
+        return zstd.ZstdDecompressor().decompress(payload, max_output_size=ZSTD_MAX_OUTPUT_SIZE)

testbed/dpkp__kafka-python/kafka/conn.py

@@ -0,0 +1,1534 @@
+from __future__ import absolute_import, division
+
+import copy
+import errno
+import io
+import logging
+from random import shuffle, uniform
+
+# selectors in stdlib as of py3.4
+try:
+    import selectors  # pylint: disable=import-error
+except ImportError:
+    # vendored backport module
+    from kafka.vendor import selectors34 as selectors
+
+import socket
+import struct
+import threading
+import time
+
+from kafka.vendor import six
+
+import kafka.errors as Errors
+from kafka.future import Future
+from kafka.metrics.stats import Avg, Count, Max, Rate
+from kafka.oauth.abstract import AbstractTokenProvider
+from kafka.protocol.admin import SaslHandShakeRequest, DescribeAclsRequest_v2, DescribeClientQuotasRequest
+from kafka.protocol.commit import OffsetFetchRequest
+from kafka.protocol.offset import OffsetRequest
+from kafka.protocol.produce import ProduceRequest
+from kafka.protocol.metadata import MetadataRequest
+from kafka.protocol.fetch import FetchRequest
+from kafka.protocol.parser import KafkaProtocol
+from kafka.protocol.types import Int32, Int8
+from kafka.scram import ScramClient
+from kafka.version import __version__
+
+
+if six.PY2:
+    ConnectionError = socket.error
+    TimeoutError = socket.error
+    BlockingIOError = Exception
+
+log = logging.getLogger(__name__)
+
+DEFAULT_KAFKA_PORT = 9092
+
+SASL_QOP_AUTH = 1
+SASL_QOP_AUTH_INT = 2
+SASL_QOP_AUTH_CONF = 4
+
+try:
+    import ssl
+    ssl_available = True
+    try:
+        SSLEOFError = ssl.SSLEOFError
+        SSLWantReadError = ssl.SSLWantReadError
+        SSLWantWriteError = ssl.SSLWantWriteError
+        SSLZeroReturnError = ssl.SSLZeroReturnError
+    except AttributeError:
+        # support older ssl libraries
+        log.warning('Old SSL module detected.'
+                    ' SSL error handling may not operate cleanly.'
+                    ' Consider upgrading to Python 3.3 or 2.7.9')
+        SSLEOFError = ssl.SSLError
+        SSLWantReadError = ssl.SSLError
+        SSLWantWriteError = ssl.SSLError
+        SSLZeroReturnError = ssl.SSLError
+except ImportError:
+    # support Python without ssl libraries
+    ssl_available = False
+    class SSLWantReadError(Exception):
+        pass
+    class SSLWantWriteError(Exception):
+        pass
+
+# needed for SASL_GSSAPI authentication:
+try:
+    import gssapi
+    from gssapi.raw.misc import GSSError
+except ImportError:
+    #no gssapi available, will disable gssapi mechanism
+    gssapi = None
+    GSSError = None
+
+
+AFI_NAMES = {
+    socket.AF_UNSPEC: "unspecified",
+    socket.AF_INET: "IPv4",
+    socket.AF_INET6: "IPv6",
+}
+
+
+class ConnectionStates(object):
+    DISCONNECTING = '<disconnecting>'
+    DISCONNECTED = '<disconnected>'
+    CONNECTING = '<connecting>'
+    HANDSHAKE = '<handshake>'
+    CONNECTED = '<connected>'
+    AUTHENTICATING = '<authenticating>'
+
+
+class BrokerConnection(object):
+    """Initialize a Kafka broker connection
+
+    Keyword Arguments:
+        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. Also
+            submitted to GroupCoordinator for logging with respect to
+            consumer group administration. Default: 'kafka-python-{version}'
+        reconnect_backoff_ms (int): The amount of time in milliseconds to
+            wait before attempting to reconnect to a given host.
+            Default: 50.
+        reconnect_backoff_max_ms (int): The maximum amount of time in
+            milliseconds to backoff/wait when reconnecting to a broker that has
+            repeatedly failed to connect. If provided, the backoff per host
+            will increase exponentially for each consecutive connection
+            failure, up to this maximum. Once the maximum is reached,
+            reconnection attempts will continue periodically with this fixed
+            rate. To avoid connection storms, a randomization factor of 0.2
+            will be applied to the backoff resulting in a random range between
+            20% below and 20% above the computed value. Default: 1000.
+        request_timeout_ms (int): Client request timeout in milliseconds.
+            Default: 30000.
+        max_in_flight_requests_per_connection (int): Requests are pipelined
+            to kafka brokers up to this number of maximum requests per
+            broker connection. Default: 5.
+        receive_buffer_bytes (int): The size of the TCP receive buffer
+            (SO_RCVBUF) to use when reading data. Default: None (relies on
+            system defaults). Java client defaults to 32768.
+        send_buffer_bytes (int): The size of the TCP send buffer
+            (SO_SNDBUF) to use when sending data. Default: None (relies on
+            system defaults). Java client defaults to 131072.
+        socket_options (list): List of tuple-arguments to socket.setsockopt
+            to apply to broker connection sockets. Default:
+            [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]
+        security_protocol (str): Protocol used to communicate with brokers.
+            Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL.
+            Default: PLAINTEXT.
+        ssl_context (ssl.SSLContext): pre-configured SSLContext for wrapping
+            socket connections. If provided, all other ssl_* configurations
+            will be ignored. Default: None.
+        ssl_check_hostname (bool): flag to configure whether ssl handshake
+            should verify that the certificate matches the brokers hostname.
+            default: True.
+        ssl_cafile (str): optional filename of ca file to use in certificate
+            verification. default: None.
+        ssl_certfile (str): optional filename of file in pem format containing
+            the client certificate, as well as any ca certificates needed to
+            establish the certificate's authenticity. default: None.
+        ssl_keyfile (str): optional filename containing the client private key.
+            default: None.
+        ssl_password (callable, str, bytes, bytearray): optional password or
+            callable function that returns a password, for decrypting the
+            client private key. Default: None.
+        ssl_crlfile (str): optional filename containing the CRL to check for
+            certificate expiration. By default, no CRL check is done. When
+            providing a file, only the leaf certificate will be checked against
+            this CRL. The CRL can only be checked with Python 3.4+ or 2.7.9+.
+            default: None.
+        ssl_ciphers (str): optionally set the available ciphers for ssl
+            connections. It should be a string in the OpenSSL cipher list
+            format. If no cipher can be selected (because compile-time options
+            or other configuration forbids use of all the specified ciphers),
+            an ssl.SSLError will be raised. See ssl.SSLContext.set_ciphers
+        api_version (tuple): Specify which Kafka API version to use.
+            Accepted values are: (0, 8, 0), (0, 8, 1), (0, 8, 2), (0, 9),
+            (0, 10). Default: (0, 8, 2)
+        api_version_auto_timeout_ms (int): number of milliseconds to throw a
+            timeout exception from the constructor when checking the broker
+            api version. Only applies if api_version is None
+        selector (selectors.BaseSelector): Provide a specific selector
+            implementation to use for I/O multiplexing.
+            Default: selectors.DefaultSelector
+        state_change_callback (callable): function to be called when the
+            connection state changes from CONNECTING to CONNECTED etc.
+        metrics (kafka.metrics.Metrics): Optionally provide a metrics
+            instance for capturing network IO stats. Default: None.
+        metric_group_prefix (str): Prefix for metric names. Default: ''
+        sasl_mechanism (str): Authentication mechanism when security_protocol
+            is configured for SASL_PLAINTEXT or SASL_SSL. Valid values are:
+            PLAIN, GSSAPI, OAUTHBEARER, SCRAM-SHA-256, SCRAM-SHA-512.
+        sasl_plain_username (str): username for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_plain_password (str): password for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_kerberos_service_name (str): Service name to include in GSSAPI
+            sasl mechanism handshake. Default: 'kafka'
+        sasl_kerberos_domain_name (str): kerberos domain name to use in GSSAPI
+            sasl mechanism handshake. Default: one of bootstrap servers
+        sasl_oauth_token_provider (AbstractTokenProvider): OAuthBearer token provider
+            instance. (See kafka.oauth.abstract). Default: None
+    """
+
+    DEFAULT_CONFIG = {
+        'client_id': 'kafka-python-' + __version__,
+        'node_id': 0,
+        'request_timeout_ms': 30000,
+        'reconnect_backoff_ms': 50,
+        'reconnect_backoff_max_ms': 1000,
+        'max_in_flight_requests_per_connection': 5,
+        'receive_buffer_bytes': None,
+        'send_buffer_bytes': None,
+        'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],
+        'sock_chunk_bytes': 4096,  # undocumented experimental option
+        'sock_chunk_buffer_count': 1000,  # undocumented experimental option
+        'security_protocol': 'PLAINTEXT',
+        'ssl_context': None,
+        'ssl_check_hostname': True,
+        'ssl_cafile': None,
+        'ssl_certfile': None,
+        'ssl_keyfile': None,
+        'ssl_crlfile': None,
+        'ssl_password': None,
+        'ssl_ciphers': None,
+        'api_version': (0, 8, 2),  # default to most restrictive
+        'selector': selectors.DefaultSelector,
+        'state_change_callback': lambda node_id, sock, conn: True,
+        'metrics': None,
+        'metric_group_prefix': '',
+        'sasl_mechanism': None,
+        'sasl_plain_username': None,
+        'sasl_plain_password': None,
+        'sasl_kerberos_service_name': 'kafka',
+        'sasl_kerberos_domain_name': None,
+        'sasl_oauth_token_provider': None
+    }
+    SECURITY_PROTOCOLS = ('PLAINTEXT', 'SSL', 'SASL_PLAINTEXT', 'SASL_SSL')
+    SASL_MECHANISMS = ('PLAIN', 'GSSAPI', 'OAUTHBEARER', "SCRAM-SHA-256", "SCRAM-SHA-512")
+
+    def __init__(self, host, port, afi, **configs):
+        self.host = host
+        self.port = port
+        self.afi = afi
+        self._sock_afi = afi
+        self._sock_addr = None
+        self._api_versions = None
+
+        self.config = copy.copy(self.DEFAULT_CONFIG)
+        for key in self.config:
+            if key in configs:
+                self.config[key] = configs[key]
+
+        self.node_id = self.config.pop('node_id')
+
+        if self.config['receive_buffer_bytes'] is not None:
+            self.config['socket_options'].append(
+                (socket.SOL_SOCKET, socket.SO_RCVBUF,
+                 self.config['receive_buffer_bytes']))
+        if self.config['send_buffer_bytes'] is not None:
+            self.config['socket_options'].append(
+                 (socket.SOL_SOCKET, socket.SO_SNDBUF,
+                 self.config['send_buffer_bytes']))
+
+        assert self.config['security_protocol'] in self.SECURITY_PROTOCOLS, (
+            'security_protocol must be in ' + ', '.join(self.SECURITY_PROTOCOLS))
+
+        if self.config['security_protocol'] in ('SSL', 'SASL_SSL'):
+            assert ssl_available, "Python wasn't built with SSL support"
+
+        if self.config['security_protocol'] in ('SASL_PLAINTEXT', 'SASL_SSL'):
+            assert self.config['sasl_mechanism'] in self.SASL_MECHANISMS, (
+                'sasl_mechanism must be in ' + ', '.join(self.SASL_MECHANISMS))
+            if self.config['sasl_mechanism'] in ('PLAIN', 'SCRAM-SHA-256', 'SCRAM-SHA-512'):
+                assert self.config['sasl_plain_username'] is not None, (
+                    'sasl_plain_username required for PLAIN or SCRAM sasl'
+                )
+                assert self.config['sasl_plain_password'] is not None, (
+                    'sasl_plain_password required for PLAIN or SCRAM sasl'
+                )
+            if self.config['sasl_mechanism'] == 'GSSAPI':
+                assert gssapi is not None, 'GSSAPI lib not available'
+                assert self.config['sasl_kerberos_service_name'] is not None, 'sasl_kerberos_service_name required for GSSAPI sasl'
+            if self.config['sasl_mechanism'] == 'OAUTHBEARER':
+                token_provider = self.config['sasl_oauth_token_provider']
+                assert token_provider is not None, 'sasl_oauth_token_provider required for OAUTHBEARER sasl'
+                assert callable(getattr(token_provider, "token", None)), 'sasl_oauth_token_provider must implement method #token()'
+        # This is not a general lock / this class is not generally thread-safe yet
+        # However, to avoid pushing responsibility for maintaining
+        # per-connection locks to the upstream client, we will use this lock to
+        # make sure that access to the protocol buffer is synchronized
+        # when sends happen on multiple threads
+        self._lock = threading.Lock()
+
+        # the protocol parser instance manages actual tracking of the
+        # sequence of in-flight requests to responses, which should
+        # function like a FIFO queue. For additional request data,
+        # including tracking request futures and timestamps, we
+        # can use a simple dictionary of correlation_id => request data
+        self.in_flight_requests = dict()
+
+        self._protocol = KafkaProtocol(
+            client_id=self.config['client_id'],
+            api_version=self.config['api_version'])
+        self.state = ConnectionStates.DISCONNECTED
+        self._reset_reconnect_backoff()
+        self._sock = None
+        self._send_buffer = b''
+        self._ssl_context = None
+        if self.config['ssl_context'] is not None:
+            self._ssl_context = self.config['ssl_context']
+        self._sasl_auth_future = None
+        self.last_attempt = 0
+        self._gai = []
+        self._sensors = None
+        if self.config['metrics']:
+            self._sensors = BrokerConnectionMetrics(self.config['metrics'],
+                                                    self.config['metric_group_prefix'],
+                                                    self.node_id)
+
+    def _dns_lookup(self):
+        self._gai = dns_lookup(self.host, self.port, self.afi)
+        if not self._gai:
+            log.error('DNS lookup failed for %s:%i (%s)',
+                      self.host, self.port, self.afi)
+            return False
+        return True
+
+    def _next_afi_sockaddr(self):
+        if not self._gai:
+            if not self._dns_lookup():
+                return
+        afi, _, __, ___, sockaddr = self._gai.pop(0)
+        return (afi, sockaddr)
+
+    def connect_blocking(self, timeout=float('inf')):
+        if self.connected():
+            return True
+        timeout += time.time()
+        # First attempt to perform dns lookup
+        # note that the underlying interface, socket.getaddrinfo,
+        # has no explicit timeout so we may exceed the user-specified timeout
+        self._dns_lookup()
+
+        # Loop once over all returned dns entries
+        selector = None
+        while self._gai:
+            while time.time() < timeout:
+                self.connect()
+                if self.connected():
+                    if selector is not None:
+                        selector.close()
+                    return True
+                elif self.connecting():
+                    if selector is None:
+                        selector = self.config['selector']()
+                        selector.register(self._sock, selectors.EVENT_WRITE)
+                    selector.select(1)
+                elif self.disconnected():
+                    if selector is not None:
+                        selector.close()
+                        selector = None
+                    break
+            else:
+                break
+        return False
+
+    def connect(self):
+        """Attempt to connect and return ConnectionState"""
+        if self.state is ConnectionStates.DISCONNECTED and not self.blacked_out():
+            self.last_attempt = time.time()
+            next_lookup = self._next_afi_sockaddr()
+            if not next_lookup:
+                self.close(Errors.KafkaConnectionError('DNS failure'))
+                return self.state
+            else:
+                log.debug('%s: creating new socket', self)
+                assert self._sock is None
+                self._sock_afi, self._sock_addr = next_lookup
+                self._sock = socket.socket(self._sock_afi, socket.SOCK_STREAM)
+
+            for option in self.config['socket_options']:
+                log.debug('%s: setting socket option %s', self, option)
+                self._sock.setsockopt(*option)
+
+            self._sock.setblocking(False)
+            self.state = ConnectionStates.CONNECTING
+            self.config['state_change_callback'](self.node_id, self._sock, self)
+            log.info('%s: connecting to %s:%d [%s %s]', self, self.host,
+                     self.port, self._sock_addr, AFI_NAMES[self._sock_afi])
+
+        if self.state is ConnectionStates.CONNECTING:
+            # in non-blocking mode, use repeated calls to socket.connect_ex
+            # to check connection status
+            ret = None
+            try:
+                ret = self._sock.connect_ex(self._sock_addr)
+            except socket.error as err:
+                ret = err.errno
+
+            # Connection succeeded
+            if not ret or ret == errno.EISCONN:
+                log.debug('%s: established TCP connection', self)
+
+                if self.config['security_protocol'] in ('SSL', 'SASL_SSL'):
+                    log.debug('%s: initiating SSL handshake', self)
+                    self.state = ConnectionStates.HANDSHAKE
+                    self.config['state_change_callback'](self.node_id, self._sock, self)
+                    # _wrap_ssl can alter the connection state -- disconnects on failure
+                    self._wrap_ssl()
+
+                elif self.config['security_protocol'] == 'SASL_PLAINTEXT':
+                    log.debug('%s: initiating SASL authentication', self)
+                    self.state = ConnectionStates.AUTHENTICATING
+                    self.config['state_change_callback'](self.node_id, self._sock, self)
+
+                else:
+                    # security_protocol PLAINTEXT
+                    log.info('%s: Connection complete.', self)
+                    self.state = ConnectionStates.CONNECTED
+                    self._reset_reconnect_backoff()
+                    self.config['state_change_callback'](self.node_id, self._sock, self)
+
+            # Connection failed
+            # WSAEINVAL == 10022, but errno.WSAEINVAL is not available on non-win systems
+            elif ret not in (errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK, 10022):
+                log.error('Connect attempt to %s returned error %s.'
+                          ' Disconnecting.', self, ret)
+                errstr = errno.errorcode.get(ret, 'UNKNOWN')
+                self.close(Errors.KafkaConnectionError('{} {}'.format(ret, errstr)))
+                return self.state
+
+            # Needs retry
+            else:
+                pass
+
+        if self.state is ConnectionStates.HANDSHAKE:
+            if self._try_handshake():
+                log.debug('%s: completed SSL handshake.', self)
+                if self.config['security_protocol'] == 'SASL_SSL':
+                    log.debug('%s: initiating SASL authentication', self)
+                    self.state = ConnectionStates.AUTHENTICATING
+                else:
+                    log.info('%s: Connection complete.', self)
+                    self.state = ConnectionStates.CONNECTED
+                    self._reset_reconnect_backoff()
+                self.config['state_change_callback'](self.node_id, self._sock, self)
+
+        if self.state is ConnectionStates.AUTHENTICATING:
+            assert self.config['security_protocol'] in ('SASL_PLAINTEXT', 'SASL_SSL')
+            if self._try_authenticate():
+                # _try_authenticate has side-effects: possibly disconnected on socket errors
+                if self.state is ConnectionStates.AUTHENTICATING:
+                    log.info('%s: Connection complete.', self)
+                    self.state = ConnectionStates.CONNECTED
+                    self._reset_reconnect_backoff()
+                    self.config['state_change_callback'](self.node_id, self._sock, self)
+
+        if self.state not in (ConnectionStates.CONNECTED,
+                              ConnectionStates.DISCONNECTED):
+            # Connection timed out
+            request_timeout = self.config['request_timeout_ms'] / 1000.0
+            if time.time() > request_timeout + self.last_attempt:
+                log.error('Connection attempt to %s timed out', self)
+                self.close(Errors.KafkaConnectionError('timeout'))
+                return self.state
+
+        return self.state
+
+    def _wrap_ssl(self):
+        assert self.config['security_protocol'] in ('SSL', 'SASL_SSL')
+        if self._ssl_context is None:
+            log.debug('%s: configuring default SSL Context', self)
+            self._ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)  # pylint: disable=no-member
+            self._ssl_context.options |= ssl.OP_NO_SSLv2  # pylint: disable=no-member
+            self._ssl_context.options |= ssl.OP_NO_SSLv3  # pylint: disable=no-member
+            self._ssl_context.verify_mode = ssl.CERT_OPTIONAL
+            if self.config['ssl_check_hostname']:
+                self._ssl_context.check_hostname = True
+            if self.config['ssl_cafile']:
+                log.info('%s: Loading SSL CA from %s', self, self.config['ssl_cafile'])
+                self._ssl_context.load_verify_locations(self.config['ssl_cafile'])
+                self._ssl_context.verify_mode = ssl.CERT_REQUIRED
+            else:
+                log.info('%s: Loading system default SSL CAs from %s', self, ssl.get_default_verify_paths())
+                self._ssl_context.load_default_certs()
+            if self.config['ssl_certfile'] and self.config['ssl_keyfile']:
+                log.info('%s: Loading SSL Cert from %s', self, self.config['ssl_certfile'])
+                log.info('%s: Loading SSL Key from %s', self, self.config['ssl_keyfile'])
+                self._ssl_context.load_cert_chain(
+                    certfile=self.config['ssl_certfile'],
+                    keyfile=self.config['ssl_keyfile'],
+                    password=self.config['ssl_password'])
+            if self.config['ssl_crlfile']:
+                if not hasattr(ssl, 'VERIFY_CRL_CHECK_LEAF'):
+                    raise RuntimeError('This version of Python does not support ssl_crlfile!')
+                log.info('%s: Loading SSL CRL from %s', self, self.config['ssl_crlfile'])
+                self._ssl_context.load_verify_locations(self.config['ssl_crlfile'])
+                # pylint: disable=no-member
+                self._ssl_context.verify_flags |= ssl.VERIFY_CRL_CHECK_LEAF
+            if self.config['ssl_ciphers']:
+                log.info('%s: Setting SSL Ciphers: %s', self, self.config['ssl_ciphers'])
+                self._ssl_context.set_ciphers(self.config['ssl_ciphers'])
+        log.debug('%s: wrapping socket in ssl context', self)
+        try:
+            self._sock = self._ssl_context.wrap_socket(
+                self._sock,
+                server_hostname=self.host,
+                do_handshake_on_connect=False)
+        except ssl.SSLError as e:
+            log.exception('%s: Failed to wrap socket in SSLContext!', self)
+            self.close(e)
+
+    def _try_handshake(self):
+        assert self.config['security_protocol'] in ('SSL', 'SASL_SSL')
+        try:
+            self._sock.do_handshake()
+            return True
+        # old ssl in python2.6 will swallow all SSLErrors here...
+        except (SSLWantReadError, SSLWantWriteError):
+            pass
+        except (SSLZeroReturnError, ConnectionError, TimeoutError, SSLEOFError):
+            log.warning('SSL connection closed by server during handshake.')
+            self.close(Errors.KafkaConnectionError('SSL connection closed by server during handshake'))
+        # Other SSLErrors will be raised to user
+
+        return False
+
+    def _try_authenticate(self):
+        assert self.config['api_version'] is None or self.config['api_version'] >= (0, 10)
+
+        if self._sasl_auth_future is None:
+            # Build a SaslHandShakeRequest message
+            request = SaslHandShakeRequest[0](self.config['sasl_mechanism'])
+            future = Future()
+            sasl_response = self._send(request)
+            sasl_response.add_callback(self._handle_sasl_handshake_response, future)
+            sasl_response.add_errback(lambda f, e: f.failure(e), future)
+            self._sasl_auth_future = future
+
+        for r, f in self.recv():
+            f.success(r)
+
+        # A connection error could trigger close() which will reset the future
+        if self._sasl_auth_future is None:
+            return False
+        elif self._sasl_auth_future.failed():
+            ex = self._sasl_auth_future.exception
+            if not isinstance(ex, Errors.KafkaConnectionError):
+                raise ex  # pylint: disable-msg=raising-bad-type
+        return self._sasl_auth_future.succeeded()
+
+    def _handle_sasl_handshake_response(self, future, response):
+        error_type = Errors.for_code(response.error_code)
+        if error_type is not Errors.NoError:
+            error = error_type(self)
+            self.close(error=error)
+            return future.failure(error_type(self))
+
+        if self.config['sasl_mechanism'] not in response.enabled_mechanisms:
+            return future.failure(
+                Errors.UnsupportedSaslMechanismError(
+                    'Kafka broker does not support %s sasl mechanism. Enabled mechanisms are: %s'
+                    % (self.config['sasl_mechanism'], response.enabled_mechanisms)))
+        elif self.config['sasl_mechanism'] == 'PLAIN':
+            return self._try_authenticate_plain(future)
+        elif self.config['sasl_mechanism'] == 'GSSAPI':
+            return self._try_authenticate_gssapi(future)
+        elif self.config['sasl_mechanism'] == 'OAUTHBEARER':
+            return self._try_authenticate_oauth(future)
+        elif self.config['sasl_mechanism'].startswith("SCRAM-SHA-"):
+            return self._try_authenticate_scram(future)
+        else:
+            return future.failure(
+                Errors.UnsupportedSaslMechanismError(
+                    'kafka-python does not support SASL mechanism %s' %
+                    self.config['sasl_mechanism']))
+
+    def _send_bytes(self, data):
+        """Send some data via non-blocking IO
+
+        Note: this method is not synchronized internally; you should
+        always hold the _lock before calling
+
+        Returns: number of bytes
+        Raises: socket exception
+        """
+        total_sent = 0
+        while total_sent < len(data):
+            try:
+                sent_bytes = self._sock.send(data[total_sent:])
+                total_sent += sent_bytes
+            except (SSLWantReadError, SSLWantWriteError):
+                break
+            except (ConnectionError, TimeoutError) as e:
+                if six.PY2 and e.errno == errno.EWOULDBLOCK:
+                    break
+                raise
+            except BlockingIOError:
+                if six.PY3:
+                    break
+                raise
+        return total_sent
+
+    def _send_bytes_blocking(self, data):
+        self._sock.settimeout(self.config['request_timeout_ms'] / 1000)
+        total_sent = 0
+        try:
+            while total_sent < len(data):
+                sent_bytes = self._sock.send(data[total_sent:])
+                total_sent += sent_bytes
+            if total_sent != len(data):
+                raise ConnectionError('Buffer overrun during socket send')
+            return total_sent
+        finally:
+            self._sock.settimeout(0.0)
+
+    def _recv_bytes_blocking(self, n):
+        self._sock.settimeout(self.config['request_timeout_ms'] / 1000)
+        try:
+            data = b''
+            while len(data) < n:
+                fragment = self._sock.recv(n - len(data))
+                if not fragment:
+                    raise ConnectionError('Connection reset during recv')
+                data += fragment
+            return data
+        finally:
+            self._sock.settimeout(0.0)
+
+    def _try_authenticate_plain(self, future):
+        if self.config['security_protocol'] == 'SASL_PLAINTEXT':
+            log.warning('%s: Sending username and password in the clear', self)
+
+        data = b''
+        # Send PLAIN credentials per RFC-4616
+        msg = bytes('\0'.join([self.config['sasl_plain_username'],
+                               self.config['sasl_plain_username'],
+                               self.config['sasl_plain_password']]).encode('utf-8'))
+        size = Int32.encode(len(msg))
+
+        err = None
+        close = False
+        with self._lock:
+            if not self._can_send_recv():
+                err = Errors.NodeNotReadyError(str(self))
+                close = False
+            else:
+                try:
+                    self._send_bytes_blocking(size + msg)
+
+                    # The server will send a zero sized message (that is Int32(0)) on success.
+                    # The connection is closed on failure
+                    data = self._recv_bytes_blocking(4)
+
+                except (ConnectionError, TimeoutError) as e:
+                    log.exception("%s: Error receiving reply from server", self)
+                    err = Errors.KafkaConnectionError("%s: %s" % (self, e))
+                    close = True
+
+        if err is not None:
+            if close:
+                self.close(error=err)
+            return future.failure(err)
+
+        if data != b'\x00\x00\x00\x00':
+            error = Errors.AuthenticationFailedError('Unrecognized response during authentication')
+            return future.failure(error)
+
+        log.info('%s: Authenticated as %s via PLAIN', self, self.config['sasl_plain_username'])
+        return future.success(True)
+
+    def _try_authenticate_scram(self, future):
+        if self.config['security_protocol'] == 'SASL_PLAINTEXT':
+            log.warning('%s: Exchanging credentials in the clear', self)
+
+        scram_client = ScramClient(
+            self.config['sasl_plain_username'], self.config['sasl_plain_password'], self.config['sasl_mechanism']
+        )
+
+        err = None
+        close = False
+        with self._lock:
+            if not self._can_send_recv():
+                err = Errors.NodeNotReadyError(str(self))
+                close = False
+            else:
+                try:
+                    client_first = scram_client.first_message().encode('utf-8')
+                    size = Int32.encode(len(client_first))
+                    self._send_bytes_blocking(size + client_first)
+
+                    (data_len,) = struct.unpack('>i', self._recv_bytes_blocking(4))
+                    server_first = self._recv_bytes_blocking(data_len).decode('utf-8')
+                    scram_client.process_server_first_message(server_first)
+
+                    client_final = scram_client.final_message().encode('utf-8')
+                    size = Int32.encode(len(client_final))
+                    self._send_bytes_blocking(size + client_final)
+
+                    (data_len,) = struct.unpack('>i', self._recv_bytes_blocking(4))
+                    server_final = self._recv_bytes_blocking(data_len).decode('utf-8')
+                    scram_client.process_server_final_message(server_final)
+
+                except (ConnectionError, TimeoutError) as e:
+                    log.exception("%s: Error receiving reply from server", self)
+                    err = Errors.KafkaConnectionError("%s: %s" % (self, e))
+                    close = True
+
+        if err is not None:
+            if close:
+                self.close(error=err)
+            return future.failure(err)
+
+        log.info(
+            '%s: Authenticated as %s via %s', self, self.config['sasl_plain_username'], self.config['sasl_mechanism']
+        )
+        return future.success(True)
+
+    def _try_authenticate_gssapi(self, future):
+        kerberos_damin_name = self.config['sasl_kerberos_domain_name'] or self.host
+        auth_id = self.config['sasl_kerberos_service_name'] + '@' + kerberos_damin_name
+        gssapi_name = gssapi.Name(
+            auth_id,
+            name_type=gssapi.NameType.hostbased_service
+        ).canonicalize(gssapi.MechType.kerberos)
+        log.debug('%s: GSSAPI name: %s', self, gssapi_name)
+
+        err = None
+        close = False
+        with self._lock:
+            if not self._can_send_recv():
+                err = Errors.NodeNotReadyError(str(self))
+                close = False
+            else:
+                # Establish security context and negotiate protection level
+                # For reference RFC 2222, section 7.2.1
+                try:
+                    # Exchange tokens until authentication either succeeds or fails
+                    client_ctx = gssapi.SecurityContext(name=gssapi_name, usage='initiate')
+                    received_token = None
+                    while not client_ctx.complete:
+                        # calculate an output token from kafka token (or None if first iteration)
+                        output_token = client_ctx.step(received_token)
+
+                        # pass output token to kafka, or send empty response if the security
+                        # context is complete (output token is None in that case)
+                        if output_token is None:
+                            self._send_bytes_blocking(Int32.encode(0))
+                        else:
+                            msg = output_token
+                            size = Int32.encode(len(msg))
+                            self._send_bytes_blocking(size + msg)
+
+                        # The server will send a token back. Processing of this token either
+                        # establishes a security context, or it needs further token exchange.
+                        # The gssapi will be able to identify the needed next step.
+                        # The connection is closed on failure.
+                        header = self._recv_bytes_blocking(4)
+                        (token_size,) = struct.unpack('>i', header)
+                        received_token = self._recv_bytes_blocking(token_size)
+
+                    # Process the security layer negotiation token, sent by the server
+                    # once the security context is established.
+
+                    # unwraps message containing supported protection levels and msg size
+                    msg = client_ctx.unwrap(received_token).message
+                    # Kafka currently doesn't support integrity or confidentiality security layers, so we
+                    # simply set QoP to 'auth' only (first octet). We reuse the max message size proposed
+                    # by the server
+                    msg = Int8.encode(SASL_QOP_AUTH & Int8.decode(io.BytesIO(msg[0:1]))) + msg[1:]
+                    # add authorization identity to the response, GSS-wrap and send it
+                    msg = client_ctx.wrap(msg + auth_id.encode(), False).message
+                    size = Int32.encode(len(msg))
+                    self._send_bytes_blocking(size + msg)
+
+                except (ConnectionError, TimeoutError) as e:
+                    log.exception("%s: Error receiving reply from server",  self)
+                    err = Errors.KafkaConnectionError("%s: %s" % (self, e))
+                    close = True
+                except Exception as e:
+                    err = e
+                    close = True
+
+        if err is not None:
+            if close:
+                self.close(error=err)
+            return future.failure(err)
+
+        log.info('%s: Authenticated as %s via GSSAPI', self, gssapi_name)
+        return future.success(True)
+
+    def _try_authenticate_oauth(self, future):
+        data = b''
+
+        msg = bytes(self._build_oauth_client_request().encode("utf-8"))
+        size = Int32.encode(len(msg))
+
+        err = None
+        close = False
+        with self._lock:
+            if not self._can_send_recv():
+                err = Errors.NodeNotReadyError(str(self))
+                close = False
+            else:
+                try:
+                    # Send SASL OAuthBearer request with OAuth token
+                    self._send_bytes_blocking(size + msg)
+
+                    # The server will send a zero sized message (that is Int32(0)) on success.
+                    # The connection is closed on failure
+                    data = self._recv_bytes_blocking(4)
+
+                except (ConnectionError, TimeoutError) as e:
+                    log.exception("%s: Error receiving reply from server", self)
+                    err = Errors.KafkaConnectionError("%s: %s" % (self, e))
+                    close = True
+
+        if err is not None:
+            if close:
+                self.close(error=err)
+            return future.failure(err)
+
+        if data != b'\x00\x00\x00\x00':
+            error = Errors.AuthenticationFailedError('Unrecognized response during authentication')
+            return future.failure(error)
+
+        log.info('%s: Authenticated via OAuth', self)
+        return future.success(True)
+
+    def _build_oauth_client_request(self):
+        token_provider = self.config['sasl_oauth_token_provider']
+        return "n,,\x01auth=Bearer {}{}\x01\x01".format(token_provider.token(), self._token_extensions())
+
+    def _token_extensions(self):
+        """
+        Return a string representation of the OPTIONAL key-value pairs that can be sent with an OAUTHBEARER
+        initial request.
+        """
+        token_provider = self.config['sasl_oauth_token_provider']
+
+        # Only run if the #extensions() method is implemented by the clients Token Provider class
+        # Builds up a string separated by \x01 via a dict of key value pairs
+        if callable(getattr(token_provider, "extensions", None)) and len(token_provider.extensions()) > 0:
+            msg = "\x01".join(["{}={}".format(k, v) for k, v in token_provider.extensions().items()])
+            return "\x01" + msg
+        else:
+            return ""
+
+    def blacked_out(self):
+        """
+        Return true if we are disconnected from the given node and can't
+        re-establish a connection yet
+        """
+        if self.state is ConnectionStates.DISCONNECTED:
+            if time.time() < self.last_attempt + self._reconnect_backoff:
+                return True
+        return False
+
+    def connection_delay(self):
+        """
+        Return the number of milliseconds to wait, based on the connection
+        state, before attempting to send data. When disconnected, this respects
+        the reconnect backoff time. When connecting or connected, returns a very
+        large number to handle slow/stalled connections.
+        """
+        time_waited = time.time() - (self.last_attempt or 0)
+        if self.state is ConnectionStates.DISCONNECTED:
+            return max(self._reconnect_backoff - time_waited, 0) * 1000
+        else:
+            # When connecting or connected, we should be able to delay
+            # indefinitely since other events (connection or data acked) will
+            # cause a wakeup once data can be sent.
+            return float('inf')
+
+    def connected(self):
+        """Return True iff socket is connected."""
+        return self.state is ConnectionStates.CONNECTED
+
+    def connecting(self):
+        """Returns True if still connecting (this may encompass several
+        different states, such as SSL handshake, authorization, etc)."""
+        return self.state in (ConnectionStates.CONNECTING,
+                              ConnectionStates.HANDSHAKE,
+                              ConnectionStates.AUTHENTICATING)
+
+    def disconnected(self):
+        """Return True iff socket is closed"""
+        return self.state is ConnectionStates.DISCONNECTED
+
+    def _reset_reconnect_backoff(self):
+        self._failures = 0
+        self._reconnect_backoff = self.config['reconnect_backoff_ms'] / 1000.0
+
+    def _update_reconnect_backoff(self):
+        # Do not mark as failure if there are more dns entries available to try
+        if len(self._gai) > 0:
+            return
+        if self.config['reconnect_backoff_max_ms'] > self.config['reconnect_backoff_ms']:
+            self._failures += 1
+            self._reconnect_backoff = self.config['reconnect_backoff_ms'] * 2 ** (self._failures - 1)
+            self._reconnect_backoff = min(self._reconnect_backoff, self.config['reconnect_backoff_max_ms'])
+            self._reconnect_backoff *= uniform(0.8, 1.2)
+            self._reconnect_backoff /= 1000.0
+            log.debug('%s: reconnect backoff %s after %s failures', self, self._reconnect_backoff, self._failures)
+
+    def _close_socket(self):
+        if hasattr(self, '_sock') and self._sock is not None:
+            self._sock.close()
+            self._sock = None
+
+    def __del__(self):
+        self._close_socket()
+
+    def close(self, error=None):
+        """Close socket and fail all in-flight-requests.
+
+        Arguments:
+            error (Exception, optional): pending in-flight-requests
+                will be failed with this exception.
+                Default: kafka.errors.KafkaConnectionError.
+        """
+        if self.state is ConnectionStates.DISCONNECTED:
+            return
+        with self._lock:
+            if self.state is ConnectionStates.DISCONNECTED:
+                return
+            log.info('%s: Closing connection. %s', self, error or '')
+            self._update_reconnect_backoff()
+            self._sasl_auth_future = None
+            self._protocol = KafkaProtocol(
+                client_id=self.config['client_id'],
+                api_version=self.config['api_version'])
+            self._send_buffer = b''
+            if error is None:
+                error = Errors.Cancelled(str(self))
+            ifrs = list(self.in_flight_requests.items())
+            self.in_flight_requests.clear()
+            self.state = ConnectionStates.DISCONNECTED
+            # To avoid race conditions and/or deadlocks
+            # keep a reference to the socket but leave it
+            # open until after the state_change_callback
+            # This should give clients a change to deregister
+            # the socket fd from selectors cleanly.
+            sock = self._sock
+            self._sock = None
+
+        # drop lock before state change callback and processing futures
+        self.config['state_change_callback'](self.node_id, sock, self)
+        sock.close()
+        for (_correlation_id, (future, _timestamp)) in ifrs:
+            future.failure(error)
+
+    def _can_send_recv(self):
+        """Return True iff socket is ready for requests / responses"""
+        return self.state in (ConnectionStates.AUTHENTICATING,
+                              ConnectionStates.CONNECTED)
+
+    def send(self, request, blocking=True):
+        """Queue request for async network send, return Future()"""
+        future = Future()
+        if self.connecting():
+            return future.failure(Errors.NodeNotReadyError(str(self)))
+        elif not self.connected():
+            return future.failure(Errors.KafkaConnectionError(str(self)))
+        elif not self.can_send_more():
+            return future.failure(Errors.TooManyInFlightRequests(str(self)))
+        return self._send(request, blocking=blocking)
+
+    def _send(self, request, blocking=True):
+        future = Future()
+        with self._lock:
+            if not self._can_send_recv():
+                # In this case, since we created the future above,
+                # we know there are no callbacks/errbacks that could fire w/
+                # lock. So failing + returning inline should be safe
+                return future.failure(Errors.NodeNotReadyError(str(self)))
+
+            correlation_id = self._protocol.send_request(request)
+
+            log.debug('%s Request %d: %s', self, correlation_id, request)
+            if request.expect_response():
+                sent_time = time.time()
+                assert correlation_id not in self.in_flight_requests, 'Correlation ID already in-flight!'
+                self.in_flight_requests[correlation_id] = (future, sent_time)
+            else:
+                future.success(None)
+
+        # Attempt to replicate behavior from prior to introduction of
+        # send_pending_requests() / async sends
+        if blocking:
+            self.send_pending_requests()
+
+        return future
+
+    def send_pending_requests(self):
+        """Attempts to send pending requests messages via blocking IO
+        If all requests have been sent, return True
+        Otherwise, if the socket is blocked and there are more bytes to send,
+        return False.
+        """
+        try:
+            with self._lock:
+                if not self._can_send_recv():
+                    return False
+                data = self._protocol.send_bytes()
+                total_bytes = self._send_bytes_blocking(data)
+
+            if self._sensors:
+                self._sensors.bytes_sent.record(total_bytes)
+            return True
+
+        except (ConnectionError, TimeoutError) as e:
+            log.exception("Error sending request data to %s", self)
+            error = Errors.KafkaConnectionError("%s: %s" % (self, e))
+            self.close(error=error)
+            return False
+
+    def send_pending_requests_v2(self):
+        """Attempts to send pending requests messages via non-blocking IO
+        If all requests have been sent, return True
+        Otherwise, if the socket is blocked and there are more bytes to send,
+        return False.
+        """
+        try:
+            with self._lock:
+                if not self._can_send_recv():
+                    return False
+
+                # _protocol.send_bytes returns encoded requests to send
+                # we send them via _send_bytes()
+                # and hold leftover bytes in _send_buffer
+                if not self._send_buffer:
+                    self._send_buffer = self._protocol.send_bytes()
+
+                total_bytes = 0
+                if self._send_buffer:
+                    total_bytes = self._send_bytes(self._send_buffer)
+                    self._send_buffer = self._send_buffer[total_bytes:]
+
+            if self._sensors:
+                self._sensors.bytes_sent.record(total_bytes)
+            # Return True iff send buffer is empty
+            return len(self._send_buffer) == 0
+
+        except (ConnectionError, TimeoutError, Exception) as e:
+            log.exception("Error sending request data to %s", self)
+            error = Errors.KafkaConnectionError("%s: %s" % (self, e))
+            self.close(error=error)
+            return False
+
+    def can_send_more(self):
+        """Return True unless there are max_in_flight_requests_per_connection."""
+        max_ifrs = self.config['max_in_flight_requests_per_connection']
+        return len(self.in_flight_requests) < max_ifrs
+
+    def recv(self):
+        """Non-blocking network receive.
+
+        Return list of (response, future) tuples
+        """
+        responses = self._recv()
+        if not responses and self.requests_timed_out():
+            log.warning('%s timed out after %s ms. Closing connection.',
+                        self, self.config['request_timeout_ms'])
+            self.close(error=Errors.RequestTimedOutError(
+                'Request timed out after %s ms' %
+                self.config['request_timeout_ms']))
+            return ()
+
+        # augment responses w/ correlation_id, future, and timestamp
+        for i, (correlation_id, response) in enumerate(responses):
+            try:
+                with self._lock:
+                    (future, timestamp) = self.in_flight_requests.pop(correlation_id)
+            except KeyError:
+                self.close(Errors.KafkaConnectionError('Received unrecognized correlation id'))
+                return ()
+            latency_ms = (time.time() - timestamp) * 1000
+            if self._sensors:
+                self._sensors.request_time.record(latency_ms)
+
+            log.debug('%s Response %d (%s ms): %s', self, correlation_id, latency_ms, response)
+            responses[i] = (response, future)
+
+        return responses
+
+    def _recv(self):
+        """Take all available bytes from socket, return list of any responses from parser"""
+        recvd = []
+        err = None
+        with self._lock:
+            if not self._can_send_recv():
+                log.warning('%s cannot recv: socket not connected', self)
+                return ()
+
+            while len(recvd) < self.config['sock_chunk_buffer_count']:
+                try:
+                    data = self._sock.recv(self.config['sock_chunk_bytes'])
+                    # We expect socket.recv to raise an exception if there are no
+                    # bytes available to read from the socket in non-blocking mode.
+                    # but if the socket is disconnected, we will get empty data
+                    # without an exception raised
+                    if not data:
+                        log.error('%s: socket disconnected', self)
+                        err = Errors.KafkaConnectionError('socket disconnected')
+                        break
+                    else:
+                        recvd.append(data)
+
+                except (SSLWantReadError, SSLWantWriteError):
+                    break
+                except (ConnectionError, TimeoutError) as e:
+                    if six.PY2 and e.errno == errno.EWOULDBLOCK:
+                        break
+                    log.exception('%s: Error receiving network data'
+                                  ' closing socket', self)
+                    err = Errors.KafkaConnectionError(e)
+                    break
+                except BlockingIOError:
+                    if six.PY3:
+                        break
+                    # For PY2 this is a catchall and should be re-raised
+                    raise
+
+            # Only process bytes if there was no connection exception
+            if err is None:
+                recvd_data = b''.join(recvd)
+                if self._sensors:
+                    self._sensors.bytes_received.record(len(recvd_data))
+
+                # We need to keep the lock through protocol receipt
+                # so that we ensure that the processed byte order is the
+                # same as the received byte order
+                try:
+                    return self._protocol.receive_bytes(recvd_data)
+                except Errors.KafkaProtocolError as e:
+                    err = e
+
+        self.close(error=err)
+        return ()
+
+    def requests_timed_out(self):
+        with self._lock:
+            if self.in_flight_requests:
+                get_timestamp = lambda v: v[1]
+                oldest_at = min(map(get_timestamp,
+                                    self.in_flight_requests.values()))
+                timeout = self.config['request_timeout_ms'] / 1000.0
+                if time.time() >= oldest_at + timeout:
+                    return True
+            return False
+
+    def _handle_api_version_response(self, response):
+        error_type = Errors.for_code(response.error_code)
+        assert error_type is Errors.NoError, "API version check failed"
+        self._api_versions = dict([
+            (api_key, (min_version, max_version))
+            for api_key, min_version, max_version in response.api_versions
+        ])
+        return self._api_versions
+
+    def get_api_versions(self):
+        if self._api_versions is not None:
+            return self._api_versions
+
+        version = self.check_version()
+        if version < (0, 10, 0):
+            raise Errors.UnsupportedVersionError(
+                "ApiVersion not supported by cluster version {} < 0.10.0"
+                .format(version))
+        # _api_versions is set as a side effect of check_versions() on a cluster
+        # that supports 0.10.0 or later
+        return self._api_versions
+
+    def _infer_broker_version_from_api_versions(self, api_versions):
+        # The logic here is to check the list of supported request versions
+        # in reverse order. As soon as we find one that works, return it
+        test_cases = [
+            # format (<broker version>, <needed struct>)
+            ((2, 6, 0), DescribeClientQuotasRequest[0]),
+            ((2, 5, 0), DescribeAclsRequest_v2),
+            ((2, 4, 0), ProduceRequest[8]),
+            ((2, 3, 0), FetchRequest[11]),
+            ((2, 2, 0), OffsetRequest[5]),
+            ((2, 1, 0), FetchRequest[10]),
+            ((2, 0, 0), FetchRequest[8]),
+            ((1, 1, 0), FetchRequest[7]),
+            ((1, 0, 0), MetadataRequest[5]),
+            ((0, 11, 0), MetadataRequest[4]),
+            ((0, 10, 2), OffsetFetchRequest[2]),
+            ((0, 10, 1), MetadataRequest[2]),
+        ]
+
+        # Get the best match of test cases
+        for broker_version, struct in sorted(test_cases, reverse=True):
+            if struct.API_KEY not in api_versions:
+                continue
+            min_version, max_version = api_versions[struct.API_KEY]
+            if min_version <= struct.API_VERSION <= max_version:
+                return broker_version
+
+        # We know that ApiVersionResponse is only supported in 0.10+
+        # so if all else fails, choose that
+        return (0, 10, 0)
+
+    def check_version(self, timeout=2, strict=False, topics=[]):
+        """Attempt to guess the broker version.
+
+        Note: This is a blocking call.
+
+        Returns: version tuple, i.e. (0, 10), (0, 9), (0, 8, 2), ...
+        """
+        timeout_at = time.time() + timeout
+        log.info('Probing node %s broker version', self.node_id)
+        # Monkeypatch some connection configurations to avoid timeouts
+        override_config = {
+            'request_timeout_ms': timeout * 1000,
+            'max_in_flight_requests_per_connection': 5
+        }
+        stashed = {}
+        for key in override_config:
+            stashed[key] = self.config[key]
+            self.config[key] = override_config[key]
+
+        def reset_override_configs():
+            for key in stashed:
+                self.config[key] = stashed[key]
+
+        # kafka kills the connection when it doesn't recognize an API request
+        # so we can send a test request and then follow immediately with a
+        # vanilla MetadataRequest. If the server did not recognize the first
+        # request, both will be failed with a ConnectionError that wraps
+        # socket.error (32, 54, or 104)
+        from kafka.protocol.admin import ApiVersionRequest, ListGroupsRequest
+        from kafka.protocol.commit import OffsetFetchRequest, GroupCoordinatorRequest
+
+        test_cases = [
+            # All cases starting from 0.10 will be based on ApiVersionResponse
+            ((0, 10), ApiVersionRequest[0]()),
+            ((0, 9), ListGroupsRequest[0]()),
+            ((0, 8, 2), GroupCoordinatorRequest[0]('kafka-python-default-group')),
+            ((0, 8, 1), OffsetFetchRequest[0]('kafka-python-default-group', [])),
+            ((0, 8, 0), MetadataRequest[0](topics)),
+        ]
+
+        for version, request in test_cases:
+            if not self.connect_blocking(timeout_at - time.time()):
+                reset_override_configs()
+                raise Errors.NodeNotReadyError()
+            f = self.send(request)
+            # HACK: sleeping to wait for socket to send bytes
+            time.sleep(0.1)
+            # when broker receives an unrecognized request API
+            # it abruptly closes our socket.
+            # so we attempt to send a second request immediately
+            # that we believe it will definitely recognize (metadata)
+            # the attempt to write to a disconnected socket should
+            # immediately fail and allow us to infer that the prior
+            # request was unrecognized
+            mr = self.send(MetadataRequest[0](topics))
+
+            selector = self.config['selector']()
+            selector.register(self._sock, selectors.EVENT_READ)
+            while not (f.is_done and mr.is_done):
+                selector.select(1)
+                for response, future in self.recv():
+                    future.success(response)
+            selector.close()
+
+            if f.succeeded():
+                if isinstance(request, ApiVersionRequest[0]):
+                    # Starting from 0.10 kafka broker we determine version
+                    # by looking at ApiVersionResponse
+                    api_versions = self._handle_api_version_response(f.value)
+                    version = self._infer_broker_version_from_api_versions(api_versions)
+                log.info('Broker version identified as %s', '.'.join(map(str, version)))
+                log.info('Set configuration api_version=%s to skip auto'
+                         ' check_version requests on startup', version)
+                break
+
+            # Only enable strict checking to verify that we understand failure
+            # modes. For most users, the fact that the request failed should be
+            # enough to rule out a particular broker version.
+            if strict:
+                # If the socket flush hack did not work (which should force the
+                # connection to close and fail all pending requests), then we
+                # get a basic Request Timeout. This is not ideal, but we'll deal
+                if isinstance(f.exception, Errors.RequestTimedOutError):
+                    pass
+
+                # 0.9 brokers do not close the socket on unrecognized api
+                # requests (bug...). In this case we expect to see a correlation
+                # id mismatch
+                elif (isinstance(f.exception, Errors.CorrelationIdError) and
+                      version == (0, 10)):
+                    pass
+                elif six.PY2:
+                    assert isinstance(f.exception.args[0], socket.error)
+                    assert f.exception.args[0].errno in (32, 54, 104)
+                else:
+                    assert isinstance(f.exception.args[0], ConnectionError)
+            log.info("Broker is not v%s -- it did not recognize %s",
+                     version, request.__class__.__name__)
+        else:
+            reset_override_configs()
+            raise Errors.UnrecognizedBrokerVersion()
+
+        reset_override_configs()
+        return version
+
+    def __str__(self):
+        return "<BrokerConnection node_id=%s host=%s:%d %s [%s %s]>" % (
+            self.node_id, self.host, self.port, self.state,
+            AFI_NAMES[self._sock_afi], self._sock_addr)
+
+
+class BrokerConnectionMetrics(object):
+    def __init__(self, metrics, metric_group_prefix, node_id):
+        self.metrics = metrics
+
+        # Any broker may have registered summary metrics already
+        # but if not, we need to create them so we can set as parents below
+        all_conns_transferred = metrics.get_sensor('bytes-sent-received')
+        if not all_conns_transferred:
+            metric_group_name = metric_group_prefix + '-metrics'
+
+            bytes_transferred = metrics.sensor('bytes-sent-received')
+            bytes_transferred.add(metrics.metric_name(
+                'network-io-rate', metric_group_name,
+                'The average number of network operations (reads or writes) on all'
+                ' connections per second.'), Rate(sampled_stat=Count()))
+
+            bytes_sent = metrics.sensor('bytes-sent',
+                                        parents=[bytes_transferred])
+            bytes_sent.add(metrics.metric_name(
+                'outgoing-byte-rate', metric_group_name,
+                'The average number of outgoing bytes sent per second to all'
+                ' servers.'), Rate())
+            bytes_sent.add(metrics.metric_name(
+                'request-rate', metric_group_name,
+                'The average number of requests sent per second.'),
+                Rate(sampled_stat=Count()))
+            bytes_sent.add(metrics.metric_name(
+                'request-size-avg', metric_group_name,
+                'The average size of all requests in the window.'), Avg())
+            bytes_sent.add(metrics.metric_name(
+                'request-size-max', metric_group_name,
+                'The maximum size of any request sent in the window.'), Max())
+
+            bytes_received = metrics.sensor('bytes-received',
+                                            parents=[bytes_transferred])
+            bytes_received.add(metrics.metric_name(
+                'incoming-byte-rate', metric_group_name,
+                'Bytes/second read off all sockets'), Rate())
+            bytes_received.add(metrics.metric_name(
+                'response-rate', metric_group_name,
+                'Responses received sent per second.'),
+                Rate(sampled_stat=Count()))
+
+            request_latency = metrics.sensor('request-latency')
+            request_latency.add(metrics.metric_name(
+                'request-latency-avg', metric_group_name,
+                'The average request latency in ms.'),
+                Avg())
+            request_latency.add(metrics.metric_name(
+                'request-latency-max', metric_group_name,
+                'The maximum request latency in ms.'),
+                Max())
+
+        # if one sensor of the metrics has been registered for the connection,
+        # then all other sensors should have been registered; and vice versa
+        node_str = 'node-{0}'.format(node_id)
+        node_sensor = metrics.get_sensor(node_str + '.bytes-sent')
+        if not node_sensor:
+            metric_group_name = metric_group_prefix + '-node-metrics.' + node_str
+
+            bytes_sent = metrics.sensor(
+                node_str + '.bytes-sent',
+                parents=[metrics.get_sensor('bytes-sent')])
+            bytes_sent.add(metrics.metric_name(
+                'outgoing-byte-rate', metric_group_name,
+                'The average number of outgoing bytes sent per second.'),
+                Rate())
+            bytes_sent.add(metrics.metric_name(
+                'request-rate', metric_group_name,
+                'The average number of requests sent per second.'),
+                Rate(sampled_stat=Count()))
+            bytes_sent.add(metrics.metric_name(
+                'request-size-avg', metric_group_name,
+                'The average size of all requests in the window.'),
+                Avg())
+            bytes_sent.add(metrics.metric_name(
+                'request-size-max', metric_group_name,
+                'The maximum size of any request sent in the window.'),
+                Max())
+
+            bytes_received = metrics.sensor(
+                node_str + '.bytes-received',
+                parents=[metrics.get_sensor('bytes-received')])
+            bytes_received.add(metrics.metric_name(
+                'incoming-byte-rate', metric_group_name,
+                'Bytes/second read off node-connection socket'),
+                Rate())
+            bytes_received.add(metrics.metric_name(
+                'response-rate', metric_group_name,
+                'The average number of responses received per second.'),
+                Rate(sampled_stat=Count()))
+
+            request_time = metrics.sensor(
+                node_str + '.latency',
+                parents=[metrics.get_sensor('request-latency')])
+            request_time.add(metrics.metric_name(
+                'request-latency-avg', metric_group_name,
+                'The average request latency in ms.'),
+                Avg())
+            request_time.add(metrics.metric_name(
+                'request-latency-max', metric_group_name,
+                'The maximum request latency in ms.'),
+                Max())
+
+        self.bytes_sent = metrics.sensor(node_str + '.bytes-sent')
+        self.bytes_received = metrics.sensor(node_str + '.bytes-received')
+        self.request_time = metrics.sensor(node_str + '.latency')
+
+
+def _address_family(address):
+    """
+        Attempt to determine the family of an address (or hostname)
+
+        :return: either socket.AF_INET or socket.AF_INET6 or socket.AF_UNSPEC if the address family
+                 could not be determined
+    """
+    if address.startswith('[') and address.endswith(']'):
+        return socket.AF_INET6
+    for af in (socket.AF_INET, socket.AF_INET6):
+        try:
+            socket.inet_pton(af, address)
+            return af
+        except (ValueError, AttributeError, socket.error):
+            continue
+    return socket.AF_UNSPEC
+
+
+def get_ip_port_afi(host_and_port_str):
+    """
+        Parse the IP and port from a string in the format of:
+
+            * host_or_ip          <- Can be either IPv4 address literal or hostname/fqdn
+            * host_or_ipv4:port   <- Can be either IPv4 address literal or hostname/fqdn
+            * [host_or_ip]        <- IPv6 address literal
+            * [host_or_ip]:port.  <- IPv6 address literal
+
+        .. note:: IPv6 address literals with ports *must* be enclosed in brackets
+
+        .. note:: If the port is not specified, default will be returned.
+
+        :return: tuple (host, port, afi), afi will be socket.AF_INET or socket.AF_INET6 or socket.AF_UNSPEC
+    """
+    host_and_port_str = host_and_port_str.strip()
+    if host_and_port_str.startswith('['):
+        af = socket.AF_INET6
+        host, rest = host_and_port_str[1:].split(']')
+        if rest:
+            port = int(rest[1:])
+        else:
+            port = DEFAULT_KAFKA_PORT
+        return host, port, af
+    else:
+        if ':' not in host_and_port_str:
+            af = _address_family(host_and_port_str)
+            return host_and_port_str, DEFAULT_KAFKA_PORT, af
+        else:
+            # now we have something with a colon in it and no square brackets. It could be
+            # either an IPv6 address literal (e.g., "::1") or an IP:port pair or a host:port pair
+            try:
+                # if it decodes as an IPv6 address, use that
+                socket.inet_pton(socket.AF_INET6, host_and_port_str)
+                return host_and_port_str, DEFAULT_KAFKA_PORT, socket.AF_INET6
+            except AttributeError:
+                log.warning('socket.inet_pton not available on this platform.'
+                            ' consider `pip install win_inet_pton`')
+                pass
+            except (ValueError, socket.error):
+                # it's a host:port pair
+                pass
+            host, port = host_and_port_str.rsplit(':', 1)
+            port = int(port)
+
+            af = _address_family(host)
+            return host, port, af
+
+
+def collect_hosts(hosts, randomize=True):
+    """
+    Collects a comma-separated set of hosts (host:port) and optionally
+    randomize the returned list.
+    """
+
+    if isinstance(hosts, six.string_types):
+        hosts = hosts.strip().split(',')
+
+    result = []
+    afi = socket.AF_INET
+    for host_port in hosts:
+
+        host, port, afi = get_ip_port_afi(host_port)
+
+        if port < 0:
+            port = DEFAULT_KAFKA_PORT
+
+        result.append((host, port, afi))
+
+    if randomize:
+        shuffle(result)
+
+    return result
+
+
+def is_inet_4_or_6(gai):
+    """Given a getaddrinfo struct, return True iff ipv4 or ipv6"""
+    return gai[0] in (socket.AF_INET, socket.AF_INET6)
+
+
+def dns_lookup(host, port, afi=socket.AF_UNSPEC):
+    """Returns a list of getaddrinfo structs, optionally filtered to an afi (ipv4 / ipv6)"""
+    # XXX: all DNS functions in Python are blocking. If we really
+    # want to be non-blocking here, we need to use a 3rd-party
+    # library like python-adns, or move resolution onto its
+    # own thread. This will be subject to the default libc
+    # name resolution timeout (5s on most Linux boxes)
+    try:
+        return list(filter(is_inet_4_or_6,
+                           socket.getaddrinfo(host, port, afi,
+                                              socket.SOCK_STREAM)))
+    except socket.gaierror as ex:
+        log.warning('DNS lookup failed for %s:%d,'
+                    ' exception was %s. Is your'
+                    ' advertised.listeners (called'
+                    ' advertised.host.name before Kafka 9)'
+                    ' correct and resolvable?',
+                    host, port, ex)
+        return []

testbed/dpkp__kafka-python/kafka/errors.py

@@ -0,0 +1,538 @@
+from __future__ import absolute_import
+
+import inspect
+import sys
+
+
+class KafkaError(RuntimeError):
+    retriable = False
+    # whether metadata should be refreshed on error
+    invalid_metadata = False
+
+    def __str__(self):
+        if not self.args:
+            return self.__class__.__name__
+        return '{0}: {1}'.format(self.__class__.__name__,
+                               super(KafkaError, self).__str__())
+
+
+class IllegalStateError(KafkaError):
+    pass
+
+
+class IllegalArgumentError(KafkaError):
+    pass
+
+
+class NoBrokersAvailable(KafkaError):
+    retriable = True
+    invalid_metadata = True
+
+
+class NodeNotReadyError(KafkaError):
+    retriable = True
+
+
+class KafkaProtocolError(KafkaError):
+    retriable = True
+
+
+class CorrelationIdError(KafkaProtocolError):
+    retriable = True
+
+
+class Cancelled(KafkaError):
+    retriable = True
+
+
+class TooManyInFlightRequests(KafkaError):
+    retriable = True
+
+
+class StaleMetadata(KafkaError):
+    retriable = True
+    invalid_metadata = True
+
+
+class MetadataEmptyBrokerList(KafkaError):
+    retriable = True
+
+
+class UnrecognizedBrokerVersion(KafkaError):
+    pass
+
+
+class IncompatibleBrokerVersion(KafkaError):
+    pass
+
+
+class CommitFailedError(KafkaError):
+    def __init__(self, *args, **kwargs):
+        super(CommitFailedError, self).__init__(
+            """Commit cannot be completed since the group has already
+            rebalanced and assigned the partitions to another member.
+            This means that the time between subsequent calls to poll()
+            was longer than the configured max_poll_interval_ms, which
+            typically implies that the poll loop is spending too much
+            time message processing. You can address this either by
+            increasing the rebalance timeout with max_poll_interval_ms,
+            or by reducing the maximum size of batches returned in poll()
+            with max_poll_records.
+            """, *args, **kwargs)
+
+
+class AuthenticationMethodNotSupported(KafkaError):
+    pass
+
+
+class AuthenticationFailedError(KafkaError):
+    retriable = False
+
+
+class BrokerResponseError(KafkaError):
+    errno = None
+    message = None
+    description = None
+
+    def __str__(self):
+        """Add errno to standard KafkaError str"""
+        return '[Error {0}] {1}'.format(
+            self.errno,
+            super(BrokerResponseError, self).__str__())
+
+
+class NoError(BrokerResponseError):
+    errno = 0
+    message = 'NO_ERROR'
+    description = 'No error--it worked!'
+
+
+class UnknownError(BrokerResponseError):
+    errno = -1
+    message = 'UNKNOWN'
+    description = 'An unexpected server error.'
+
+
+class OffsetOutOfRangeError(BrokerResponseError):
+    errno = 1
+    message = 'OFFSET_OUT_OF_RANGE'
+    description = ('The requested offset is outside the range of offsets'
+                   ' maintained by the server for the given topic/partition.')
+
+
+class CorruptRecordException(BrokerResponseError):
+    errno = 2
+    message = 'CORRUPT_MESSAGE'
+    description = ('This message has failed its CRC checksum, exceeds the'
+                   ' valid size, or is otherwise corrupt.')
+
+# Backward compatibility
+InvalidMessageError = CorruptRecordException
+
+
+class UnknownTopicOrPartitionError(BrokerResponseError):
+    errno = 3
+    message = 'UNKNOWN_TOPIC_OR_PARTITION'
+    description = ('This request is for a topic or partition that does not'
+                   ' exist on this broker.')
+    retriable = True
+    invalid_metadata = True
+
+
+class InvalidFetchRequestError(BrokerResponseError):
+    errno = 4
+    message = 'INVALID_FETCH_SIZE'
+    description = 'The message has a negative size.'
+
+
+class LeaderNotAvailableError(BrokerResponseError):
+    errno = 5
+    message = 'LEADER_NOT_AVAILABLE'
+    description = ('This error is thrown if we are in the middle of a'
+                   ' leadership election and there is currently no leader for'
+                   ' this partition and hence it is unavailable for writes.')
+    retriable = True
+    invalid_metadata = True
+
+
+class NotLeaderForPartitionError(BrokerResponseError):
+    errno = 6
+    message = 'NOT_LEADER_FOR_PARTITION'
+    description = ('This error is thrown if the client attempts to send'
+                   ' messages to a replica that is not the leader for some'
+                   ' partition. It indicates that the clients metadata is out'
+                   ' of date.')
+    retriable = True
+    invalid_metadata = True
+
+
+class RequestTimedOutError(BrokerResponseError):
+    errno = 7
+    message = 'REQUEST_TIMED_OUT'
+    description = ('This error is thrown if the request exceeds the'
+                   ' user-specified time limit in the request.')
+    retriable = True
+
+
+class BrokerNotAvailableError(BrokerResponseError):
+    errno = 8
+    message = 'BROKER_NOT_AVAILABLE'
+    description = ('This is not a client facing error and is used mostly by'
+                   ' tools when a broker is not alive.')
+
+
+class ReplicaNotAvailableError(BrokerResponseError):
+    errno = 9
+    message = 'REPLICA_NOT_AVAILABLE'
+    description = ('If replica is expected on a broker, but is not (this can be'
+                   ' safely ignored).')
+
+
+class MessageSizeTooLargeError(BrokerResponseError):
+    errno = 10
+    message = 'MESSAGE_SIZE_TOO_LARGE'
+    description = ('The server has a configurable maximum message size to avoid'
+                   ' unbounded memory allocation. This error is thrown if the'
+                   ' client attempt to produce a message larger than this'
+                   ' maximum.')
+
+
+class StaleControllerEpochError(BrokerResponseError):
+    errno = 11
+    message = 'STALE_CONTROLLER_EPOCH'
+    description = 'Internal error code for broker-to-broker communication.'
+
+
+class OffsetMetadataTooLargeError(BrokerResponseError):
+    errno = 12
+    message = 'OFFSET_METADATA_TOO_LARGE'
+    description = ('If you specify a string larger than configured maximum for'
+                   ' offset metadata.')
+
+
+# TODO is this deprecated? https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol#AGuideToTheKafkaProtocol-ErrorCodes
+class StaleLeaderEpochCodeError(BrokerResponseError):
+    errno = 13
+    message = 'STALE_LEADER_EPOCH_CODE'
+
+
+class GroupLoadInProgressError(BrokerResponseError):
+    errno = 14
+    message = 'OFFSETS_LOAD_IN_PROGRESS'
+    description = ('The broker returns this error code for an offset fetch'
+                   ' request if it is still loading offsets (after a leader'
+                   ' change for that offsets topic partition), or in response'
+                   ' to group membership requests (such as heartbeats) when'
+                   ' group metadata is being loaded by the coordinator.')
+    retriable = True
+
+
+class GroupCoordinatorNotAvailableError(BrokerResponseError):
+    errno = 15
+    message = 'CONSUMER_COORDINATOR_NOT_AVAILABLE'
+    description = ('The broker returns this error code for group coordinator'
+                   ' requests, offset commits, and most group management'
+                   ' requests if the offsets topic has not yet been created, or'
+                   ' if the group coordinator is not active.')
+    retriable = True
+
+
+class NotCoordinatorForGroupError(BrokerResponseError):
+    errno = 16
+    message = 'NOT_COORDINATOR_FOR_CONSUMER'
+    description = ('The broker returns this error code if it receives an offset'
+                   ' fetch or commit request for a group that it is not a'
+                   ' coordinator for.')
+    retriable = True
+
+
+class InvalidTopicError(BrokerResponseError):
+    errno = 17
+    message = 'INVALID_TOPIC'
+    description = ('For a request which attempts to access an invalid topic'
+                   ' (e.g. one which has an illegal name), or if an attempt'
+                   ' is made to write to an internal topic (such as the'
+                   ' consumer offsets topic).')
+
+
+class RecordListTooLargeError(BrokerResponseError):
+    errno = 18
+    message = 'RECORD_LIST_TOO_LARGE'
+    description = ('If a message batch in a produce request exceeds the maximum'
+                   ' configured segment size.')
+
+
+class NotEnoughReplicasError(BrokerResponseError):
+    errno = 19
+    message = 'NOT_ENOUGH_REPLICAS'
+    description = ('Returned from a produce request when the number of in-sync'
+                   ' replicas is lower than the configured minimum and'
+                   ' requiredAcks is -1.')
+    retriable = True
+
+
+class NotEnoughReplicasAfterAppendError(BrokerResponseError):
+    errno = 20
+    message = 'NOT_ENOUGH_REPLICAS_AFTER_APPEND'
+    description = ('Returned from a produce request when the message was'
+                   ' written to the log, but with fewer in-sync replicas than'
+                   ' required.')
+    retriable = True
+
+
+class InvalidRequiredAcksError(BrokerResponseError):
+    errno = 21
+    message = 'INVALID_REQUIRED_ACKS'
+    description = ('Returned from a produce request if the requested'
+                   ' requiredAcks is invalid (anything other than -1, 1, or 0).')
+
+
+class IllegalGenerationError(BrokerResponseError):
+    errno = 22
+    message = 'ILLEGAL_GENERATION'
+    description = ('Returned from group membership requests (such as heartbeats)'
+                   ' when the generation id provided in the request is not the'
+                   ' current generation.')
+
+
+class InconsistentGroupProtocolError(BrokerResponseError):
+    errno = 23
+    message = 'INCONSISTENT_GROUP_PROTOCOL'
+    description = ('Returned in join group when the member provides a protocol'
+                   ' type or set of protocols which is not compatible with the'
+                   ' current group.')
+
+
+class InvalidGroupIdError(BrokerResponseError):
+    errno = 24
+    message = 'INVALID_GROUP_ID'
+    description = 'Returned in join group when the groupId is empty or null.'
+
+
+class UnknownMemberIdError(BrokerResponseError):
+    errno = 25
+    message = 'UNKNOWN_MEMBER_ID'
+    description = ('Returned from group requests (offset commits/fetches,'
+                   ' heartbeats, etc) when the memberId is not in the current'
+                   ' generation.')
+
+
+class InvalidSessionTimeoutError(BrokerResponseError):
+    errno = 26
+    message = 'INVALID_SESSION_TIMEOUT'
+    description = ('Return in join group when the requested session timeout is'
+                   ' outside of the allowed range on the broker')
+
+
+class RebalanceInProgressError(BrokerResponseError):
+    errno = 27
+    message = 'REBALANCE_IN_PROGRESS'
+    description = ('Returned in heartbeat requests when the coordinator has'
+                   ' begun rebalancing the group. This indicates to the client'
+                   ' that it should rejoin the group.')
+
+
+class InvalidCommitOffsetSizeError(BrokerResponseError):
+    errno = 28
+    message = 'INVALID_COMMIT_OFFSET_SIZE'
+    description = ('This error indicates that an offset commit was rejected'
+                   ' because of oversize metadata.')
+
+
+class TopicAuthorizationFailedError(BrokerResponseError):
+    errno = 29
+    message = 'TOPIC_AUTHORIZATION_FAILED'
+    description = ('Returned by the broker when the client is not authorized to'
+                   ' access the requested topic.')
+
+
+class GroupAuthorizationFailedError(BrokerResponseError):
+    errno = 30
+    message = 'GROUP_AUTHORIZATION_FAILED'
+    description = ('Returned by the broker when the client is not authorized to'
+                   ' access a particular groupId.')
+
+
+class ClusterAuthorizationFailedError(BrokerResponseError):
+    errno = 31
+    message = 'CLUSTER_AUTHORIZATION_FAILED'
+    description = ('Returned by the broker when the client is not authorized to'
+                   ' use an inter-broker or administrative API.')
+
+
+class InvalidTimestampError(BrokerResponseError):
+    errno = 32
+    message = 'INVALID_TIMESTAMP'
+    description = 'The timestamp of the message is out of acceptable range.'
+
+
+class UnsupportedSaslMechanismError(BrokerResponseError):
+    errno = 33
+    message = 'UNSUPPORTED_SASL_MECHANISM'
+    description = 'The broker does not support the requested SASL mechanism.'
+
+
+class IllegalSaslStateError(BrokerResponseError):
+    errno = 34
+    message = 'ILLEGAL_SASL_STATE'
+    description = 'Request is not valid given the current SASL state.'
+
+
+class UnsupportedVersionError(BrokerResponseError):
+    errno = 35
+    message = 'UNSUPPORTED_VERSION'
+    description = 'The version of API is not supported.'
+
+
+class TopicAlreadyExistsError(BrokerResponseError):
+    errno = 36
+    message = 'TOPIC_ALREADY_EXISTS'
+    description = 'Topic with this name already exists.'
+
+
+class InvalidPartitionsError(BrokerResponseError):
+    errno = 37
+    message = 'INVALID_PARTITIONS'
+    description = 'Number of partitions is invalid.'
+
+
+class InvalidReplicationFactorError(BrokerResponseError):
+    errno = 38
+    message = 'INVALID_REPLICATION_FACTOR'
+    description = 'Replication-factor is invalid.'
+
+
+class InvalidReplicationAssignmentError(BrokerResponseError):
+    errno = 39
+    message = 'INVALID_REPLICATION_ASSIGNMENT'
+    description = 'Replication assignment is invalid.'
+
+
+class InvalidConfigurationError(BrokerResponseError):
+    errno = 40
+    message = 'INVALID_CONFIG'
+    description = 'Configuration is invalid.'
+
+
+class NotControllerError(BrokerResponseError):
+    errno = 41
+    message = 'NOT_CONTROLLER'
+    description = 'This is not the correct controller for this cluster.'
+    retriable = True
+
+
+class InvalidRequestError(BrokerResponseError):
+    errno = 42
+    message = 'INVALID_REQUEST'
+    description = ('This most likely occurs because of a request being'
+                   ' malformed by the client library or the message was'
+                   ' sent to an incompatible broker. See the broker logs'
+                   ' for more details.')
+
+
+class UnsupportedForMessageFormatError(BrokerResponseError):
+    errno = 43
+    message = 'UNSUPPORTED_FOR_MESSAGE_FORMAT'
+    description = ('The message format version on the broker does not'
+                   ' support this request.')
+
+
+class PolicyViolationError(BrokerResponseError):
+    errno = 44
+    message = 'POLICY_VIOLATION'
+    description = 'Request parameters do not satisfy the configured policy.'
+
+
+class SecurityDisabledError(BrokerResponseError):
+    errno = 54
+    message = 'SECURITY_DISABLED'
+    description = 'Security features are disabled.'
+
+
+class NonEmptyGroupError(BrokerResponseError):
+    errno = 68
+    message = 'NON_EMPTY_GROUP'
+    description = 'The group is not empty.'
+
+
+class GroupIdNotFoundError(BrokerResponseError):
+    errno = 69
+    message = 'GROUP_ID_NOT_FOUND'
+    description = 'The group id does not exist.'
+
+
+class KafkaUnavailableError(KafkaError):
+    pass
+
+
+class KafkaTimeoutError(KafkaError):
+    pass
+
+
+class FailedPayloadsError(KafkaError):
+    def __init__(self, payload, *args):
+        super(FailedPayloadsError, self).__init__(*args)
+        self.payload = payload
+
+
+class KafkaConnectionError(KafkaError):
+    retriable = True
+    invalid_metadata = True
+
+
+class ProtocolError(KafkaError):
+    pass
+
+
+class UnsupportedCodecError(KafkaError):
+    pass
+
+
+class KafkaConfigurationError(KafkaError):
+    pass
+
+
+class QuotaViolationError(KafkaError):
+    pass
+
+
+class AsyncProducerQueueFull(KafkaError):
+    def __init__(self, failed_msgs, *args):
+        super(AsyncProducerQueueFull, self).__init__(*args)
+        self.failed_msgs = failed_msgs
+
+
+def _iter_broker_errors():
+    for name, obj in inspect.getmembers(sys.modules[__name__]):
+        if inspect.isclass(obj) and issubclass(obj, BrokerResponseError) and obj != BrokerResponseError:
+            yield obj
+
+
+kafka_errors = dict([(x.errno, x) for x in _iter_broker_errors()])
+
+
+def for_code(error_code):
+    return kafka_errors.get(error_code, UnknownError)
+
+
+def check_error(response):
+    if isinstance(response, Exception):
+        raise response
+    if response.error:
+        error_class = kafka_errors.get(response.error, UnknownError)
+        raise error_class(response)
+
+
+RETRY_BACKOFF_ERROR_TYPES = (
+    KafkaUnavailableError, LeaderNotAvailableError,
+    KafkaConnectionError, FailedPayloadsError
+)
+
+
+RETRY_REFRESH_ERROR_TYPES = (
+    NotLeaderForPartitionError, UnknownTopicOrPartitionError,
+    LeaderNotAvailableError, KafkaConnectionError
+)
+
+
+RETRY_ERROR_TYPES = RETRY_BACKOFF_ERROR_TYPES + RETRY_REFRESH_ERROR_TYPES

testbed/dpkp__kafka-python/kafka/future.py

@@ -0,0 +1,83 @@
+from __future__ import absolute_import
+
+import functools
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class Future(object):
+    error_on_callbacks = False # and errbacks
+
+    def __init__(self):
+        self.is_done = False
+        self.value = None
+        self.exception = None
+        self._callbacks = []
+        self._errbacks = []
+
+    def succeeded(self):
+        return self.is_done and not bool(self.exception)
+
+    def failed(self):
+        return self.is_done and bool(self.exception)
+
+    def retriable(self):
+        try:
+            return self.exception.retriable
+        except AttributeError:
+            return False
+
+    def success(self, value):
+        assert not self.is_done, 'Future is already complete'
+        self.value = value
+        self.is_done = True
+        if self._callbacks:
+            self._call_backs('callback', self._callbacks, self.value)
+        return self
+
+    def failure(self, e):
+        assert not self.is_done, 'Future is already complete'
+        self.exception = e if type(e) is not type else e()
+        assert isinstance(self.exception, BaseException), (
+            'future failed without an exception')
+        self.is_done = True
+        self._call_backs('errback', self._errbacks, self.exception)
+        return self
+
+    def add_callback(self, f, *args, **kwargs):
+        if args or kwargs:
+            f = functools.partial(f, *args, **kwargs)
+        if self.is_done and not self.exception:
+            self._call_backs('callback', [f], self.value)
+        else:
+            self._callbacks.append(f)
+        return self
+
+    def add_errback(self, f, *args, **kwargs):
+        if args or kwargs:
+            f = functools.partial(f, *args, **kwargs)
+        if self.is_done and self.exception:
+            self._call_backs('errback', [f], self.exception)
+        else:
+            self._errbacks.append(f)
+        return self
+
+    def add_both(self, f, *args, **kwargs):
+        self.add_callback(f, *args, **kwargs)
+        self.add_errback(f, *args, **kwargs)
+        return self
+
+    def chain(self, future):
+        self.add_callback(future.success)
+        self.add_errback(future.failure)
+        return self
+
+    def _call_backs(self, back_type, backs, value):
+        for f in backs:
+            try:
+                f(value)
+            except Exception as e:
+                log.exception('Error processing %s', back_type)
+                if self.error_on_callbacks:
+                    raise e

testbed/dpkp__kafka-python/kafka/metrics/measurable.py

@@ -0,0 +1,29 @@
+from __future__ import absolute_import
+
+import abc
+
+
+class AbstractMeasurable(object):
+    """A measurable quantity that can be registered as a metric"""
+    @abc.abstractmethod
+    def measure(self, config, now):
+        """
+        Measure this quantity and return the result
+
+        Arguments:
+            config (MetricConfig): The configuration for this metric
+            now (int): The POSIX time in milliseconds the measurement
+                is being taken
+
+        Returns:
+            The measured value
+        """
+        raise NotImplementedError
+
+
+class AnonMeasurable(AbstractMeasurable):
+    def __init__(self, measure_fn):
+        self._measure_fn = measure_fn
+
+    def measure(self, config, now):
+        return float(self._measure_fn(config, now))

testbed/dpkp__kafka-python/kafka/metrics/stat.py

@@ -0,0 +1,23 @@
+from __future__ import absolute_import
+
+import abc
+
+
+class AbstractStat(object):
+    """
+    An AbstractStat is a quantity such as average, max, etc that is computed
+    off the stream of updates to a sensor
+    """
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractmethod
+    def record(self, config, value, time_ms):
+        """
+        Record the given value
+
+        Arguments:
+            config (MetricConfig): The configuration to use for this metric
+            value (float): The value to record
+            timeMs (int): The POSIX time in milliseconds this value occurred
+        """
+        raise NotImplementedError

testbed/dpkp__kafka-python/kafka/metrics/stats/sensor.py

@@ -0,0 +1,134 @@
+from __future__ import absolute_import
+
+import threading
+import time
+
+from kafka.errors import QuotaViolationError
+from kafka.metrics import KafkaMetric
+
+
+class Sensor(object):
+    """
+    A sensor applies a continuous sequence of numerical values
+    to a set of associated metrics. For example a sensor on
+    message size would record a sequence of message sizes using
+    the `record(double)` api and would maintain a set
+    of metrics about request sizes such as the average or max.
+    """
+    def __init__(self, registry, name, parents, config,
+                 inactive_sensor_expiration_time_seconds):
+        if not name:
+            raise ValueError('name must be non-empty')
+        self._lock = threading.RLock()
+        self._registry = registry
+        self._name = name
+        self._parents = parents or []
+        self._metrics = []
+        self._stats = []
+        self._config = config
+        self._inactive_sensor_expiration_time_ms = (
+            inactive_sensor_expiration_time_seconds * 1000)
+        self._last_record_time = time.time() * 1000
+        self._check_forest(set())
+
+    def _check_forest(self, sensors):
+        """Validate that this sensor doesn't end up referencing itself."""
+        if self in sensors:
+            raise ValueError('Circular dependency in sensors: %s is its own'
+                             'parent.' % (self.name,))
+        sensors.add(self)
+        for parent in self._parents:
+            parent._check_forest(sensors)
+
+    @property
+    def name(self):
+        """
+        The name this sensor is registered with.
+        This name will be unique among all registered sensors.
+        """
+        return self._name
+
+    @property
+    def metrics(self):
+        return tuple(self._metrics)
+
+    def record(self, value=1.0, time_ms=None):
+        """
+        Record a value at a known time.
+        Arguments:
+            value (double): The value we are recording
+            time_ms (int): A POSIX timestamp in milliseconds.
+                Default: The time when record() is evaluated (now)
+
+        Raises:
+            QuotaViolationException: if recording this value moves a
+                metric beyond its configured maximum or minimum bound
+        """
+        if time_ms is None:
+            time_ms = time.time() * 1000
+        self._last_record_time = time_ms
+        with self._lock:  # XXX high volume, might be performance issue
+            # increment all the stats
+            for stat in self._stats:
+                stat.record(self._config, value, time_ms)
+            self._check_quotas(time_ms)
+        for parent in self._parents:
+            parent.record(value, time_ms)
+
+    def _check_quotas(self, time_ms):
+        """
+        Check if we have violated our quota for any metric that
+        has a configured quota
+        """
+        for metric in self._metrics:
+            if metric.config and metric.config.quota:
+                value = metric.value(time_ms)
+                if not metric.config.quota.is_acceptable(value):
+                    raise QuotaViolationError("'%s' violated quota. Actual: "
+                                              "%d, Threshold: %d" %
+                                              (metric.metric_name,
+                                               value,
+                                               metric.config.quota.bound))
+
+    def add_compound(self, compound_stat, config=None):
+        """
+        Register a compound statistic with this sensor which
+        yields multiple measurable quantities (like a histogram)
+
+        Arguments:
+            stat (AbstractCompoundStat): The stat to register
+            config (MetricConfig): The configuration for this stat.
+                If None then the stat will use the default configuration
+                for this sensor.
+        """
+        if not compound_stat:
+            raise ValueError('compound stat must be non-empty')
+        self._stats.append(compound_stat)
+        for named_measurable in compound_stat.stats():
+            metric = KafkaMetric(named_measurable.name, named_measurable.stat,
+                                 config or self._config)
+            self._registry.register_metric(metric)
+            self._metrics.append(metric)
+
+    def add(self, metric_name, stat, config=None):
+        """
+        Register a metric with this sensor
+
+        Arguments:
+            metric_name (MetricName): The name of the metric
+            stat (AbstractMeasurableStat): The statistic to keep
+            config (MetricConfig): A special configuration for this metric.
+                If None use the sensor default configuration.
+        """
+        with self._lock:
+            metric = KafkaMetric(metric_name, stat, config or self._config)
+            self._registry.register_metric(metric)
+            self._metrics.append(metric)
+            self._stats.append(stat)
+
+    def has_expired(self):
+        """
+        Return True if the Sensor is eligible for removal due to inactivity.
+        """
+        return ((time.time() * 1000 - self._last_record_time) >
+                self._inactive_sensor_expiration_time_ms)

testbed/dpkp__kafka-python/kafka/oauth/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import absolute_import
+
+from kafka.oauth.abstract import AbstractTokenProvider

testbed/dpkp__kafka-python/kafka/oauth/abstract.py

@@ -0,0 +1,42 @@
+from __future__ import absolute_import
+
+import abc
+
+# This statement is compatible with both Python 2.7 & 3+
+ABC = abc.ABCMeta('ABC', (object,), {'__slots__': ()})
+
+class AbstractTokenProvider(ABC):
+    """
+    A Token Provider must be used for the SASL OAuthBearer protocol.
+
+    The implementation should ensure token reuse so that multiple
+    calls at connect time do not create multiple tokens. The implementation
+    should also periodically refresh the token in order to guarantee
+    that each call returns an unexpired token. A timeout error should
+    be returned after a short period of inactivity so that the
+    broker can log debugging info and retry.
+
+    Token Providers MUST implement the token() method
+    """
+
+    def __init__(self, **config):
+        pass
+
+    @abc.abstractmethod
+    def token(self):
+        """
+        Returns a (str) ID/Access Token to be sent to the Kafka
+        client.
+        """
+        pass
+
+    def extensions(self):
+        """
+        This is an OPTIONAL method that may be implemented.
+
+        Returns a map of key-value pairs that can
+        be sent with the SASL/OAUTHBEARER initial client request. If
+        not implemented, the values are ignored. This feature is only available
+        in Kafka >= 2.1.0.
+        """
+        return {}

testbed/dpkp__kafka-python/kafka/partitioner/default.py

@@ -0,0 +1,102 @@
+from __future__ import absolute_import
+
+import random
+
+from kafka.vendor import six
+
+
+class DefaultPartitioner(object):
+    """Default partitioner.
+
+    Hashes key to partition using murmur2 hashing (from java client)
+    If key is None, selects partition randomly from available,
+    or from all partitions if none are currently available
+    """
+    @classmethod
+    def __call__(cls, key, all_partitions, available):
+        """
+        Get the partition corresponding to key
+        :param key: partitioning key
+        :param all_partitions: list of all partitions sorted by partition ID
+        :param available: list of available partitions in no particular order
+        :return: one of the values from all_partitions or available
+        """
+        if key is None:
+            if available:
+                return random.choice(available)
+            return random.choice(all_partitions)
+
+        idx = murmur2(key)
+        idx &= 0x7fffffff
+        idx %= len(all_partitions)
+        return all_partitions[idx]
+
+
+# https://github.com/apache/kafka/blob/0.8.2/clients/src/main/java/org/apache/kafka/common/utils/Utils.java#L244
+def murmur2(data):
+    """Pure-python Murmur2 implementation.
+
+    Based on java client, see org.apache.kafka.common.utils.Utils.murmur2
+
+    Args:
+        data (bytes): opaque bytes
+
+    Returns: MurmurHash2 of data
+    """
+    # Python2 bytes is really a str, causing the bitwise operations below to fail
+    # so convert to bytearray.
+    if six.PY2:
+        data = bytearray(bytes(data))
+
+    length = len(data)
+    seed = 0x9747b28c
+    # 'm' and 'r' are mixing constants generated offline.
+    # They're not really 'magic', they just happen to work well.
+    m = 0x5bd1e995
+    r = 24
+
+    # Initialize the hash to a random value
+    h = seed ^ length
+    length4 = length // 4
+
+    for i in range(length4):
+        i4 = i * 4
+        k = ((data[i4 + 0] & 0xff) +
+            ((data[i4 + 1] & 0xff) << 8) +
+            ((data[i4 + 2] & 0xff) << 16) +
+            ((data[i4 + 3] & 0xff) << 24))
+        k &= 0xffffffff
+        k *= m
+        k &= 0xffffffff
+        k ^= (k % 0x100000000) >> r # k ^= k >>> r
+        k &= 0xffffffff
+        k *= m
+        k &= 0xffffffff
+
+        h *= m
+        h &= 0xffffffff
+        h ^= k
+        h &= 0xffffffff
+
+    # Handle the last few bytes of the input array
+    extra_bytes = length % 4
+    if extra_bytes >= 3:
+        h ^= (data[(length & ~3) + 2] & 0xff) << 16
+        h &= 0xffffffff
+    if extra_bytes >= 2:
+        h ^= (data[(length & ~3) + 1] & 0xff) << 8
+        h &= 0xffffffff
+    if extra_bytes >= 1:
+        h ^= (data[length & ~3] & 0xff)
+        h &= 0xffffffff
+        h *= m
+        h &= 0xffffffff
+
+    h ^= (h % 0x100000000) >> 13 # h >>> 13;
+    h &= 0xffffffff
+    h *= m
+    h &= 0xffffffff
+    h ^= (h % 0x100000000) >> 15 # h >>> 15;
+    h &= 0xffffffff
+
+    return h

testbed/dpkp__kafka-python/kafka/producer/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import absolute_import
+
+from kafka.producer.kafka import KafkaProducer
+
+__all__ = [
+    'KafkaProducer'
+]

testbed/dpkp__kafka-python/kafka/producer/future.py

@@ -0,0 +1,71 @@
+from __future__ import absolute_import
+
+import collections
+import threading
+
+from kafka import errors as Errors
+from kafka.future import Future
+
+
+class FutureProduceResult(Future):
+    def __init__(self, topic_partition):
+        super(FutureProduceResult, self).__init__()
+        self.topic_partition = topic_partition
+        self._latch = threading.Event()
+
+    def success(self, value):
+        ret = super(FutureProduceResult, self).success(value)
+        self._latch.set()
+        return ret
+
+    def failure(self, error):
+        ret = super(FutureProduceResult, self).failure(error)
+        self._latch.set()
+        return ret
+
+    def wait(self, timeout=None):
+        # wait() on python2.6 returns None instead of the flag value
+        return self._latch.wait(timeout) or self._latch.is_set()
+
+
+class FutureRecordMetadata(Future):
+    def __init__(self, produce_future, relative_offset, timestamp_ms, checksum, serialized_key_size, serialized_value_size, serialized_header_size):
+        super(FutureRecordMetadata, self).__init__()
+        self._produce_future = produce_future
+        # packing args as a tuple is a minor speed optimization
+        self.args = (relative_offset, timestamp_ms, checksum, serialized_key_size, serialized_value_size, serialized_header_size)
+        produce_future.add_callback(self._produce_success)
+        produce_future.add_errback(self.failure)
+
+    def _produce_success(self, offset_and_timestamp):
+        offset, produce_timestamp_ms, log_start_offset = offset_and_timestamp
+
+        # Unpacking from args tuple is minor speed optimization
+        (relative_offset, timestamp_ms, checksum,
+         serialized_key_size, serialized_value_size, serialized_header_size) = self.args
+
+        # None is when Broker does not support the API (<0.10) and
+        # -1 is when the broker is configured for CREATE_TIME timestamps
+        if produce_timestamp_ms is not None and produce_timestamp_ms != -1:
+            timestamp_ms = produce_timestamp_ms
+        if offset != -1 and relative_offset is not None:
+            offset += relative_offset
+        tp = self._produce_future.topic_partition
+        metadata = RecordMetadata(tp[0], tp[1], tp, offset, timestamp_ms, log_start_offset,
+                                  checksum, serialized_key_size,
+                                  serialized_value_size, serialized_header_size)
+        self.success(metadata)
+
+    def get(self, timeout=None):
+        if not self.is_done and not self._produce_future.wait(timeout):
+            raise Errors.KafkaTimeoutError(
+                "Timeout after waiting for %s secs." % (timeout,))
+        assert self.is_done
+        if self.failed():
+            raise self.exception # pylint: disable-msg=raising-bad-type
+        return self.value
+
+
+RecordMetadata = collections.namedtuple(
+    'RecordMetadata', ['topic', 'partition', 'topic_partition', 'offset', 'timestamp', 'log_start_offset',
+                       'checksum', 'serialized_key_size', 'serialized_value_size', 'serialized_header_size'])

testbed/dpkp__kafka-python/kafka/producer/kafka.py

@@ -0,0 +1,749 @@
+from __future__ import absolute_import
+
+import atexit
+import copy
+import logging
+import socket
+import threading
+import time
+import weakref
+
+from kafka.vendor import six
+
+import kafka.errors as Errors
+from kafka.client_async import KafkaClient, selectors
+from kafka.codec import has_gzip, has_snappy, has_lz4, has_zstd
+from kafka.metrics import MetricConfig, Metrics
+from kafka.partitioner.default import DefaultPartitioner
+from kafka.producer.future import FutureRecordMetadata, FutureProduceResult
+from kafka.producer.record_accumulator import AtomicInteger, RecordAccumulator
+from kafka.producer.sender import Sender
+from kafka.record.default_records import DefaultRecordBatchBuilder
+from kafka.record.legacy_records import LegacyRecordBatchBuilder
+from kafka.serializer import Serializer
+from kafka.structs import TopicPartition
+
+
+log = logging.getLogger(__name__)
+PRODUCER_CLIENT_ID_SEQUENCE = AtomicInteger()
+
+
+class KafkaProducer(object):
+    """A Kafka client that publishes records to the Kafka cluster.
+
+    The producer is thread safe and sharing a single producer instance across
+    threads will generally be faster than having multiple instances.
+
+    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 I/O
+    thread that is responsible for turning these records into requests and
+    transmitting them to the cluster.
+
+    :meth:`~kafka.KafkaProducer.send` 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 blocking on the full commit of
+    the record, the slowest but most durable setting.
+
+    If the request fails, the producer can automatically retry, unless
+    'retries' is configured to 0. Enabling retries also opens up the
+    possibility of duplicates (see the documentation on message
+    delivery semantics for details:
+    https://kafka.apache.org/documentation.html#semantics
+    ).
+
+    The producer maintains buffers of unsent records for each partition. These
+    buffers are of a size specified by the 'batch_size' config. Making this
+    larger can result in more batching, but requires more memory (since we will
+    generally have one of these buffers for each active partition).
+
+    By default a buffer is available to send immediately even if there is
+    additional unused space in the buffer. However if you want to reduce the
+    number of requests you can set 'linger_ms' to something greater than 0.
+    This will instruct the producer to wait up to that number of milliseconds
+    before sending a request in hope that more records will arrive to fill up
+    the same batch. This is analogous to Nagle's algorithm in TCP. Note that
+    records that arrive close together in time will generally batch together
+    even with linger_ms=0 so under heavy load batching will occur regardless of
+    the linger configuration; however setting this to something larger than 0
+    can lead to fewer, more efficient requests when not under maximal load at
+    the cost of a small amount of latency.
+
+    The buffer_memory controls the total amount of memory available to the
+    producer for buffering. If records are sent faster than they can be
+    transmitted to the server then this buffer space will be exhausted. When
+    the buffer space is exhausted additional send calls will block.
+
+    The key_serializer and value_serializer instruct how to turn the key and
+    value objects the user provides into bytes.
+
+    Keyword 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: 'kafka-python-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.
+                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: Wait for leader to write the record to its local log only.
+                Broker 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: Wait for the full set of in-sync replicas to write 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.
+        compression_type (str): The compression type for all data generated by
+            the producer. Valid values are 'gzip', 'snappy', 'lz4', 'zstd' 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.
+        retries (int): Setting a value greater than zero will cause the client
+            to resend any record whose send fails with a potentially transient
+            error. Note that this retry is no different than if the client
+            resent the record upon receiving the error. Allowing retries
+            without setting max_in_flight_requests_per_connection to 1 will
+            potentially change the ordering of records because if two batches
+            are sent to a single partition, and the first fails and is retried
+            but the second succeeds, then the records in the second batch may
+            appear first.
+            Default: 0.
+        batch_size (int): Requests sent to brokers will contain multiple
+            batches, one for each partition with data available to be sent.
+            A small batch size will make batching less common and may reduce
+            throughput (a batch size of zero will disable batching entirely).
+            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, rather than immediately sending out a
+            record the producer will wait for up to the given delay to allow
+            other records to be sent so that the sends can be batched together.
+            This can be thought of as analogous to Nagle's algorithm in TCP.
+            This setting gives the upper bound on the delay for batching: once
+            we get batch_size worth of records for a partition it will be sent
+            immediately regardless of this setting, however if we have fewer
+            than this many bytes accumulated for this partition we will
+            'linger' for the specified time waiting for more records to show
+            up. This setting defaults to 0 (i.e. no delay). Setting linger_ms=5
+            would have the effect of reducing the number of requests sent but
+            would add up to 5ms of latency to records sent in the absence of
+            load. Default: 0.
+        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).
+        buffer_memory (int): The total bytes of memory the producer should use
+            to buffer records waiting to be sent to the server. If records are
+            sent faster than they can be delivered to the server the producer
+            will block up to max_block_ms, raising an exception on timeout.
+            In the current implementation, this setting is an approximation.
+            Default: 33554432 (32MB)
+        connections_max_idle_ms: Close idle connections after the number of
+            milliseconds specified by this config. The broker closes idle
+            connections after connections.max.idle.ms, so this avoids hitting
+            unexpected socket disconnected errors on the client.
+            Default: 540000
+        max_block_ms (int): Number of milliseconds to block during
+            :meth:`~kafka.KafkaProducer.send` and
+            :meth:`~kafka.KafkaProducer.partitions_for`. These methods can be
+            blocked either because the buffer is full or metadata unavailable.
+            Blocking in the user-supplied serializers or partitioner will not be
+            counted against this timeout. Default: 60000.
+        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
+        retry_backoff_ms (int): Milliseconds to backoff when retrying on
+            errors. Default: 100.
+        request_timeout_ms (int): Client request timeout in milliseconds.
+            Default: 30000.
+        receive_buffer_bytes (int): The size of the TCP receive buffer
+            (SO_RCVBUF) to use when reading data. Default: None (relies on
+            system defaults). Java client defaults to 32768.
+        send_buffer_bytes (int): The size of the TCP send buffer
+            (SO_SNDBUF) to use when sending data. Default: None (relies on
+            system defaults). Java client defaults to 131072.
+        socket_options (list): List of tuple-arguments to socket.setsockopt
+            to apply to broker connection sockets. Default:
+            [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]
+        reconnect_backoff_ms (int): The amount of time in milliseconds to
+            wait before attempting to reconnect to a given host.
+            Default: 50.
+        reconnect_backoff_max_ms (int): The maximum amount of time in
+            milliseconds to backoff/wait when reconnecting to a broker that has
+            repeatedly failed to connect. If provided, the backoff per host
+            will increase exponentially for each consecutive connection
+            failure, up to this maximum. Once the maximum is reached,
+            reconnection attempts will continue periodically with this fixed
+            rate. To avoid connection storms, a randomization factor of 0.2
+            will be applied to the backoff resulting in a random range between
+            20% below and 20% above the computed value. Default: 1000.
+        max_in_flight_requests_per_connection (int): Requests are pipelined
+            to kafka brokers up to this number of maximum requests per
+            broker connection. Note that if this setting is set to be greater
+            than 1 and there are failed sends, there is a risk of message
+            re-ordering due to retries (i.e., if retries are enabled).
+            Default: 5.
+        security_protocol (str): Protocol used to communicate with brokers.
+            Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL.
+            Default: PLAINTEXT.
+        ssl_context (ssl.SSLContext): pre-configured SSLContext for wrapping
+            socket connections. If provided, all other ssl_* configurations
+            will be ignored. Default: None.
+        ssl_check_hostname (bool): flag to configure whether ssl handshake
+            should verify that the certificate matches the brokers hostname.
+            default: true.
+        ssl_cafile (str): optional filename of ca file to use in certificate
+            veriication. default: none.
+        ssl_certfile (str): optional filename of file in pem format containing
+            the client certificate, as well as any ca certificates needed to
+            establish the certificate's authenticity. default: none.
+        ssl_keyfile (str): optional filename containing the client private key.
+            default: none.
+        ssl_password (str): optional password to be used when loading the
+            certificate chain. default: none.
+        ssl_crlfile (str): optional filename containing the CRL to check for
+            certificate expiration. By default, no CRL check is done. When
+            providing a file, only the leaf certificate will be checked against
+            this CRL. The CRL can only be checked with Python 3.4+ or 2.7.9+.
+            default: none.
+        ssl_ciphers (str): optionally set the available ciphers for ssl
+            connections. It should be a string in the OpenSSL cipher list
+            format. If no cipher can be selected (because compile-time options
+            or other configuration forbids use of all the specified ciphers),
+            an ssl.SSLError will be raised. See ssl.SSLContext.set_ciphers
+        api_version (tuple): Specify which Kafka API version to use. If set to
+            None, the client will attempt to infer the broker version by probing
+            various APIs. Example: (0, 10, 2). Default: None
+        api_version_auto_timeout_ms (int): number of milliseconds to throw a
+            timeout exception from the constructor when checking the broker
+            api version. Only applies if api_version set to None.
+        metric_reporters (list): A list of classes to use as metrics reporters.
+            Implementing the AbstractMetricsReporter interface allows plugging
+            in classes that will be notified of new metric creation. Default: []
+        metrics_num_samples (int): The number of samples maintained to compute
+            metrics. Default: 2
+        metrics_sample_window_ms (int): The maximum age in milliseconds of
+            samples used to compute metrics. Default: 30000
+        selector (selectors.BaseSelector): Provide a specific selector
+            implementation to use for I/O multiplexing.
+            Default: selectors.DefaultSelector
+        sasl_mechanism (str): Authentication mechanism when security_protocol
+            is configured for SASL_PLAINTEXT or SASL_SSL. Valid values are:
+            PLAIN, GSSAPI, OAUTHBEARER, SCRAM-SHA-256, SCRAM-SHA-512.
+        sasl_plain_username (str): username for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_plain_password (str): password for sasl PLAIN and SCRAM authentication.
+            Required if sasl_mechanism is PLAIN or one of the SCRAM mechanisms.
+        sasl_kerberos_service_name (str): Service name to include in GSSAPI
+            sasl mechanism handshake. Default: 'kafka'
+        sasl_kerberos_domain_name (str): kerberos domain name to use in GSSAPI
+            sasl mechanism handshake. Default: one of bootstrap servers
+        sasl_oauth_token_provider (AbstractTokenProvider): OAuthBearer token provider
+            instance. (See kafka.oauth.abstract). Default: None
+
+    Note:
+        Configuration parameters are described in more detail at
+        https://kafka.apache.org/0100/configuration.html#producerconfigs
+    """
+    DEFAULT_CONFIG = {
+        'bootstrap_servers': 'localhost',
+        'client_id': None,
+        'key_serializer': None,
+        'value_serializer': None,
+        'acks': 1,
+        'bootstrap_topics_filter': set(),
+        'compression_type': None,
+        'retries': 0,
+        'batch_size': 16384,
+        'linger_ms': 0,
+        'partitioner': DefaultPartitioner(),
+        'buffer_memory': 33554432,
+        'connections_max_idle_ms': 9 * 60 * 1000,
+        'max_block_ms': 60000,
+        'max_request_size': 1048576,
+        'metadata_max_age_ms': 300000,
+        'retry_backoff_ms': 100,
+        'request_timeout_ms': 30000,
+        'receive_buffer_bytes': None,
+        'send_buffer_bytes': None,
+        'socket_options': [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)],
+        'sock_chunk_bytes': 4096,  # undocumented experimental option
+        'sock_chunk_buffer_count': 1000,  # undocumented experimental option
+        'reconnect_backoff_ms': 50,
+        'reconnect_backoff_max_ms': 1000,
+        'max_in_flight_requests_per_connection': 5,
+        'security_protocol': 'PLAINTEXT',
+        'ssl_context': None,
+        'ssl_check_hostname': True,
+        'ssl_cafile': None,
+        'ssl_certfile': None,
+        'ssl_keyfile': None,
+        'ssl_crlfile': None,
+        'ssl_password': None,
+        'ssl_ciphers': None,
+        'api_version': None,
+        'api_version_auto_timeout_ms': 2000,
+        'metric_reporters': [],
+        'metrics_num_samples': 2,
+        'metrics_sample_window_ms': 30000,
+        'selector': selectors.DefaultSelector,
+        'sasl_mechanism': None,
+        'sasl_plain_username': None,
+        'sasl_plain_password': None,
+        'sasl_kerberos_service_name': 'kafka',
+        'sasl_kerberos_domain_name': None,
+        'sasl_oauth_token_provider': None
+    }
+
+    _COMPRESSORS = {
+        'gzip': (has_gzip, LegacyRecordBatchBuilder.CODEC_GZIP),
+        'snappy': (has_snappy, LegacyRecordBatchBuilder.CODEC_SNAPPY),
+        'lz4': (has_lz4, LegacyRecordBatchBuilder.CODEC_LZ4),
+        'zstd': (has_zstd, DefaultRecordBatchBuilder.CODEC_ZSTD),
+        None: (lambda: True, LegacyRecordBatchBuilder.CODEC_NONE),
+    }
+
+    def __init__(self, **configs):
+        log.debug("Starting the Kafka producer")  # trace
+        self.config = copy.copy(self.DEFAULT_CONFIG)
+        for key in self.config:
+            if key in configs:
+                self.config[key] = configs.pop(key)
+
+        # Only check for extra config keys in top-level class
+        assert not configs, 'Unrecognized configs: %s' % (configs,)
+
+        if self.config['client_id'] is None:
+            self.config['client_id'] = 'kafka-python-producer-%s' % \
+                                       (PRODUCER_CLIENT_ID_SEQUENCE.increment(),)
+
+        if self.config['acks'] == 'all':
+            self.config['acks'] = -1
+
+        # api_version was previously a str. accept old format for now
+        if isinstance(self.config['api_version'], str):
+            deprecated = self.config['api_version']
+            if deprecated == 'auto':
+                self.config['api_version'] = None
+            else:
+                self.config['api_version'] = tuple(map(int, deprecated.split('.')))
+            log.warning('use api_version=%s [tuple] -- "%s" as str is deprecated',
+                        str(self.config['api_version']), deprecated)
+
+        # Configure metrics
+        metrics_tags = {'client-id': self.config['client_id']}
+        metric_config = MetricConfig(samples=self.config['metrics_num_samples'],
+                                     time_window_ms=self.config['metrics_sample_window_ms'],
+                                     tags=metrics_tags)
+        reporters = [reporter() for reporter in self.config['metric_reporters']]
+        self._metrics = Metrics(metric_config, reporters)
+
+        client = KafkaClient(metrics=self._metrics, metric_group_prefix='producer',
+                             wakeup_timeout_ms=self.config['max_block_ms'],
+                             **self.config)
+
+        # Get auto-discovered version from client if necessary
+        if self.config['api_version'] is None:
+            self.config['api_version'] = client.config['api_version']
+
+        if self.config['compression_type'] == 'lz4':
+            assert self.config['api_version'] >= (0, 8, 2), 'LZ4 Requires >= Kafka 0.8.2 Brokers'
+
+        if self.config['compression_type'] == 'zstd':
+            assert self.config['api_version'] >= (2, 1, 0), 'Zstd Requires >= Kafka 2.1.0 Brokers'
+
+        # Check compression_type for library support
+        ct = self.config['compression_type']
+        if ct not in self._COMPRESSORS:
+            raise ValueError("Not supported codec: {}".format(ct))
+        else:
+            checker, compression_attrs = self._COMPRESSORS[ct]
+            assert checker(), "Libraries for {} compression codec not found".format(ct)
+            self.config['compression_attrs'] = compression_attrs
+
+        message_version = self._max_usable_produce_magic()
+        self._accumulator = RecordAccumulator(message_version=message_version, metrics=self._metrics, **self.config)
+        self._metadata = client.cluster
+        guarantee_message_order = bool(self.config['max_in_flight_requests_per_connection'] == 1)
+        self._sender = Sender(client, self._metadata,
+                              self._accumulator, self._metrics,
+                              guarantee_message_order=guarantee_message_order,
+                              **self.config)
+        self._sender.daemon = True
+        self._sender.start()
+        self._closed = False
+
+        self._cleanup = self._cleanup_factory()
+        atexit.register(self._cleanup)
+        log.debug("Kafka producer started")
+
+    def bootstrap_connected(self):
+        """Return True if the bootstrap is connected."""
+        return self._sender.bootstrap_connected()
+
+    def _cleanup_factory(self):
+        """Build a cleanup clojure that doesn't increase our ref count"""
+        _self = weakref.proxy(self)
+        def wrapper():
+            try:
+                _self.close(timeout=0)
+            except (ReferenceError, AttributeError):
+                pass
+        return wrapper
+
+    def _unregister_cleanup(self):
+        if getattr(self, '_cleanup', None):
+            if hasattr(atexit, 'unregister'):
+                atexit.unregister(self._cleanup)  # pylint: disable=no-member
+
+            # py2 requires removing from private attribute...
+            else:
+
+                # ValueError on list.remove() if the exithandler no longer exists
+                # but that is fine here
+                try:
+                    atexit._exithandlers.remove(  # pylint: disable=no-member
+                        (self._cleanup, (), {}))
+                except ValueError:
+                    pass
+        self._cleanup = None
+
+    def __del__(self):
+        # Disable logger during destruction to avoid touching dangling references
+        class NullLogger(object):
+            def __getattr__(self, name):
+                return lambda *args: None
+
+        global log
+        log = NullLogger()
+
+        self.close()
+
+    def close(self, timeout=None):
+        """Close this producer.
+
+        Arguments:
+            timeout (float, optional): timeout in seconds to wait for completion.
+        """
+
+        # drop our atexit handler now to avoid leaks
+        self._unregister_cleanup()
+
+        if not hasattr(self, '_closed') or self._closed:
+            log.info('Kafka producer closed')
+            return
+        if timeout is None:
+            # threading.TIMEOUT_MAX is available in Python3.3+
+            timeout = getattr(threading, 'TIMEOUT_MAX', float('inf'))
+        if getattr(threading, 'TIMEOUT_MAX', False):
+            assert 0 <= timeout <= getattr(threading, 'TIMEOUT_MAX')
+        else:
+            assert timeout >= 0
+
+        log.info("Closing the Kafka producer with %s secs timeout.", timeout)
+        invoked_from_callback = bool(threading.current_thread() is self._sender)
+        if timeout > 0:
+            if invoked_from_callback:
+                log.warning("Overriding close timeout %s secs to 0 in order to"
+                            " prevent useless blocking due to self-join. This"
+                            " means you have incorrectly invoked close with a"
+                            " non-zero timeout from the producer call-back.",
+                            timeout)
+            else:
+                # Try to close gracefully.
+                if self._sender is not None:
+                    self._sender.initiate_close()
+                    self._sender.join(timeout)
+
+        if self._sender is not None and self._sender.is_alive():
+            log.info("Proceeding to force close the producer since pending"
+                     " requests could not be completed within timeout %s.",
+                     timeout)
+            self._sender.force_close()
+
+        self._metrics.close()
+        try:
+            self.config['key_serializer'].close()
+        except AttributeError:
+            pass
+        try:
+            self.config['value_serializer'].close()
+        except AttributeError:
+            pass
+        self._closed = True
+        log.debug("The Kafka producer has closed.")
+
+    def partitions_for(self, topic):
+        """Returns set of all known partitions for the topic."""
+        max_wait = self.config['max_block_ms'] / 1000.0
+        return self._wait_on_metadata(topic, max_wait)
+
+    def _max_usable_produce_magic(self):
+        if self.config['api_version'] >= (0, 11):
+            return 2
+        elif self.config['api_version'] >= (0, 10):
+            return 1
+        else:
+            return 0
+
+    def _estimate_size_in_bytes(self, key, value, headers=[]):
+        magic = self._max_usable_produce_magic()
+        if magic == 2:
+            return DefaultRecordBatchBuilder.estimate_size_in_bytes(
+                key, value, headers)
+        else:
+            return LegacyRecordBatchBuilder.estimate_size_in_bytes(
+                magic, self.config['compression_type'], key, value)
+
+    def send(self, topic, value=None, key=None, headers=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:
+                https://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.
+            headers (optional): a list of header key value pairs. List items
+                are tuples of str key and bytes value.
+            timestamp_ms (int, optional): epoch milliseconds (from Jan 1 1970 UTC)
+                to use as the message timestamp. Defaults to current time.
+
+        Returns:
+            FutureRecordMetadata: resolves to RecordMetadata
+
+        Raises:
+            KafkaTimeoutError: if unable to fetch topic metadata, or unable
+                to obtain memory buffer prior to configured max_block_ms
+        """
+        assert value is not None or self.config['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'
+        key_bytes = value_bytes = None
+        try:
+            self._wait_on_metadata(topic, self.config['max_block_ms'] / 1000.0)
+
+            key_bytes = self._serialize(
+                self.config['key_serializer'],
+                topic, key)
+            value_bytes = self._serialize(
+                self.config['value_serializer'],
+                topic, value)
+            assert type(key_bytes) in (bytes, bytearray, memoryview, type(None))
+            assert type(value_bytes) in (bytes, bytearray, memoryview, type(None))
+
+            partition = self._partition(topic, partition, key, value,
+                                        key_bytes, value_bytes)
+
+            if headers is None:
+                headers = []
+            assert type(headers) == list
+            assert all(type(item) == tuple and len(item) == 2 and type(item[0]) == str and type(item[1]) == bytes for item in headers)
+
+            message_size = self._estimate_size_in_bytes(key_bytes, value_bytes, headers)
+            self._ensure_valid_record_size(message_size)
+
+            tp = TopicPartition(topic, partition)
+            log.debug("Sending (key=%r value=%r headers=%r) to %s", key, value, headers, tp)
+            result = self._accumulator.append(tp, timestamp_ms,
+                                              key_bytes, value_bytes, headers,
+                                              self.config['max_block_ms'],
+                                              estimated_size=message_size)
+            future, batch_is_full, new_batch_created = result
+            if batch_is_full or new_batch_created:
+                log.debug("Waking up the sender since %s is either full or"
+                          " getting a new batch", tp)
+                self._sender.wakeup()
+
+            return future
+            # handling exceptions and record the errors;
+            # for API exceptions return them in the future,
+            # for other exceptions raise directly
+        except Errors.BrokerResponseError as e:
+            log.debug("Exception occurred during message send: %s", e)
+            return FutureRecordMetadata(
+                FutureProduceResult(TopicPartition(topic, partition)),
+                -1, None, None,
+                len(key_bytes) if key_bytes is not None else -1,
+                len(value_bytes) if value_bytes is not None else -1,
+                sum(len(h_key.encode("utf-8")) + len(h_value) for h_key, h_value in headers) if headers else -1,
+            ).failure(e)
+
+    def flush(self, timeout=None):
+        """
+        Invoking this method makes all buffered records immediately available
+        to send (even if linger_ms is greater than 0) and blocks on the
+        completion of the requests associated with these records. The
+        post-condition of :meth:`~kafka.KafkaProducer.flush` is that any
+        previously sent record will have completed
+        (e.g. Future.is_done() == True). A request is considered completed when
+        either it is successfully acknowledged according to the 'acks'
+        configuration for the producer, or it results in an error.
+
+        Other threads can continue sending messages while one thread is blocked
+        waiting for a flush call to complete; however, no guarantee is made
+        about the completion of messages sent after the flush call begins.
+
+        Arguments:
+            timeout (float, optional): timeout in seconds to wait for completion.
+
+        Raises:
+            KafkaTimeoutError: failure to flush buffered records within the
+                provided timeout
+        """
+        log.debug("Flushing accumulated records in producer.")  # trace
+        self._accumulator.begin_flush()
+        self._sender.wakeup()
+        self._accumulator.await_flush_completion(timeout=timeout)
+
+    def _ensure_valid_record_size(self, size):
+        """Validate that the record size isn't too large."""
+        if size > self.config['max_request_size']:
+            raise Errors.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" % (size,))
+        if size > self.config['buffer_memory']:
+            raise Errors.MessageSizeTooLargeError(
+                "The message is %d bytes when serialized which is larger than"
+                " the total memory buffer you have configured with the"
+                " buffer_memory configuration." % (size,))
+
+    def _wait_on_metadata(self, topic, max_wait):
+        """
+        Wait for cluster metadata including partitions for the given topic to
+        be available.
+
+        Arguments:
+            topic (str): topic we want metadata for
+            max_wait (float): maximum time in secs for waiting on the metadata
+
+        Returns:
+            set: partition ids for the topic
+
+        Raises:
+            KafkaTimeoutError: if partitions for topic were not obtained before
+                specified max_wait timeout
+        """
+        # add topic to metadata topic list if it is not there already.
+        self._sender.add_topic(topic)
+        begin = time.time()
+        elapsed = 0.0
+        metadata_event = None
+        while True:
+            partitions = self._metadata.partitions_for_topic(topic)
+            if partitions is not None:
+                return partitions
+
+            if not metadata_event:
+                metadata_event = threading.Event()
+
+            log.debug("Requesting metadata update for topic %s", topic)
+
+            metadata_event.clear()
+            future = self._metadata.request_update()
+            future.add_both(lambda e, *args: e.set(), metadata_event)
+            self._sender.wakeup()
+            metadata_event.wait(max_wait - elapsed)
+            elapsed = time.time() - begin
+            if not metadata_event.is_set():
+                raise Errors.KafkaTimeoutError(
+                    "Failed to update metadata after %.1f secs." % (max_wait,))
+            elif topic in self._metadata.unauthorized_topics:
+                raise Errors.TopicAuthorizationFailedError(topic)
+            else:
+                log.debug("_wait_on_metadata woke after %s secs.", elapsed)
+
+    def _serialize(self, f, topic, data):
+        if not f:
+            return data
+        if isinstance(f, Serializer):
+            return f.serialize(topic, data)
+        return f(data)
+
+    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 = sorted(self._metadata.partitions_for_topic(topic))
+        available = list(self._metadata.available_partitions_for_topic(topic))
+        return self.config['partitioner'](serialized_key,
+                                          all_partitions,
+                                          available)
+
+    def metrics(self, raw=False):
+        """Get metrics on producer performance.
+
+        This is ported from the Java Producer, for details see:
+        https://kafka.apache.org/documentation/#producer_monitoring
+
+        Warning:
+            This is an unstable interface. It may change in future
+            releases without warning.
+        """
+        if raw:
+            return self._metrics.metrics.copy()
+
+        metrics = {}
+        for k, v in six.iteritems(self._metrics.metrics.copy()):
+            if k.group not in metrics:
+                metrics[k.group] = {}
+            if k.name not in metrics[k.group]:
+                metrics[k.group][k.name] = {}
+            metrics[k.group][k.name] = v.value()
+        return metrics

testbed/dpkp__kafka-python/kafka/producer/record_accumulator.py

@@ -0,0 +1,590 @@
+from __future__ import absolute_import
+
+import collections
+import copy
+import logging
+import threading
+import time
+
+import kafka.errors as Errors
+from kafka.producer.buffer import SimpleBufferPool
+from kafka.producer.future import FutureRecordMetadata, FutureProduceResult
+from kafka.record.memory_records import MemoryRecordsBuilder
+from kafka.structs import TopicPartition
+
+
+log = logging.getLogger(__name__)
+
+
+class AtomicInteger(object):
+    def __init__(self, val=0):
+        self._lock = threading.Lock()
+        self._val = val
+
+    def increment(self):
+        with self._lock:
+            self._val += 1
+            return self._val
+
+    def decrement(self):
+        with self._lock:
+            self._val -= 1
+            return self._val
+
+    def get(self):
+        return self._val
+
+
+class ProducerBatch(object):
+    def __init__(self, tp, records, buffer):
+        self.max_record_size = 0
+        now = time.time()
+        self.created = now
+        self.drained = None
+        self.attempts = 0
+        self.last_attempt = now
+        self.last_append = now
+        self.records = records
+        self.topic_partition = tp
+        self.produce_future = FutureProduceResult(tp)
+        self._retry = False
+        self._buffer = buffer  # We only save it, we don't write to it
+
+    @property
+    def record_count(self):
+        return self.records.next_offset()
+
+    def try_append(self, timestamp_ms, key, value, headers):
+        metadata = self.records.append(timestamp_ms, key, value, headers)
+        if metadata is None:
+            return None
+
+        self.max_record_size = max(self.max_record_size, metadata.size)
+        self.last_append = time.time()
+        future = FutureRecordMetadata(self.produce_future, metadata.offset,
+                                      metadata.timestamp, metadata.crc,
+                                      len(key) if key is not None else -1,
+                                      len(value) if value is not None else -1,
+                                      sum(len(h_key.encode("utf-8")) + len(h_val) for h_key, h_val in headers) if headers else -1)
+        return future
+
+    def done(self, base_offset=None, timestamp_ms=None, exception=None, log_start_offset=None, global_error=None):
+        level = logging.DEBUG if exception is None else logging.WARNING
+        log.log(level, "Produced messages to topic-partition %s with base offset"
+                  " %s log start offset %s and error %s.", self.topic_partition, base_offset,
+                  log_start_offset, global_error)  # trace
+        if self.produce_future.is_done:
+            log.warning('Batch is already closed -- ignoring batch.done()')
+            return
+        elif exception is None:
+            self.produce_future.success((base_offset, timestamp_ms, log_start_offset))
+        else:
+            self.produce_future.failure(exception)
+
+    def maybe_expire(self, request_timeout_ms, retry_backoff_ms, linger_ms, is_full):
+        """Expire batches if metadata is not available
+
+        A batch whose metadata is not available should be expired if one
+        of the following is true:
+
+          * the batch is not in retry AND request timeout has elapsed after
+            it is ready (full or linger.ms has reached).
+
+          * the batch is in retry AND request timeout has elapsed after the
+            backoff period ended.
+        """
+        now = time.time()
+        since_append = now - self.last_append
+        since_ready = now - (self.created + linger_ms / 1000.0)
+        since_backoff = now - (self.last_attempt + retry_backoff_ms / 1000.0)
+        timeout = request_timeout_ms / 1000.0
+
+        error = None
+        if not self.in_retry() and is_full and timeout < since_append:
+            error = "%d seconds have passed since last append" % (since_append,)
+        elif not self.in_retry() and timeout < since_ready:
+            error = "%d seconds have passed since batch creation plus linger time" % (since_ready,)
+        elif self.in_retry() and timeout < since_backoff:
+            error = "%d seconds have passed since last attempt plus backoff time" % (since_backoff,)
+
+        if error:
+            self.records.close()
+            self.done(-1, None, Errors.KafkaTimeoutError(
+                "Batch for %s containing %s record(s) expired: %s" % (
+                self.topic_partition, self.records.next_offset(), error)))
+            return True
+        return False
+
+    def in_retry(self):
+        return self._retry
+
+    def set_retry(self):
+        self._retry = True
+
+    def buffer(self):
+        return self._buffer
+
+    def __str__(self):
+        return 'ProducerBatch(topic_partition=%s, record_count=%d)' % (
+            self.topic_partition, self.records.next_offset())
+
+
+class RecordAccumulator(object):
+    """
+    This class maintains a dequeue per TopicPartition that accumulates messages
+    into MessageSets to be sent to the server.
+
+    The accumulator attempts to bound memory use, and append calls will block
+    when that memory is exhausted.
+
+    Keyword Arguments:
+        batch_size (int): Requests sent to brokers will contain multiple
+            batches, one for each partition with data available to be sent.
+            A small batch size will make batching less common and may reduce
+            throughput (a batch size of zero will disable batching entirely).
+            Default: 16384
+        buffer_memory (int): The total bytes of memory the producer should use
+            to buffer records waiting to be sent to the server. If records are
+            sent faster than they can be delivered to the server the producer
+            will block up to max_block_ms, raising an exception on timeout.
+            In the current implementation, this setting is an approximation.
+            Default: 33554432 (32MB)
+        compression_attrs (int): The compression type for all data generated by
+            the producer. Valid values are gzip(1), snappy(2), lz4(3), or
+            none(0).
+            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.
+        linger_ms (int): An artificial delay time to add before declaring a
+            messageset (that isn't full) ready for sending. This allows
+            time for more records to arrive. Setting a non-zero linger_ms
+            will trade off some latency for potentially better throughput
+            due to more batching (and hence fewer, larger requests).
+            Default: 0
+        retry_backoff_ms (int): An artificial delay time to retry the
+            produce request upon receiving an error. This avoids exhausting
+            all retries in a short period of time. Default: 100
+    """
+    DEFAULT_CONFIG = {
+        'buffer_memory': 33554432,
+        'batch_size': 16384,
+        'compression_attrs': 0,
+        'linger_ms': 0,
+        'retry_backoff_ms': 100,
+        'message_version': 0,
+        'metrics': None,
+        'metric_group_prefix': 'producer-metrics',
+    }
+
+    def __init__(self, **configs):
+        self.config = copy.copy(self.DEFAULT_CONFIG)
+        for key in self.config:
+            if key in configs:
+                self.config[key] = configs.pop(key)
+
+        self._closed = False
+        self._flushes_in_progress = AtomicInteger()
+        self._appends_in_progress = AtomicInteger()
+        self._batches = collections.defaultdict(collections.deque) # TopicPartition: [ProducerBatch]
+        self._tp_locks = {None: threading.Lock()} # TopicPartition: Lock, plus a lock to add entries
+        self._free = SimpleBufferPool(self.config['buffer_memory'],
+                                      self.config['batch_size'],
+                                      metrics=self.config['metrics'],
+                                      metric_group_prefix=self.config['metric_group_prefix'])
+        self._incomplete = IncompleteProducerBatches()
+        # The following variables should only be accessed by the sender thread,
+        # so we don't need to protect them w/ locking.
+        self.muted = set()
+        self._drain_index = 0
+
+    def append(self, tp, timestamp_ms, key, value, headers, max_time_to_block_ms,
+               estimated_size=0):
+        """Add a record to the accumulator, return the append result.
+
+        The append result will contain the future metadata, and flag for
+        whether the appended batch is full or a new batch is created
+
+        Arguments:
+            tp (TopicPartition): The topic/partition to which this record is
+                being sent
+            timestamp_ms (int): The timestamp of the record (epoch ms)
+            key (bytes): The key for the record
+            value (bytes): The value for the record
+            headers (List[Tuple[str, bytes]]): The header fields for the record
+            max_time_to_block_ms (int): The maximum time in milliseconds to
+                block for buffer memory to be available
+
+        Returns:
+            tuple: (future, batch_is_full, new_batch_created)
+        """
+        assert isinstance(tp, TopicPartition), 'not TopicPartition'
+        assert not self._closed, 'RecordAccumulator is closed'
+        # We keep track of the number of appending thread to make sure we do
+        # not miss batches in abortIncompleteBatches().
+        self._appends_in_progress.increment()
+        try:
+            if tp not in self._tp_locks:
+                with self._tp_locks[None]:
+                    if tp not in self._tp_locks:
+                        self._tp_locks[tp] = threading.Lock()
+
+            with self._tp_locks[tp]:
+                # check if we have an in-progress batch
+                dq = self._batches[tp]
+                if dq:
+                    last = dq[-1]
+                    future = last.try_append(timestamp_ms, key, value, headers)
+                    if future is not None:
+                        batch_is_full = len(dq) > 1 or last.records.is_full()
+                        return future, batch_is_full, False
+
+            size = max(self.config['batch_size'], estimated_size)
+            log.debug("Allocating a new %d byte message buffer for %s", size, tp) # trace
+            buf = self._free.allocate(size, max_time_to_block_ms)
+            with self._tp_locks[tp]:
+                # Need to check if producer is closed again after grabbing the
+                # dequeue lock.
+                assert not self._closed, 'RecordAccumulator is closed'
+
+                if dq:
+                    last = dq[-1]
+                    future = last.try_append(timestamp_ms, key, value, headers)
+                    if future is not None:
+                        # Somebody else found us a batch, return the one we
+                        # waited for! Hopefully this doesn't happen often...
+                        self._free.deallocate(buf)
+                        batch_is_full = len(dq) > 1 or last.records.is_full()
+                        return future, batch_is_full, False
+
+                records = MemoryRecordsBuilder(
+                    self.config['message_version'],
+                    self.config['compression_attrs'],
+                    self.config['batch_size']
+                )
+
+                batch = ProducerBatch(tp, records, buf)
+                future = batch.try_append(timestamp_ms, key, value, headers)
+                if not future:
+                    raise Exception()
+
+                dq.append(batch)
+                self._incomplete.add(batch)
+                batch_is_full = len(dq) > 1 or batch.records.is_full()
+                return future, batch_is_full, True
+        finally:
+            self._appends_in_progress.decrement()
+
+    def abort_expired_batches(self, request_timeout_ms, cluster):
+        """Abort the batches that have been sitting in RecordAccumulator for
+        more than the configured request_timeout due to metadata being
+        unavailable.
+
+        Arguments:
+            request_timeout_ms (int): milliseconds to timeout
+            cluster (ClusterMetadata): current metadata for kafka cluster
+
+        Returns:
+            list of ProducerBatch that were expired
+        """
+        expired_batches = []
+        to_remove = []
+        count = 0
+        for tp in list(self._batches.keys()):
+            assert tp in self._tp_locks, 'TopicPartition not in locks dict'
+
+            # We only check if the batch should be expired if the partition
+            # does not have a batch in flight. This is to avoid the later
+            # batches get expired when an earlier batch is still in progress.
+            # This protection only takes effect when user sets
+            # max.in.flight.request.per.connection=1. Otherwise the expiration
+            # order is not guranteed.
+            if tp in self.muted:
+                continue
+
+            with self._tp_locks[tp]:
+                # iterate over the batches and expire them if they have stayed
+                # in accumulator for more than request_timeout_ms
+                dq = self._batches[tp]
+                for batch in dq:
+                    is_full = bool(bool(batch != dq[-1]) or batch.records.is_full())
+                    # check if the batch is expired
+                    if batch.maybe_expire(request_timeout_ms,
+                                          self.config['retry_backoff_ms'],
+                                          self.config['linger_ms'],
+                                          is_full):
+                        expired_batches.append(batch)
+                        to_remove.append(batch)
+                        count += 1
+                        self.deallocate(batch)
+                    else:
+                        # Stop at the first batch that has not expired.
+                        break
+
+                # Python does not allow us to mutate the dq during iteration
+                # Assuming expired batches are infrequent, this is better than
+                # creating a new copy of the deque for iteration on every loop
+                if to_remove:
+                    for batch in to_remove:
+                        dq.remove(batch)
+                    to_remove = []
+
+        if expired_batches:
+            log.warning("Expired %d batches in accumulator", count) # trace
+
+        return expired_batches
+
+    def reenqueue(self, batch):
+        """Re-enqueue the given record batch in the accumulator to retry."""
+        now = time.time()
+        batch.attempts += 1
+        batch.last_attempt = now
+        batch.last_append = now
+        batch.set_retry()
+        assert batch.topic_partition in self._tp_locks, 'TopicPartition not in locks dict'
+        assert batch.topic_partition in self._batches, 'TopicPartition not in batches'
+        dq = self._batches[batch.topic_partition]
+        with self._tp_locks[batch.topic_partition]:
+            dq.appendleft(batch)
+
+    def ready(self, cluster):
+        """
+        Get a list of nodes whose partitions are ready to be sent, and the
+        earliest time at which any non-sendable partition will be ready;
+        Also return the flag for whether there are any unknown leaders for the
+        accumulated partition batches.
+
+        A destination node is ready to send if:
+
+         * There is at least one partition that is not backing off its send
+         * and those partitions are not muted (to prevent reordering if
+           max_in_flight_requests_per_connection is set to 1)
+         * and any of the following are true:
+
+           * The record set is full
+           * The record set has sat in the accumulator for at least linger_ms
+             milliseconds
+           * The accumulator is out of memory and threads are blocking waiting
+             for data (in this case all partitions are immediately considered
+             ready).
+           * The accumulator has been closed
+
+        Arguments:
+            cluster (ClusterMetadata):
+
+        Returns:
+            tuple:
+                ready_nodes (set): node_ids that have ready batches
+                next_ready_check (float): secs until next ready after backoff
+                unknown_leaders_exist (bool): True if metadata refresh needed
+        """
+        ready_nodes = set()
+        next_ready_check = 9999999.99
+        unknown_leaders_exist = False
+        now = time.time()
+
+        exhausted = bool(self._free.queued() > 0)
+        # several threads are accessing self._batches -- to simplify
+        # concurrent access, we iterate over a snapshot of partitions
+        # and lock each partition separately as needed
+        partitions = list(self._batches.keys())
+        for tp in partitions:
+            leader = cluster.leader_for_partition(tp)
+            if leader is None or leader == -1:
+                unknown_leaders_exist = True
+                continue
+            elif leader in ready_nodes:
+                continue
+            elif tp in self.muted:
+                continue
+
+            with self._tp_locks[tp]:
+                dq = self._batches[tp]
+                if not dq:
+                    continue
+                batch = dq[0]
+                retry_backoff = self.config['retry_backoff_ms'] / 1000.0
+                linger = self.config['linger_ms'] / 1000.0
+                backing_off = bool(batch.attempts > 0 and
+                                   batch.last_attempt + retry_backoff > now)
+                waited_time = now - batch.last_attempt
+                time_to_wait = retry_backoff if backing_off else linger
+                time_left = max(time_to_wait - waited_time, 0)
+                full = bool(len(dq) > 1 or batch.records.is_full())
+                expired = bool(waited_time >= time_to_wait)
+
+                sendable = (full or expired or exhausted or self._closed or
+                            self._flush_in_progress())
+
+                if sendable and not backing_off:
+                    ready_nodes.add(leader)
+                else:
+                    # Note that this results in a conservative estimate since
+                    # an un-sendable partition may have a leader that will
+                    # later be found to have sendable data. However, this is
+                    # good enough since we'll just wake up and then sleep again
+                    # for the remaining time.
+                    next_ready_check = min(time_left, next_ready_check)
+
+        return ready_nodes, next_ready_check, unknown_leaders_exist
+
+    def has_unsent(self):
+        """Return whether there is any unsent record in the accumulator."""
+        for tp in list(self._batches.keys()):
+            with self._tp_locks[tp]:
+                dq = self._batches[tp]
+                if len(dq):
+                    return True
+        return False
+
+    def drain(self, cluster, nodes, max_size):
+        """
+        Drain all the data for the given nodes and collate them into a list of
+        batches that will fit within the specified size on a per-node basis.
+        This method attempts to avoid choosing the same topic-node repeatedly.
+
+        Arguments:
+            cluster (ClusterMetadata): The current cluster metadata
+            nodes (list): list of node_ids to drain
+            max_size (int): maximum number of bytes to drain
+
+        Returns:
+            dict: {node_id: list of ProducerBatch} with total size less than the
+                requested max_size.
+        """
+        if not nodes:
+            return {}
+
+        now = time.time()
+        batches = {}
+        for node_id in nodes:
+            size = 0
+            partitions = list(cluster.partitions_for_broker(node_id))
+            ready = []
+            # to make starvation less likely this loop doesn't start at 0
+            self._drain_index %= len(partitions)
+            start = self._drain_index
+            while True:
+                tp = partitions[self._drain_index]
+                if tp in self._batches and tp not in self.muted:
+                    with self._tp_locks[tp]:
+                        dq = self._batches[tp]
+                        if dq:
+                            first = dq[0]
+                            backoff = (
+                                bool(first.attempts > 0) and
+                                bool(first.last_attempt +
+                                     self.config['retry_backoff_ms'] / 1000.0
+                                     > now)
+                            )
+                            # Only drain the batch if it is not during backoff
+                            if not backoff:
+                                if (size + first.records.size_in_bytes() > max_size
+                                    and len(ready) > 0):
+                                    # there is a rare case that a single batch
+                                    # size is larger than the request size due
+                                    # to compression; in this case we will
+                                    # still eventually send this batch in a
+                                    # single request
+                                    break
+                                else:
+                                    batch = dq.popleft()
+                                    batch.records.close()
+                                    size += batch.records.size_in_bytes()
+                                    ready.append(batch)
+                                    batch.drained = now
+
+                self._drain_index += 1
+                self._drain_index %= len(partitions)
+                if start == self._drain_index:
+                    break
+
+            batches[node_id] = ready
+        return batches
+
+    def deallocate(self, batch):
+        """Deallocate the record batch."""
+        self._incomplete.remove(batch)
+        self._free.deallocate(batch.buffer())
+
+    def _flush_in_progress(self):
+        """Are there any threads currently waiting on a flush?"""
+        return self._flushes_in_progress.get() > 0
+
+    def begin_flush(self):
+        """
+        Initiate the flushing of data from the accumulator...this makes all
+        requests immediately ready
+        """
+        self._flushes_in_progress.increment()
+
+    def await_flush_completion(self, timeout=None):
+        """
+        Mark all partitions as ready to send and block until the send is complete
+        """
+        try:
+            for batch in self._incomplete.all():
+                log.debug('Waiting on produce to %s',
+                          batch.produce_future.topic_partition)
+                if not batch.produce_future.wait(timeout=timeout):
+                    raise Errors.KafkaTimeoutError('Timeout waiting for future')
+                if not batch.produce_future.is_done:
+                    raise Errors.UnknownError('Future not done')
+
+                if batch.produce_future.failed():
+                    log.warning(batch.produce_future.exception)
+        finally:
+            self._flushes_in_progress.decrement()
+
+    def abort_incomplete_batches(self):
+        """
+        This function is only called when sender is closed forcefully. It will fail all the
+        incomplete batches and return.
+        """
+        # We need to keep aborting the incomplete batch until no thread is trying to append to
+        # 1. Avoid losing batches.
+        # 2. Free up memory in case appending threads are blocked on buffer full.
+        # This is a tight loop but should be able to get through very quickly.
+        while True:
+            self._abort_batches()
+            if not self._appends_in_progress.get():
+                break
+        # After this point, no thread will append any messages because they will see the close
+        # flag set. We need to do the last abort after no thread was appending in case the there was a new
+        # batch appended by the last appending thread.
+        self._abort_batches()
+        self._batches.clear()
+
+    def _abort_batches(self):
+        """Go through incomplete batches and abort them."""
+        error = Errors.IllegalStateError("Producer is closed forcefully.")
+        for batch in self._incomplete.all():
+            tp = batch.topic_partition
+            # Close the batch before aborting
+            with self._tp_locks[tp]:
+                batch.records.close()
+            batch.done(exception=error)
+            self.deallocate(batch)
+
+    def close(self):
+        """Close this accumulator and force all the record buffers to be drained."""
+        self._closed = True
+
+
+class IncompleteProducerBatches(object):
+    """A threadsafe helper class to hold ProducerBatches that haven't been ack'd yet"""
+
+    def __init__(self):
+        self._incomplete = set()
+        self._lock = threading.Lock()
+
+    def add(self, batch):
+        with self._lock:
+            return self._incomplete.add(batch)
+
+    def remove(self, batch):
+        with self._lock:
+            return self._incomplete.remove(batch)
+
+    def all(self):
+        with self._lock:
+            return list(self._incomplete)

testbed/dpkp__kafka-python/kafka/producer/sender.py

@@ -0,0 +1,517 @@
+from __future__ import absolute_import, division
+
+import collections
+import copy
+import logging
+import threading
+import time
+
+from kafka.vendor import six
+
+from kafka import errors as Errors
+from kafka.metrics.measurable import AnonMeasurable
+from kafka.metrics.stats import Avg, Max, Rate
+from kafka.protocol.produce import ProduceRequest
+from kafka.structs import TopicPartition
+from kafka.version import __version__
+
+log = logging.getLogger(__name__)
+
+
+class Sender(threading.Thread):
+    """
+    The background thread that handles the sending of produce requests to the
+    Kafka cluster. This thread makes metadata requests to renew its view of the
+    cluster and then sends produce requests to the appropriate nodes.
+    """
+    DEFAULT_CONFIG = {
+        'max_request_size': 1048576,
+        'acks': 1,
+        'retries': 0,
+        'request_timeout_ms': 30000,
+        'guarantee_message_order': False,
+        'client_id': 'kafka-python-' + __version__,
+        'api_version': (0, 8, 0),
+    }
+
+    def __init__(self, client, metadata, accumulator, metrics, **configs):
+        super(Sender, self).__init__()
+        self.config = copy.copy(self.DEFAULT_CONFIG)
+        for key in self.config:
+            if key in configs:
+                self.config[key] = configs.pop(key)
+
+        self.name = self.config['client_id'] + '-network-thread'
+        self._client = client
+        self._accumulator = accumulator
+        self._metadata = client.cluster
+        self._running = True
+        self._force_close = False
+        self._topics_to_add = set()
+        self._sensors = SenderMetrics(metrics, self._client, self._metadata)
+
+    def run(self):
+        """The main run loop for the sender thread."""
+        log.debug("Starting Kafka producer I/O thread.")
+
+        # main loop, runs until close is called
+        while self._running:
+            try:
+                self.run_once()
+            except Exception:
+                log.exception("Uncaught error in kafka producer I/O thread")
+
+        log.debug("Beginning shutdown of Kafka producer I/O thread, sending"
+                  " remaining records.")
+
+        # okay we stopped accepting requests but there may still be
+        # requests in the accumulator or waiting for acknowledgment,
+        # wait until these are completed.
+        while (not self._force_close
+               and (self._accumulator.has_unsent()
+                    or self._client.in_flight_request_count() > 0)):
+            try:
+                self.run_once()
+            except Exception:
+                log.exception("Uncaught error in kafka producer I/O thread")
+
+        if self._force_close:
+            # We need to fail all the incomplete batches and wake up the
+            # threads waiting on the futures.
+            self._accumulator.abort_incomplete_batches()
+
+        try:
+            self._client.close()
+        except Exception:
+            log.exception("Failed to close network client")
+
+        log.debug("Shutdown of Kafka producer I/O thread has completed.")
+
+    def run_once(self):
+        """Run a single iteration of sending."""
+        while self._topics_to_add:
+            self._client.add_topic(self._topics_to_add.pop())
+
+        # get the list of partitions with data ready to send
+        result = self._accumulator.ready(self._metadata)
+        ready_nodes, next_ready_check_delay, unknown_leaders_exist = result
+
+        # if there are any partitions whose leaders are not known yet, force
+        # metadata update
+        if unknown_leaders_exist:
+            log.debug('Unknown leaders exist, requesting metadata update')
+            self._metadata.request_update()
+
+        # remove any nodes we aren't ready to send to
+        not_ready_timeout = float('inf')
+        for node in list(ready_nodes):
+            if not self._client.is_ready(node):
+                log.debug('Node %s not ready; delaying produce of accumulated batch', node)
+                self._client.maybe_connect(node, wakeup=False)
+                ready_nodes.remove(node)
+                not_ready_timeout = min(not_ready_timeout,
+                                        self._client.connection_delay(node))
+
+        # create produce requests
+        batches_by_node = self._accumulator.drain(
+            self._metadata, ready_nodes, self.config['max_request_size'])
+
+        if self.config['guarantee_message_order']:
+            # Mute all the partitions drained
+            for batch_list in six.itervalues(batches_by_node):
+                for batch in batch_list:
+                    self._accumulator.muted.add(batch.topic_partition)
+
+        expired_batches = self._accumulator.abort_expired_batches(
+            self.config['request_timeout_ms'], self._metadata)
+        for expired_batch in expired_batches:
+            self._sensors.record_errors(expired_batch.topic_partition.topic, expired_batch.record_count)
+
+        self._sensors.update_produce_request_metrics(batches_by_node)
+        requests = self._create_produce_requests(batches_by_node)
+        # If we have any nodes that are ready to send + have sendable data,
+        # poll with 0 timeout so this can immediately loop and try sending more
+        # data. Otherwise, the timeout is determined by nodes that have
+        # partitions with data that isn't yet sendable (e.g. lingering, backing
+        # off). Note that this specifically does not include nodes with
+        # sendable data that aren't ready to send since they would cause busy
+        # looping.
+        poll_timeout_ms = min(next_ready_check_delay * 1000, not_ready_timeout)
+        if ready_nodes:
+            log.debug("Nodes with data ready to send: %s", ready_nodes) # trace
+            log.debug("Created %d produce requests: %s", len(requests), requests) # trace
+            poll_timeout_ms = 0
+
+        for node_id, request in six.iteritems(requests):
+            batches = batches_by_node[node_id]
+            log.debug('Sending Produce Request: %r', request)
+            (self._client.send(node_id, request, wakeup=False)
+                 .add_callback(
+                     self._handle_produce_response, node_id, time.time(), batches)
+                 .add_errback(
+                     self._failed_produce, batches, node_id))
+
+        # if some partitions are already ready to be sent, the select time
+        # would be 0; otherwise if some partition already has some data
+        # accumulated but not ready yet, the select time will be the time
+        # difference between now and its linger expiry time; otherwise the
+        # select time will be the time difference between now and the
+        # metadata expiry time
+        self._client.poll(timeout_ms=poll_timeout_ms)
+
+    def initiate_close(self):
+        """Start closing the sender (won't complete until all data is sent)."""
+        self._running = False
+        self._accumulator.close()
+        self.wakeup()
+
+    def force_close(self):
+        """Closes the sender without sending out any pending messages."""
+        self._force_close = True
+        self.initiate_close()
+
+    def add_topic(self, topic):
+        # This is generally called from a separate thread
+        # so this needs to be a thread-safe operation
+        # we assume that checking set membership across threads
+        # is ok where self._client._topics should never
+        # remove topics for a producer instance, only add them.
+        if topic not in self._client._topics:
+            self._topics_to_add.add(topic)
+            self.wakeup()
+
+    def _failed_produce(self, batches, node_id, error):
+        log.debug("Error sending produce request to node %d: %s", node_id, error) # trace
+        for batch in batches:
+            self._complete_batch(batch, error, -1, None)
+
+    def _handle_produce_response(self, node_id, send_time, batches, response):
+        """Handle a produce response."""
+        # if we have a response, parse it
+        log.debug('Parsing produce response: %r', response)
+        if response:
+            batches_by_partition = dict([(batch.topic_partition, batch)
+                                         for batch in batches])
+
+            for topic, partitions in response.topics:
+                for partition_info in partitions:
+                    global_error = None
+                    log_start_offset = None
+                    if response.API_VERSION < 2:
+                        partition, error_code, offset = partition_info
+                        ts = None
+                    elif 2 <= response.API_VERSION <= 4:
+                        partition, error_code, offset, ts = partition_info
+                    elif 5 <= response.API_VERSION <= 7:
+                        partition, error_code, offset, ts, log_start_offset = partition_info
+                    else:
+                        # the ignored parameter is record_error of type list[(batch_index: int, error_message: str)]
+                        partition, error_code, offset, ts, log_start_offset, _, global_error = partition_info
+                    tp = TopicPartition(topic, partition)
+                    error = Errors.for_code(error_code)
+                    batch = batches_by_partition[tp]
+                    self._complete_batch(batch, error, offset, ts, log_start_offset, global_error)
+
+            if response.API_VERSION > 0:
+                self._sensors.record_throttle_time(response.throttle_time_ms, node=node_id)
+
+        else:
+            # this is the acks = 0 case, just complete all requests
+            for batch in batches:
+                self._complete_batch(batch, None, -1, None)
+
+    def _complete_batch(self, batch, error, base_offset, timestamp_ms=None, log_start_offset=None, global_error=None):
+        """Complete or retry the given batch of records.
+
+        Arguments:
+            batch (RecordBatch): The record batch
+            error (Exception): The error (or None if none)
+            base_offset (int): The base offset assigned to the records if successful
+            timestamp_ms (int, optional): The timestamp returned by the broker for this batch
+            log_start_offset (int): The start offset of the log at the time this produce response was created
+            global_error (str): The summarising error message
+        """
+        # Standardize no-error to None
+        if error is Errors.NoError:
+            error = None
+
+        if error is not None and self._can_retry(batch, error):
+            # retry
+            log.warning("Got error produce response on topic-partition %s,"
+                        " retrying (%d attempts left). Error: %s",
+                        batch.topic_partition,
+                        self.config['retries'] - batch.attempts - 1,
+                        global_error or error)
+            self._accumulator.reenqueue(batch)
+            self._sensors.record_retries(batch.topic_partition.topic, batch.record_count)
+        else:
+            if error is Errors.TopicAuthorizationFailedError:
+                error = error(batch.topic_partition.topic)
+
+            # tell the user the result of their request
+            batch.done(base_offset, timestamp_ms, error, log_start_offset, global_error)
+            self._accumulator.deallocate(batch)
+            if error is not None:
+                self._sensors.record_errors(batch.topic_partition.topic, batch.record_count)
+
+        if getattr(error, 'invalid_metadata', False):
+            self._metadata.request_update()
+
+        # Unmute the completed partition.
+        if self.config['guarantee_message_order']:
+            self._accumulator.muted.remove(batch.topic_partition)
+
+    def _can_retry(self, batch, error):
+        """
+        We can retry a send if the error is transient and the number of
+        attempts taken is fewer than the maximum allowed
+        """
+        return (batch.attempts < self.config['retries']
+                and getattr(error, 'retriable', False))
+
+    def _create_produce_requests(self, collated):
+        """
+        Transfer the record batches into a list of produce requests on a
+        per-node basis.
+
+        Arguments:
+            collated: {node_id: [RecordBatch]}
+
+        Returns:
+            dict: {node_id: ProduceRequest} (version depends on api_version)
+        """
+        requests = {}
+        for node_id, batches in six.iteritems(collated):
+            requests[node_id] = self._produce_request(
+                node_id, self.config['acks'],
+                self.config['request_timeout_ms'], batches)
+        return requests
+
+    def _produce_request(self, node_id, acks, timeout, batches):
+        """Create a produce request from the given record batches.
+
+        Returns:
+            ProduceRequest (version depends on api_version)
+        """
+        produce_records_by_partition = collections.defaultdict(dict)
+        for batch in batches:
+            topic = batch.topic_partition.topic
+            partition = batch.topic_partition.partition
+
+            buf = batch.records.buffer()
+            produce_records_by_partition[topic][partition] = buf
+
+        kwargs = {}
+        if self.config['api_version'] >= (2, 1):
+            version = 7
+        elif self.config['api_version'] >= (2, 0):
+            version = 6
+        elif self.config['api_version'] >= (1, 1):
+            version = 5
+        elif self.config['api_version'] >= (1, 0):
+            version = 4
+        elif self.config['api_version'] >= (0, 11):
+            version = 3
+            kwargs = dict(transactional_id=None)
+        elif self.config['api_version'] >= (0, 10):
+            version = 2
+        elif self.config['api_version'] == (0, 9):
+            version = 1
+        else:
+            version = 0
+        return ProduceRequest[version](
+            required_acks=acks,
+            timeout=timeout,
+            topics=[(topic, list(partition_info.items()))
+                    for topic, partition_info
+                    in six.iteritems(produce_records_by_partition)],
+            **kwargs
+        )
+
+    def wakeup(self):
+        """Wake up the selector associated with this send thread."""
+        self._client.wakeup()
+
+    def bootstrap_connected(self):
+        return self._client.bootstrap_connected()
+
+
+class SenderMetrics(object):
+
+    def __init__(self, metrics, client, metadata):
+        self.metrics = metrics
+        self._client = client
+        self._metadata = metadata
+
+        sensor_name = 'batch-size'
+        self.batch_size_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('batch-size-avg', Avg(),
+                        sensor_name=sensor_name,
+                        description='The average number of bytes sent per partition per-request.')
+        self.add_metric('batch-size-max', Max(),
+                        sensor_name=sensor_name,
+                        description='The max number of bytes sent per partition per-request.')
+
+        sensor_name = 'compression-rate'
+        self.compression_rate_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('compression-rate-avg', Avg(),
+                        sensor_name=sensor_name,
+                        description='The average compression rate of record batches.')
+
+        sensor_name = 'queue-time'
+        self.queue_time_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('record-queue-time-avg', Avg(),
+                        sensor_name=sensor_name,
+                        description='The average time in ms record batches spent in the record accumulator.')
+        self.add_metric('record-queue-time-max', Max(),
+                        sensor_name=sensor_name,
+                        description='The maximum time in ms record batches spent in the record accumulator.')
+
+        sensor_name = 'produce-throttle-time'
+        self.produce_throttle_time_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('produce-throttle-time-avg', Avg(),
+                        sensor_name=sensor_name,
+                        description='The average throttle time in ms')
+        self.add_metric('produce-throttle-time-max', Max(),
+                        sensor_name=sensor_name,
+                        description='The maximum throttle time in ms')
+
+        sensor_name = 'records-per-request'
+        self.records_per_request_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('record-send-rate', Rate(),
+                        sensor_name=sensor_name,
+                        description='The average number of records sent per second.')
+        self.add_metric('records-per-request-avg', Avg(),
+                        sensor_name=sensor_name,
+                        description='The average number of records per request.')
+
+        sensor_name = 'bytes'
+        self.byte_rate_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('byte-rate', Rate(),
+                        sensor_name=sensor_name,
+                        description='The average number of bytes sent per second.')
+
+        sensor_name = 'record-retries'
+        self.retry_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('record-retry-rate', Rate(),
+                        sensor_name=sensor_name,
+                        description='The average per-second number of retried record sends')
+
+        sensor_name = 'errors'
+        self.error_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('record-error-rate', Rate(),
+                        sensor_name=sensor_name,
+                        description='The average per-second number of record sends that resulted in errors')
+
+        sensor_name = 'record-size-max'
+        self.max_record_size_sensor = self.metrics.sensor(sensor_name)
+        self.add_metric('record-size-max', Max(),
+                        sensor_name=sensor_name,
+                        description='The maximum record size across all batches')
+        self.add_metric('record-size-avg', Avg(),
+                        sensor_name=sensor_name,
+                        description='The average maximum record size per batch')
+
+        self.add_metric('requests-in-flight',
+                        AnonMeasurable(lambda *_: self._client.in_flight_request_count()),
+                        description='The current number of in-flight requests awaiting a response.')
+
+        self.add_metric('metadata-age',
+                        AnonMeasurable(lambda _, now: (now - self._metadata._last_successful_refresh_ms) / 1000),
+                        description='The age in seconds of the current producer metadata being used.')
+
+    def add_metric(self, metric_name, measurable, group_name='producer-metrics',
+                   description=None, tags=None,
+                   sensor_name=None):
+        m = self.metrics
+        metric = m.metric_name(metric_name, group_name, description, tags)
+        if sensor_name:
+            sensor = m.sensor(sensor_name)
+            sensor.add(metric, measurable)
+        else:
+            m.add_metric(metric, measurable)
+
+    def maybe_register_topic_metrics(self, topic):
+
+        def sensor_name(name):
+            return 'topic.{0}.{1}'.format(topic, name)
+
+        # if one sensor of the metrics has been registered for the topic,
+        # then all other sensors should have been registered; and vice versa
+        if not self.metrics.get_sensor(sensor_name('records-per-batch')):
+
+            self.add_metric('record-send-rate', Rate(),
+                            sensor_name=sensor_name('records-per-batch'),
+                            group_name='producer-topic-metrics.' + topic,
+                            description= 'Records sent per second for topic ' + topic)
+
+            self.add_metric('byte-rate', Rate(),
+                            sensor_name=sensor_name('bytes'),
+                            group_name='producer-topic-metrics.' + topic,
+                            description='Bytes per second for topic ' + topic)
+
+            self.add_metric('compression-rate', Avg(),
+                            sensor_name=sensor_name('compression-rate'),
+                            group_name='producer-topic-metrics.' + topic,
+                            description='Average Compression ratio for topic ' + topic)
+
+            self.add_metric('record-retry-rate', Rate(),
+                            sensor_name=sensor_name('record-retries'),
+                            group_name='producer-topic-metrics.' + topic,
+                            description='Record retries per second for topic ' + topic)
+
+            self.add_metric('record-error-rate', Rate(),
+                            sensor_name=sensor_name('record-errors'),
+                            group_name='producer-topic-metrics.' + topic,
+                            description='Record errors per second for topic ' + topic)
+
+    def update_produce_request_metrics(self, batches_map):
+        for node_batch in batches_map.values():
+            records = 0
+            total_bytes = 0
+            for batch in node_batch:
+                # register all per-topic metrics at once
+                topic = batch.topic_partition.topic
+                self.maybe_register_topic_metrics(topic)
+
+                # per-topic record send rate
+                topic_records_count = self.metrics.get_sensor(
+                    'topic.' + topic + '.records-per-batch')
+                topic_records_count.record(batch.record_count)
+
+                # per-topic bytes send rate
+                topic_byte_rate = self.metrics.get_sensor(
+                    'topic.' + topic + '.bytes')
+                topic_byte_rate.record(batch.records.size_in_bytes())
+
+                # per-topic compression rate
+                topic_compression_rate = self.metrics.get_sensor(
+                    'topic.' + topic + '.compression-rate')
+                topic_compression_rate.record(batch.records.compression_rate())
+
+                # global metrics
+                self.batch_size_sensor.record(batch.records.size_in_bytes())
+                if batch.drained:
+                    self.queue_time_sensor.record(batch.drained - batch.created)
+                self.compression_rate_sensor.record(batch.records.compression_rate())
+                self.max_record_size_sensor.record(batch.max_record_size)
+                records += batch.record_count
+                total_bytes += batch.records.size_in_bytes()
+
+            self.records_per_request_sensor.record(records)
+            self.byte_rate_sensor.record(total_bytes)
+
+    def record_retries(self, topic, count):
+        self.retry_sensor.record(count)
+        sensor = self.metrics.get_sensor('topic.' + topic + '.record-retries')
+        if sensor:
+            sensor.record(count)
+
+    def record_errors(self, topic, count):
+        self.error_sensor.record(count)
+        sensor = self.metrics.get_sensor('topic.' + topic + '.record-errors')
+        if sensor:
+            sensor.record(count)
+
+    def record_throttle_time(self, throttle_time_ms, node=None):
+        self.produce_throttle_time_sensor.record(throttle_time_ms)

testbed/dpkp__kafka-python/kafka/protocol/__init__.py

@@ -0,0 +1,47 @@
+from __future__ import absolute_import
+
+
+API_KEYS = {
+    0: 'Produce',
+    1: 'Fetch',
+    2: 'ListOffsets',
+    3: 'Metadata',
+    4: 'LeaderAndIsr',
+    5: 'StopReplica',
+    6: 'UpdateMetadata',
+    7: 'ControlledShutdown',
+    8: 'OffsetCommit',
+    9: 'OffsetFetch',
+    10: 'FindCoordinator',
+    11: 'JoinGroup',
+    12: 'Heartbeat',
+    13: 'LeaveGroup',
+    14: 'SyncGroup',
+    15: 'DescribeGroups',
+    16: 'ListGroups',
+    17: 'SaslHandshake',
+    18: 'ApiVersions',
+    19: 'CreateTopics',
+    20: 'DeleteTopics',
+    21: 'DeleteRecords',
+    22: 'InitProducerId',
+    23: 'OffsetForLeaderEpoch',
+    24: 'AddPartitionsToTxn',
+    25: 'AddOffsetsToTxn',
+    26: 'EndTxn',
+    27: 'WriteTxnMarkers',
+    28: 'TxnOffsetCommit',
+    29: 'DescribeAcls',
+    30: 'CreateAcls',
+    31: 'DeleteAcls',
+    32: 'DescribeConfigs',
+    33: 'AlterConfigs',
+    36: 'SaslAuthenticate',
+    37: 'CreatePartitions',
+    38: 'CreateDelegationToken',
+    39: 'RenewDelegationToken',
+    40: 'ExpireDelegationToken',
+    41: 'DescribeDelegationToken',
+    42: 'DeleteGroups',
+    48: 'DescribeClientQuotas',
+}

testbed/dpkp__kafka-python/kafka/protocol/abstract.py

@@ -0,0 +1,19 @@
+from __future__ import absolute_import
+
+import abc
+
+
+class AbstractType(object):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractmethod
+    def encode(cls, value): # pylint: disable=no-self-argument
+        pass
+
+    @abc.abstractmethod
+    def decode(cls, data): # pylint: disable=no-self-argument
+        pass
+
+    @classmethod
+    def repr(cls, value):
+        return repr(value)

testbed/dpkp__kafka-python/kafka/protocol/admin.py

@@ -0,0 +1,965 @@
+from __future__ import absolute_import
+
+from kafka.protocol.api import Request, Response
+from kafka.protocol.types import Array, Boolean, Bytes, Int8, Int16, Int32, Int64, Schema, String, Float64
+
+
+class ApiVersionResponse_v0(Response):
+    API_KEY = 18
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('api_versions', Array(
+            ('api_key', Int16),
+            ('min_version', Int16),
+            ('max_version', Int16)))
+    )
+
+
+class ApiVersionResponse_v1(Response):
+    API_KEY = 18
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('api_versions', Array(
+            ('api_key', Int16),
+            ('min_version', Int16),
+            ('max_version', Int16))),
+        ('throttle_time_ms', Int32)
+    )
+
+
+class ApiVersionResponse_v2(Response):
+    API_KEY = 18
+    API_VERSION = 2
+    SCHEMA = ApiVersionResponse_v1.SCHEMA
+
+
+class ApiVersionRequest_v0(Request):
+    API_KEY = 18
+    API_VERSION = 0
+    RESPONSE_TYPE = ApiVersionResponse_v0
+    SCHEMA = Schema()
+
+
+class ApiVersionRequest_v1(Request):
+    API_KEY = 18
+    API_VERSION = 1
+    RESPONSE_TYPE = ApiVersionResponse_v1
+    SCHEMA = ApiVersionRequest_v0.SCHEMA
+
+
+class ApiVersionRequest_v2(Request):
+    API_KEY = 18
+    API_VERSION = 2
+    RESPONSE_TYPE = ApiVersionResponse_v1
+    SCHEMA = ApiVersionRequest_v0.SCHEMA
+
+
+ApiVersionRequest = [
+    ApiVersionRequest_v0, ApiVersionRequest_v1, ApiVersionRequest_v2,
+]
+ApiVersionResponse = [
+    ApiVersionResponse_v0, ApiVersionResponse_v1, ApiVersionResponse_v2,
+]
+
+
+class CreateTopicsResponse_v0(Response):
+    API_KEY = 19
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('topic_errors', Array(
+            ('topic', String('utf-8')),
+            ('error_code', Int16)))
+    )
+
+
+class CreateTopicsResponse_v1(Response):
+    API_KEY = 19
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('topic_errors', Array(
+            ('topic', String('utf-8')),
+            ('error_code', Int16),
+            ('error_message', String('utf-8'))))
+    )
+
+
+class CreateTopicsResponse_v2(Response):
+    API_KEY = 19
+    API_VERSION = 2
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topic_errors', Array(
+            ('topic', String('utf-8')),
+            ('error_code', Int16),
+            ('error_message', String('utf-8'))))
+    )
+
+class CreateTopicsResponse_v3(Response):
+    API_KEY = 19
+    API_VERSION = 3
+    SCHEMA = CreateTopicsResponse_v2.SCHEMA
+
+
+class CreateTopicsRequest_v0(Request):
+    API_KEY = 19
+    API_VERSION = 0
+    RESPONSE_TYPE = CreateTopicsResponse_v0
+    SCHEMA = Schema(
+        ('create_topic_requests', Array(
+            ('topic', String('utf-8')),
+            ('num_partitions', Int32),
+            ('replication_factor', Int16),
+            ('replica_assignment', Array(
+                ('partition_id', Int32),
+                ('replicas', Array(Int32)))),
+            ('configs', Array(
+                ('config_key', String('utf-8')),
+                ('config_value', String('utf-8')))))),
+        ('timeout', Int32)
+    )
+
+
+class CreateTopicsRequest_v1(Request):
+    API_KEY = 19
+    API_VERSION = 1
+    RESPONSE_TYPE = CreateTopicsResponse_v1
+    SCHEMA = Schema(
+        ('create_topic_requests', Array(
+            ('topic', String('utf-8')),
+            ('num_partitions', Int32),
+            ('replication_factor', Int16),
+            ('replica_assignment', Array(
+                ('partition_id', Int32),
+                ('replicas', Array(Int32)))),
+            ('configs', Array(
+                ('config_key', String('utf-8')),
+                ('config_value', String('utf-8')))))),
+        ('timeout', Int32),
+        ('validate_only', Boolean)
+    )
+
+
+class CreateTopicsRequest_v2(Request):
+    API_KEY = 19
+    API_VERSION = 2
+    RESPONSE_TYPE = CreateTopicsResponse_v2
+    SCHEMA = CreateTopicsRequest_v1.SCHEMA
+
+
+class CreateTopicsRequest_v3(Request):
+    API_KEY = 19
+    API_VERSION = 3
+    RESPONSE_TYPE = CreateTopicsResponse_v3
+    SCHEMA = CreateTopicsRequest_v1.SCHEMA
+
+
+CreateTopicsRequest = [
+    CreateTopicsRequest_v0, CreateTopicsRequest_v1,
+    CreateTopicsRequest_v2, CreateTopicsRequest_v3,
+]
+CreateTopicsResponse = [
+    CreateTopicsResponse_v0, CreateTopicsResponse_v1,
+    CreateTopicsResponse_v2, CreateTopicsResponse_v3,
+]
+
+
+class DeleteTopicsResponse_v0(Response):
+    API_KEY = 20
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('topic_error_codes', Array(
+            ('topic', String('utf-8')),
+            ('error_code', Int16)))
+    )
+
+
+class DeleteTopicsResponse_v1(Response):
+    API_KEY = 20
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topic_error_codes', Array(
+            ('topic', String('utf-8')),
+            ('error_code', Int16)))
+    )
+
+
+class DeleteTopicsResponse_v2(Response):
+    API_KEY = 20
+    API_VERSION = 2
+    SCHEMA = DeleteTopicsResponse_v1.SCHEMA
+
+
+class DeleteTopicsResponse_v3(Response):
+    API_KEY = 20
+    API_VERSION = 3
+    SCHEMA = DeleteTopicsResponse_v1.SCHEMA
+
+
+class DeleteTopicsRequest_v0(Request):
+    API_KEY = 20
+    API_VERSION = 0
+    RESPONSE_TYPE = DeleteTopicsResponse_v0
+    SCHEMA = Schema(
+        ('topics', Array(String('utf-8'))),
+        ('timeout', Int32)
+    )
+
+
+class DeleteTopicsRequest_v1(Request):
+    API_KEY = 20
+    API_VERSION = 1
+    RESPONSE_TYPE = DeleteTopicsResponse_v1
+    SCHEMA = DeleteTopicsRequest_v0.SCHEMA
+
+
+class DeleteTopicsRequest_v2(Request):
+    API_KEY = 20
+    API_VERSION = 2
+    RESPONSE_TYPE = DeleteTopicsResponse_v2
+    SCHEMA = DeleteTopicsRequest_v0.SCHEMA
+
+
+class DeleteTopicsRequest_v3(Request):
+    API_KEY = 20
+    API_VERSION = 3
+    RESPONSE_TYPE = DeleteTopicsResponse_v3
+    SCHEMA = DeleteTopicsRequest_v0.SCHEMA
+
+
+DeleteTopicsRequest = [
+    DeleteTopicsRequest_v0, DeleteTopicsRequest_v1,
+    DeleteTopicsRequest_v2, DeleteTopicsRequest_v3,
+]
+DeleteTopicsResponse = [
+    DeleteTopicsResponse_v0, DeleteTopicsResponse_v1,
+    DeleteTopicsResponse_v2, DeleteTopicsResponse_v3,
+]
+
+
+class ListGroupsResponse_v0(Response):
+    API_KEY = 16
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('groups', Array(
+            ('group', String('utf-8')),
+            ('protocol_type', String('utf-8'))))
+    )
+
+
+class ListGroupsResponse_v1(Response):
+    API_KEY = 16
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('error_code', Int16),
+        ('groups', Array(
+            ('group', String('utf-8')),
+            ('protocol_type', String('utf-8'))))
+    )
+
+class ListGroupsResponse_v2(Response):
+    API_KEY = 16
+    API_VERSION = 2
+    SCHEMA = ListGroupsResponse_v1.SCHEMA
+
+
+class ListGroupsRequest_v0(Request):
+    API_KEY = 16
+    API_VERSION = 0
+    RESPONSE_TYPE = ListGroupsResponse_v0
+    SCHEMA = Schema()
+
+
+class ListGroupsRequest_v1(Request):
+    API_KEY = 16
+    API_VERSION = 1
+    RESPONSE_TYPE = ListGroupsResponse_v1
+    SCHEMA = ListGroupsRequest_v0.SCHEMA
+
+class ListGroupsRequest_v2(Request):
+    API_KEY = 16
+    API_VERSION = 1
+    RESPONSE_TYPE = ListGroupsResponse_v2
+    SCHEMA = ListGroupsRequest_v0.SCHEMA
+
+
+ListGroupsRequest = [
+    ListGroupsRequest_v0, ListGroupsRequest_v1,
+    ListGroupsRequest_v2,
+]
+ListGroupsResponse = [
+    ListGroupsResponse_v0, ListGroupsResponse_v1,
+    ListGroupsResponse_v2,
+]
+
+
+class DescribeGroupsResponse_v0(Response):
+    API_KEY = 15
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('groups', Array(
+            ('error_code', Int16),
+            ('group', String('utf-8')),
+            ('state', String('utf-8')),
+            ('protocol_type', String('utf-8')),
+            ('protocol', String('utf-8')),
+            ('members', Array(
+                ('member_id', String('utf-8')),
+                ('client_id', String('utf-8')),
+                ('client_host', String('utf-8')),
+                ('member_metadata', Bytes),
+                ('member_assignment', Bytes)))))
+    )
+
+
+class DescribeGroupsResponse_v1(Response):
+    API_KEY = 15
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('groups', Array(
+            ('error_code', Int16),
+            ('group', String('utf-8')),
+            ('state', String('utf-8')),
+            ('protocol_type', String('utf-8')),
+            ('protocol', String('utf-8')),
+            ('members', Array(
+                ('member_id', String('utf-8')),
+                ('client_id', String('utf-8')),
+                ('client_host', String('utf-8')),
+                ('member_metadata', Bytes),
+                ('member_assignment', Bytes)))))
+    )
+
+
+class DescribeGroupsResponse_v2(Response):
+    API_KEY = 15
+    API_VERSION = 2
+    SCHEMA = DescribeGroupsResponse_v1.SCHEMA
+
+
+class DescribeGroupsResponse_v3(Response):
+    API_KEY = 15
+    API_VERSION = 3
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('groups', Array(
+            ('error_code', Int16),
+            ('group', String('utf-8')),
+            ('state', String('utf-8')),
+            ('protocol_type', String('utf-8')),
+            ('protocol', String('utf-8')),
+            ('members', Array(
+                ('member_id', String('utf-8')),
+                ('client_id', String('utf-8')),
+                ('client_host', String('utf-8')),
+                ('member_metadata', Bytes),
+                ('member_assignment', Bytes)))),
+            ('authorized_operations', Int32))
+    )
+
+
+class DescribeGroupsRequest_v0(Request):
+    API_KEY = 15
+    API_VERSION = 0
+    RESPONSE_TYPE = DescribeGroupsResponse_v0
+    SCHEMA = Schema(
+        ('groups', Array(String('utf-8')))
+    )
+
+
+class DescribeGroupsRequest_v1(Request):
+    API_KEY = 15
+    API_VERSION = 1
+    RESPONSE_TYPE = DescribeGroupsResponse_v1
+    SCHEMA = DescribeGroupsRequest_v0.SCHEMA
+
+
+class DescribeGroupsRequest_v2(Request):
+    API_KEY = 15
+    API_VERSION = 2
+    RESPONSE_TYPE = DescribeGroupsResponse_v2
+    SCHEMA = DescribeGroupsRequest_v0.SCHEMA
+
+
+class DescribeGroupsRequest_v3(Request):
+    API_KEY = 15
+    API_VERSION = 3
+    RESPONSE_TYPE = DescribeGroupsResponse_v2
+    SCHEMA = Schema(
+        ('groups', Array(String('utf-8'))),
+        ('include_authorized_operations', Boolean)
+    )
+
+
+DescribeGroupsRequest = [
+    DescribeGroupsRequest_v0, DescribeGroupsRequest_v1,
+    DescribeGroupsRequest_v2, DescribeGroupsRequest_v3,
+]
+DescribeGroupsResponse = [
+    DescribeGroupsResponse_v0, DescribeGroupsResponse_v1,
+    DescribeGroupsResponse_v2, DescribeGroupsResponse_v3,
+]
+
+
+class SaslHandShakeResponse_v0(Response):
+    API_KEY = 17
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('enabled_mechanisms', Array(String('utf-8')))
+    )
+
+
+class SaslHandShakeResponse_v1(Response):
+    API_KEY = 17
+    API_VERSION = 1
+    SCHEMA = SaslHandShakeResponse_v0.SCHEMA
+
+
+class SaslHandShakeRequest_v0(Request):
+    API_KEY = 17
+    API_VERSION = 0
+    RESPONSE_TYPE = SaslHandShakeResponse_v0
+    SCHEMA = Schema(
+        ('mechanism', String('utf-8'))
+    )
+
+
+class SaslHandShakeRequest_v1(Request):
+    API_KEY = 17
+    API_VERSION = 1
+    RESPONSE_TYPE = SaslHandShakeResponse_v1
+    SCHEMA = SaslHandShakeRequest_v0.SCHEMA
+
+
+SaslHandShakeRequest = [SaslHandShakeRequest_v0, SaslHandShakeRequest_v1]
+SaslHandShakeResponse = [SaslHandShakeResponse_v0, SaslHandShakeResponse_v1]
+
+
+class DescribeAclsResponse_v0(Response):
+    API_KEY = 29
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('error_code', Int16),
+        ('error_message', String('utf-8')),
+        ('resources', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('acls', Array(
+                ('principal', String('utf-8')),
+                ('host', String('utf-8')),
+                ('operation', Int8),
+                ('permission_type', Int8)))))
+    )
+
+
+class DescribeAclsResponse_v1(Response):
+    API_KEY = 29
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('error_code', Int16),
+        ('error_message', String('utf-8')),
+        ('resources', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('resource_pattern_type', Int8),
+            ('acls', Array(
+                ('principal', String('utf-8')),
+                ('host', String('utf-8')),
+                ('operation', Int8),
+                ('permission_type', Int8)))))
+    )
+
+
+class DescribeAclsResponse_v2(Response):
+    API_KEY = 29
+    API_VERSION = 2
+    SCHEMA = DescribeAclsResponse_v1.SCHEMA
+
+
+class DescribeAclsRequest_v0(Request):
+    API_KEY = 29
+    API_VERSION = 0
+    RESPONSE_TYPE = DescribeAclsResponse_v0
+    SCHEMA = Schema(
+        ('resource_type', Int8),
+        ('resource_name', String('utf-8')),
+        ('principal', String('utf-8')),
+        ('host', String('utf-8')),
+        ('operation', Int8),
+        ('permission_type', Int8)
+    )
+
+
+class DescribeAclsRequest_v1(Request):
+    API_KEY = 29
+    API_VERSION = 1
+    RESPONSE_TYPE = DescribeAclsResponse_v1
+    SCHEMA = Schema(
+        ('resource_type', Int8),
+        ('resource_name', String('utf-8')),
+        ('resource_pattern_type_filter', Int8),
+        ('principal', String('utf-8')),
+        ('host', String('utf-8')),
+        ('operation', Int8),
+        ('permission_type', Int8)
+    )
+
+
+class DescribeAclsRequest_v2(Request):
+    """
+    Enable flexible version
+    """
+    API_KEY = 29
+    API_VERSION = 2
+    RESPONSE_TYPE = DescribeAclsResponse_v2
+    SCHEMA = DescribeAclsRequest_v1.SCHEMA
+
+
+DescribeAclsRequest = [DescribeAclsRequest_v0, DescribeAclsRequest_v1]
+DescribeAclsResponse = [DescribeAclsResponse_v0, DescribeAclsResponse_v1]
+
+class CreateAclsResponse_v0(Response):
+    API_KEY = 30
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('creation_responses', Array(
+            ('error_code', Int16),
+            ('error_message', String('utf-8'))))
+    )
+
+class CreateAclsResponse_v1(Response):
+    API_KEY = 30
+    API_VERSION = 1
+    SCHEMA = CreateAclsResponse_v0.SCHEMA
+
+class CreateAclsRequest_v0(Request):
+    API_KEY = 30
+    API_VERSION = 0
+    RESPONSE_TYPE = CreateAclsResponse_v0
+    SCHEMA = Schema(
+        ('creations', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('principal', String('utf-8')),
+            ('host', String('utf-8')),
+            ('operation', Int8),
+            ('permission_type', Int8)))
+    )
+
+class CreateAclsRequest_v1(Request):
+    API_KEY = 30
+    API_VERSION = 1
+    RESPONSE_TYPE = CreateAclsResponse_v1
+    SCHEMA = Schema(
+        ('creations', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('resource_pattern_type', Int8),
+            ('principal', String('utf-8')),
+            ('host', String('utf-8')),
+            ('operation', Int8),
+            ('permission_type', Int8)))
+    )
+
+CreateAclsRequest = [CreateAclsRequest_v0, CreateAclsRequest_v1]
+CreateAclsResponse = [CreateAclsResponse_v0, CreateAclsResponse_v1]
+
+class DeleteAclsResponse_v0(Response):
+    API_KEY = 31
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('filter_responses', Array(
+            ('error_code', Int16),
+            ('error_message', String('utf-8')),
+            ('matching_acls', Array(
+                ('error_code', Int16),
+                ('error_message', String('utf-8')),
+                ('resource_type', Int8),
+                ('resource_name', String('utf-8')),
+                ('principal', String('utf-8')),
+                ('host', String('utf-8')),
+                ('operation', Int8),
+                ('permission_type', Int8)))))
+    )
+
+class DeleteAclsResponse_v1(Response):
+    API_KEY = 31
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('filter_responses', Array(
+            ('error_code', Int16),
+            ('error_message', String('utf-8')),
+            ('matching_acls', Array(
+                ('error_code', Int16),
+                ('error_message', String('utf-8')),
+                ('resource_type', Int8),
+                ('resource_name', String('utf-8')),
+                ('resource_pattern_type', Int8),
+                ('principal', String('utf-8')),
+                ('host', String('utf-8')),
+                ('operation', Int8),
+                ('permission_type', Int8)))))
+    )
+
+class DeleteAclsRequest_v0(Request):
+    API_KEY = 31
+    API_VERSION = 0
+    RESPONSE_TYPE = DeleteAclsResponse_v0
+    SCHEMA = Schema(
+        ('filters', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('principal', String('utf-8')),
+            ('host', String('utf-8')),
+            ('operation', Int8),
+            ('permission_type', Int8)))
+    )
+
+class DeleteAclsRequest_v1(Request):
+    API_KEY = 31
+    API_VERSION = 1
+    RESPONSE_TYPE = DeleteAclsResponse_v1
+    SCHEMA = Schema(
+        ('filters', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('resource_pattern_type_filter', Int8),
+            ('principal', String('utf-8')),
+            ('host', String('utf-8')),
+            ('operation', Int8),
+            ('permission_type', Int8)))
+    )
+
+DeleteAclsRequest = [DeleteAclsRequest_v0, DeleteAclsRequest_v1]
+DeleteAclsResponse = [DeleteAclsResponse_v0, DeleteAclsResponse_v1]
+
+class AlterConfigsResponse_v0(Response):
+    API_KEY = 33
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('resources', Array(
+            ('error_code', Int16),
+            ('error_message', String('utf-8')),
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8'))))
+    )
+
+
+class AlterConfigsResponse_v1(Response):
+    API_KEY = 33
+    API_VERSION = 1
+    SCHEMA = AlterConfigsResponse_v0.SCHEMA
+
+
+class AlterConfigsRequest_v0(Request):
+    API_KEY = 33
+    API_VERSION = 0
+    RESPONSE_TYPE = AlterConfigsResponse_v0
+    SCHEMA = Schema(
+        ('resources', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('config_entries', Array(
+                ('config_name', String('utf-8')),
+                ('config_value', String('utf-8')))))),
+        ('validate_only', Boolean)
+    )
+
+class AlterConfigsRequest_v1(Request):
+    API_KEY = 33
+    API_VERSION = 1
+    RESPONSE_TYPE = AlterConfigsResponse_v1
+    SCHEMA = AlterConfigsRequest_v0.SCHEMA
+
+AlterConfigsRequest = [AlterConfigsRequest_v0, AlterConfigsRequest_v1]
+AlterConfigsResponse = [AlterConfigsResponse_v0, AlterConfigsRequest_v1]
+
+
+class DescribeConfigsResponse_v0(Response):
+    API_KEY = 32
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('resources', Array(
+            ('error_code', Int16),
+            ('error_message', String('utf-8')),
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('config_entries', Array(
+                ('config_names', String('utf-8')),
+                ('config_value', String('utf-8')),
+                ('read_only', Boolean),
+                ('is_default', Boolean),
+                ('is_sensitive', Boolean)))))
+    )
+
+class DescribeConfigsResponse_v1(Response):
+    API_KEY = 32
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('resources', Array(
+            ('error_code', Int16),
+            ('error_message', String('utf-8')),
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('config_entries', Array(
+                ('config_names', String('utf-8')),
+                ('config_value', String('utf-8')),
+                ('read_only', Boolean),
+                ('is_default', Boolean),
+                ('is_sensitive', Boolean),
+                ('config_synonyms', Array(
+                    ('config_name', String('utf-8')),
+                    ('config_value', String('utf-8')),
+                    ('config_source', Int8)))))))
+    )
+
+class DescribeConfigsResponse_v2(Response):
+    API_KEY = 32
+    API_VERSION = 2
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('resources', Array(
+            ('error_code', Int16),
+            ('error_message', String('utf-8')),
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('config_entries', Array(
+                ('config_names', String('utf-8')),
+                ('config_value', String('utf-8')),
+                ('read_only', Boolean),
+                ('config_source', Int8),
+                ('is_sensitive', Boolean),
+                ('config_synonyms', Array(
+                    ('config_name', String('utf-8')),
+                    ('config_value', String('utf-8')),
+                    ('config_source', Int8)))))))
+    )
+
+class DescribeConfigsRequest_v0(Request):
+    API_KEY = 32
+    API_VERSION = 0
+    RESPONSE_TYPE = DescribeConfigsResponse_v0
+    SCHEMA = Schema(
+        ('resources', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('config_names', Array(String('utf-8')))))
+    )
+
+class DescribeConfigsRequest_v1(Request):
+    API_KEY = 32
+    API_VERSION = 1
+    RESPONSE_TYPE = DescribeConfigsResponse_v1
+    SCHEMA = Schema(
+        ('resources', Array(
+            ('resource_type', Int8),
+            ('resource_name', String('utf-8')),
+            ('config_names', Array(String('utf-8'))))),
+        ('include_synonyms', Boolean)
+    )
+
+
+class DescribeConfigsRequest_v2(Request):
+    API_KEY = 32
+    API_VERSION = 2
+    RESPONSE_TYPE = DescribeConfigsResponse_v2
+    SCHEMA = DescribeConfigsRequest_v1.SCHEMA
+
+
+DescribeConfigsRequest = [
+    DescribeConfigsRequest_v0, DescribeConfigsRequest_v1,
+    DescribeConfigsRequest_v2,
+]
+DescribeConfigsResponse = [
+    DescribeConfigsResponse_v0, DescribeConfigsResponse_v1,
+    DescribeConfigsResponse_v2,
+]
+
+
+class SaslAuthenticateResponse_v0(Response):
+    API_KEY = 36
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('error_message', String('utf-8')),
+        ('sasl_auth_bytes', Bytes)
+    )
+
+
+class SaslAuthenticateResponse_v1(Response):
+    API_KEY = 36
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('error_message', String('utf-8')),
+        ('sasl_auth_bytes', Bytes),
+        ('session_lifetime_ms', Int64)
+    )
+
+
+class SaslAuthenticateRequest_v0(Request):
+    API_KEY = 36
+    API_VERSION = 0
+    RESPONSE_TYPE = SaslAuthenticateResponse_v0
+    SCHEMA = Schema(
+        ('sasl_auth_bytes', Bytes)
+    )
+
+
+class SaslAuthenticateRequest_v1(Request):
+    API_KEY = 36
+    API_VERSION = 1
+    RESPONSE_TYPE = SaslAuthenticateResponse_v1
+    SCHEMA = SaslAuthenticateRequest_v0.SCHEMA
+
+
+SaslAuthenticateRequest = [
+    SaslAuthenticateRequest_v0, SaslAuthenticateRequest_v1,
+]
+SaslAuthenticateResponse = [
+    SaslAuthenticateResponse_v0, SaslAuthenticateResponse_v1,
+]
+
+
+class CreatePartitionsResponse_v0(Response):
+    API_KEY = 37
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topic_errors', Array(
+            ('topic', String('utf-8')),
+            ('error_code', Int16),
+            ('error_message', String('utf-8'))))
+    )
+
+
+class CreatePartitionsResponse_v1(Response):
+    API_KEY = 37
+    API_VERSION = 1
+    SCHEMA = CreatePartitionsResponse_v0.SCHEMA
+
+
+class CreatePartitionsRequest_v0(Request):
+    API_KEY = 37
+    API_VERSION = 0
+    RESPONSE_TYPE = CreatePartitionsResponse_v0
+    SCHEMA = Schema(
+        ('topic_partitions', Array(
+            ('topic', String('utf-8')),
+            ('new_partitions', Schema(
+                ('count', Int32),
+                ('assignment', Array(Array(Int32))))))),
+        ('timeout', Int32),
+        ('validate_only', Boolean)
+    )
+
+
+class CreatePartitionsRequest_v1(Request):
+    API_KEY = 37
+    API_VERSION = 1
+    SCHEMA = CreatePartitionsRequest_v0.SCHEMA
+    RESPONSE_TYPE = CreatePartitionsResponse_v1
+
+
+CreatePartitionsRequest = [
+    CreatePartitionsRequest_v0, CreatePartitionsRequest_v1,
+]
+CreatePartitionsResponse = [
+    CreatePartitionsResponse_v0, CreatePartitionsResponse_v1,
+]
+
+
+class DeleteGroupsResponse_v0(Response):
+    API_KEY = 42
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ("throttle_time_ms", Int32),
+        ("results", Array(
+            ("group_id", String("utf-8")),
+            ("error_code", Int16)))
+    )
+
+
+class DeleteGroupsResponse_v1(Response):
+    API_KEY = 42
+    API_VERSION = 1
+    SCHEMA = DeleteGroupsResponse_v0.SCHEMA
+
+
+class DeleteGroupsRequest_v0(Request):
+    API_KEY = 42
+    API_VERSION = 0
+    RESPONSE_TYPE = DeleteGroupsResponse_v0
+    SCHEMA = Schema(
+        ("groups_names", Array(String("utf-8")))
+    )
+
+
+class DeleteGroupsRequest_v1(Request):
+    API_KEY = 42
+    API_VERSION = 1
+    RESPONSE_TYPE = DeleteGroupsResponse_v1
+    SCHEMA = DeleteGroupsRequest_v0.SCHEMA
+
+
+DeleteGroupsRequest = [
+    DeleteGroupsRequest_v0, DeleteGroupsRequest_v1
+]
+
+DeleteGroupsResponse = [
+    DeleteGroupsResponse_v0, DeleteGroupsResponse_v1
+]
+
+
+class DescribeClientQuotasResponse_v0(Request):
+    API_KEY = 48
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('error_code', Int16),
+        ('error_message', String('utf-8')),
+        ('entries', Array(
+            ('entity', Array(
+                ('entity_type', String('utf-8')),
+                ('entity_name', String('utf-8')))),
+            ('values', Array(
+                ('name', String('utf-8')),
+                ('value', Float64))))),
+    )
+
+
+class DescribeClientQuotasRequest_v0(Request):
+    API_KEY = 48
+    API_VERSION = 0
+    RESPONSE_TYPE = DescribeClientQuotasResponse_v0
+    SCHEMA = Schema(
+        ('components', Array(
+            ('entity_type', String('utf-8')),
+            ('match_type', Int8),
+            ('match', String('utf-8')),
+        )),
+        ('strict', Boolean)
+    )
+
+
+DescribeClientQuotasRequest = [
+    DescribeClientQuotasRequest_v0,
+]
+
+DescribeClientQuotasResponse = [
+    DescribeClientQuotasResponse_v0,
+]

testbed/dpkp__kafka-python/kafka/protocol/api.py

@@ -0,0 +1,97 @@
+from __future__ import absolute_import
+
+import abc
+
+from kafka.protocol.struct import Struct
+from kafka.protocol.types import Int16, Int32, String, Schema, Array
+
+
+class RequestHeader(Struct):
+    SCHEMA = Schema(
+        ('api_key', Int16),
+        ('api_version', Int16),
+        ('correlation_id', Int32),
+        ('client_id', String('utf-8'))
+    )
+
+    def __init__(self, request, correlation_id=0, client_id='kafka-python'):
+        super(RequestHeader, self).__init__(
+            request.API_KEY, request.API_VERSION, correlation_id, client_id
+        )
+
+
+class Request(Struct):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractproperty
+    def API_KEY(self):
+        """Integer identifier for api request"""
+        pass
+
+    @abc.abstractproperty
+    def API_VERSION(self):
+        """Integer of api request version"""
+        pass
+
+    @abc.abstractproperty
+    def SCHEMA(self):
+        """An instance of Schema() representing the request structure"""
+        pass
+
+    @abc.abstractproperty
+    def RESPONSE_TYPE(self):
+        """The Response class associated with the api request"""
+        pass
+
+    def expect_response(self):
+        """Override this method if an api request does not always generate a response"""
+        return True
+
+    def to_object(self):
+        return _to_object(self.SCHEMA, self)
+
+
+class Response(Struct):
+    __metaclass__ = abc.ABCMeta
+
+    @abc.abstractproperty
+    def API_KEY(self):
+        """Integer identifier for api request/response"""
+        pass
+
+    @abc.abstractproperty
+    def API_VERSION(self):
+        """Integer of api request/response version"""
+        pass
+
+    @abc.abstractproperty
+    def SCHEMA(self):
+        """An instance of Schema() representing the response structure"""
+        pass
+
+    def to_object(self):
+        return _to_object(self.SCHEMA, self)
+
+
+def _to_object(schema, data):
+    obj = {}
+    for idx, (name, _type) in enumerate(zip(schema.names, schema.fields)):
+        if isinstance(data, Struct):
+            val = data.get_item(name)
+        else:
+            val = data[idx]
+
+        if isinstance(_type, Schema):
+            obj[name] = _to_object(_type, val)
+        elif isinstance(_type, Array):
+            if isinstance(_type.array_of, (Array, Schema)):
+                obj[name] = [
+                    _to_object(_type.array_of, x)
+                    for x in val
+                ]
+            else:
+                obj[name] = val
+        else:
+            obj[name] = val
+
+    return obj

testbed/dpkp__kafka-python/kafka/protocol/commit.py

@@ -0,0 +1,255 @@
+from __future__ import absolute_import
+
+from kafka.protocol.api import Request, Response
+from kafka.protocol.types import Array, Int8, Int16, Int32, Int64, Schema, String
+
+
+class OffsetCommitResponse_v0(Response):
+    API_KEY = 8
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16)))))
+    )
+
+
+class OffsetCommitResponse_v1(Response):
+    API_KEY = 8
+    API_VERSION = 1
+    SCHEMA = OffsetCommitResponse_v0.SCHEMA
+
+
+class OffsetCommitResponse_v2(Response):
+    API_KEY = 8
+    API_VERSION = 2
+    SCHEMA = OffsetCommitResponse_v1.SCHEMA
+
+
+class OffsetCommitResponse_v3(Response):
+    API_KEY = 8
+    API_VERSION = 3
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16)))))
+    )
+
+
+class OffsetCommitRequest_v0(Request):
+    API_KEY = 8
+    API_VERSION = 0  # Zookeeper-backed storage
+    RESPONSE_TYPE = OffsetCommitResponse_v0
+    SCHEMA = Schema(
+        ('consumer_group', String('utf-8')),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('metadata', String('utf-8'))))))
+    )
+
+
+class OffsetCommitRequest_v1(Request):
+    API_KEY = 8
+    API_VERSION = 1  # Kafka-backed storage
+    RESPONSE_TYPE = OffsetCommitResponse_v1
+    SCHEMA = Schema(
+        ('consumer_group', String('utf-8')),
+        ('consumer_group_generation_id', Int32),
+        ('consumer_id', String('utf-8')),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('timestamp', Int64),
+                ('metadata', String('utf-8'))))))
+    )
+
+
+class OffsetCommitRequest_v2(Request):
+    API_KEY = 8
+    API_VERSION = 2  # added retention_time, dropped timestamp
+    RESPONSE_TYPE = OffsetCommitResponse_v2
+    SCHEMA = Schema(
+        ('consumer_group', String('utf-8')),
+        ('consumer_group_generation_id', Int32),
+        ('consumer_id', String('utf-8')),
+        ('retention_time', Int64),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('metadata', String('utf-8'))))))
+    )
+    DEFAULT_GENERATION_ID = -1
+    DEFAULT_RETENTION_TIME = -1
+
+
+class OffsetCommitRequest_v3(Request):
+    API_KEY = 8
+    API_VERSION = 3
+    RESPONSE_TYPE = OffsetCommitResponse_v3
+    SCHEMA = OffsetCommitRequest_v2.SCHEMA
+
+
+OffsetCommitRequest = [
+    OffsetCommitRequest_v0, OffsetCommitRequest_v1,
+    OffsetCommitRequest_v2, OffsetCommitRequest_v3
+]
+OffsetCommitResponse = [
+    OffsetCommitResponse_v0, OffsetCommitResponse_v1,
+    OffsetCommitResponse_v2, OffsetCommitResponse_v3
+]
+
+
+class OffsetFetchResponse_v0(Response):
+    API_KEY = 9
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('metadata', String('utf-8')),
+                ('error_code', Int16)))))
+    )
+
+
+class OffsetFetchResponse_v1(Response):
+    API_KEY = 9
+    API_VERSION = 1
+    SCHEMA = OffsetFetchResponse_v0.SCHEMA
+
+
+class OffsetFetchResponse_v2(Response):
+    # Added in KIP-88
+    API_KEY = 9
+    API_VERSION = 2
+    SCHEMA = Schema(
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('metadata', String('utf-8')),
+                ('error_code', Int16))))),
+        ('error_code', Int16)
+    )
+
+
+class OffsetFetchResponse_v3(Response):
+    API_KEY = 9
+    API_VERSION = 3
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('metadata', String('utf-8')),
+                ('error_code', Int16))))),
+        ('error_code', Int16)
+    )
+
+
+class OffsetFetchRequest_v0(Request):
+    API_KEY = 9
+    API_VERSION = 0  # zookeeper-backed storage
+    RESPONSE_TYPE = OffsetFetchResponse_v0
+    SCHEMA = Schema(
+        ('consumer_group', String('utf-8')),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(Int32))))
+    )
+
+
+class OffsetFetchRequest_v1(Request):
+    API_KEY = 9
+    API_VERSION = 1  # kafka-backed storage
+    RESPONSE_TYPE = OffsetFetchResponse_v1
+    SCHEMA = OffsetFetchRequest_v0.SCHEMA
+
+
+class OffsetFetchRequest_v2(Request):
+    # KIP-88: Allows passing null topics to return offsets for all partitions
+    # that the consumer group has a stored offset for, even if no consumer in
+    # the group is currently consuming that partition.
+    API_KEY = 9
+    API_VERSION = 2
+    RESPONSE_TYPE = OffsetFetchResponse_v2
+    SCHEMA = OffsetFetchRequest_v1.SCHEMA
+
+
+class OffsetFetchRequest_v3(Request):
+    API_KEY = 9
+    API_VERSION = 3
+    RESPONSE_TYPE = OffsetFetchResponse_v3
+    SCHEMA = OffsetFetchRequest_v2.SCHEMA
+
+
+OffsetFetchRequest = [
+    OffsetFetchRequest_v0, OffsetFetchRequest_v1,
+    OffsetFetchRequest_v2, OffsetFetchRequest_v3,
+]
+OffsetFetchResponse = [
+    OffsetFetchResponse_v0, OffsetFetchResponse_v1,
+    OffsetFetchResponse_v2, OffsetFetchResponse_v3,
+]
+
+
+class GroupCoordinatorResponse_v0(Response):
+    API_KEY = 10
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('coordinator_id', Int32),
+        ('host', String('utf-8')),
+        ('port', Int32)
+    )
+
+
+class GroupCoordinatorResponse_v1(Response):
+    API_KEY = 10
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('error_code', Int16),
+        ('error_message', String('utf-8')),
+        ('coordinator_id', Int32),
+        ('host', String('utf-8')),
+        ('port', Int32)
+    )
+
+
+class GroupCoordinatorRequest_v0(Request):
+    API_KEY = 10
+    API_VERSION = 0
+    RESPONSE_TYPE = GroupCoordinatorResponse_v0
+    SCHEMA = Schema(
+        ('consumer_group', String('utf-8'))
+    )
+
+
+class GroupCoordinatorRequest_v1(Request):
+    API_KEY = 10
+    API_VERSION = 1
+    RESPONSE_TYPE = GroupCoordinatorResponse_v1
+    SCHEMA = Schema(
+        ('coordinator_key', String('utf-8')),
+        ('coordinator_type', Int8)
+    )
+
+
+GroupCoordinatorRequest = [GroupCoordinatorRequest_v0, GroupCoordinatorRequest_v1]
+GroupCoordinatorResponse = [GroupCoordinatorResponse_v0, GroupCoordinatorResponse_v1]

testbed/dpkp__kafka-python/kafka/protocol/fetch.py

@@ -0,0 +1,386 @@
+from __future__ import absolute_import
+
+from kafka.protocol.api import Request, Response
+from kafka.protocol.types import Array, Int8, Int16, Int32, Int64, Schema, String, Bytes
+
+
+class FetchResponse_v0(Response):
+    API_KEY = 1
+    API_VERSION = 0
+    SCHEMA = Schema(
+        ('topics', Array(
+            ('topics', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16),
+                ('highwater_offset', Int64),
+                ('message_set', Bytes)))))
+    )
+
+
+class FetchResponse_v1(Response):
+    API_KEY = 1
+    API_VERSION = 1
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topics', Array(
+            ('topics', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16),
+                ('highwater_offset', Int64),
+                ('message_set', Bytes)))))
+    )
+
+
+class FetchResponse_v2(Response):
+    API_KEY = 1
+    API_VERSION = 2
+    SCHEMA = FetchResponse_v1.SCHEMA  # message format changed internally
+
+
+class FetchResponse_v3(Response):
+    API_KEY = 1
+    API_VERSION = 3
+    SCHEMA = FetchResponse_v2.SCHEMA
+
+
+class FetchResponse_v4(Response):
+    API_KEY = 1
+    API_VERSION = 4
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topics', Array(
+            ('topics', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16),
+                ('highwater_offset', Int64),
+                ('last_stable_offset', Int64),
+                ('aborted_transactions', Array(
+                    ('producer_id', Int64),
+                    ('first_offset', Int64))),
+                ('message_set', Bytes)))))
+    )
+
+
+class FetchResponse_v5(Response):
+    API_KEY = 1
+    API_VERSION = 5
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('topics', Array(
+            ('topics', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16),
+                ('highwater_offset', Int64),
+                ('last_stable_offset', Int64),
+                ('log_start_offset', Int64),
+                ('aborted_transactions', Array(
+                    ('producer_id', Int64),
+                    ('first_offset', Int64))),
+                ('message_set', Bytes)))))
+    )
+
+
+class FetchResponse_v6(Response):
+    """
+    Same as FetchResponse_v5. The version number is bumped up to indicate that the client supports KafkaStorageException.
+    The KafkaStorageException will be translated to NotLeaderForPartitionException in the response if version <= 5
+    """
+    API_KEY = 1
+    API_VERSION = 6
+    SCHEMA = FetchResponse_v5.SCHEMA
+
+
+class FetchResponse_v7(Response):
+    """
+    Add error_code and session_id to response
+    """
+    API_KEY = 1
+    API_VERSION = 7
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('error_code', Int16),
+        ('session_id', Int32),
+        ('topics', Array(
+            ('topics', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16),
+                ('highwater_offset', Int64),
+                ('last_stable_offset', Int64),
+                ('log_start_offset', Int64),
+                ('aborted_transactions', Array(
+                    ('producer_id', Int64),
+                    ('first_offset', Int64))),
+                ('message_set', Bytes)))))
+    )
+
+
+class FetchResponse_v8(Response):
+    API_KEY = 1
+    API_VERSION = 8
+    SCHEMA = FetchResponse_v7.SCHEMA
+
+
+class FetchResponse_v9(Response):
+    API_KEY = 1
+    API_VERSION = 9
+    SCHEMA = FetchResponse_v7.SCHEMA
+
+
+class FetchResponse_v10(Response):
+    API_KEY = 1
+    API_VERSION = 10
+    SCHEMA = FetchResponse_v7.SCHEMA
+
+
+class FetchResponse_v11(Response):
+    API_KEY = 1
+    API_VERSION = 11
+    SCHEMA = Schema(
+        ('throttle_time_ms', Int32),
+        ('error_code', Int16),
+        ('session_id', Int32),
+        ('topics', Array(
+            ('topics', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('error_code', Int16),
+                ('highwater_offset', Int64),
+                ('last_stable_offset', Int64),
+                ('log_start_offset', Int64),
+                ('aborted_transactions', Array(
+                    ('producer_id', Int64),
+                    ('first_offset', Int64))),
+                ('preferred_read_replica', Int32),
+                ('message_set', Bytes)))))
+    )
+
+
+class FetchRequest_v0(Request):
+    API_KEY = 1
+    API_VERSION = 0
+    RESPONSE_TYPE = FetchResponse_v0
+    SCHEMA = Schema(
+        ('replica_id', Int32),
+        ('max_wait_time', Int32),
+        ('min_bytes', Int32),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('max_bytes', Int32)))))
+    )
+
+
+class FetchRequest_v1(Request):
+    API_KEY = 1
+    API_VERSION = 1
+    RESPONSE_TYPE = FetchResponse_v1
+    SCHEMA = FetchRequest_v0.SCHEMA
+
+
+class FetchRequest_v2(Request):
+    API_KEY = 1
+    API_VERSION = 2
+    RESPONSE_TYPE = FetchResponse_v2
+    SCHEMA = FetchRequest_v1.SCHEMA
+
+
+class FetchRequest_v3(Request):
+    API_KEY = 1
+    API_VERSION = 3
+    RESPONSE_TYPE = FetchResponse_v3
+    SCHEMA = Schema(
+        ('replica_id', Int32),
+        ('max_wait_time', Int32),
+        ('min_bytes', Int32),
+        ('max_bytes', Int32),  # This new field is only difference from FR_v2
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('max_bytes', Int32)))))
+    )
+
+
+class FetchRequest_v4(Request):
+    # Adds isolation_level field
+    API_KEY = 1
+    API_VERSION = 4
+    RESPONSE_TYPE = FetchResponse_v4
+    SCHEMA = Schema(
+        ('replica_id', Int32),
+        ('max_wait_time', Int32),
+        ('min_bytes', Int32),
+        ('max_bytes', Int32),
+        ('isolation_level', Int8),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('offset', Int64),
+                ('max_bytes', Int32)))))
+    )
+
+
+class FetchRequest_v5(Request):
+    # This may only be used in broker-broker api calls
+    API_KEY = 1
+    API_VERSION = 5
+    RESPONSE_TYPE = FetchResponse_v5
+    SCHEMA = Schema(
+        ('replica_id', Int32),
+        ('max_wait_time', Int32),
+        ('min_bytes', Int32),
+        ('max_bytes', Int32),
+        ('isolation_level', Int8),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('fetch_offset', Int64),
+                ('log_start_offset', Int64),
+                ('max_bytes', Int32)))))
+    )
+
+
+class FetchRequest_v6(Request):
+    """
+    The body of FETCH_REQUEST_V6 is the same as FETCH_REQUEST_V5.
+    The version number is bumped up to indicate that the client supports KafkaStorageException.
+    The KafkaStorageException will be translated to NotLeaderForPartitionException in the response if version <= 5
+    """
+    API_KEY = 1
+    API_VERSION = 6
+    RESPONSE_TYPE = FetchResponse_v6
+    SCHEMA = FetchRequest_v5.SCHEMA
+
+
+class FetchRequest_v7(Request):
+    """
+    Add incremental fetch requests
+    """
+    API_KEY = 1
+    API_VERSION = 7
+    RESPONSE_TYPE = FetchResponse_v7
+    SCHEMA = Schema(
+        ('replica_id', Int32),
+        ('max_wait_time', Int32),
+        ('min_bytes', Int32),
+        ('max_bytes', Int32),
+        ('isolation_level', Int8),
+        ('session_id', Int32),
+        ('session_epoch', Int32),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('fetch_offset', Int64),
+                ('log_start_offset', Int64),
+                ('max_bytes', Int32))))),
+        ('forgotten_topics_data', Array(
+            ('topic', String),
+            ('partitions', Array(Int32))
+        )),
+    )
+
+
+class FetchRequest_v8(Request):
+    """
+    bump used to indicate that on quota violation brokers send out responses before throttling.
+    """
+    API_KEY = 1
+    API_VERSION = 8
+    RESPONSE_TYPE = FetchResponse_v8
+    SCHEMA = FetchRequest_v7.SCHEMA
+
+
+class FetchRequest_v9(Request):
+    """
+    adds the current leader epoch (see KIP-320)
+    """
+    API_KEY = 1
+    API_VERSION = 9
+    RESPONSE_TYPE = FetchResponse_v9
+    SCHEMA = Schema(
+        ('replica_id', Int32),
+        ('max_wait_time', Int32),
+        ('min_bytes', Int32),
+        ('max_bytes', Int32),
+        ('isolation_level', Int8),
+        ('session_id', Int32),
+        ('session_epoch', Int32),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('current_leader_epoch', Int32),
+                ('fetch_offset', Int64),
+                ('log_start_offset', Int64),
+                ('max_bytes', Int32))))),
+        ('forgotten_topics_data', Array(
+            ('topic', String),
+            ('partitions', Array(Int32)),
+        )),
+    )
+
+
+class FetchRequest_v10(Request):
+    """
+    bumped up to indicate ZStandard capability. (see KIP-110)
+    """
+    API_KEY = 1
+    API_VERSION = 10
+    RESPONSE_TYPE = FetchResponse_v10
+    SCHEMA = FetchRequest_v9.SCHEMA
+
+
+class FetchRequest_v11(Request):
+    """
+    added rack ID to support read from followers (KIP-392)
+    """
+    API_KEY = 1
+    API_VERSION = 11
+    RESPONSE_TYPE = FetchResponse_v11
+    SCHEMA = Schema(
+        ('replica_id', Int32),
+        ('max_wait_time', Int32),
+        ('min_bytes', Int32),
+        ('max_bytes', Int32),
+        ('isolation_level', Int8),
+        ('session_id', Int32),
+        ('session_epoch', Int32),
+        ('topics', Array(
+            ('topic', String('utf-8')),
+            ('partitions', Array(
+                ('partition', Int32),
+                ('current_leader_epoch', Int32),
+                ('fetch_offset', Int64),
+                ('log_start_offset', Int64),
+                ('max_bytes', Int32))))),
+        ('forgotten_topics_data', Array(
+            ('topic', String),
+            ('partitions', Array(Int32))
+        )),
+        ('rack_id', String('utf-8')),
+    )
+
+
+FetchRequest = [
+    FetchRequest_v0, FetchRequest_v1, FetchRequest_v2,
+    FetchRequest_v3, FetchRequest_v4, FetchRequest_v5,
+    FetchRequest_v6, FetchRequest_v7, FetchRequest_v8,
+    FetchRequest_v9, FetchRequest_v10, FetchRequest_v11,
+]
+FetchResponse = [
+    FetchResponse_v0, FetchResponse_v1, FetchResponse_v2,
+    FetchResponse_v3, FetchResponse_v4, FetchResponse_v5,
+    FetchResponse_v6, FetchResponse_v7, FetchResponse_v8,
+    FetchResponse_v9, FetchResponse_v10, FetchResponse_v11,
+]

testbed/dpkp__kafka-python/kafka/protocol/frame.py

@@ -0,0 +1,30 @@
+class KafkaBytes(bytearray):
+    def __init__(self, size):
+        super(KafkaBytes, self).__init__(size)
+        self._idx = 0
+
+    def read(self, nbytes=None):
+        if nbytes is None:
+            nbytes = len(self) - self._idx
+        start = self._idx
+        self._idx += nbytes
+        if self._idx > len(self):
+            self._idx = len(self)
+        return bytes(self[start:self._idx])
+
+    def write(self, data):
+        start = self._idx
+        self._idx += len(data)
+        self[start:self._idx] = data
+
+    def seek(self, idx):
+        self._idx = idx
+
+    def tell(self):
+        return self._idx
+
+    def __str__(self):
+        return 'KafkaBytes(%d)' % len(self)
+
+    def __repr__(self):
+        return str(self)

testbed/dpkp__kafka-python/kafka/protocol/message.py

@@ -0,0 +1,216 @@
+from __future__ import absolute_import
+
+import io
+import time
+
+from kafka.codec import (has_gzip, has_snappy, has_lz4, has_zstd,
+                     gzip_decode, snappy_decode, zstd_decode,
+                     lz4_decode, lz4_decode_old_kafka)
+from kafka.protocol.frame import KafkaBytes
+from kafka.protocol.struct import Struct
+from kafka.protocol.types import (
+    Int8, Int32, Int64, Bytes, Schema, AbstractType
+)
+from kafka.util import crc32, WeakMethod
+
+
+class Message(Struct):
+    SCHEMAS = [
+        Schema(
+            ('crc', Int32),
+            ('magic', Int8),
+            ('attributes', Int8),
+            ('key', Bytes),
+            ('value', Bytes)),
+        Schema(
+            ('crc', Int32),
+            ('magic', Int8),
+            ('attributes', Int8),
+            ('timestamp', Int64),
+            ('key', Bytes),
+            ('value', Bytes)),
+    ]
+    SCHEMA = SCHEMAS[1]
+    CODEC_MASK = 0x07
+    CODEC_GZIP = 0x01
+    CODEC_SNAPPY = 0x02
+    CODEC_LZ4 = 0x03
+    CODEC_ZSTD = 0x04
+    TIMESTAMP_TYPE_MASK = 0x08
+    HEADER_SIZE = 22  # crc(4), magic(1), attributes(1), timestamp(8), key+value size(4*2)
+
+    def __init__(self, value, key=None, magic=0, attributes=0, crc=0,
+                 timestamp=None):
+        assert value is None or isinstance(value, bytes), 'value must be bytes'
+        assert key is None or isinstance(key, bytes), 'key must be bytes'
+        assert magic > 0 or timestamp is None, 'timestamp not supported in v0'
+
+        # Default timestamp to now for v1 messages
+        if magic > 0 and timestamp is None:
+            timestamp = int(time.time() * 1000)
+        self.timestamp = timestamp
+        self.crc = crc
+        self._validated_crc = None
+        self.magic = magic
+        self.attributes = attributes
+        self.key = key
+        self.value = value
+        self.encode = WeakMethod(self._encode_self)
+
+    @property
+    def timestamp_type(self):
+        """0 for CreateTime; 1 for LogAppendTime; None if unsupported.
+
+        Value is determined by broker; produced messages should always set to 0
+        Requires Kafka >= 0.10 / message version >= 1
+        """
+        if self.magic == 0:
+            return None
+        elif self.attributes & self.TIMESTAMP_TYPE_MASK:
+            return 1
+        else:
+            return 0
+
+    def _encode_self(self, recalc_crc=True):
+        version = self.magic
+        if version == 1:
+            fields = (self.crc, self.magic, self.attributes, self.timestamp, self.key, self.value)
+        elif version == 0:
+            fields = (self.crc, self.magic, self.attributes, self.key, self.value)
+        else:
+            raise ValueError('Unrecognized message version: %s' % (version,))
+        message = Message.SCHEMAS[version].encode(fields)
+        if not recalc_crc:
+            return message
+        self.crc = crc32(message[4:])
+        crc_field = self.SCHEMAS[version].fields[0]
+        return crc_field.encode(self.crc) + message[4:]
+
+    @classmethod
+    def decode(cls, data):
+        _validated_crc = None
+        if isinstance(data, bytes):
+            _validated_crc = crc32(data[4:])
+            data = io.BytesIO(data)
+        # Partial decode required to determine message version
+        base_fields = cls.SCHEMAS[0].fields[0:3]
+        crc, magic, attributes = [field.decode(data) for field in base_fields]
+        remaining = cls.SCHEMAS[magic].fields[3:]
+        fields = [field.decode(data) for field in remaining]
+        if magic == 1:
+            timestamp = fields[0]
+        else:
+            timestamp = None
+        msg = cls(fields[-1], key=fields[-2],
+                  magic=magic, attributes=attributes, crc=crc,
+                  timestamp=timestamp)
+        msg._validated_crc = _validated_crc
+        return msg
+
+    def validate_crc(self):
+        if self._validated_crc is None:
+            raw_msg = self._encode_self(recalc_crc=False)
+            self._validated_crc = crc32(raw_msg[4:])
+        if self.crc == self._validated_crc:
+            return True
+        return False
+
+    def is_compressed(self):
+        return self.attributes & self.CODEC_MASK != 0
+
+    def decompress(self):
+        codec = self.attributes & self.CODEC_MASK
+        assert codec in (self.CODEC_GZIP, self.CODEC_SNAPPY, self.CODEC_LZ4, self.CODEC_ZSTD)
+        if codec == self.CODEC_GZIP:
+            assert has_gzip(), 'Gzip decompression unsupported'
+            raw_bytes = gzip_decode(self.value)
+        elif codec == self.CODEC_SNAPPY:
+            assert has_snappy(), 'Snappy decompression unsupported'
+            raw_bytes = snappy_decode(self.value)
+        elif codec == self.CODEC_LZ4:
+            assert has_lz4(), 'LZ4 decompression unsupported'
+            if self.magic == 0:
+                raw_bytes = lz4_decode_old_kafka(self.value)
+            else:
+                raw_bytes = lz4_decode(self.value)
+        elif codec == self.CODEC_ZSTD:
+            assert has_zstd(), "ZSTD decompression unsupported"
+            raw_bytes = zstd_decode(self.value)
+        else:
+            raise Exception('This should be impossible')
+
+        return MessageSet.decode(raw_bytes, bytes_to_read=len(raw_bytes))
+
+    def __hash__(self):
+        return hash(self._encode_self(recalc_crc=False))
+
+
+class PartialMessage(bytes):
+    def __repr__(self):
+        return 'PartialMessage(%s)' % (self,)
+
+
+class MessageSet(AbstractType):
+    ITEM = Schema(
+        ('offset', Int64),
+        ('message', Bytes)
+    )
+    HEADER_SIZE = 12  # offset + message_size
+
+    @classmethod
+    def encode(cls, items, prepend_size=True):
+        # RecordAccumulator encodes messagesets internally
+        if isinstance(items, (io.BytesIO, KafkaBytes)):
+            size = Int32.decode(items)
+            if prepend_size:
+                # rewind and return all the bytes
+                items.seek(items.tell() - 4)
+                size += 4
+            return items.read(size)
+
+        encoded_values = []
+        for (offset, message) in items:
+            encoded_values.append(Int64.encode(offset))
+            encoded_values.append(Bytes.encode(message))
+        encoded = b''.join(encoded_values)
+        if prepend_size:
+            return Bytes.encode(encoded)
+        else:
+            return encoded
+
+    @classmethod
+    def decode(cls, data, bytes_to_read=None):
+        """Compressed messages should pass in bytes_to_read (via message size)
+        otherwise, we decode from data as Int32
+        """
+        if isinstance(data, bytes):
+            data = io.BytesIO(data)
+        if bytes_to_read is None:
+            bytes_to_read = Int32.decode(data)
+
+        # if FetchRequest max_bytes is smaller than the available message set
+        # the server returns partial data for the final message
+        # So create an internal buffer to avoid over-reading
+        raw = io.BytesIO(data.read(bytes_to_read))
+
+        items = []
+        while bytes_to_read:
+            try:
+                offset = Int64.decode(raw)
+                msg_bytes = Bytes.decode(raw)
+                bytes_to_read -= 8 + 4 + len(msg_bytes)
+                items.append((offset, len(msg_bytes), Message.decode(msg_bytes)))
+            except ValueError:
+                # PartialMessage to signal that max_bytes may be too small
+                items.append((None, None, PartialMessage()))
+                break
+        return items
+
+    @classmethod
+    def repr(cls, messages):
+        if isinstance(messages, (KafkaBytes, io.BytesIO)):
+            offset = messages.tell()
+            decoded = cls.decode(messages)
+            messages.seek(offset)
+            messages = decoded
+        return str([cls.ITEM.repr(m) for m in messages])