librdkafka
The Apache Kafka C/C++ client library
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
rdkafka.h
Go to the documentation of this file.
1 /*
2  * librdkafka - Apache Kafka C library
3  *
4  * Copyright (c) 2012-2020 Magnus Edenhill
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright notice,
11  * this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright notice,
13  * this list of conditions and the following disclaimer in the documentation
14  * and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
28 
43 /* @cond NO_DOC */
44 #ifndef _RDKAFKA_H_
45 #define _RDKAFKA_H_
46 
47 #include <stdio.h>
48 #include <inttypes.h>
49 #include <sys/types.h>
50 
51 #ifdef __cplusplus
52 extern "C" {
53 #if 0
54 } /* Restore indent */
55 #endif
56 #endif
57 
58 #ifdef _WIN32
59 #include <basetsd.h>
60 #ifndef WIN32_MEAN_AND_LEAN
61 #define WIN32_MEAN_AND_LEAN
62 #endif
63 #include <winsock2.h> /* for sockaddr, .. */
64 #ifndef _SSIZE_T_DEFINED
65 #define _SSIZE_T_DEFINED
66 typedef SSIZE_T ssize_t;
67 #endif
68 #define RD_UNUSED
69 #define RD_INLINE __inline
70 #define RD_DEPRECATED __declspec(deprecated)
71 #undef RD_EXPORT
72 #ifdef LIBRDKAFKA_STATICLIB
73 #define RD_EXPORT
74 #else
75 #ifdef LIBRDKAFKA_EXPORTS
76 #define RD_EXPORT __declspec(dllexport)
77 #else
78 #define RD_EXPORT __declspec(dllimport)
79 #endif
80 #ifndef LIBRDKAFKA_TYPECHECKS
81 #define LIBRDKAFKA_TYPECHECKS 0
82 #endif
83 #endif
84 
85 #else
86 #include <sys/socket.h> /* for sockaddr, .. */
87 
88 #define RD_UNUSED __attribute__((unused))
89 #define RD_INLINE inline
90 #define RD_EXPORT
91 #define RD_DEPRECATED __attribute__((deprecated))
92 
93 #ifndef LIBRDKAFKA_TYPECHECKS
94 #define LIBRDKAFKA_TYPECHECKS 1
95 #endif
96 #endif
97 
98 
104 #if LIBRDKAFKA_TYPECHECKS
105 #define _LRK_TYPECHECK(RET,TYPE,ARG) \
106  ({ if (0) { TYPE __t RD_UNUSED = (ARG); } RET; })
107 
108 #define _LRK_TYPECHECK2(RET,TYPE,ARG,TYPE2,ARG2) \
109  ({ \
110  if (0) { \
111  TYPE __t RD_UNUSED = (ARG); \
112  TYPE2 __t2 RD_UNUSED = (ARG2); \
113  } \
114  RET; })
115 
116 #define _LRK_TYPECHECK3(RET,TYPE,ARG,TYPE2,ARG2,TYPE3,ARG3) \
117  ({ \
118  if (0) { \
119  TYPE __t RD_UNUSED = (ARG); \
120  TYPE2 __t2 RD_UNUSED = (ARG2); \
121  TYPE3 __t3 RD_UNUSED = (ARG3); \
122  } \
123  RET; })
124 #else
125 #define _LRK_TYPECHECK(RET,TYPE,ARG) (RET)
126 #define _LRK_TYPECHECK2(RET,TYPE,ARG,TYPE2,ARG2) (RET)
127 #define _LRK_TYPECHECK3(RET,TYPE,ARG,TYPE2,ARG2,TYPE3,ARG3) (RET)
128 #endif
129 
130 /* @endcond */
131 
132 
154 #define RD_KAFKA_VERSION 0x010502ff
155 
164 RD_EXPORT
165 int rd_kafka_version(void);
166 
172 RD_EXPORT
173 const char *rd_kafka_version_str (void);
174 
193 typedef enum rd_kafka_type_t {
194  RD_KAFKA_PRODUCER,
195  RD_KAFKA_CONSUMER
196 } rd_kafka_type_t;
197 
198 
204 typedef enum rd_kafka_timestamp_type_t {
205  RD_KAFKA_TIMESTAMP_NOT_AVAILABLE,
206  RD_KAFKA_TIMESTAMP_CREATE_TIME,
207  RD_KAFKA_TIMESTAMP_LOG_APPEND_TIME
208 } rd_kafka_timestamp_type_t;
209 
210 
211 
218 RD_EXPORT
219 const char *rd_kafka_get_debug_contexts(void);
220 
228 #define RD_KAFKA_DEBUG_CONTEXTS \
229  "all,generic,broker,topic,metadata,feature,queue,msg,protocol,cgrp,security,fetch,interceptor,plugin,consumer,admin,eos,mock"
230 
231 
232 /* @cond NO_DOC */
233 /* Private types to provide ABI compatibility */
234 typedef struct rd_kafka_s rd_kafka_t;
235 typedef struct rd_kafka_topic_s rd_kafka_topic_t;
236 typedef struct rd_kafka_conf_s rd_kafka_conf_t;
237 typedef struct rd_kafka_topic_conf_s rd_kafka_topic_conf_t;
238 typedef struct rd_kafka_queue_s rd_kafka_queue_t;
239 typedef struct rd_kafka_op_s rd_kafka_event_t;
240 typedef struct rd_kafka_topic_result_s rd_kafka_topic_result_t;
241 typedef struct rd_kafka_consumer_group_metadata_s
242 rd_kafka_consumer_group_metadata_t;
243 typedef struct rd_kafka_error_s rd_kafka_error_t;
244 typedef struct rd_kafka_headers_s rd_kafka_headers_t;
245 /* @endcond */
246 
247 
260 typedef enum {
261  /* Internal errors to rdkafka: */
263  RD_KAFKA_RESP_ERR__BEGIN = -200,
265  RD_KAFKA_RESP_ERR__BAD_MSG = -199,
267  RD_KAFKA_RESP_ERR__BAD_COMPRESSION = -198,
269  RD_KAFKA_RESP_ERR__DESTROY = -197,
271  RD_KAFKA_RESP_ERR__FAIL = -196,
273  RD_KAFKA_RESP_ERR__TRANSPORT = -195,
275  RD_KAFKA_RESP_ERR__CRIT_SYS_RESOURCE = -194,
277  RD_KAFKA_RESP_ERR__RESOLVE = -193,
279  RD_KAFKA_RESP_ERR__MSG_TIMED_OUT = -192,
284  RD_KAFKA_RESP_ERR__PARTITION_EOF = -191,
286  RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION = -190,
288  RD_KAFKA_RESP_ERR__FS = -189,
290  RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC = -188,
292  RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN = -187,
294  RD_KAFKA_RESP_ERR__INVALID_ARG = -186,
296  RD_KAFKA_RESP_ERR__TIMED_OUT = -185,
298  RD_KAFKA_RESP_ERR__QUEUE_FULL = -184,
300  RD_KAFKA_RESP_ERR__ISR_INSUFF = -183,
302  RD_KAFKA_RESP_ERR__NODE_UPDATE = -182,
304  RD_KAFKA_RESP_ERR__SSL = -181,
306  RD_KAFKA_RESP_ERR__WAIT_COORD = -180,
308  RD_KAFKA_RESP_ERR__UNKNOWN_GROUP = -179,
310  RD_KAFKA_RESP_ERR__IN_PROGRESS = -178,
312  RD_KAFKA_RESP_ERR__PREV_IN_PROGRESS = -177,
314  RD_KAFKA_RESP_ERR__EXISTING_SUBSCRIPTION = -176,
316  RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS = -175,
318  RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS = -174,
320  RD_KAFKA_RESP_ERR__CONFLICT = -173,
322  RD_KAFKA_RESP_ERR__STATE = -172,
324  RD_KAFKA_RESP_ERR__UNKNOWN_PROTOCOL = -171,
326  RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED = -170,
328  RD_KAFKA_RESP_ERR__AUTHENTICATION = -169,
330  RD_KAFKA_RESP_ERR__NO_OFFSET = -168,
332  RD_KAFKA_RESP_ERR__OUTDATED = -167,
334  RD_KAFKA_RESP_ERR__TIMED_OUT_QUEUE = -166,
336  RD_KAFKA_RESP_ERR__UNSUPPORTED_FEATURE = -165,
338  RD_KAFKA_RESP_ERR__WAIT_CACHE = -164,
340  RD_KAFKA_RESP_ERR__INTR = -163,
342  RD_KAFKA_RESP_ERR__KEY_SERIALIZATION = -162,
344  RD_KAFKA_RESP_ERR__VALUE_SERIALIZATION = -161,
346  RD_KAFKA_RESP_ERR__KEY_DESERIALIZATION = -160,
348  RD_KAFKA_RESP_ERR__VALUE_DESERIALIZATION = -159,
350  RD_KAFKA_RESP_ERR__PARTIAL = -158,
352  RD_KAFKA_RESP_ERR__READ_ONLY = -157,
354  RD_KAFKA_RESP_ERR__NOENT = -156,
356  RD_KAFKA_RESP_ERR__UNDERFLOW = -155,
358  RD_KAFKA_RESP_ERR__INVALID_TYPE = -154,
360  RD_KAFKA_RESP_ERR__RETRY = -153,
362  RD_KAFKA_RESP_ERR__PURGE_QUEUE = -152,
364  RD_KAFKA_RESP_ERR__PURGE_INFLIGHT = -151,
366  RD_KAFKA_RESP_ERR__FATAL = -150,
368  RD_KAFKA_RESP_ERR__INCONSISTENT = -149,
370  RD_KAFKA_RESP_ERR__GAPLESS_GUARANTEE = -148,
372  RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED = -147,
374  RD_KAFKA_RESP_ERR__UNKNOWN_BROKER = -146,
376  RD_KAFKA_RESP_ERR__NOT_CONFIGURED = -145,
378  RD_KAFKA_RESP_ERR__FENCED = -144,
380  RD_KAFKA_RESP_ERR__APPLICATION = -143,
381 
383  RD_KAFKA_RESP_ERR__END = -100,
384 
385  /* Kafka broker errors: */
387  RD_KAFKA_RESP_ERR_UNKNOWN = -1,
389  RD_KAFKA_RESP_ERR_NO_ERROR = 0,
391  RD_KAFKA_RESP_ERR_OFFSET_OUT_OF_RANGE = 1,
393  RD_KAFKA_RESP_ERR_INVALID_MSG = 2,
395  RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART = 3,
397  RD_KAFKA_RESP_ERR_INVALID_MSG_SIZE = 4,
399  RD_KAFKA_RESP_ERR_LEADER_NOT_AVAILABLE = 5,
401  RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION = 6,
403  RD_KAFKA_RESP_ERR_REQUEST_TIMED_OUT = 7,
405  RD_KAFKA_RESP_ERR_BROKER_NOT_AVAILABLE = 8,
407  RD_KAFKA_RESP_ERR_REPLICA_NOT_AVAILABLE = 9,
409  RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE = 10,
411  RD_KAFKA_RESP_ERR_STALE_CTRL_EPOCH = 11,
413  RD_KAFKA_RESP_ERR_OFFSET_METADATA_TOO_LARGE = 12,
415  RD_KAFKA_RESP_ERR_NETWORK_EXCEPTION = 13,
417  RD_KAFKA_RESP_ERR_COORDINATOR_LOAD_IN_PROGRESS = 14,
419 #define RD_KAFKA_RESP_ERR_GROUP_LOAD_IN_PROGRESS \
420  RD_KAFKA_RESP_ERR_COORDINATOR_LOAD_IN_PROGRESS
421 
422  RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE = 15,
424 #define RD_KAFKA_RESP_ERR_GROUP_COORDINATOR_NOT_AVAILABLE \
425  RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE
426 
427  RD_KAFKA_RESP_ERR_NOT_COORDINATOR = 16,
429 #define RD_KAFKA_RESP_ERR_NOT_COORDINATOR_FOR_GROUP \
430  RD_KAFKA_RESP_ERR_NOT_COORDINATOR
431 
432  RD_KAFKA_RESP_ERR_TOPIC_EXCEPTION = 17,
434  RD_KAFKA_RESP_ERR_RECORD_LIST_TOO_LARGE = 18,
436  RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS = 19,
438  RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS_AFTER_APPEND = 20,
440  RD_KAFKA_RESP_ERR_INVALID_REQUIRED_ACKS = 21,
442  RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION = 22,
444  RD_KAFKA_RESP_ERR_INCONSISTENT_GROUP_PROTOCOL = 23,
446  RD_KAFKA_RESP_ERR_INVALID_GROUP_ID = 24,
448  RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID = 25,
450  RD_KAFKA_RESP_ERR_INVALID_SESSION_TIMEOUT = 26,
452  RD_KAFKA_RESP_ERR_REBALANCE_IN_PROGRESS = 27,
454  RD_KAFKA_RESP_ERR_INVALID_COMMIT_OFFSET_SIZE = 28,
456  RD_KAFKA_RESP_ERR_TOPIC_AUTHORIZATION_FAILED = 29,
458  RD_KAFKA_RESP_ERR_GROUP_AUTHORIZATION_FAILED = 30,
460  RD_KAFKA_RESP_ERR_CLUSTER_AUTHORIZATION_FAILED = 31,
462  RD_KAFKA_RESP_ERR_INVALID_TIMESTAMP = 32,
464  RD_KAFKA_RESP_ERR_UNSUPPORTED_SASL_MECHANISM = 33,
466  RD_KAFKA_RESP_ERR_ILLEGAL_SASL_STATE = 34,
468  RD_KAFKA_RESP_ERR_UNSUPPORTED_VERSION = 35,
470  RD_KAFKA_RESP_ERR_TOPIC_ALREADY_EXISTS = 36,
472  RD_KAFKA_RESP_ERR_INVALID_PARTITIONS = 37,
474  RD_KAFKA_RESP_ERR_INVALID_REPLICATION_FACTOR = 38,
476  RD_KAFKA_RESP_ERR_INVALID_REPLICA_ASSIGNMENT = 39,
478  RD_KAFKA_RESP_ERR_INVALID_CONFIG = 40,
480  RD_KAFKA_RESP_ERR_NOT_CONTROLLER = 41,
482  RD_KAFKA_RESP_ERR_INVALID_REQUEST = 42,
484  RD_KAFKA_RESP_ERR_UNSUPPORTED_FOR_MESSAGE_FORMAT = 43,
486  RD_KAFKA_RESP_ERR_POLICY_VIOLATION = 44,
488  RD_KAFKA_RESP_ERR_OUT_OF_ORDER_SEQUENCE_NUMBER = 45,
490  RD_KAFKA_RESP_ERR_DUPLICATE_SEQUENCE_NUMBER = 46,
492  RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH = 47,
494  RD_KAFKA_RESP_ERR_INVALID_TXN_STATE = 48,
497  RD_KAFKA_RESP_ERR_INVALID_PRODUCER_ID_MAPPING = 49,
500  RD_KAFKA_RESP_ERR_INVALID_TRANSACTION_TIMEOUT = 50,
503  RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS = 51,
507  RD_KAFKA_RESP_ERR_TRANSACTION_COORDINATOR_FENCED = 52,
509  RD_KAFKA_RESP_ERR_TRANSACTIONAL_ID_AUTHORIZATION_FAILED = 53,
511  RD_KAFKA_RESP_ERR_SECURITY_DISABLED = 54,
513  RD_KAFKA_RESP_ERR_OPERATION_NOT_ATTEMPTED = 55,
515  RD_KAFKA_RESP_ERR_KAFKA_STORAGE_ERROR = 56,
517  RD_KAFKA_RESP_ERR_LOG_DIR_NOT_FOUND = 57,
519  RD_KAFKA_RESP_ERR_SASL_AUTHENTICATION_FAILED = 58,
521  RD_KAFKA_RESP_ERR_UNKNOWN_PRODUCER_ID = 59,
523  RD_KAFKA_RESP_ERR_REASSIGNMENT_IN_PROGRESS = 60,
525  RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTH_DISABLED = 61,
527  RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_NOT_FOUND = 62,
529  RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_OWNER_MISMATCH = 63,
531  RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_REQUEST_NOT_ALLOWED = 64,
533  RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTHORIZATION_FAILED = 65,
535  RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_EXPIRED = 66,
537  RD_KAFKA_RESP_ERR_INVALID_PRINCIPAL_TYPE = 67,
539  RD_KAFKA_RESP_ERR_NON_EMPTY_GROUP = 68,
541  RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND = 69,
543  RD_KAFKA_RESP_ERR_FETCH_SESSION_ID_NOT_FOUND = 70,
545  RD_KAFKA_RESP_ERR_INVALID_FETCH_SESSION_EPOCH = 71,
547  RD_KAFKA_RESP_ERR_LISTENER_NOT_FOUND = 72,
549  RD_KAFKA_RESP_ERR_TOPIC_DELETION_DISABLED = 73,
551  RD_KAFKA_RESP_ERR_FENCED_LEADER_EPOCH = 74,
553  RD_KAFKA_RESP_ERR_UNKNOWN_LEADER_EPOCH = 75,
555  RD_KAFKA_RESP_ERR_UNSUPPORTED_COMPRESSION_TYPE = 76,
557  RD_KAFKA_RESP_ERR_STALE_BROKER_EPOCH = 77,
559  RD_KAFKA_RESP_ERR_OFFSET_NOT_AVAILABLE = 78,
561  RD_KAFKA_RESP_ERR_MEMBER_ID_REQUIRED = 79,
563  RD_KAFKA_RESP_ERR_PREFERRED_LEADER_NOT_AVAILABLE = 80,
565  RD_KAFKA_RESP_ERR_GROUP_MAX_SIZE_REACHED = 81,
568  RD_KAFKA_RESP_ERR_FENCED_INSTANCE_ID = 82,
570  RD_KAFKA_RESP_ERR_ELIGIBLE_LEADERS_NOT_AVAILABLE = 83,
572  RD_KAFKA_RESP_ERR_ELECTION_NOT_NEEDED = 84,
574  RD_KAFKA_RESP_ERR_NO_REASSIGNMENT_IN_PROGRESS = 85,
576  RD_KAFKA_RESP_ERR_GROUP_SUBSCRIBED_TO_TOPIC = 86,
578  RD_KAFKA_RESP_ERR_INVALID_RECORD = 87,
580  RD_KAFKA_RESP_ERR_UNSTABLE_OFFSET_COMMIT = 88,
581 
582  RD_KAFKA_RESP_ERR_END_ALL,
583 } rd_kafka_resp_err_t;
584 
585 
591 struct rd_kafka_err_desc {
592  rd_kafka_resp_err_t code;
593  const char *name;
594  const char *desc;
595 };
596 
597 
601 RD_EXPORT
602 void rd_kafka_get_err_descs (const struct rd_kafka_err_desc **errdescs,
603  size_t *cntp);
604 
605 
606 
607 
613 RD_EXPORT
614 const char *rd_kafka_err2str (rd_kafka_resp_err_t err);
615 
616 
617 
623 RD_EXPORT
624 const char *rd_kafka_err2name (rd_kafka_resp_err_t err);
625 
626 
652 RD_EXPORT
653 rd_kafka_resp_err_t rd_kafka_last_error (void);
654 
655 
680 RD_EXPORT RD_DEPRECATED
681 rd_kafka_resp_err_t rd_kafka_errno2err(int errnox);
682 
683 
696 RD_EXPORT RD_DEPRECATED
697 int rd_kafka_errno (void);
698 
699 
700 
701 
728 RD_EXPORT
729 rd_kafka_resp_err_t rd_kafka_fatal_error (rd_kafka_t *rk,
730  char *errstr, size_t errstr_size);
731 
732 
750 RD_EXPORT rd_kafka_resp_err_t
751 rd_kafka_test_fatal_error (rd_kafka_t *rk, rd_kafka_resp_err_t err,
752  const char *reason);
753 
754 
759 RD_EXPORT
760 rd_kafka_resp_err_t rd_kafka_error_code (const rd_kafka_error_t *error);
761 
770 RD_EXPORT
771 const char *rd_kafka_error_name (const rd_kafka_error_t *error);
772 
779 RD_EXPORT
780 const char *rd_kafka_error_string (const rd_kafka_error_t *error);
781 
782 
787 RD_EXPORT
788 int rd_kafka_error_is_fatal (const rd_kafka_error_t *error);
789 
790 
795 RD_EXPORT
796 int rd_kafka_error_is_retriable (const rd_kafka_error_t *error);
797 
798 
809 RD_EXPORT
810 int rd_kafka_error_txn_requires_abort (const rd_kafka_error_t *error);
811 
817 RD_EXPORT
818 void rd_kafka_error_destroy (rd_kafka_error_t *error);
819 
820 
829 RD_EXPORT
830 rd_kafka_error_t *rd_kafka_error_new (rd_kafka_resp_err_t code,
831  const char *fmt, ...);
832 
833 
849 typedef struct rd_kafka_topic_partition_s {
850  char *topic;
851  int32_t partition;
852  int64_t offset;
853  void *metadata;
854  size_t metadata_size;
855  void *opaque;
856  rd_kafka_resp_err_t err;
857  void *_private;
859 } rd_kafka_topic_partition_t;
860 
861 
866 RD_EXPORT
867 void rd_kafka_topic_partition_destroy (rd_kafka_topic_partition_t *rktpar);
868 
869 
874 typedef struct rd_kafka_topic_partition_list_s {
875  int cnt;
876  int size;
877  rd_kafka_topic_partition_t *elems;
878 } rd_kafka_topic_partition_list_t;
879 
880 
895 RD_EXPORT
896 rd_kafka_topic_partition_list_t *rd_kafka_topic_partition_list_new (int size);
897 
898 
902 RD_EXPORT
903 void
904 rd_kafka_topic_partition_list_destroy (rd_kafka_topic_partition_list_t *rkparlist);
905 
915 RD_EXPORT
916 rd_kafka_topic_partition_t *
917 rd_kafka_topic_partition_list_add (rd_kafka_topic_partition_list_t *rktparlist,
918  const char *topic, int32_t partition);
919 
920 
929 RD_EXPORT
930 void
931 rd_kafka_topic_partition_list_add_range (rd_kafka_topic_partition_list_t
932  *rktparlist,
933  const char *topic,
934  int32_t start, int32_t stop);
935 
936 
937 
949 RD_EXPORT
950 int
951 rd_kafka_topic_partition_list_del (rd_kafka_topic_partition_list_t *rktparlist,
952  const char *topic, int32_t partition);
953 
954 
962 RD_EXPORT
963 int
964 rd_kafka_topic_partition_list_del_by_idx (
965  rd_kafka_topic_partition_list_t *rktparlist,
966  int idx);
967 
968 
976 RD_EXPORT
977 rd_kafka_topic_partition_list_t *
978 rd_kafka_topic_partition_list_copy (const rd_kafka_topic_partition_list_t *src);
979 
980 
981 
982 
990 RD_EXPORT
991 rd_kafka_resp_err_t rd_kafka_topic_partition_list_set_offset (
992  rd_kafka_topic_partition_list_t *rktparlist,
993  const char *topic, int32_t partition, int64_t offset);
994 
995 
996 
1002 RD_EXPORT
1003 rd_kafka_topic_partition_t *
1004 rd_kafka_topic_partition_list_find (rd_kafka_topic_partition_list_t *rktparlist,
1005  const char *topic, int32_t partition);
1006 
1007 
1017 RD_EXPORT void
1018 rd_kafka_topic_partition_list_sort (rd_kafka_topic_partition_list_t *rktparlist,
1019  int (*cmp) (const void *a, const void *b,
1020  void *cmp_opaque),
1021  void *cmp_opaque);
1022 
1023 
1041 typedef enum rd_kafka_vtype_t {
1042  RD_KAFKA_VTYPE_END,
1043  RD_KAFKA_VTYPE_TOPIC,
1044  RD_KAFKA_VTYPE_RKT,
1045  RD_KAFKA_VTYPE_PARTITION,
1046  RD_KAFKA_VTYPE_VALUE,
1047  RD_KAFKA_VTYPE_KEY,
1048  RD_KAFKA_VTYPE_OPAQUE,
1053  RD_KAFKA_VTYPE_MSGFLAGS,
1054  RD_KAFKA_VTYPE_TIMESTAMP,
1055  RD_KAFKA_VTYPE_HEADER,
1057  RD_KAFKA_VTYPE_HEADERS,
1058 } rd_kafka_vtype_t;
1059 
1060 
1067 typedef struct rd_kafka_vu_s {
1068  rd_kafka_vtype_t vtype;
1070  union {
1071  const char *cstr;
1072  rd_kafka_topic_t *rkt;
1073  int i;
1074  int32_t i32;
1075  int64_t i64;
1076  struct {
1077  void *ptr;
1078  size_t size;
1079  } mem;
1080  struct {
1081  const char *name;
1082  const void *val;
1083  ssize_t size;
1084  } header;
1085  rd_kafka_headers_t *headers;
1086  void *ptr;
1087  char _pad[64];
1088  } u;
1089 } rd_kafka_vu_t;
1090 
1099 #define RD_KAFKA_V_END RD_KAFKA_VTYPE_END
1100 
1106 #define RD_KAFKA_V_TOPIC(topic) \
1107  _LRK_TYPECHECK(RD_KAFKA_VTYPE_TOPIC, const char *, topic), \
1108  (const char *)topic
1109 
1114 #define RD_KAFKA_V_RKT(rkt) \
1115  _LRK_TYPECHECK(RD_KAFKA_VTYPE_RKT, rd_kafka_topic_t *, rkt), \
1116  (rd_kafka_topic_t *)rkt
1117 
1122 #define RD_KAFKA_V_PARTITION(partition) \
1123  _LRK_TYPECHECK(RD_KAFKA_VTYPE_PARTITION, int32_t, partition), \
1124  (int32_t)partition
1125 
1130 #define RD_KAFKA_V_VALUE(VALUE,LEN) \
1131  _LRK_TYPECHECK2(RD_KAFKA_VTYPE_VALUE, void *, VALUE, size_t, LEN), \
1132  (void *)VALUE, (size_t)LEN
1133 
1138 #define RD_KAFKA_V_KEY(KEY,LEN) \
1139  _LRK_TYPECHECK2(RD_KAFKA_VTYPE_KEY, const void *, KEY, size_t, LEN), \
1140  (void *)KEY, (size_t)LEN
1141 
1148 #define RD_KAFKA_V_OPAQUE(msg_opaque) \
1149  _LRK_TYPECHECK(RD_KAFKA_VTYPE_OPAQUE, void *, msg_opaque), \
1150  (void *)msg_opaque
1151 
1157 #define RD_KAFKA_V_MSGFLAGS(msgflags) \
1158  _LRK_TYPECHECK(RD_KAFKA_VTYPE_MSGFLAGS, int, msgflags), \
1159  (int)msgflags
1160 
1166 #define RD_KAFKA_V_TIMESTAMP(timestamp) \
1167  _LRK_TYPECHECK(RD_KAFKA_VTYPE_TIMESTAMP, int64_t, timestamp), \
1168  (int64_t)timestamp
1169 
1177 #define RD_KAFKA_V_HEADER(NAME,VALUE,LEN) \
1178  _LRK_TYPECHECK3(RD_KAFKA_VTYPE_HEADER, const char *, NAME, \
1179  const void *, VALUE, ssize_t, LEN), \
1180  (const char *)NAME, (const void *)VALUE, (ssize_t)LEN
1181 
1193 #define RD_KAFKA_V_HEADERS(HDRS) \
1194  _LRK_TYPECHECK(RD_KAFKA_VTYPE_HEADERS, rd_kafka_headers_t *, HDRS), \
1195  (rd_kafka_headers_t *)HDRS
1196 
1197 
1228 RD_EXPORT rd_kafka_headers_t *rd_kafka_headers_new (size_t initial_count);
1229 
1234 RD_EXPORT void rd_kafka_headers_destroy (rd_kafka_headers_t *hdrs);
1235 
1239 RD_EXPORT rd_kafka_headers_t *
1240 rd_kafka_headers_copy (const rd_kafka_headers_t *src);
1241 
1259 RD_EXPORT rd_kafka_resp_err_t
1260 rd_kafka_header_add (rd_kafka_headers_t *hdrs,
1261  const char *name, ssize_t name_size,
1262  const void *value, ssize_t value_size);
1263 
1271 RD_EXPORT rd_kafka_resp_err_t
1272 rd_kafka_header_remove (rd_kafka_headers_t *hdrs, const char *name);
1273 
1274 
1292 RD_EXPORT rd_kafka_resp_err_t
1293 rd_kafka_header_get_last (const rd_kafka_headers_t *hdrs,
1294  const char *name, const void **valuep, size_t *sizep);
1295 
1309 RD_EXPORT rd_kafka_resp_err_t
1310 rd_kafka_header_get (const rd_kafka_headers_t *hdrs, size_t idx,
1311  const char *name, const void **valuep, size_t *sizep);
1312 
1313 
1321 RD_EXPORT rd_kafka_resp_err_t
1322 rd_kafka_header_get_all (const rd_kafka_headers_t *hdrs, size_t idx,
1323  const char **namep,
1324  const void **valuep, size_t *sizep);
1325 
1326 
1327 
1340 // FIXME: This doesn't show up in docs for some reason
1341 // "Compound rd_kafka_message_t is not documented."
1342 
1356 typedef struct rd_kafka_message_s {
1357  rd_kafka_resp_err_t err;
1358  rd_kafka_topic_t *rkt;
1359  int32_t partition;
1360  void *payload;
1364  size_t len;
1367  void *key;
1369  size_t key_len;
1371  int64_t offset;
1379  void *_private;
1385 } rd_kafka_message_t;
1386 
1387 
1391 RD_EXPORT
1392 void rd_kafka_message_destroy(rd_kafka_message_t *rkmessage);
1393 
1394 
1395 
1396 
1403 RD_EXPORT
1404 const char *rd_kafka_message_errstr (const rd_kafka_message_t *rkmessage);
1405 
1406 
1418 RD_EXPORT
1419 int64_t rd_kafka_message_timestamp (const rd_kafka_message_t *rkmessage,
1420  rd_kafka_timestamp_type_t *tstype);
1421 
1422 
1423 
1430 RD_EXPORT
1431 int64_t rd_kafka_message_latency (const rd_kafka_message_t *rkmessage);
1432 
1433 
1440 RD_EXPORT
1441 int32_t rd_kafka_message_broker_id (const rd_kafka_message_t *rkmessage);
1442 
1443 
1460 RD_EXPORT rd_kafka_resp_err_t
1461 rd_kafka_message_headers (const rd_kafka_message_t *rkmessage,
1462  rd_kafka_headers_t **hdrsp);
1463 
1475 RD_EXPORT rd_kafka_resp_err_t
1476 rd_kafka_message_detach_headers (rd_kafka_message_t *rkmessage,
1477  rd_kafka_headers_t **hdrsp);
1478 
1479 
1492 RD_EXPORT
1493 void rd_kafka_message_set_headers (rd_kafka_message_t *rkmessage,
1494  rd_kafka_headers_t *hdrs);
1495 
1496 
1502 RD_EXPORT size_t rd_kafka_header_cnt (const rd_kafka_headers_t *hdrs);
1503 
1504 
1510 typedef enum {
1514  RD_KAFKA_MSG_STATUS_NOT_PERSISTED = 0,
1515 
1519  RD_KAFKA_MSG_STATUS_POSSIBLY_PERSISTED = 1,
1520 
1524  RD_KAFKA_MSG_STATUS_PERSISTED = 2
1525 } rd_kafka_msg_status_t;
1526 
1527 
1534 RD_EXPORT rd_kafka_msg_status_t
1535 rd_kafka_message_status (const rd_kafka_message_t *rkmessage);
1536 
1552 typedef enum {
1553  RD_KAFKA_CONF_UNKNOWN = -2,
1554  RD_KAFKA_CONF_INVALID = -1,
1557  RD_KAFKA_CONF_OK = 0
1558 } rd_kafka_conf_res_t;
1559 
1560 
1594 RD_EXPORT
1595 rd_kafka_conf_t *rd_kafka_conf_new(void);
1596 
1597 
1601 RD_EXPORT
1602 void rd_kafka_conf_destroy(rd_kafka_conf_t *conf);
1603 
1604 
1611 RD_EXPORT
1612 rd_kafka_conf_t *rd_kafka_conf_dup(const rd_kafka_conf_t *conf);
1613 
1614 
1619 RD_EXPORT
1620 rd_kafka_conf_t *rd_kafka_conf_dup_filter (const rd_kafka_conf_t *conf,
1621  size_t filter_cnt,
1622  const char **filter);
1623 
1624 
1625 
1634 RD_EXPORT
1635 const rd_kafka_conf_t *rd_kafka_conf (rd_kafka_t *rk);
1636 
1637 
1657 RD_EXPORT
1658 rd_kafka_conf_res_t rd_kafka_conf_set(rd_kafka_conf_t *conf,
1659  const char *name,
1660  const char *value,
1661  char *errstr, size_t errstr_size);
1662 
1663 
1669 RD_EXPORT
1670 void rd_kafka_conf_set_events(rd_kafka_conf_t *conf, int events);
1671 
1672 
1708 RD_EXPORT void
1709 rd_kafka_conf_set_background_event_cb (rd_kafka_conf_t *conf,
1710  void (*event_cb) (rd_kafka_t *rk,
1711  rd_kafka_event_t *rkev,
1712  void *opaque));
1713 
1714 
1718 RD_EXPORT
1719 void rd_kafka_conf_set_dr_cb(rd_kafka_conf_t *conf,
1720  void (*dr_cb) (rd_kafka_t *rk,
1721  void *payload, size_t len,
1722  rd_kafka_resp_err_t err,
1723  void *opaque, void *msg_opaque));
1724 
1755 RD_EXPORT
1756 void rd_kafka_conf_set_dr_msg_cb(rd_kafka_conf_t *conf,
1757  void (*dr_msg_cb) (rd_kafka_t *rk,
1758  const rd_kafka_message_t *
1759  rkmessage,
1760  void *opaque));
1761 
1762 
1770 RD_EXPORT
1771 void rd_kafka_conf_set_consume_cb (rd_kafka_conf_t *conf,
1772  void (*consume_cb) (rd_kafka_message_t *
1773  rkmessage,
1774  void *opaque));
1775 
1850 RD_EXPORT
1851 void rd_kafka_conf_set_rebalance_cb (
1852  rd_kafka_conf_t *conf,
1853  void (*rebalance_cb) (rd_kafka_t *rk,
1854  rd_kafka_resp_err_t err,
1855  rd_kafka_topic_partition_list_t *partitions,
1856  void *opaque));
1857 
1858 
1859 
1877 RD_EXPORT
1878 void rd_kafka_conf_set_offset_commit_cb (
1879  rd_kafka_conf_t *conf,
1880  void (*offset_commit_cb) (rd_kafka_t *rk,
1881  rd_kafka_resp_err_t err,
1882  rd_kafka_topic_partition_list_t *offsets,
1883  void *opaque));
1884 
1885 
1908 RD_EXPORT
1909 void rd_kafka_conf_set_error_cb(rd_kafka_conf_t *conf,
1910  void (*error_cb) (rd_kafka_t *rk, int err,
1911  const char *reason,
1912  void *opaque));
1913 
1931 RD_EXPORT
1932 void rd_kafka_conf_set_throttle_cb (rd_kafka_conf_t *conf,
1933  void (*throttle_cb) (
1934  rd_kafka_t *rk,
1935  const char *broker_name,
1936  int32_t broker_id,
1937  int throttle_time_ms,
1938  void *opaque));
1939 
1940 
1957 RD_EXPORT
1958 void rd_kafka_conf_set_log_cb(rd_kafka_conf_t *conf,
1959  void (*log_cb) (const rd_kafka_t *rk, int level,
1960  const char *fac, const char *buf));
1961 
1962 
1985 RD_EXPORT
1986 void rd_kafka_conf_set_stats_cb(rd_kafka_conf_t *conf,
1987  int (*stats_cb) (rd_kafka_t *rk,
1988  char *json,
1989  size_t json_len,
1990  void *opaque));
1991 
2027 RD_EXPORT
2028 void rd_kafka_conf_set_oauthbearer_token_refresh_cb (
2029  rd_kafka_conf_t *conf,
2030  void (*oauthbearer_token_refresh_cb) (rd_kafka_t *rk,
2031  const char *oauthbearer_config,
2032  void *opaque));
2033 
2051 RD_EXPORT
2052 void rd_kafka_conf_set_socket_cb(rd_kafka_conf_t *conf,
2053  int (*socket_cb) (int domain, int type,
2054  int protocol,
2055  void *opaque));
2056 
2057 
2058 
2074 RD_EXPORT void
2075 rd_kafka_conf_set_connect_cb (rd_kafka_conf_t *conf,
2076  int (*connect_cb) (int sockfd,
2077  const struct sockaddr *addr,
2078  int addrlen,
2079  const char *id,
2080  void *opaque));
2081 
2092 RD_EXPORT void
2093 rd_kafka_conf_set_closesocket_cb (rd_kafka_conf_t *conf,
2094  int (*closesocket_cb) (int sockfd,
2095  void *opaque));
2096 
2097 
2098 
2099 #ifndef _WIN32
2100 
2117 RD_EXPORT
2118 void rd_kafka_conf_set_open_cb (rd_kafka_conf_t *conf,
2119  int (*open_cb) (const char *pathname,
2120  int flags, mode_t mode,
2121  void *opaque));
2122 #endif
2123 
2124 
2166 RD_EXPORT
2167 rd_kafka_conf_res_t rd_kafka_conf_set_ssl_cert_verify_cb (
2168  rd_kafka_conf_t *conf,
2169  int (*ssl_cert_verify_cb) (rd_kafka_t *rk,
2170  const char *broker_name,
2171  int32_t broker_id,
2172  int *x509_error,
2173  int depth,
2174  const char *buf, size_t size,
2175  char *errstr, size_t errstr_size,
2176  void *opaque));
2177 
2178 
2186 typedef enum rd_kafka_cert_type_t {
2187  RD_KAFKA_CERT_PUBLIC_KEY,
2188  RD_KAFKA_CERT_PRIVATE_KEY,
2189  RD_KAFKA_CERT_CA,
2190  RD_KAFKA_CERT__CNT,
2191 } rd_kafka_cert_type_t;
2192 
2200 typedef enum rd_kafka_cert_enc_t {
2201  RD_KAFKA_CERT_ENC_PKCS12,
2202  RD_KAFKA_CERT_ENC_DER,
2203  RD_KAFKA_CERT_ENC_PEM,
2204  RD_KAFKA_CERT_ENC__CNT,
2205 } rd_kafka_cert_enc_t;
2206 
2207 
2239 RD_EXPORT rd_kafka_conf_res_t
2240 rd_kafka_conf_set_ssl_cert (rd_kafka_conf_t *conf,
2241  rd_kafka_cert_type_t cert_type,
2242  rd_kafka_cert_enc_t cert_enc,
2243  const void *buffer, size_t size,
2244  char *errstr, size_t errstr_size);
2245 
2246 
2252 RD_EXPORT
2253 void rd_kafka_conf_set_opaque(rd_kafka_conf_t *conf, void *opaque);
2254 
2259 RD_EXPORT
2260 void *rd_kafka_opaque(const rd_kafka_t *rk);
2261 
2262 
2263 
2277 RD_EXPORT
2278 void rd_kafka_conf_set_default_topic_conf (rd_kafka_conf_t *conf,
2279  rd_kafka_topic_conf_t *tconf);
2280 
2281 
2282 
2302 RD_EXPORT
2303 rd_kafka_conf_res_t rd_kafka_conf_get (const rd_kafka_conf_t *conf,
2304  const char *name,
2305  char *dest, size_t *dest_size);
2306 
2307 
2313 RD_EXPORT
2314 rd_kafka_conf_res_t rd_kafka_topic_conf_get (const rd_kafka_topic_conf_t *conf,
2315  const char *name,
2316  char *dest, size_t *dest_size);
2317 
2318 
2327 RD_EXPORT
2328 const char **rd_kafka_conf_dump(rd_kafka_conf_t *conf, size_t *cntp);
2329 
2330 
2339 RD_EXPORT
2340 const char **rd_kafka_topic_conf_dump(rd_kafka_topic_conf_t *conf,
2341  size_t *cntp);
2342 
2347 RD_EXPORT
2348 void rd_kafka_conf_dump_free(const char **arr, size_t cnt);
2349 
2357 RD_EXPORT
2358 void rd_kafka_conf_properties_show(FILE *fp);
2359 
2377 RD_EXPORT
2378 rd_kafka_topic_conf_t *rd_kafka_topic_conf_new(void);
2379 
2380 
2384 RD_EXPORT
2385 rd_kafka_topic_conf_t *rd_kafka_topic_conf_dup(const rd_kafka_topic_conf_t
2386  *conf);
2387 
2392 RD_EXPORT
2393 rd_kafka_topic_conf_t *rd_kafka_default_topic_conf_dup (rd_kafka_t *rk);
2394 
2395 
2399 RD_EXPORT
2400 void rd_kafka_topic_conf_destroy(rd_kafka_topic_conf_t *topic_conf);
2401 
2402 
2411 RD_EXPORT
2412 rd_kafka_conf_res_t rd_kafka_topic_conf_set(rd_kafka_topic_conf_t *conf,
2413  const char *name,
2414  const char *value,
2415  char *errstr, size_t errstr_size);
2416 
2423 RD_EXPORT
2424 void rd_kafka_topic_conf_set_opaque(rd_kafka_topic_conf_t *conf,
2425  void *rkt_opaque);
2426 
2427 
2447 RD_EXPORT
2448 void
2449 rd_kafka_topic_conf_set_partitioner_cb (rd_kafka_topic_conf_t *topic_conf,
2450  int32_t (*partitioner) (
2451  const rd_kafka_topic_t *rkt,
2452  const void *keydata,
2453  size_t keylen,
2454  int32_t partition_cnt,
2455  void *rkt_opaque,
2456  void *msg_opaque));
2457 
2458 
2484 RD_EXPORT void
2485 rd_kafka_topic_conf_set_msg_order_cmp (rd_kafka_topic_conf_t *topic_conf,
2486  int (*msg_order_cmp) (
2487  const rd_kafka_message_t *a,
2488  const rd_kafka_message_t *b));
2489 
2490 
2498 RD_EXPORT
2499 int rd_kafka_topic_partition_available(const rd_kafka_topic_t *rkt,
2500  int32_t partition);
2501 
2502 
2503 /*******************************************************************
2504  * *
2505  * Partitioners provided by rdkafka *
2506  * *
2507  *******************************************************************/
2508 
2522 RD_EXPORT
2523 int32_t rd_kafka_msg_partitioner_random(const rd_kafka_topic_t *rkt,
2524  const void *key, size_t keylen,
2525  int32_t partition_cnt,
2526  void *rkt_opaque, void *msg_opaque);
2527 
2541 RD_EXPORT
2542 int32_t rd_kafka_msg_partitioner_consistent (const rd_kafka_topic_t *rkt,
2543  const void *key, size_t keylen,
2544  int32_t partition_cnt,
2545  void *rkt_opaque, void *msg_opaque);
2546 
2562 RD_EXPORT
2563 int32_t rd_kafka_msg_partitioner_consistent_random (const rd_kafka_topic_t *rkt,
2564  const void *key, size_t keylen,
2565  int32_t partition_cnt,
2566  void *rkt_opaque, void *msg_opaque);
2567 
2568 
2582 RD_EXPORT
2583 int32_t rd_kafka_msg_partitioner_murmur2 (const rd_kafka_topic_t *rkt,
2584  const void *key, size_t keylen,
2585  int32_t partition_cnt,
2586  void *rkt_opaque,
2587  void *msg_opaque);
2588 
2603 RD_EXPORT
2604 int32_t rd_kafka_msg_partitioner_murmur2_random (const rd_kafka_topic_t *rkt,
2605  const void *key, size_t keylen,
2606  int32_t partition_cnt,
2607  void *rkt_opaque,
2608  void *msg_opaque);
2609 
2610 
2624 RD_EXPORT
2625 int32_t rd_kafka_msg_partitioner_fnv1a (const rd_kafka_topic_t *rkt,
2626  const void *key, size_t keylen,
2627  int32_t partition_cnt,
2628  void *rkt_opaque,
2629  void *msg_opaque);
2630 
2631 
2646 RD_EXPORT
2647 int32_t rd_kafka_msg_partitioner_fnv1a_random (const rd_kafka_topic_t *rkt,
2648  const void *key, size_t keylen,
2649  int32_t partition_cnt,
2650  void *rkt_opaque,
2651  void *msg_opaque);
2652 
2653 
2694 RD_EXPORT
2695 rd_kafka_t *rd_kafka_new(rd_kafka_type_t type, rd_kafka_conf_t *conf,
2696  char *errstr, size_t errstr_size);
2697 
2698 
2713 RD_EXPORT
2714 void rd_kafka_destroy(rd_kafka_t *rk);
2715 
2716 
2721 RD_EXPORT
2722 void rd_kafka_destroy_flags (rd_kafka_t *rk, int flags);
2723 
2738 #define RD_KAFKA_DESTROY_F_NO_CONSUMER_CLOSE 0x8
2739 
2740 
2741 
2745 RD_EXPORT
2746 const char *rd_kafka_name(const rd_kafka_t *rk);
2747 
2748 
2752 RD_EXPORT
2753 rd_kafka_type_t rd_kafka_type(const rd_kafka_t *rk);
2754 
2755 
2766 RD_EXPORT
2767 char *rd_kafka_memberid (const rd_kafka_t *rk);
2768 
2769 
2770 
2789 RD_EXPORT
2790 char *rd_kafka_clusterid (rd_kafka_t *rk, int timeout_ms);
2791 
2792 
2808 RD_EXPORT
2809 int32_t rd_kafka_controllerid (rd_kafka_t *rk, int timeout_ms);
2810 
2811 
2833 RD_EXPORT
2834 rd_kafka_topic_t *rd_kafka_topic_new(rd_kafka_t *rk, const char *topic,
2835  rd_kafka_topic_conf_t *conf);
2836 
2837 
2838 
2847 RD_EXPORT
2848 void rd_kafka_topic_destroy(rd_kafka_topic_t *rkt);
2849 
2850 
2854 RD_EXPORT
2855 const char *rd_kafka_topic_name(const rd_kafka_topic_t *rkt);
2856 
2857 
2862 RD_EXPORT
2863 void *rd_kafka_topic_opaque (const rd_kafka_topic_t *rkt);
2864 
2865 
2872 #define RD_KAFKA_PARTITION_UA ((int32_t)-1)
2873 
2874 
2901 RD_EXPORT
2902 int rd_kafka_poll(rd_kafka_t *rk, int timeout_ms);
2903 
2904 
2915 RD_EXPORT
2916 void rd_kafka_yield (rd_kafka_t *rk);
2917 
2918 
2919 
2920 
2928 RD_EXPORT rd_kafka_resp_err_t
2929 rd_kafka_pause_partitions (rd_kafka_t *rk,
2930  rd_kafka_topic_partition_list_t *partitions);
2931 
2932 
2933 
2941 RD_EXPORT rd_kafka_resp_err_t
2942 rd_kafka_resume_partitions (rd_kafka_t *rk,
2943  rd_kafka_topic_partition_list_t *partitions);
2944 
2945 
2946 
2947 
2956 RD_EXPORT rd_kafka_resp_err_t
2957 rd_kafka_query_watermark_offsets (rd_kafka_t *rk,
2958  const char *topic, int32_t partition,
2959  int64_t *low, int64_t *high, int timeout_ms);
2960 
2961 
2978 RD_EXPORT rd_kafka_resp_err_t
2979 rd_kafka_get_watermark_offsets (rd_kafka_t *rk,
2980  const char *topic, int32_t partition,
2981  int64_t *low, int64_t *high);
2982 
2983 
2984 
3009 RD_EXPORT rd_kafka_resp_err_t
3010 rd_kafka_offsets_for_times (rd_kafka_t *rk,
3011  rd_kafka_topic_partition_list_t *offsets,
3012  int timeout_ms);
3013 
3014 
3031 RD_EXPORT
3032 void rd_kafka_mem_free (rd_kafka_t *rk, void *ptr);
3033 
3034 
3058 RD_EXPORT
3059 rd_kafka_queue_t *rd_kafka_queue_new(rd_kafka_t *rk);
3060 
3064 RD_EXPORT
3065 void rd_kafka_queue_destroy(rd_kafka_queue_t *rkqu);
3066 
3067 
3074 RD_EXPORT
3075 rd_kafka_queue_t *rd_kafka_queue_get_main (rd_kafka_t *rk);
3076 
3077 
3087 RD_EXPORT
3088 rd_kafka_queue_t *rd_kafka_queue_get_consumer (rd_kafka_t *rk);
3089 
3100 RD_EXPORT
3101 rd_kafka_queue_t *rd_kafka_queue_get_partition (rd_kafka_t *rk,
3102  const char *topic,
3103  int32_t partition);
3104 
3127 RD_EXPORT
3128 rd_kafka_queue_t *rd_kafka_queue_get_background (rd_kafka_t *rk);
3129 
3130 
3141 RD_EXPORT
3142 void rd_kafka_queue_forward (rd_kafka_queue_t *src, rd_kafka_queue_t *dst);
3143 
3161 RD_EXPORT
3162 rd_kafka_resp_err_t rd_kafka_set_log_queue (rd_kafka_t *rk,
3163  rd_kafka_queue_t *rkqu);
3164 
3165 
3169 RD_EXPORT
3170 size_t rd_kafka_queue_length (rd_kafka_queue_t *rkqu);
3171 
3172 
3190 RD_EXPORT
3191 void rd_kafka_queue_io_event_enable (rd_kafka_queue_t *rkqu, int fd,
3192  const void *payload, size_t size);
3193 
3210 RD_EXPORT
3211 void rd_kafka_queue_cb_event_enable (rd_kafka_queue_t *rkqu,
3212  void (*event_cb) (rd_kafka_t *rk,
3213  void *qev_opaque),
3214  void *qev_opaque);
3215 
3226 #define RD_KAFKA_OFFSET_BEGINNING -2
3228 #define RD_KAFKA_OFFSET_END -1
3230 #define RD_KAFKA_OFFSET_STORED -1000
3232 #define RD_KAFKA_OFFSET_INVALID -1001
3236 #define RD_KAFKA_OFFSET_TAIL_BASE -2000 /* internal: do not use */
3237 
3244 #define RD_KAFKA_OFFSET_TAIL(CNT) (RD_KAFKA_OFFSET_TAIL_BASE - (CNT))
3245 
3279 RD_EXPORT
3280 int rd_kafka_consume_start(rd_kafka_topic_t *rkt, int32_t partition,
3281  int64_t offset);
3282 
3297 RD_EXPORT
3298 int rd_kafka_consume_start_queue(rd_kafka_topic_t *rkt, int32_t partition,
3299  int64_t offset, rd_kafka_queue_t *rkqu);
3300 
3314 RD_EXPORT
3315 int rd_kafka_consume_stop(rd_kafka_topic_t *rkt, int32_t partition);
3316 
3317 
3318 
3333 RD_EXPORT
3334 rd_kafka_resp_err_t rd_kafka_seek (rd_kafka_topic_t *rkt,
3335  int32_t partition,
3336  int64_t offset,
3337  int timeout_ms);
3338 
3339 
3364 RD_EXPORT
3365 rd_kafka_message_t *rd_kafka_consume(rd_kafka_topic_t *rkt, int32_t partition,
3366  int timeout_ms);
3367 
3368 
3369 
3395 RD_EXPORT
3396 ssize_t rd_kafka_consume_batch(rd_kafka_topic_t *rkt, int32_t partition,
3397  int timeout_ms,
3398  rd_kafka_message_t **rkmessages,
3399  size_t rkmessages_size);
3400 
3401 
3402 
3436 RD_EXPORT
3437 int rd_kafka_consume_callback(rd_kafka_topic_t *rkt, int32_t partition,
3438  int timeout_ms,
3439  void (*consume_cb) (rd_kafka_message_t
3440  *rkmessage,
3441  void *commit_opaque),
3442  void *commit_opaque);
3443 
3444 
3461 RD_EXPORT
3462 rd_kafka_message_t *rd_kafka_consume_queue(rd_kafka_queue_t *rkqu,
3463  int timeout_ms);
3464 
3470 RD_EXPORT
3471 ssize_t rd_kafka_consume_batch_queue(rd_kafka_queue_t *rkqu,
3472  int timeout_ms,
3473  rd_kafka_message_t **rkmessages,
3474  size_t rkmessages_size);
3475 
3485 RD_EXPORT
3486 int rd_kafka_consume_callback_queue (rd_kafka_queue_t *rkqu,
3487  int timeout_ms,
3488  void (*consume_cb) (rd_kafka_message_t
3489  *rkmessage,
3490  void *commit_opaque),
3491  void *commit_opaque);
3492 
3493 
3520 RD_EXPORT
3521 rd_kafka_resp_err_t rd_kafka_offset_store (rd_kafka_topic_t *rkt,
3522  int32_t partition, int64_t offset);
3523 
3524 
3545 RD_EXPORT rd_kafka_resp_err_t
3546 rd_kafka_offsets_store (rd_kafka_t *rk,
3547  rd_kafka_topic_partition_list_t *offsets);
3601 RD_EXPORT rd_kafka_resp_err_t
3602 rd_kafka_subscribe (rd_kafka_t *rk,
3603  const rd_kafka_topic_partition_list_t *topics);
3604 
3605 
3609 RD_EXPORT
3610 rd_kafka_resp_err_t rd_kafka_unsubscribe (rd_kafka_t *rk);
3611 
3612 
3622 RD_EXPORT rd_kafka_resp_err_t
3623 rd_kafka_subscription (rd_kafka_t *rk,
3624  rd_kafka_topic_partition_list_t **topics);
3625 
3626 
3627 
3657 RD_EXPORT
3658 rd_kafka_message_t *rd_kafka_consumer_poll (rd_kafka_t *rk, int timeout_ms);
3659 
3677 RD_EXPORT
3678 rd_kafka_resp_err_t rd_kafka_consumer_close (rd_kafka_t *rk);
3679 
3680 
3681 
3699 RD_EXPORT rd_kafka_resp_err_t
3700 rd_kafka_assign (rd_kafka_t *rk,
3701  const rd_kafka_topic_partition_list_t *partitions);
3702 
3712 RD_EXPORT rd_kafka_resp_err_t
3713 rd_kafka_assignment (rd_kafka_t *rk,
3714  rd_kafka_topic_partition_list_t **partitions);
3715 
3716 
3717 
3718 
3739 RD_EXPORT rd_kafka_resp_err_t
3740 rd_kafka_commit (rd_kafka_t *rk, const rd_kafka_topic_partition_list_t *offsets,
3741  int async);
3742 
3743 
3750 RD_EXPORT rd_kafka_resp_err_t
3751 rd_kafka_commit_message (rd_kafka_t *rk, const rd_kafka_message_t *rkmessage,
3752  int async);
3753 
3754 
3777 RD_EXPORT rd_kafka_resp_err_t
3778 rd_kafka_commit_queue (rd_kafka_t *rk,
3779  const rd_kafka_topic_partition_list_t *offsets,
3780  rd_kafka_queue_t *rkqu,
3781  void (*cb) (rd_kafka_t *rk,
3782  rd_kafka_resp_err_t err,
3783  rd_kafka_topic_partition_list_t *offsets,
3784  void *commit_opaque),
3785  void *commit_opaque);
3786 
3787 
3800 RD_EXPORT rd_kafka_resp_err_t
3801 rd_kafka_committed (rd_kafka_t *rk,
3802  rd_kafka_topic_partition_list_t *partitions,
3803  int timeout_ms);
3804 
3805 
3806 
3823 RD_EXPORT rd_kafka_resp_err_t
3824 rd_kafka_position (rd_kafka_t *rk,
3825  rd_kafka_topic_partition_list_t *partitions);
3826 
3827 
3828 
3829 
3841 RD_EXPORT rd_kafka_consumer_group_metadata_t *
3842 rd_kafka_consumer_group_metadata (rd_kafka_t *rk);
3843 
3844 
3852 RD_EXPORT rd_kafka_consumer_group_metadata_t *
3853 rd_kafka_consumer_group_metadata_new (const char *group_id);
3854 
3855 
3860 RD_EXPORT void
3861 rd_kafka_consumer_group_metadata_destroy (rd_kafka_consumer_group_metadata_t *);
3862 
3863 
3884 RD_EXPORT rd_kafka_error_t *
3885 rd_kafka_consumer_group_metadata_write (
3886  const rd_kafka_consumer_group_metadata_t *cgmd,
3887  void **bufferp, size_t *sizep);
3888 
3909 RD_EXPORT rd_kafka_error_t *
3910 rd_kafka_consumer_group_metadata_read (
3911  rd_kafka_consumer_group_metadata_t **cgmdp,
3912  const void *buffer, size_t size);
3913 
3929 #define RD_KAFKA_MSG_F_FREE 0x1
3930 #define RD_KAFKA_MSG_F_COPY 0x2
3931 #define RD_KAFKA_MSG_F_BLOCK 0x4
3942 #define RD_KAFKA_MSG_F_PARTITION 0x8
4049 RD_EXPORT
4050 int rd_kafka_produce(rd_kafka_topic_t *rkt, int32_t partition,
4051  int msgflags,
4052  void *payload, size_t len,
4053  const void *key, size_t keylen,
4054  void *msg_opaque);
4055 
4056 
4070 RD_EXPORT
4071 rd_kafka_resp_err_t rd_kafka_producev (rd_kafka_t *rk, ...);
4072 
4073 
4085 RD_EXPORT
4086 rd_kafka_error_t *rd_kafka_produceva (rd_kafka_t *rk,
4087  const rd_kafka_vu_t *vus,
4088  size_t cnt);
4089 
4090 
4120 RD_EXPORT
4121 int rd_kafka_produce_batch(rd_kafka_topic_t *rkt, int32_t partition,
4122  int msgflags,
4123  rd_kafka_message_t *rkmessages, int message_cnt);
4124 
4125 
4126 
4127 
4149 RD_EXPORT
4150 rd_kafka_resp_err_t rd_kafka_flush (rd_kafka_t *rk, int timeout_ms);
4151 
4152 
4153 
4184 RD_EXPORT
4185 rd_kafka_resp_err_t rd_kafka_purge (rd_kafka_t *rk, int purge_flags);
4186 
4187 
4195 #define RD_KAFKA_PURGE_F_QUEUE 0x1
4196 
4204 #define RD_KAFKA_PURGE_F_INFLIGHT 0x2
4205 
4206 
4210 #define RD_KAFKA_PURGE_F_NON_BLOCKING 0x4
4211 
4212 
4227 typedef struct rd_kafka_metadata_broker {
4228  int32_t id;
4229  char *host;
4230  int port;
4231 } rd_kafka_metadata_broker_t;
4232 
4236 typedef struct rd_kafka_metadata_partition {
4237  int32_t id;
4238  rd_kafka_resp_err_t err;
4239  int32_t leader;
4240  int replica_cnt;
4241  int32_t *replicas;
4242  int isr_cnt;
4243  int32_t *isrs;
4244 } rd_kafka_metadata_partition_t;
4245 
4249 typedef struct rd_kafka_metadata_topic {
4250  char *topic;
4251  int partition_cnt;
4252  struct rd_kafka_metadata_partition *partitions;
4253  rd_kafka_resp_err_t err;
4254 } rd_kafka_metadata_topic_t;
4255 
4256 
4260 typedef struct rd_kafka_metadata {
4261  int broker_cnt;
4262  struct rd_kafka_metadata_broker *brokers;
4264  int topic_cnt;
4265  struct rd_kafka_metadata_topic *topics;
4267  int32_t orig_broker_id;
4268  char *orig_broker_name;
4269 } rd_kafka_metadata_t;
4270 
4271 
4292 RD_EXPORT
4293 rd_kafka_resp_err_t
4294 rd_kafka_metadata (rd_kafka_t *rk, int all_topics,
4295  rd_kafka_topic_t *only_rkt,
4296  const struct rd_kafka_metadata **metadatap,
4297  int timeout_ms);
4298 
4302 RD_EXPORT
4303 void rd_kafka_metadata_destroy(const struct rd_kafka_metadata *metadata);
4304 
4305 
4325 struct rd_kafka_group_member_info {
4326  char *member_id;
4327  char *client_id;
4328  char *client_host;
4329  void *member_metadata;
4331  int member_metadata_size;
4332  void *member_assignment;
4334  int member_assignment_size;
4335 };
4336 
4340 struct rd_kafka_group_info {
4341  struct rd_kafka_metadata_broker broker;
4342  char *group;
4343  rd_kafka_resp_err_t err;
4344  char *state;
4345  char *protocol_type;
4346  char *protocol;
4347  struct rd_kafka_group_member_info *members;
4348  int member_cnt;
4349 };
4350 
4356 struct rd_kafka_group_list {
4357  struct rd_kafka_group_info *groups;
4358  int group_cnt;
4359 };
4360 
4361 
4389 RD_EXPORT
4390 rd_kafka_resp_err_t
4391 rd_kafka_list_groups (rd_kafka_t *rk, const char *group,
4392  const struct rd_kafka_group_list **grplistp,
4393  int timeout_ms);
4394 
4398 RD_EXPORT
4399 void rd_kafka_group_list_destroy (const struct rd_kafka_group_list *grplist);
4400 
4401 
4442 RD_EXPORT
4443 int rd_kafka_brokers_add(rd_kafka_t *rk, const char *brokerlist);
4444 
4445 
4446 
4447 
4460 RD_EXPORT RD_DEPRECATED
4461 void rd_kafka_set_logger(rd_kafka_t *rk,
4462  void (*func) (const rd_kafka_t *rk, int level,
4463  const char *fac, const char *buf));
4464 
4465 
4475 RD_EXPORT
4476 void rd_kafka_set_log_level(rd_kafka_t *rk, int level);
4477 
4478 
4482 RD_EXPORT
4483 void rd_kafka_log_print(const rd_kafka_t *rk, int level,
4484  const char *fac, const char *buf);
4485 
4486 
4492 RD_EXPORT
4493 void rd_kafka_log_syslog(const rd_kafka_t *rk, int level,
4494  const char *fac, const char *buf);
4495 
4496 
4519 RD_EXPORT
4520 int rd_kafka_outq_len(rd_kafka_t *rk);
4521 
4522 
4523 
4530 RD_EXPORT
4531 void rd_kafka_dump(FILE *fp, rd_kafka_t *rk);
4532 
4533 
4534 
4540 RD_EXPORT
4541 int rd_kafka_thread_cnt(void);
4542 
4543 
4551 typedef enum rd_kafka_thread_type_t {
4552  RD_KAFKA_THREAD_MAIN,
4553  RD_KAFKA_THREAD_BACKGROUND,
4554  RD_KAFKA_THREAD_BROKER
4555 } rd_kafka_thread_type_t;
4556 
4557 
4566 RD_EXPORT
4567 int rd_kafka_wait_destroyed(int timeout_ms);
4568 
4569 
4575 RD_EXPORT
4576 int rd_kafka_unittest (void);
4577 
4578 
4596 RD_EXPORT
4597 rd_kafka_resp_err_t rd_kafka_poll_set_consumer (rd_kafka_t *rk);
4598 
4599 
4615 typedef int rd_kafka_event_type_t;
4616 #define RD_KAFKA_EVENT_NONE 0x0
4617 #define RD_KAFKA_EVENT_DR 0x1
4618 #define RD_KAFKA_EVENT_FETCH 0x2
4619 #define RD_KAFKA_EVENT_LOG 0x4
4620 #define RD_KAFKA_EVENT_ERROR 0x8
4621 #define RD_KAFKA_EVENT_REBALANCE 0x10
4622 #define RD_KAFKA_EVENT_OFFSET_COMMIT 0x20
4623 #define RD_KAFKA_EVENT_STATS 0x40
4624 #define RD_KAFKA_EVENT_CREATETOPICS_RESULT 100
4625 #define RD_KAFKA_EVENT_DELETETOPICS_RESULT 101
4626 #define RD_KAFKA_EVENT_CREATEPARTITIONS_RESULT 102
4627 #define RD_KAFKA_EVENT_ALTERCONFIGS_RESULT 103
4628 #define RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT 104
4629 #define RD_KAFKA_EVENT_OAUTHBEARER_TOKEN_REFRESH 0x100
4640 RD_EXPORT
4641 rd_kafka_event_type_t rd_kafka_event_type (const rd_kafka_event_t *rkev);
4642 
4649 RD_EXPORT
4650 const char *rd_kafka_event_name (const rd_kafka_event_t *rkev);
4651 
4652 
4662 RD_EXPORT
4663 void rd_kafka_event_destroy (rd_kafka_event_t *rkev);
4664 
4665 
4681 RD_EXPORT
4682 const rd_kafka_message_t *rd_kafka_event_message_next (rd_kafka_event_t *rkev);
4683 
4684 
4698 RD_EXPORT
4699 size_t rd_kafka_event_message_array (rd_kafka_event_t *rkev,
4700  const rd_kafka_message_t **rkmessages,
4701  size_t size);
4702 
4703 
4711 RD_EXPORT
4712 size_t rd_kafka_event_message_count (rd_kafka_event_t *rkev);
4713 
4714 
4726 RD_EXPORT
4727 const char *rd_kafka_event_config_string (rd_kafka_event_t *rkev);
4728 
4729 
4738 RD_EXPORT
4739 rd_kafka_resp_err_t rd_kafka_event_error (rd_kafka_event_t *rkev);
4740 
4741 
4750 RD_EXPORT
4751 const char *rd_kafka_event_error_string (rd_kafka_event_t *rkev);
4752 
4753 
4762 RD_EXPORT
4763 int rd_kafka_event_error_is_fatal (rd_kafka_event_t *rkev);
4764 
4765 
4778 RD_EXPORT
4779 void *rd_kafka_event_opaque (rd_kafka_event_t *rkev);
4780 
4781 
4790 RD_EXPORT
4791 int rd_kafka_event_log (rd_kafka_event_t *rkev,
4792  const char **fac, const char **str, int *level);
4793 
4794 
4806 RD_EXPORT
4807 int rd_kafka_event_debug_contexts (rd_kafka_event_t *rkev,
4808  char *dst, size_t dstsize);
4809 
4810 
4822 RD_EXPORT
4823 const char *rd_kafka_event_stats (rd_kafka_event_t *rkev);
4824 
4825 
4835 RD_EXPORT rd_kafka_topic_partition_list_t *
4836 rd_kafka_event_topic_partition_list (rd_kafka_event_t *rkev);
4837 
4838 
4848 RD_EXPORT rd_kafka_topic_partition_t *
4849 rd_kafka_event_topic_partition (rd_kafka_event_t *rkev);
4850 
4851 
4853 typedef rd_kafka_event_t rd_kafka_CreateTopics_result_t;
4855 typedef rd_kafka_event_t rd_kafka_DeleteTopics_result_t;
4857 typedef rd_kafka_event_t rd_kafka_CreatePartitions_result_t;
4859 typedef rd_kafka_event_t rd_kafka_AlterConfigs_result_t;
4861 typedef rd_kafka_event_t rd_kafka_DescribeConfigs_result_t;
4862 
4872 RD_EXPORT const rd_kafka_CreateTopics_result_t *
4873 rd_kafka_event_CreateTopics_result (rd_kafka_event_t *rkev);
4874 
4884 RD_EXPORT const rd_kafka_DeleteTopics_result_t *
4885 rd_kafka_event_DeleteTopics_result (rd_kafka_event_t *rkev);
4886 
4896 RD_EXPORT const rd_kafka_CreatePartitions_result_t *
4897 rd_kafka_event_CreatePartitions_result (rd_kafka_event_t *rkev);
4898 
4908 RD_EXPORT const rd_kafka_AlterConfigs_result_t *
4909 rd_kafka_event_AlterConfigs_result (rd_kafka_event_t *rkev);
4910 
4920 RD_EXPORT const rd_kafka_DescribeConfigs_result_t *
4921 rd_kafka_event_DescribeConfigs_result (rd_kafka_event_t *rkev);
4922 
4923 
4924 
4925 
4935 RD_EXPORT
4936 rd_kafka_event_t *rd_kafka_queue_poll (rd_kafka_queue_t *rkqu, int timeout_ms);
4937 
4951 RD_EXPORT
4952 int rd_kafka_queue_poll_callback (rd_kafka_queue_t *rkqu, int timeout_ms);
4953 
4954 
4996 typedef rd_kafka_resp_err_t
4997 (rd_kafka_plugin_f_conf_init_t) (rd_kafka_conf_t *conf,
4998  void **plug_opaquep,
4999  char *errstr, size_t errstr_size);
5000 
5080 typedef rd_kafka_conf_res_t
5081 (rd_kafka_interceptor_f_on_conf_set_t) (rd_kafka_conf_t *conf,
5082  const char *name, const char *val,
5083  char *errstr, size_t errstr_size,
5084  void *ic_opaque);
5085 
5086 
5103 typedef rd_kafka_resp_err_t
5104 (rd_kafka_interceptor_f_on_conf_dup_t) (rd_kafka_conf_t *new_conf,
5105  const rd_kafka_conf_t *old_conf,
5106  size_t filter_cnt,
5107  const char **filter,
5108  void *ic_opaque);
5109 
5110 
5117 typedef rd_kafka_resp_err_t
5118 (rd_kafka_interceptor_f_on_conf_destroy_t) (void *ic_opaque);
5119 
5120 
5138 typedef rd_kafka_resp_err_t
5139 (rd_kafka_interceptor_f_on_new_t) (rd_kafka_t *rk, const rd_kafka_conf_t *conf,
5140  void *ic_opaque,
5141  char *errstr, size_t errstr_size);
5142 
5143 
5151 typedef rd_kafka_resp_err_t
5152 (rd_kafka_interceptor_f_on_destroy_t) (rd_kafka_t *rk, void *ic_opaque);
5153 
5154 
5155 
5156 
5177 typedef rd_kafka_resp_err_t
5178 (rd_kafka_interceptor_f_on_send_t) (rd_kafka_t *rk,
5179  rd_kafka_message_t *rkmessage,
5180  void *ic_opaque);
5181 
5204 typedef rd_kafka_resp_err_t
5205 (rd_kafka_interceptor_f_on_acknowledgement_t) (rd_kafka_t *rk,
5206  rd_kafka_message_t *rkmessage,
5207  void *ic_opaque);
5208 
5209 
5226 typedef rd_kafka_resp_err_t
5227 (rd_kafka_interceptor_f_on_consume_t) (rd_kafka_t *rk,
5228  rd_kafka_message_t *rkmessage,
5229  void *ic_opaque);
5230 
5251 typedef rd_kafka_resp_err_t
5252 (rd_kafka_interceptor_f_on_commit_t) (
5253  rd_kafka_t *rk,
5254  const rd_kafka_topic_partition_list_t *offsets,
5255  rd_kafka_resp_err_t err, void *ic_opaque);
5256 
5257 
5279 typedef rd_kafka_resp_err_t
5280 (rd_kafka_interceptor_f_on_request_sent_t) (
5281  rd_kafka_t *rk,
5282  int sockfd,
5283  const char *brokername,
5284  int32_t brokerid,
5285  int16_t ApiKey,
5286  int16_t ApiVersion,
5287  int32_t CorrId,
5288  size_t size,
5289  void *ic_opaque);
5290 
5291 
5308 typedef rd_kafka_resp_err_t
5309 (rd_kafka_interceptor_f_on_thread_start_t) (
5310  rd_kafka_t *rk,
5311  rd_kafka_thread_type_t thread_type,
5312  const char *thread_name,
5313  void *ic_opaque);
5314 
5315 
5335 typedef rd_kafka_resp_err_t
5336 (rd_kafka_interceptor_f_on_thread_exit_t) (
5337  rd_kafka_t *rk,
5338  rd_kafka_thread_type_t thread_type,
5339  const char *thread_name,
5340  void *ic_opaque);
5341 
5342 
5343 
5356 RD_EXPORT rd_kafka_resp_err_t
5357 rd_kafka_conf_interceptor_add_on_conf_set (
5358  rd_kafka_conf_t *conf, const char *ic_name,
5359  rd_kafka_interceptor_f_on_conf_set_t *on_conf_set,
5360  void *ic_opaque);
5361 
5362 
5375 RD_EXPORT rd_kafka_resp_err_t
5376 rd_kafka_conf_interceptor_add_on_conf_dup (
5377  rd_kafka_conf_t *conf, const char *ic_name,
5378  rd_kafka_interceptor_f_on_conf_dup_t *on_conf_dup,
5379  void *ic_opaque);
5380 
5394 RD_EXPORT rd_kafka_resp_err_t
5395 rd_kafka_conf_interceptor_add_on_conf_destroy (
5396  rd_kafka_conf_t *conf, const char *ic_name,
5397  rd_kafka_interceptor_f_on_conf_destroy_t *on_conf_destroy,
5398  void *ic_opaque);
5399 
5400 
5422 RD_EXPORT rd_kafka_resp_err_t
5423 rd_kafka_conf_interceptor_add_on_new (
5424  rd_kafka_conf_t *conf, const char *ic_name,
5425  rd_kafka_interceptor_f_on_new_t *on_new,
5426  void *ic_opaque);
5427 
5428 
5429 
5442 RD_EXPORT rd_kafka_resp_err_t
5443 rd_kafka_interceptor_add_on_destroy (
5444  rd_kafka_t *rk, const char *ic_name,
5445  rd_kafka_interceptor_f_on_destroy_t *on_destroy,
5446  void *ic_opaque);
5447 
5448 
5461 RD_EXPORT rd_kafka_resp_err_t
5462 rd_kafka_interceptor_add_on_send (
5463  rd_kafka_t *rk, const char *ic_name,
5464  rd_kafka_interceptor_f_on_send_t *on_send,
5465  void *ic_opaque);
5466 
5479 RD_EXPORT rd_kafka_resp_err_t
5480 rd_kafka_interceptor_add_on_acknowledgement (
5481  rd_kafka_t *rk, const char *ic_name,
5482  rd_kafka_interceptor_f_on_acknowledgement_t *on_acknowledgement,
5483  void *ic_opaque);
5484 
5485 
5498 RD_EXPORT rd_kafka_resp_err_t
5499 rd_kafka_interceptor_add_on_consume (
5500  rd_kafka_t *rk, const char *ic_name,
5501  rd_kafka_interceptor_f_on_consume_t *on_consume,
5502  void *ic_opaque);
5503 
5504 
5517 RD_EXPORT rd_kafka_resp_err_t
5518 rd_kafka_interceptor_add_on_commit (
5519  rd_kafka_t *rk, const char *ic_name,
5520  rd_kafka_interceptor_f_on_commit_t *on_commit,
5521  void *ic_opaque);
5522 
5523 
5536 RD_EXPORT rd_kafka_resp_err_t
5537 rd_kafka_interceptor_add_on_request_sent (
5538  rd_kafka_t *rk, const char *ic_name,
5539  rd_kafka_interceptor_f_on_request_sent_t *on_request_sent,
5540  void *ic_opaque);
5541 
5542 
5555 RD_EXPORT rd_kafka_resp_err_t
5556 rd_kafka_interceptor_add_on_thread_start (
5557  rd_kafka_t *rk, const char *ic_name,
5558  rd_kafka_interceptor_f_on_thread_start_t *on_thread_start,
5559  void *ic_opaque);
5560 
5561 
5574 RD_EXPORT rd_kafka_resp_err_t
5575 rd_kafka_interceptor_add_on_thread_exit (
5576  rd_kafka_t *rk, const char *ic_name,
5577  rd_kafka_interceptor_f_on_thread_exit_t *on_thread_exit,
5578  void *ic_opaque);
5579 
5580 
5581 
5602 RD_EXPORT rd_kafka_resp_err_t
5603 rd_kafka_topic_result_error (const rd_kafka_topic_result_t *topicres);
5604 
5611 RD_EXPORT const char *
5612 rd_kafka_topic_result_error_string (const rd_kafka_topic_result_t *topicres);
5613 
5619 RD_EXPORT const char *
5620 rd_kafka_topic_result_name (const rd_kafka_topic_result_t *topicres);
5621 
5622 
5669 typedef enum rd_kafka_admin_op_t {
5670  RD_KAFKA_ADMIN_OP_ANY = 0,
5671  RD_KAFKA_ADMIN_OP_CREATETOPICS,
5672  RD_KAFKA_ADMIN_OP_DELETETOPICS,
5673  RD_KAFKA_ADMIN_OP_CREATEPARTITIONS,
5674  RD_KAFKA_ADMIN_OP_ALTERCONFIGS,
5675  RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS,
5676  RD_KAFKA_ADMIN_OP__CNT
5677 } rd_kafka_admin_op_t;
5678 
5691 typedef struct rd_kafka_AdminOptions_s rd_kafka_AdminOptions_t;
5692 
5712 RD_EXPORT rd_kafka_AdminOptions_t *
5713 rd_kafka_AdminOptions_new (rd_kafka_t *rk, rd_kafka_admin_op_t for_api);
5714 
5715 
5719 RD_EXPORT void rd_kafka_AdminOptions_destroy (rd_kafka_AdminOptions_t *options);
5720 
5721 
5740 RD_EXPORT rd_kafka_resp_err_t
5741 rd_kafka_AdminOptions_set_request_timeout (rd_kafka_AdminOptions_t *options,
5742  int timeout_ms,
5743  char *errstr, size_t errstr_size);
5744 
5745 
5772 RD_EXPORT rd_kafka_resp_err_t
5773 rd_kafka_AdminOptions_set_operation_timeout (rd_kafka_AdminOptions_t *options,
5774  int timeout_ms,
5775  char *errstr, size_t errstr_size);
5776 
5777 
5796 RD_EXPORT rd_kafka_resp_err_t
5797 rd_kafka_AdminOptions_set_validate_only (rd_kafka_AdminOptions_t *options,
5798  int true_or_false,
5799  char *errstr, size_t errstr_size);
5800 
5801 
5827 RD_EXPORT rd_kafka_resp_err_t
5828 rd_kafka_AdminOptions_set_broker (rd_kafka_AdminOptions_t *options,
5829  int32_t broker_id,
5830  char *errstr, size_t errstr_size);
5831 
5832 
5833 
5838 RD_EXPORT void
5839 rd_kafka_AdminOptions_set_opaque (rd_kafka_AdminOptions_t *options,
5840  void *ev_opaque);
5841 
5842 
5843 
5844 
5845 
5846 
5847 /*
5848  * CreateTopics - create topics in cluster.
5849  *
5850  */
5851 
5852 
5854 typedef struct rd_kafka_NewTopic_s rd_kafka_NewTopic_t;
5855 
5875 RD_EXPORT rd_kafka_NewTopic_t *
5876 rd_kafka_NewTopic_new (const char *topic, int num_partitions,
5877  int replication_factor,
5878  char *errstr, size_t errstr_size);
5879 
5884 RD_EXPORT void
5885 rd_kafka_NewTopic_destroy (rd_kafka_NewTopic_t *new_topic);
5886 
5887 
5893 RD_EXPORT void
5894 rd_kafka_NewTopic_destroy_array (rd_kafka_NewTopic_t **new_topics,
5895  size_t new_topic_cnt);
5896 
5897 
5919 RD_EXPORT rd_kafka_resp_err_t
5920 rd_kafka_NewTopic_set_replica_assignment (rd_kafka_NewTopic_t *new_topic,
5921  int32_t partition,
5922  int32_t *broker_ids,
5923  size_t broker_id_cnt,
5924  char *errstr, size_t errstr_size);
5925 
5938 RD_EXPORT rd_kafka_resp_err_t
5939 rd_kafka_NewTopic_set_config (rd_kafka_NewTopic_t *new_topic,
5940  const char *name, const char *value);
5941 
5942 
5961 RD_EXPORT void
5962 rd_kafka_CreateTopics (rd_kafka_t *rk,
5963  rd_kafka_NewTopic_t **new_topics,
5964  size_t new_topic_cnt,
5965  const rd_kafka_AdminOptions_t *options,
5966  rd_kafka_queue_t *rkqu);
5967 
5968 
5981 RD_EXPORT const rd_kafka_topic_result_t **
5982 rd_kafka_CreateTopics_result_topics (
5983  const rd_kafka_CreateTopics_result_t *result,
5984  size_t *cntp);
5985 
5986 
5987 
5988 
5989 
5990 /*
5991  * DeleteTopics - delete topics from cluster
5992  *
5993  */
5994 
5996 typedef struct rd_kafka_DeleteTopic_s rd_kafka_DeleteTopic_t;
5997 
6007 RD_EXPORT rd_kafka_DeleteTopic_t *
6008 rd_kafka_DeleteTopic_new (const char *topic);
6009 
6014 RD_EXPORT void
6015 rd_kafka_DeleteTopic_destroy (rd_kafka_DeleteTopic_t *del_topic);
6016 
6022 RD_EXPORT void
6023 rd_kafka_DeleteTopic_destroy_array (rd_kafka_DeleteTopic_t **del_topics,
6024  size_t del_topic_cnt);
6025 
6039 RD_EXPORT
6040 void rd_kafka_DeleteTopics (rd_kafka_t *rk,
6041  rd_kafka_DeleteTopic_t **del_topics,
6042  size_t del_topic_cnt,
6043  const rd_kafka_AdminOptions_t *options,
6044  rd_kafka_queue_t *rkqu);
6045 
6046 
6047 
6060 RD_EXPORT const rd_kafka_topic_result_t **
6061 rd_kafka_DeleteTopics_result_topics (
6062  const rd_kafka_DeleteTopics_result_t *result,
6063  size_t *cntp);
6064 
6065 
6066 
6067 
6068 
6069 
6076 typedef struct rd_kafka_NewPartitions_s rd_kafka_NewPartitions_t;
6077 
6094 RD_EXPORT rd_kafka_NewPartitions_t *
6095 rd_kafka_NewPartitions_new (const char *topic, size_t new_total_cnt,
6096  char *errstr, size_t errstr_size);
6097 
6102 RD_EXPORT void
6103 rd_kafka_NewPartitions_destroy (rd_kafka_NewPartitions_t *new_parts);
6104 
6110 RD_EXPORT void
6111 rd_kafka_NewPartitions_destroy_array (rd_kafka_NewPartitions_t **new_parts,
6112  size_t new_parts_cnt);
6113 
6136 RD_EXPORT rd_kafka_resp_err_t
6137 rd_kafka_NewPartitions_set_replica_assignment (rd_kafka_NewPartitions_t *new_parts,
6138  int32_t new_partition_idx,
6139  int32_t *broker_ids,
6140  size_t broker_id_cnt,
6141  char *errstr,
6142  size_t errstr_size);
6143 
6144 
6163 RD_EXPORT void
6164 rd_kafka_CreatePartitions (rd_kafka_t *rk,
6165  rd_kafka_NewPartitions_t **new_parts,
6166  size_t new_parts_cnt,
6167  const rd_kafka_AdminOptions_t *options,
6168  rd_kafka_queue_t *rkqu);
6169 
6170 
6171 
6184 RD_EXPORT const rd_kafka_topic_result_t **
6185 rd_kafka_CreatePartitions_result_topics (
6186  const rd_kafka_CreatePartitions_result_t *result,
6187  size_t *cntp);
6188 
6189 
6190 
6191 
6192 
6207 typedef enum rd_kafka_ConfigSource_t {
6210  RD_KAFKA_CONFIG_SOURCE_UNKNOWN_CONFIG = 0,
6212  RD_KAFKA_CONFIG_SOURCE_DYNAMIC_TOPIC_CONFIG = 1,
6214  RD_KAFKA_CONFIG_SOURCE_DYNAMIC_BROKER_CONFIG = 2,
6217  RD_KAFKA_CONFIG_SOURCE_DYNAMIC_DEFAULT_BROKER_CONFIG = 3,
6220  RD_KAFKA_CONFIG_SOURCE_STATIC_BROKER_CONFIG = 4,
6223  RD_KAFKA_CONFIG_SOURCE_DEFAULT_CONFIG = 5,
6224 
6226  RD_KAFKA_CONFIG_SOURCE__CNT,
6227 } rd_kafka_ConfigSource_t;
6228 
6229 
6233 RD_EXPORT const char *
6234 rd_kafka_ConfigSource_name (rd_kafka_ConfigSource_t confsource);
6235 
6236 
6238 typedef struct rd_kafka_ConfigEntry_s rd_kafka_ConfigEntry_t;
6239 
6243 RD_EXPORT const char *
6244 rd_kafka_ConfigEntry_name (const rd_kafka_ConfigEntry_t *entry);
6245 
6250 RD_EXPORT const char *
6251 rd_kafka_ConfigEntry_value (const rd_kafka_ConfigEntry_t *entry);
6252 
6256 RD_EXPORT rd_kafka_ConfigSource_t
6257 rd_kafka_ConfigEntry_source (const rd_kafka_ConfigEntry_t *entry);
6258 
6263 RD_EXPORT int
6264 rd_kafka_ConfigEntry_is_read_only (const rd_kafka_ConfigEntry_t *entry);
6265 
6271 RD_EXPORT int
6272 rd_kafka_ConfigEntry_is_default (const rd_kafka_ConfigEntry_t *entry);
6273 
6281 RD_EXPORT int
6282 rd_kafka_ConfigEntry_is_sensitive (const rd_kafka_ConfigEntry_t *entry);
6283 
6287 RD_EXPORT int
6288 rd_kafka_ConfigEntry_is_synonym (const rd_kafka_ConfigEntry_t *entry);
6289 
6290 
6301 RD_EXPORT const rd_kafka_ConfigEntry_t **
6302 rd_kafka_ConfigEntry_synonyms (const rd_kafka_ConfigEntry_t *entry,
6303  size_t *cntp);
6304 
6305 
6306 
6307 
6309 typedef enum rd_kafka_ResourceType_t {
6310  RD_KAFKA_RESOURCE_UNKNOWN = 0,
6311  RD_KAFKA_RESOURCE_ANY = 1,
6312  RD_KAFKA_RESOURCE_TOPIC = 2,
6313  RD_KAFKA_RESOURCE_GROUP = 3,
6314  RD_KAFKA_RESOURCE_BROKER = 4,
6315  RD_KAFKA_RESOURCE__CNT,
6316 } rd_kafka_ResourceType_t;
6317 
6321 RD_EXPORT const char *
6322 rd_kafka_ResourceType_name (rd_kafka_ResourceType_t restype);
6323 
6325 typedef struct rd_kafka_ConfigResource_s rd_kafka_ConfigResource_t;
6326 
6327 
6336 RD_EXPORT rd_kafka_ConfigResource_t *
6337 rd_kafka_ConfigResource_new (rd_kafka_ResourceType_t restype,
6338  const char *resname);
6339 
6344 RD_EXPORT void
6345 rd_kafka_ConfigResource_destroy (rd_kafka_ConfigResource_t *config);
6346 
6347 
6353 RD_EXPORT void
6354 rd_kafka_ConfigResource_destroy_array (rd_kafka_ConfigResource_t **config,
6355  size_t config_cnt);
6356 
6357 
6371 RD_EXPORT rd_kafka_resp_err_t
6372 rd_kafka_ConfigResource_set_config (rd_kafka_ConfigResource_t *config,
6373  const char *name, const char *value);
6374 
6375 
6384 RD_EXPORT const rd_kafka_ConfigEntry_t **
6385 rd_kafka_ConfigResource_configs (const rd_kafka_ConfigResource_t *config,
6386  size_t *cntp);
6387 
6388 
6389 
6393 RD_EXPORT rd_kafka_ResourceType_t
6394 rd_kafka_ConfigResource_type (const rd_kafka_ConfigResource_t *config);
6395 
6399 RD_EXPORT const char *
6400 rd_kafka_ConfigResource_name (const rd_kafka_ConfigResource_t *config);
6401 
6405 RD_EXPORT rd_kafka_resp_err_t
6406 rd_kafka_ConfigResource_error (const rd_kafka_ConfigResource_t *config);
6407 
6412 RD_EXPORT const char *
6413 rd_kafka_ConfigResource_error_string (const rd_kafka_ConfigResource_t *config);
6414 
6415 
6442 RD_EXPORT
6443 void rd_kafka_AlterConfigs (rd_kafka_t *rk,
6444  rd_kafka_ConfigResource_t **configs,
6445  size_t config_cnt,
6446  const rd_kafka_AdminOptions_t *options,
6447  rd_kafka_queue_t *rkqu);
6448 
6449 
6468 RD_EXPORT const rd_kafka_ConfigResource_t **
6469 rd_kafka_AlterConfigs_result_resources (
6470  const rd_kafka_AlterConfigs_result_t *result,
6471  size_t *cntp);
6472 
6473 
6474 
6475 
6476 
6477 
6508 RD_EXPORT
6509 void rd_kafka_DescribeConfigs (rd_kafka_t *rk,
6510  rd_kafka_ConfigResource_t **configs,
6511  size_t config_cnt,
6512  const rd_kafka_AdminOptions_t *options,
6513  rd_kafka_queue_t *rkqu);
6514 
6515 
6516 
6517 
6530 RD_EXPORT const rd_kafka_ConfigResource_t **
6531 rd_kafka_DescribeConfigs_result_resources (
6532  const rd_kafka_DescribeConfigs_result_t *result,
6533  size_t *cntp);
6534 
6589 RD_EXPORT
6590 rd_kafka_resp_err_t
6591 rd_kafka_oauthbearer_set_token (rd_kafka_t *rk,
6592  const char *token_value,
6593  int64_t md_lifetime_ms,
6594  const char *md_principal_name,
6595  const char **extensions, size_t extension_size,
6596  char *errstr, size_t errstr_size);
6597 
6618 RD_EXPORT
6619 rd_kafka_resp_err_t
6620 rd_kafka_oauthbearer_set_token_failure (rd_kafka_t *rk, const char *errstr);
6621 
6810 RD_EXPORT
6811 rd_kafka_error_t *
6812 rd_kafka_init_transactions (rd_kafka_t *rk, int timeout_ms);
6813 
6814 
6815 
6852 RD_EXPORT
6853 rd_kafka_error_t *rd_kafka_begin_transaction (rd_kafka_t *rk);
6854 
6855 
6920 RD_EXPORT
6921 rd_kafka_error_t *
6922 rd_kafka_send_offsets_to_transaction (
6923  rd_kafka_t *rk,
6924  const rd_kafka_topic_partition_list_t *offsets,
6925  const rd_kafka_consumer_group_metadata_t *cgmetadata,
6926  int timeout_ms);
6927 
6928 
6985 RD_EXPORT
6986 rd_kafka_error_t *
6987 rd_kafka_commit_transaction (rd_kafka_t *rk, int timeout_ms);
6988 
6989 
7038 RD_EXPORT
7039 rd_kafka_error_t *
7040 rd_kafka_abort_transaction (rd_kafka_t *rk, int timeout_ms);
7041 
7042 
7045 /* @cond NO_DOC */
7046 #ifdef __cplusplus
7047 }
7048 #endif
7049 #endif /* _RDKAFKA_H_ */
7050 /* @endcond NO_DOC */
rd_kafka_topic_partition_t::_private
void * _private
Definition: rdkafka.h:857
rd_kafka_message_status
RD_EXPORT rd_kafka_msg_status_t rd_kafka_message_status(const rd_kafka_message_t *rkmessage)
Returns the message's persistence status in the topic log.
rd_kafka_resp_err_t
rd_kafka_resp_err_t
Error codes.
Definition: rdkafka.h:260
rd_kafka_interceptor_f_on_send_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_send_t)(rd_kafka_t *rk, rd_kafka_message_t *rkmessage, void *ic_opaque)
on_send() is called from rd_kafka_produce*() (et.al) prior to the partitioner being called...
Definition: rdkafka.h:5194
rd_kafka_message_t::rkt
rd_kafka_topic_t * rkt
Definition: rdkafka.h:1358
rd_kafka_conf_interceptor_add_on_conf_dup
RD_EXPORT rd_kafka_resp_err_t rd_kafka_conf_interceptor_add_on_conf_dup(rd_kafka_conf_t *conf, const char *ic_name, rd_kafka_interceptor_f_on_conf_dup_t *on_conf_dup, void *ic_opaque)
Append an on_conf_dup() interceptor.
RD_KAFKA_CERT_CA
Definition: rdkafka.h:2189
rd_kafka_init_transactions
RD_EXPORT rd_kafka_error_t * rd_kafka_init_transactions(rd_kafka_t *rk, int timeout_ms)
Initialize transactions for the producer instance.
RD_KAFKA_RESP_ERR_NO_ERROR
Definition: rdkafka.h:389
rd_kafka_ConfigEntry_name
RD_EXPORT const char * rd_kafka_ConfigEntry_name(const rd_kafka_ConfigEntry_t *entry)
rd_kafka_ConfigSource_t
rd_kafka_ConfigSource_t
Apache Kafka config sources.
Definition: rdkafka.h:6223
rd_kafka_controllerid
RD_EXPORT int32_t rd_kafka_controllerid(rd_kafka_t *rk, int timeout_ms)
Returns the current ControllerId as reported in broker metadata.
rd_kafka_consume_start
RD_EXPORT int rd_kafka_consume_start(rd_kafka_topic_t *rkt, int32_t partition, int64_t offset)
Start consuming messages for topic rkt and partition at offset offset which may either be an absolute...
RD_KAFKA_RESP_ERR__UNKNOWN_PROTOCOL
Definition: rdkafka.h:324
rd_kafka_event_DeleteTopics_result
RD_EXPORT const rd_kafka_DeleteTopics_result_t * rd_kafka_event_DeleteTopics_result(rd_kafka_event_t *rkev)
Get DeleteTopics result.
rd_kafka_message_t::err
rd_kafka_resp_err_t err
Definition: rdkafka.h:1357
rd_kafka_test_fatal_error
RD_EXPORT rd_kafka_resp_err_t rd_kafka_test_fatal_error(rd_kafka_t *rk, rd_kafka_resp_err_t err, const char *reason)
Trigger a fatal error for testing purposes.
rd_kafka_conf_res_t
rd_kafka_conf_res_t
Configuration result type.
Definition: rdkafka.h:1552
rd_kafka_group_info::member_cnt
int member_cnt
Definition: rdkafka.h:4362
rd_kafka_memberid
RD_EXPORT char * rd_kafka_memberid(const rd_kafka_t *rk)
Returns this client's broker-assigned group member id.
rd_kafka_queue_forward
RD_EXPORT void rd_kafka_queue_forward(rd_kafka_queue_t *src, rd_kafka_queue_t *dst)
Forward/re-route queue src to dst. If dst is NULL the forwarding is removed.
rd_kafka_topic_partition_list_t::cnt
int cnt
Definition: rdkafka.h:875
RD_KAFKA_RESP_ERR__KEY_SERIALIZATION
Definition: rdkafka.h:342
rd_kafka_NewTopic_new
RD_EXPORT rd_kafka_NewTopic_t * rd_kafka_NewTopic_new(const char *topic, int num_partitions, int replication_factor, char *errstr, size_t errstr_size)
Create a new NewTopic object. This object is later passed to rd_kafka_CreateTopics().
rd_kafka_conf_set_ssl_cert_verify_cb
RD_EXPORT rd_kafka_conf_res_t rd_kafka_conf_set_ssl_cert_verify_cb(rd_kafka_conf_t *conf, int(*ssl_cert_verify_cb)(rd_kafka_t *rk, const char *broker_name, int32_t broker_id, int *x509_error, int depth, const char *buf, size_t size, char *errstr, size_t errstr_size, void *opaque))
Sets the verification callback of the broker certificate.
rd_kafka_consume_callback_queue
RD_EXPORT int rd_kafka_consume_callback_queue(rd_kafka_queue_t *rkqu, int timeout_ms, void(*consume_cb)(rd_kafka_message_t *rkmessage, void *commit_opaque), void *commit_opaque)
Consume multiple messages from queue with callback.
rd_kafka_ConfigResource_name
RD_EXPORT const char * rd_kafka_ConfigResource_name(const rd_kafka_ConfigResource_t *config)
rd_kafka_thread_cnt
RD_EXPORT int rd_kafka_thread_cnt(void)
Retrieve the current number of threads in use by librdkafka.
rd_kafka_conf_set_consume_cb
RD_EXPORT void rd_kafka_conf_set_consume_cb(rd_kafka_conf_t *conf, void(*consume_cb)(rd_kafka_message_t *rkmessage, void *opaque))
Consumer: Set consume callback for use with rd_kafka_consumer_poll()
rd_kafka_topic_partition_list_t::elems
rd_kafka_topic_partition_t * elems
Definition: rdkafka.h:877
rd_kafka_subscription
RD_EXPORT rd_kafka_resp_err_t rd_kafka_subscription(rd_kafka_t *rk, rd_kafka_topic_partition_list_t **topics)
Returns the current topic subscription.
rd_kafka_AdminOptions_new
RD_EXPORT rd_kafka_AdminOptions_t * rd_kafka_AdminOptions_new(rd_kafka_t *rk, rd_kafka_admin_op_t for_api)
Create a new AdminOptions object.
rd_kafka_ConfigEntry_synonyms
RD_EXPORT const rd_kafka_ConfigEntry_t ** rd_kafka_ConfigEntry_synonyms(const rd_kafka_ConfigEntry_t *entry, size_t *cntp)
RD_KAFKA_CERT_PUBLIC_KEY
Definition: rdkafka.h:2187
rd_kafka_conf_set_dr_msg_cb
RD_EXPORT void rd_kafka_conf_set_dr_msg_cb(rd_kafka_conf_t *conf, void(*dr_msg_cb)(rd_kafka_t *rk, const rd_kafka_message_t *rkmessage, void *opaque))
Producer: Set delivery report callback in provided conf object.
rd_kafka_event_name
RD_EXPORT const char * rd_kafka_event_name(const rd_kafka_event_t *rkev)
RD_KAFKA_VTYPE_TIMESTAMP
Definition: rdkafka.h:1054
rd_kafka_topic_partition_list_destroy
RD_EXPORT void rd_kafka_topic_partition_list_destroy(rd_kafka_topic_partition_list_t *rkparlist)
Free all resources used by the list and the list itself.
rd_kafka_unittest
RD_EXPORT int rd_kafka_unittest(void)
Run librdkafka's built-in unit-tests.
RD_KAFKA_RESOURCE_ANY
Definition: rdkafka.h:6327
rd_kafka_resume_partitions
RD_EXPORT rd_kafka_resp_err_t rd_kafka_resume_partitions(rd_kafka_t *rk, rd_kafka_topic_partition_list_t *partitions)
Resume producing consumption for the provided list of partitions.
rd_kafka_topic_conf_set
RD_EXPORT rd_kafka_conf_res_t rd_kafka_topic_conf_set(rd_kafka_topic_conf_t *conf, const char *name, const char *value, char *errstr, size_t errstr_size)
Sets a single rd_kafka_topic_conf_t value by property name.
rd_kafka_admin_op_t
rd_kafka_admin_op_t
Admin operation enum name for use with rd_kafka_AdminOptions_new()
Definition: rdkafka.h:5685
rd_kafka_topic_partition_list_copy
RD_EXPORT rd_kafka_topic_partition_list_t * rd_kafka_topic_partition_list_copy(const rd_kafka_topic_partition_list_t *src)
Make a copy of an existing list.
rd_kafka_header_cnt
RD_EXPORT size_t rd_kafka_header_cnt(const rd_kafka_headers_t *hdrs)
Returns the number of header key/value pairs.
rd_kafka_header_add
RD_EXPORT rd_kafka_resp_err_t rd_kafka_header_add(rd_kafka_headers_t *hdrs, const char *name, ssize_t name_size, const void *value, ssize_t value_size)
Add header with name name and value val (copied) of size size (not including null-terminator).
rd_kafka_DeleteTopics_result_t
rd_kafka_event_t rd_kafka_DeleteTopics_result_t
Definition: rdkafka.h:4871
rd_kafka_topic_conf_set_partitioner_cb
RD_EXPORT void rd_kafka_topic_conf_set_partitioner_cb(rd_kafka_topic_conf_t *topic_conf, int32_t(*partitioner)(const rd_kafka_topic_t *rkt, const void *keydata, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque))
Producer: Set partitioner callback in provided topic conf object.
rd_kafka_poll_set_consumer
RD_EXPORT rd_kafka_resp_err_t rd_kafka_poll_set_consumer(rd_kafka_t *rk)
Redirect the main (rd_kafka_poll()) queue to the KafkaConsumer's queue (rd_kafka_consumer_poll()).
rd_kafka_message_destroy
RD_EXPORT void rd_kafka_message_destroy(rd_kafka_message_t *rkmessage)
Frees resources for rkmessage and hands ownership back to rdkafka.
rd_kafka_topic_conf_get
RD_EXPORT rd_kafka_conf_res_t rd_kafka_topic_conf_get(const rd_kafka_topic_conf_t *conf, const char *name, char *dest, size_t *dest_size)
Retrieve topic configuration value for property name.
RD_KAFKA_RESP_ERR__QUEUE_FULL
Definition: rdkafka.h:298
rd_kafka_topic_result_error
RD_EXPORT rd_kafka_resp_err_t rd_kafka_topic_result_error(const rd_kafka_topic_result_t *topicres)
Topic result provides per-topic operation result information.
RD_KAFKA_RESP_ERR__NOENT
Definition: rdkafka.h:354
rd_kafka_error_name
RD_EXPORT const char * rd_kafka_error_name(const rd_kafka_error_t *error)
RD_KAFKA_RESP_ERR_UNSUPPORTED_VERSION
Definition: rdkafka.h:468
RD_KAFKA_MSG_STATUS_NOT_PERSISTED
Definition: rdkafka.h:1514
RD_KAFKA_VTYPE_TOPIC
Definition: rdkafka.h:1043
rd_kafka_position
RD_EXPORT rd_kafka_resp_err_t rd_kafka_position(rd_kafka_t *rk, rd_kafka_topic_partition_list_t *partitions)
Retrieve current positions (offsets) for topics+partitions.
RD_KAFKA_RESP_ERR__PREV_IN_PROGRESS
Definition: rdkafka.h:312
rd_kafka_queue_get_consumer
RD_EXPORT rd_kafka_queue_t * rd_kafka_queue_get_consumer(rd_kafka_t *rk)
rd_kafka_ConfigResource_error_string
RD_EXPORT const char * rd_kafka_ConfigResource_error_string(const rd_kafka_ConfigResource_t *config)
rd_kafka_group_info::state
char * state
Definition: rdkafka.h:4358
rd_kafka_ConfigEntry_is_read_only
RD_EXPORT int rd_kafka_ConfigEntry_is_read_only(const rd_kafka_ConfigEntry_t *entry)
rd_kafka_DescribeConfigs
RD_EXPORT void rd_kafka_DescribeConfigs(rd_kafka_t *rk, rd_kafka_ConfigResource_t **configs, size_t config_cnt, const rd_kafka_AdminOptions_t *options, rd_kafka_queue_t *rkqu)
Get configuration for the specified resources in configs.
rd_kafka_interceptor_f_on_request_sent_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_request_sent_t)(rd_kafka_t *rk, int sockfd, const char *brokername, int32_t brokerid, int16_t ApiKey, int16_t ApiVersion, int32_t CorrId, size_t size, void *ic_opaque)
on_request_sent() is called when a request has been fully written to a broker TCP connections socket...
Definition: rdkafka.h:5296
rd_kafka_message_t::key_len
size_t key_len
Definition: rdkafka.h:1369
rd_kafka_offsets_store
RD_EXPORT rd_kafka_resp_err_t rd_kafka_offsets_store(rd_kafka_t *rk, rd_kafka_topic_partition_list_t *offsets)
Store offsets for next auto-commit for one or more partitions.
RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN
Definition: rdkafka.h:292
rd_kafka_msg_partitioner_consistent
RD_EXPORT int32_t rd_kafka_msg_partitioner_consistent(const rd_kafka_topic_t *rkt, const void *key, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque)
Consistent partitioner.
rd_kafka_consumer_group_metadata_write
RD_EXPORT rd_kafka_error_t * rd_kafka_consumer_group_metadata_write(const rd_kafka_consumer_group_metadata_t *cgmd, void **bufferp, size_t *sizep)
Serialize the consumer group metadata to a binary format. This is mainly for client binding use and n...
rd_kafka_event_type
RD_EXPORT rd_kafka_event_type_t rd_kafka_event_type(const rd_kafka_event_t *rkev)
rd_kafka_conf_dup_filter
RD_EXPORT rd_kafka_conf_t * rd_kafka_conf_dup_filter(const rd_kafka_conf_t *conf, size_t filter_cnt, const char **filter)
Same as rd_kafka_conf_dup() but with an array of property name prefixes to filter out (ignore) when c...
rd_kafka_ConfigResource_configs
RD_EXPORT const rd_kafka_ConfigEntry_t ** rd_kafka_ConfigResource_configs(const rd_kafka_ConfigResource_t *config, size_t *cntp)
Get an array of config entries from a ConfigResource object.
RD_KAFKA_CONF_INVALID
Definition: rdkafka.h:1554
RD_KAFKA_RESP_ERR_FENCED_LEADER_EPOCH
Definition: rdkafka.h:551
RD_KAFKA_RESP_ERR_STALE_BROKER_EPOCH
Definition: rdkafka.h:557
rd_kafka_group_member_info::member_assignment_size
int member_assignment_size
Definition: rdkafka.h:4348
rd_kafka_produceva
RD_EXPORT rd_kafka_error_t * rd_kafka_produceva(rd_kafka_t *rk, const rd_kafka_vu_t *vus, size_t cnt)
Produce and send a single message to broker.
rd_kafka_new
RD_EXPORT rd_kafka_t * rd_kafka_new(rd_kafka_type_t type, rd_kafka_conf_t *conf, char *errstr, size_t errstr_size)
Creates a new Kafka handle and starts its operation according to the specified type (RD_KAFKA_CONSUME...
rd_kafka_get_err_descs
RD_EXPORT void rd_kafka_get_err_descs(const struct rd_kafka_err_desc **errdescs, size_t *cntp)
Returns the full list of error codes.
rd_kafka_group_info
Group information.
Definition: rdkafka.h:4354
rd_kafka_group_info::group
char * group
Definition: rdkafka.h:4356
rd_kafka_message_errstr
RD_EXPORT const char * rd_kafka_message_errstr(const rd_kafka_message_t *rkmessage)
Returns the error string for an errored rd_kafka_message_t or NULL if there was no error...
rd_kafka_metadata_partition_t
Partition information.
Definition: rdkafka.h:4250
RD_KAFKA_RESP_ERR__MSG_TIMED_OUT
Definition: rdkafka.h:279
RD_KAFKA_CERT_PRIVATE_KEY
Definition: rdkafka.h:2188
rd_kafka_consumer_group_metadata_read
RD_EXPORT rd_kafka_error_t * rd_kafka_consumer_group_metadata_read(rd_kafka_consumer_group_metadata_t **cgmdp, const void *buffer, size_t size)
Reads serialized consumer group metadata and returns a consumer group metadata object. This is mainly for client binding use and not for application use.
RD_KAFKA_RESP_ERR__RETRY
Definition: rdkafka.h:360
rd_kafka_interceptor_add_on_commit
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_commit(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_commit_t *on_commit, void *ic_opaque)
Append an on_commit() interceptor.
RD_KAFKA_RESP_ERR_INVALID_TXN_STATE
Definition: rdkafka.h:494
rd_kafka_purge
RD_EXPORT rd_kafka_resp_err_t rd_kafka_purge(rd_kafka_t *rk, int purge_flags)
Purge messages currently handled by the producer instance.
rd_kafka_abort_transaction
RD_EXPORT rd_kafka_error_t * rd_kafka_abort_transaction(rd_kafka_t *rk, int timeout_ms)
Aborts the ongoing transaction.
rd_kafka_event_log
RD_EXPORT int rd_kafka_event_log(rd_kafka_event_t *rkev, const char **fac, const char **str, int *level)
Extract log message from the event.
rd_kafka_offsets_for_times
RD_EXPORT rd_kafka_resp_err_t rd_kafka_offsets_for_times(rd_kafka_t *rk, rd_kafka_topic_partition_list_t *offsets, int timeout_ms)
Look up the offsets for the given partitions by timestamp.
rd_kafka_interceptor_f_on_conf_dup_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_conf_dup_t)(rd_kafka_conf_t *new_conf, const rd_kafka_conf_t *old_conf, size_t filter_cnt, const char **filter, void *ic_opaque)
on_conf_dup() is called from rd_kafka_conf_dup() in the order the interceptors were added and is used...
Definition: rdkafka.h:5120
rd_kafka_version_str
RD_EXPORT const char * rd_kafka_version_str(void)
Returns the librdkafka version as string.
rd_kafka_opaque
RD_EXPORT void * rd_kafka_opaque(const rd_kafka_t *rk)
Retrieves the opaque pointer previously set with rd_kafka_conf_set_opaque()
rd_kafka_group_member_info::client_id
char * client_id
Definition: rdkafka.h:4341
rd_kafka_err_desc::name
const char * name
Definition: rdkafka.h:593
RD_KAFKA_RESP_ERR__FS
Definition: rdkafka.h:288
rd_kafka_topic_partition_list_new
RD_EXPORT rd_kafka_topic_partition_list_t * rd_kafka_topic_partition_list_new(int size)
Create a new list/vector Topic+Partition container.
rd_kafka_DeleteTopics
RD_EXPORT void rd_kafka_DeleteTopics(rd_kafka_t *rk, rd_kafka_DeleteTopic_t **del_topics, size_t del_topic_cnt, const rd_kafka_AdminOptions_t *options, rd_kafka_queue_t *rkqu)
Delete topics from cluster as specified by the topics array of size topic_cnt elements.
RD_KAFKA_RESP_ERR_LOG_DIR_NOT_FOUND
Definition: rdkafka.h:517
rd_kafka_group_member_info::client_host
char * client_host
Definition: rdkafka.h:4342
RD_KAFKA_RESP_ERR_UNKNOWN_PRODUCER_ID
Definition: rdkafka.h:521
RD_KAFKA_CERT_ENC_PEM
Definition: rdkafka.h:2203
rd_kafka_msg_partitioner_fnv1a
RD_EXPORT int32_t rd_kafka_msg_partitioner_fnv1a(const rd_kafka_topic_t *rkt, const void *key, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque)
FNV-1a partitioner.
rd_kafka_group_list::groups
struct rd_kafka_group_info * groups
Definition: rdkafka.h:4371
rd_kafka_CreateTopics_result_t
rd_kafka_event_t rd_kafka_CreateTopics_result_t
Definition: rdkafka.h:4869
rd_kafka_commit_message
RD_EXPORT rd_kafka_resp_err_t rd_kafka_commit_message(rd_kafka_t *rk, const rd_kafka_message_t *rkmessage, int async)
Commit message's offset on broker for the message's partition. The committed offset is the message's ...
rd_kafka_consume_batch
RD_EXPORT ssize_t rd_kafka_consume_batch(rd_kafka_topic_t *rkt, int32_t partition, int timeout_ms, rd_kafka_message_t **rkmessages, size_t rkmessages_size)
Consume up to rkmessages_size from topic rkt and partition putting a pointer to each message in the a...
RD_KAFKA_VTYPE_OPAQUE
Definition: rdkafka.h:1048
RD_KAFKA_CERT_ENC_DER
Definition: rdkafka.h:2202
rd_kafka_CreatePartitions
RD_EXPORT void rd_kafka_CreatePartitions(rd_kafka_t *rk, rd_kafka_NewPartitions_t **new_parts, size_t new_parts_cnt, const rd_kafka_AdminOptions_t *options, rd_kafka_queue_t *rkqu)
Create additional partitions for the given topics, as specified by the new_parts array of size new_pa...
rd_kafka_topic_partition_list_sort
RD_EXPORT void rd_kafka_topic_partition_list_sort(rd_kafka_topic_partition_list_t *rktparlist, int(*cmp)(const void *a, const void *b, void *cmp_opaque), void *cmp_opaque)
Sort list using comparator cmp.
RD_KAFKA_RESP_ERR__UNKNOWN_GROUP
Definition: rdkafka.h:308
rd_kafka_interceptor_f_on_new_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_new_t)(rd_kafka_t *rk, const rd_kafka_conf_t *conf, void *ic_opaque, char *errstr, size_t errstr_size)
on_new() is called from rd_kafka_new() prior toreturning the newly created client instance to the app...
Definition: rdkafka.h:5155
rd_kafka_log_print
RD_EXPORT void rd_kafka_log_print(const rd_kafka_t *rk, int level, const char *fac, const char *buf)
Builtin (default) log sink: print to stderr.
rd_kafka_group_info::protocol_type
char * protocol_type
Definition: rdkafka.h:4359
rd_kafka_interceptor_f_on_acknowledgement_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_acknowledgement_t)(rd_kafka_t *rk, rd_kafka_message_t *rkmessage, void *ic_opaque)
on_acknowledgement() is called to inform interceptors that a message was succesfully delivered or per...
Definition: rdkafka.h:5221
rd_kafka_interceptor_f_on_commit_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_commit_t)(rd_kafka_t *rk, const rd_kafka_topic_partition_list_t *offsets, rd_kafka_resp_err_t err, void *ic_opaque)
on_commit() is called on completed or failed offset commit. It is called from internal librdkafka thr...
Definition: rdkafka.h:5268
RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS
Definition: rdkafka.h:316
rd_kafka_plugin_f_conf_init_t
rd_kafka_resp_err_t( rd_kafka_plugin_f_conf_init_t)(rd_kafka_conf_t *conf, void **plug_opaquep, char *errstr, size_t errstr_size)
Plugin's configuration initializer method called each time the library is referenced from configurati...
Definition: rdkafka.h:5013
rd_kafka_AdminOptions_set_request_timeout
RD_EXPORT rd_kafka_resp_err_t rd_kafka_AdminOptions_set_request_timeout(rd_kafka_AdminOptions_t *options, int timeout_ms, char *errstr, size_t errstr_size)
Sets the overall request timeout, including broker lookup, request transmission, operation time on br...
rd_kafka_conf_set
RD_EXPORT rd_kafka_conf_res_t rd_kafka_conf_set(rd_kafka_conf_t *conf, const char *name, const char *value, char *errstr, size_t errstr_size)
Sets a configuration property.
rd_kafka_outq_len
RD_EXPORT int rd_kafka_outq_len(rd_kafka_t *rk)
Returns the current out queue length.
rd_kafka_group_list::group_cnt
int group_cnt
Definition: rdkafka.h:4372
rd_kafka_consumer_group_metadata_new
RD_EXPORT rd_kafka_consumer_group_metadata_t * rd_kafka_consumer_group_metadata_new(const char *group_id)
Create a new consumer group metadata object. This is typically only used for writing tests...
RD_KAFKA_RESP_ERR__TIMED_OUT_QUEUE
Definition: rdkafka.h:334
rd_kafka_interceptor_add_on_consume
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_consume(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_consume_t *on_consume, void *ic_opaque)
Append an on_consume() interceptor.
rd_kafka_vtype_t
rd_kafka_vtype_t
Var-arg tag types.
Definition: rdkafka.h:1041
rd_kafka_event_message_next
RD_EXPORT const rd_kafka_message_t * rd_kafka_event_message_next(rd_kafka_event_t *rkev)
rd_kafka_error_txn_requires_abort
RD_EXPORT int rd_kafka_error_txn_requires_abort(const rd_kafka_error_t *error)
RD_KAFKA_RESP_ERR__UNKNOWN_BROKER
Definition: rdkafka.h:374
RD_KAFKA_THREAD_BROKER
Definition: rdkafka.h:4568
RD_KAFKA_RESP_ERR__GAPLESS_GUARANTEE
Definition: rdkafka.h:370
rd_kafka_offset_store
RD_EXPORT rd_kafka_resp_err_t rd_kafka_offset_store(rd_kafka_topic_t *rkt, int32_t partition, int64_t offset)
Store offset offset + 1 for topic rkt partition partition.
rd_kafka_conf_set_error_cb
RD_EXPORT void rd_kafka_conf_set_error_cb(rd_kafka_conf_t *conf, void(*error_cb)(rd_kafka_t *rk, int err, const char *reason, void *opaque))
Set error callback in provided conf object.
rd_kafka_group_info::err
rd_kafka_resp_err_t err
Definition: rdkafka.h:4357
rd_kafka_ResourceType_t
rd_kafka_ResourceType_t
Definition: rdkafka.h:6325
rd_kafka_message_t::len
size_t len
Definition: rdkafka.h:1364
rd_kafka_commit
RD_EXPORT rd_kafka_resp_err_t rd_kafka_commit(rd_kafka_t *rk, const rd_kafka_topic_partition_list_t *offsets, int async)
Commit offsets on broker for the provided list of partitions.
rd_kafka_AlterConfigs_result_t
rd_kafka_event_t rd_kafka_AlterConfigs_result_t
Definition: rdkafka.h:4875
rd_kafka_interceptor_f_on_thread_start_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_thread_start_t)(rd_kafka_t *rk, rd_kafka_thread_type_t thread_type, const char *thread_name, void *ic_opaque)
on_thread_start() is called from a newly created librdkafka-managed thread.
Definition: rdkafka.h:5325
rd_kafka_conf_set_default_topic_conf
RD_EXPORT void rd_kafka_conf_set_default_topic_conf(rd_kafka_conf_t *conf, rd_kafka_topic_conf_t *tconf)
Sets the default topic configuration to use for automatically subscribed topics (e.g., through pattern-matched topics). The topic config object is not usable after this call.
rd_kafka_consumer_group_metadata
RD_EXPORT rd_kafka_consumer_group_metadata_t * rd_kafka_consumer_group_metadata(rd_kafka_t *rk)
rd_kafka_send_offsets_to_transaction
RD_EXPORT rd_kafka_error_t * rd_kafka_send_offsets_to_transaction(rd_kafka_t *rk, const rd_kafka_topic_partition_list_t *offsets, const rd_kafka_consumer_group_metadata_t *cgmetadata, int timeout_ms)
Sends a list of topic partition offsets to the consumer group coordinator for cgmetadata, and marks the offsets as part part of the current transaction. These offsets will be considered committed only if the transaction is committed successfully.
RD_KAFKA_RESP_ERR_INVALID_GROUP_ID
Definition: rdkafka.h:446
rd_kafka_type
RD_EXPORT rd_kafka_type_t rd_kafka_type(const rd_kafka_t *rk)
Returns Kafka handle type.
rd_kafka_produce
RD_EXPORT int rd_kafka_produce(rd_kafka_topic_t *rkt, int32_t partition, int msgflags, void *payload, size_t len, const void *key, size_t keylen, void *msg_opaque)
Produce and send a single message to broker.
RD_KAFKA_RESP_ERR__INCONSISTENT
Definition: rdkafka.h:368
rd_kafka_interceptor_f_on_conf_set_t
rd_kafka_conf_res_t( rd_kafka_interceptor_f_on_conf_set_t)(rd_kafka_conf_t *conf, const char *name, const char *val, char *errstr, size_t errstr_size, void *ic_opaque)
on_conf_set() is called from rd_kafka_*_conf_set() in the order the interceptors were added...
Definition: rdkafka.h:5097
RD_KAFKA_RESP_ERR__NODE_UPDATE
Definition: rdkafka.h:302
rd_kafka_queue_get_background
RD_EXPORT rd_kafka_queue_t * rd_kafka_queue_get_background(rd_kafka_t *rk)
rd_kafka_event_error_string
RD_EXPORT const char * rd_kafka_event_error_string(rd_kafka_event_t *rkev)
RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID
Definition: rdkafka.h:448
RD_KAFKA_RESP_ERR_POLICY_VIOLATION
Definition: rdkafka.h:486
rd_kafka_ConfigEntry_source
RD_EXPORT rd_kafka_ConfigSource_t rd_kafka_ConfigEntry_source(const rd_kafka_ConfigEntry_t *entry)
rd_kafka_event_topic_partition
RD_EXPORT rd_kafka_topic_partition_t * rd_kafka_event_topic_partition(rd_kafka_event_t *rkev)
rd_kafka_group_info::broker
struct rd_kafka_metadata_broker broker
Definition: rdkafka.h:4355
rd_kafka_queue_destroy
RD_EXPORT void rd_kafka_queue_destroy(rd_kafka_queue_t *rkqu)
rd_kafka_queue_length
RD_EXPORT size_t rd_kafka_queue_length(rd_kafka_queue_t *rkqu)
RD_KAFKA_RESP_ERR__CONFLICT
Definition: rdkafka.h:320
rd_kafka_ConfigResource_error
RD_EXPORT rd_kafka_resp_err_t rd_kafka_ConfigResource_error(const rd_kafka_ConfigResource_t *config)
RD_KAFKA_RESOURCE__CNT
Definition: rdkafka.h:6331
rd_kafka_interceptor_add_on_acknowledgement
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_acknowledgement(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_acknowledgement_t *on_acknowledgement, void *ic_opaque)
Append an on_acknowledgement() interceptor.
RD_KAFKA_RESP_ERR_NOT_COORDINATOR
Definition: rdkafka.h:427
rd_kafka_header_get
RD_EXPORT rd_kafka_resp_err_t rd_kafka_header_get(const rd_kafka_headers_t *hdrs, size_t idx, const char *name, const void **valuep, size_t *sizep)
Iterator for headers matching name.
rd_kafka_err_desc::code
rd_kafka_resp_err_t code
Definition: rdkafka.h:592
rd_kafka_ConfigResource_set_config
RD_EXPORT rd_kafka_resp_err_t rd_kafka_ConfigResource_set_config(rd_kafka_ConfigResource_t *config, const char *name, const char *value)
Set configuration name value pair.
rd_kafka_oauthbearer_set_token_failure
RD_EXPORT rd_kafka_resp_err_t rd_kafka_oauthbearer_set_token_failure(rd_kafka_t *rk, const char *errstr)
SASL/OAUTHBEARER token refresh failure indicator.
rd_kafka_destroy
RD_EXPORT void rd_kafka_destroy(rd_kafka_t *rk)
Destroy Kafka handle.
rd_kafka_vu_t
VTYPE + argument container for use with rd_kafka_produce_va()
Definition: rdkafka.h:1067
rd_kafka_NewTopic_t
struct rd_kafka_NewTopic_s rd_kafka_NewTopic_t
Definition: rdkafka.h:5870
rd_kafka_set_log_level
RD_EXPORT void rd_kafka_set_log_level(rd_kafka_t *rk, int level)
Specifies the maximum logging level emitted by internal kafka logging and debugging.
rd_kafka_event_DescribeConfigs_result
RD_EXPORT const rd_kafka_DescribeConfigs_result_t * rd_kafka_event_DescribeConfigs_result(rd_kafka_event_t *rkev)
Get DescribeConfigs result.
RD_KAFKA_VTYPE_MSGFLAGS
Definition: rdkafka.h:1053
rd_kafka_AlterConfigs
RD_EXPORT void rd_kafka_AlterConfigs(rd_kafka_t *rk, rd_kafka_ConfigResource_t **configs, size_t config_cnt, const rd_kafka_AdminOptions_t *options, rd_kafka_queue_t *rkqu)
Update the configuration for the specified resources. Updates are not transactional so they may succe...
rd_kafka_metadata
RD_EXPORT rd_kafka_resp_err_t rd_kafka_metadata(rd_kafka_t *rk, int all_topics, rd_kafka_topic_t *only_rkt, const struct rd_kafka_metadata **metadatap, int timeout_ms)
Request Metadata from broker.
rd_kafka_CreatePartitions_result_t
rd_kafka_event_t rd_kafka_CreatePartitions_result_t
Definition: rdkafka.h:4873
rd_kafka_wait_destroyed
RD_EXPORT int rd_kafka_wait_destroyed(int timeout_ms)
Wait for all rd_kafka_t objects to be destroyed.
RD_KAFKA_CONFIG_SOURCE_DEFAULT_CONFIG
Definition: rdkafka.h:6239
rd_kafka_error_string
RD_EXPORT const char * rd_kafka_error_string(const rd_kafka_error_t *error)
RD_KAFKA_RESP_ERR_TOPIC_EXCEPTION
Definition: rdkafka.h:432
RD_KAFKA_RESP_ERR_STALE_CTRL_EPOCH
Definition: rdkafka.h:411
rd_kafka_AdminOptions_destroy
RD_EXPORT void rd_kafka_AdminOptions_destroy(rd_kafka_AdminOptions_t *options)
Destroy a AdminOptions object.
rd_kafka_interceptor_add_on_thread_exit
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_thread_exit(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_thread_exit_t *on_thread_exit, void *ic_opaque)
Append an on_thread_exit() interceptor.
rd_kafka_DescribeConfigs_result_t
rd_kafka_event_t rd_kafka_DescribeConfigs_result_t
Definition: rdkafka.h:4877
rd_kafka_message_headers
RD_EXPORT rd_kafka_resp_err_t rd_kafka_message_headers(const rd_kafka_message_t *rkmessage, rd_kafka_headers_t **hdrsp)
Get the message header list.
RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED
Definition: rdkafka.h:372
rd_kafka_message_t::offset
int64_t offset
Definition: rdkafka.h:1371
rd_kafka_topic_conf_set_opaque
RD_EXPORT void rd_kafka_topic_conf_set_opaque(rd_kafka_topic_conf_t *conf, void *rkt_opaque)
Sets the application's opaque pointer that will be passed to all topic callbacks as the rkt_opaque ar...
rd_kafka_headers_new
RD_EXPORT rd_kafka_headers_t * rd_kafka_headers_new(size_t initial_count)
Create a new headers list.
RD_KAFKA_RESP_ERR_NETWORK_EXCEPTION
Definition: rdkafka.h:415
rd_kafka_DeleteTopics_result_topics
RD_EXPORT const rd_kafka_topic_result_t ** rd_kafka_DeleteTopics_result_topics(const rd_kafka_DeleteTopics_result_t *result, size_t *cntp)
DeleteTopics result type and methods.
rd_kafka_brokers_add
RD_EXPORT int rd_kafka_brokers_add(rd_kafka_t *rk, const char *brokerlist)
Adds one or more brokers to the kafka handle's list of initial bootstrap brokers. ...
rd_kafka_errno
RD_EXPORT RD_DEPRECATED int rd_kafka_errno(void)
Returns the thread-local system errno.
rd_kafka_commit_transaction
RD_EXPORT rd_kafka_error_t * rd_kafka_commit_transaction(rd_kafka_t *rk, int timeout_ms)
Commit the current transaction (as started with rd_kafka_begin_transaction()).
rd_kafka_topic_conf_set_msg_order_cmp
RD_EXPORT void rd_kafka_topic_conf_set_msg_order_cmp(rd_kafka_topic_conf_t *topic_conf, int(*msg_order_cmp)(const rd_kafka_message_t *a, const rd_kafka_message_t *b))
Producer: Set message queueing order comparator callback.
RD_KAFKA_ADMIN_OP_DELETETOPICS
Definition: rdkafka.h:5688
rd_kafka_interceptor_f_on_destroy_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_destroy_t)(rd_kafka_t *rk, void *ic_opaque)
on_destroy() is called from rd_kafka_destroy() or (rd_kafka_new() if rd_kafka_new() fails during init...
Definition: rdkafka.h:5168
RD_KAFKA_RESP_ERR_INVALID_MSG_SIZE
Definition: rdkafka.h:397
RD_KAFKA_ADMIN_OP_ANY
Definition: rdkafka.h:5686
rd_kafka_conf_set_oauthbearer_token_refresh_cb
RD_EXPORT void rd_kafka_conf_set_oauthbearer_token_refresh_cb(rd_kafka_conf_t *conf, void(*oauthbearer_token_refresh_cb)(rd_kafka_t *rk, const char *oauthbearer_config, void *opaque))
Set SASL/OAUTHBEARER token refresh callback in provided conf object.
RD_KAFKA_RESP_ERR__CRIT_SYS_RESOURCE
Definition: rdkafka.h:275
RD_KAFKA_RESP_ERR_UNKNOWN
Definition: rdkafka.h:387
RD_KAFKA_ADMIN_OP_CREATEPARTITIONS
Definition: rdkafka.h:5689
RD_KAFKA_RESP_ERR__INVALID_TYPE
Definition: rdkafka.h:358
rd_kafka_log_syslog
RD_EXPORT void rd_kafka_log_syslog(const rd_kafka_t *rk, int level, const char *fac, const char *buf)
Builtin log sink: print to syslog.
RD_KAFKA_RESP_ERR__BEGIN
Definition: rdkafka.h:263
rd_kafka_destroy_flags
RD_EXPORT void rd_kafka_destroy_flags(rd_kafka_t *rk, int flags)
Destroy Kafka handle according to specified destroy flags.
rd_kafka_group_member_info
Group member information.
Definition: rdkafka.h:4339
rd_kafka_message_t::key
void * key
Definition: rdkafka.h:1367
rd_kafka_conf_get
RD_EXPORT rd_kafka_conf_res_t rd_kafka_conf_get(const rd_kafka_conf_t *conf, const char *name, char *dest, size_t *dest_size)
Retrieve configuration value for property name.
rd_kafka_topic_conf_new
RD_EXPORT rd_kafka_topic_conf_t * rd_kafka_topic_conf_new(void)
Create topic configuration object.
rd_kafka_get_watermark_offsets
RD_EXPORT rd_kafka_resp_err_t rd_kafka_get_watermark_offsets(rd_kafka_t *rk, const char *topic, int32_t partition, int64_t *low, int64_t *high)
Get last known low (oldest/beginning) and high (newest/end) offsets for partition.
rd_kafka_interceptor_add_on_request_sent
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_request_sent(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_request_sent_t *on_request_sent, void *ic_opaque)
Append an on_request_sent() interceptor.
rd_kafka_dump
RD_EXPORT void rd_kafka_dump(FILE *fp, rd_kafka_t *rk)
Dumps rdkafka's internal state for handle rk to stream fp.
RD_KAFKA_VTYPE_PARTITION
Definition: rdkafka.h:1045
RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC
Definition: rdkafka.h:290
rd_kafka_conf_set_closesocket_cb
RD_EXPORT void rd_kafka_conf_set_closesocket_cb(rd_kafka_conf_t *conf, int(*closesocket_cb)(int sockfd, void *opaque))
Set close socket callback.
rd_kafka_topic_partition_list_t
A growable list of Topic+Partitions.
Definition: rdkafka.h:874
rd_kafka_event_type_t
int rd_kafka_event_type_t
Event types.
Definition: rdkafka.h:4629
rd_kafka_metadata_topic_t
Topic information.
Definition: rdkafka.h:4263
rd_kafka_conf_set_throttle_cb
RD_EXPORT void rd_kafka_conf_set_throttle_cb(rd_kafka_conf_t *conf, void(*throttle_cb)(rd_kafka_t *rk, const char *broker_name, int32_t broker_id, int throttle_time_ms, void *opaque))
Set throttle callback.
rd_kafka_queue_get_main
RD_EXPORT rd_kafka_queue_t * rd_kafka_queue_get_main(rd_kafka_t *rk)
rd_kafka_conf_set_log_cb
RD_EXPORT void rd_kafka_conf_set_log_cb(rd_kafka_conf_t *conf, void(*log_cb)(const rd_kafka_t *rk, int level, const char *fac, const char *buf))
Set logger callback.
RD_KAFKA_RESP_ERR__RESOLVE
Definition: rdkafka.h:277
rd_kafka_CreateTopics
RD_EXPORT void rd_kafka_CreateTopics(rd_kafka_t *rk, rd_kafka_NewTopic_t **new_topics, size_t new_topic_cnt, const rd_kafka_AdminOptions_t *options, rd_kafka_queue_t *rkqu)
Create topics in cluster as specified by the new_topics array of size new_topic_cnt elements...
rd_kafka_event_AlterConfigs_result
RD_EXPORT const rd_kafka_AlterConfigs_result_t * rd_kafka_event_AlterConfigs_result(rd_kafka_event_t *rkev)
Get AlterConfigs result.
rd_kafka_list_groups
RD_EXPORT rd_kafka_resp_err_t rd_kafka_list_groups(rd_kafka_t *rk, const char *group, const struct rd_kafka_group_list **grplistp, int timeout_ms)
List and describe client groups in cluster.
RD_KAFKA_RESOURCE_TOPIC
Definition: rdkafka.h:6328
RD_KAFKA_VTYPE_RKT
Definition: rdkafka.h:1044
rd_kafka_NewTopic_destroy
RD_EXPORT void rd_kafka_NewTopic_destroy(rd_kafka_NewTopic_t *new_topic)
Destroy and free a NewTopic object previously created with rd_kafka_NewTopic_new() ...
rd_kafka_topic_partition_t::partition
int32_t partition
Definition: rdkafka.h:851
RD_KAFKA_RESP_ERR__TRANSPORT
Definition: rdkafka.h:273
RD_KAFKA_RESP_ERR__SSL
Definition: rdkafka.h:304
RD_KAFKA_RESP_ERR__FAIL
Definition: rdkafka.h:271
rd_kafka_topic_partition_t::opaque
void * opaque
Definition: rdkafka.h:855
rd_kafka_err_desc::desc
const char * desc
Definition: rdkafka.h:594
rd_kafka_NewPartitions_t
struct rd_kafka_NewPartitions_s rd_kafka_NewPartitions_t
Definition: rdkafka.h:6092
rd_kafka_assign
RD_EXPORT rd_kafka_resp_err_t rd_kafka_assign(rd_kafka_t *rk, const rd_kafka_topic_partition_list_t *partitions)
Atomic assignment of partitions to consume.
rd_kafka_conf_dup
RD_EXPORT rd_kafka_conf_t * rd_kafka_conf_dup(const rd_kafka_conf_t *conf)
Creates a copy/duplicate of configuration object conf.
rd_kafka_msg_partitioner_random
RD_EXPORT int32_t rd_kafka_msg_partitioner_random(const rd_kafka_topic_t *rkt, const void *key, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque)
Random partitioner.
rd_kafka_message_timestamp
RD_EXPORT int64_t rd_kafka_message_timestamp(const rd_kafka_message_t *rkmessage, rd_kafka_timestamp_type_t *tstype)
Returns the message timestamp for a consumed message.
RD_KAFKA_RESP_ERR__PURGE_INFLIGHT
Definition: rdkafka.h:364
rd_kafka_msg_partitioner_consistent_random
RD_EXPORT int32_t rd_kafka_msg_partitioner_consistent_random(const rd_kafka_topic_t *rkt, const void *key, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque)
Consistent-Random partitioner.
rd_kafka_queue_get_partition
RD_EXPORT rd_kafka_queue_t * rd_kafka_queue_get_partition(rd_kafka_t *rk, const char *topic, int32_t partition)
rd_kafka_topic_partition_list_del_by_idx
RD_EXPORT int rd_kafka_topic_partition_list_del_by_idx(rd_kafka_topic_partition_list_t *rktparlist, int idx)
Delete partition from list by elems[] index.
rd_kafka_interceptor_f_on_conf_destroy_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_conf_destroy_t)(void *ic_opaque)
on_conf_destroy() is called from rd_kafka_*_conf_destroy() in the order the interceptors were added...
Definition: rdkafka.h:5134
rd_kafka_interceptor_add_on_send
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_send(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_send_t *on_send, void *ic_opaque)
Append an on_send() interceptor.
rd_kafka_event_CreatePartitions_result
RD_EXPORT const rd_kafka_CreatePartitions_result_t * rd_kafka_event_CreatePartitions_result(rd_kafka_event_t *rkev)
Get CreatePartitions result.
rd_kafka_NewPartitions_set_replica_assignment
RD_EXPORT rd_kafka_resp_err_t rd_kafka_NewPartitions_set_replica_assignment(rd_kafka_NewPartitions_t *new_parts, int32_t new_partition_idx, int32_t *broker_ids, size_t broker_id_cnt, char *errstr, size_t errstr_size)
Set the replica (broker id) assignment for new_partition_idx to the replica set in broker_ids (of bro...
rd_kafka_topic_result_name
RD_EXPORT const char * rd_kafka_topic_result_name(const rd_kafka_topic_result_t *topicres)
RD_KAFKA_RESP_ERR_LISTENER_NOT_FOUND
Definition: rdkafka.h:547
RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE
Definition: rdkafka.h:409
RD_KAFKA_RESP_ERR__INTR
Definition: rdkafka.h:340
rd_kafka_conf_set_connect_cb
RD_EXPORT void rd_kafka_conf_set_connect_cb(rd_kafka_conf_t *conf, int(*connect_cb)(int sockfd, const struct sockaddr *addr, int addrlen, const char *id, void *opaque))
Set connect callback.
rd_kafka_mem_free
RD_EXPORT void rd_kafka_mem_free(rd_kafka_t *rk, void *ptr)
Free pointer returned by librdkafka.
rd_kafka_ConfigResource_destroy
RD_EXPORT void rd_kafka_ConfigResource_destroy(rd_kafka_ConfigResource_t *config)
Destroy and free a ConfigResource object previously created with rd_kafka_ConfigResource_new() ...
rd_kafka_conf_interceptor_add_on_new
RD_EXPORT rd_kafka_resp_err_t rd_kafka_conf_interceptor_add_on_new(rd_kafka_conf_t *conf, const char *ic_name, rd_kafka_interceptor_f_on_new_t *on_new, void *ic_opaque)
Append an on_new() interceptor.
rd_kafka_error_destroy
RD_EXPORT void rd_kafka_error_destroy(rd_kafka_error_t *error)
Free and destroy an error object.
rd_kafka_conf_set_ssl_cert
RD_EXPORT rd_kafka_conf_res_t rd_kafka_conf_set_ssl_cert(rd_kafka_conf_t *conf, rd_kafka_cert_type_t cert_type, rd_kafka_cert_enc_t cert_enc, const void *buffer, size_t size, char *errstr, size_t errstr_size)
Set certificate/key cert_type from the cert_enc encoded memory at buffer of size bytes.
rd_kafka_clusterid
RD_EXPORT char * rd_kafka_clusterid(rd_kafka_t *rk, int timeout_ms)
Returns the ClusterId as reported in broker metadata.
rd_kafka_ResourceType_name
RD_EXPORT const char * rd_kafka_ResourceType_name(rd_kafka_ResourceType_t restype)
rd_kafka_pause_partitions
RD_EXPORT rd_kafka_resp_err_t rd_kafka_pause_partitions(rd_kafka_t *rk, rd_kafka_topic_partition_list_t *partitions)
Pause producing or consumption for the provided list of partitions.
RD_KAFKA_RESP_ERR__APPLICATION
Definition: rdkafka.h:380
rd_kafka_group_list_destroy
RD_EXPORT void rd_kafka_group_list_destroy(const struct rd_kafka_group_list *grplist)
Release list memory.
RD_KAFKA_RESP_ERR_INVALID_CONFIG
Definition: rdkafka.h:478
rd_kafka_event_destroy
RD_EXPORT void rd_kafka_event_destroy(rd_kafka_event_t *rkev)
Destroy an event.
rd_kafka_NewTopic_set_config
RD_EXPORT rd_kafka_resp_err_t rd_kafka_NewTopic_set_config(rd_kafka_NewTopic_t *new_topic, const char *name, const char *value)
Set (broker-side) topic configuration name/value pair.
rd_kafka_committed
RD_EXPORT rd_kafka_resp_err_t rd_kafka_committed(rd_kafka_t *rk, rd_kafka_topic_partition_list_t *partitions, int timeout_ms)
Retrieve committed offsets for topics+partitions.
rd_kafka_ConfigResource_new
RD_EXPORT rd_kafka_ConfigResource_t * rd_kafka_ConfigResource_new(rd_kafka_ResourceType_t restype, const char *resname)
Create new ConfigResource object.
RD_KAFKA_TIMESTAMP_LOG_APPEND_TIME
Definition: rdkafka.h:207
rd_kafka_conf_set_background_event_cb
RD_EXPORT void rd_kafka_conf_set_background_event_cb(rd_kafka_conf_t *conf, void(*event_cb)(rd_kafka_t *rk, rd_kafka_event_t *rkev, void *opaque))
Generic event callback to be used with the event API to trigger callbacks for rd_kafka_event_t object...
rd_kafka_event_debug_contexts
RD_EXPORT int rd_kafka_event_debug_contexts(rd_kafka_event_t *rkev, char *dst, size_t dstsize)
Extract log debug context from event.
rd_kafka_event_error_is_fatal
RD_EXPORT int rd_kafka_event_error_is_fatal(rd_kafka_event_t *rkev)
rd_kafka_conf_new
RD_EXPORT rd_kafka_conf_t * rd_kafka_conf_new(void)
Create configuration object.
rd_kafka_queue_poll
RD_EXPORT rd_kafka_event_t * rd_kafka_queue_poll(rd_kafka_queue_t *rkqu, int timeout_ms)
Poll a queue for an event for max timeout_ms.
rd_kafka_consume_stop
RD_EXPORT int rd_kafka_consume_stop(rd_kafka_topic_t *rkt, int32_t partition)
Stop consuming messages for topic rkt and partition, purging all messages currently in the local queu...
rd_kafka_err2name
RD_EXPORT const char * rd_kafka_err2name(rd_kafka_resp_err_t err)
Returns the error code name (enum name).
rd_kafka_AdminOptions_set_operation_timeout
RD_EXPORT rd_kafka_resp_err_t rd_kafka_AdminOptions_set_operation_timeout(rd_kafka_AdminOptions_t *options, int timeout_ms, char *errstr, size_t errstr_size)
Sets the broker's operation timeout, such as the timeout for CreateTopics to complete the creation of...
RD_KAFKA_MSG_STATUS_POSSIBLY_PERSISTED
Definition: rdkafka.h:1519
rd_kafka_conf_interceptor_add_on_conf_destroy
RD_EXPORT rd_kafka_resp_err_t rd_kafka_conf_interceptor_add_on_conf_destroy(rd_kafka_conf_t *conf, const char *ic_name, rd_kafka_interceptor_f_on_conf_destroy_t *on_conf_destroy, void *ic_opaque)
Append an on_conf_destroy() interceptor.
rd_kafka_version
RD_EXPORT int rd_kafka_version(void)
Returns the librdkafka version as integer.
RD_KAFKA_RESP_ERR_ILLEGAL_SASL_STATE
Definition: rdkafka.h:466
rd_kafka_group_member_info::member_assignment
void * member_assignment
Definition: rdkafka.h:4346
rd_kafka_conf
RD_EXPORT const rd_kafka_conf_t * rd_kafka_conf(rd_kafka_t *rk)
rd_kafka_topic_partition_list_del
RD_EXPORT int rd_kafka_topic_partition_list_del(rd_kafka_topic_partition_list_t *rktparlist, const char *topic, int32_t partition)
Delete partition from list.
rd_kafka_topic_partition_list_t::size
int size
Definition: rdkafka.h:876
rd_kafka_subscribe
RD_EXPORT rd_kafka_resp_err_t rd_kafka_subscribe(rd_kafka_t *rk, const rd_kafka_topic_partition_list_t *topics)
Subscribe to topic set using balanced consumer groups.
RD_KAFKA_MSG_STATUS_PERSISTED
Definition: rdkafka.h:1524
rd_kafka_topic_partition_destroy
RD_EXPORT void rd_kafka_topic_partition_destroy(rd_kafka_topic_partition_t *rktpar)
Destroy a rd_kafka_topic_partition_t.
rd_kafka_conf_set_opaque
RD_EXPORT void rd_kafka_conf_set_opaque(rd_kafka_conf_t *conf, void *opaque)
Sets the application's opaque pointer that will be passed to callbacks.
RD_KAFKA_RESP_ERR__PURGE_QUEUE
Definition: rdkafka.h:362
RD_KAFKA_CONF_OK
Definition: rdkafka.h:1557
rd_kafka_conf_dump
RD_EXPORT const char ** rd_kafka_conf_dump(rd_kafka_conf_t *conf, size_t *cntp)
Dump the configuration properties and values of conf to an array with "key", "value" pairs...
rd_kafka_consumer_group_metadata_destroy
RD_EXPORT void rd_kafka_consumer_group_metadata_destroy(rd_kafka_consumer_group_metadata_t *)
Frees the consumer group metadata object as returned by rd_kafka_consumer_group_metadata().
rd_kafka_event_error
RD_EXPORT rd_kafka_resp_err_t rd_kafka_event_error(rd_kafka_event_t *rkev)
RD_KAFKA_RESP_ERR__OUTDATED
Definition: rdkafka.h:332
rd_kafka_topic_partition_t::topic
char * topic
Definition: rdkafka.h:850
rd_kafka_get_debug_contexts
RD_EXPORT const char * rd_kafka_get_debug_contexts(void)
Retrieve supported debug contexts for use with the "debug" configuration property. (runtime)
rd_kafka_ConfigResource_destroy_array
RD_EXPORT void rd_kafka_ConfigResource_destroy_array(rd_kafka_ConfigResource_t **config, size_t config_cnt)
Helper function to destroy all ConfigResource objects in the configs array (of config_cnt elements)...
RD_KAFKA_RESP_ERR__WAIT_CACHE
Definition: rdkafka.h:338
rd_kafka_conf_set_offset_commit_cb
RD_EXPORT void rd_kafka_conf_set_offset_commit_cb(rd_kafka_conf_t *conf, void(*offset_commit_cb)(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_kafka_topic_partition_list_t *offsets, void *opaque))
Consumer: Set offset commit callback for use with consumer groups.
rd_kafka_conf_set_rebalance_cb
RD_EXPORT void rd_kafka_conf_set_rebalance_cb(rd_kafka_conf_t *conf, void(*rebalance_cb)(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_kafka_topic_partition_list_t *partitions, void *opaque))
Consumer: Set rebalance callback for use with coordinated consumer group balancing.
rd_kafka_AdminOptions_t
struct rd_kafka_AdminOptions_s rd_kafka_AdminOptions_t
AdminOptions provides a generic mechanism for setting optional parameters for the Admin API requests...
Definition: rdkafka.h:5707
RD_KAFKA_VTYPE_END
Definition: rdkafka.h:1042
rd_kafka_queue_poll_callback
RD_EXPORT int rd_kafka_queue_poll_callback(rd_kafka_queue_t *rkqu, int timeout_ms)
Poll a queue for events served through callbacks for max timeout_ms.
rd_kafka_interceptor_f_on_consume_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_consume_t)(rd_kafka_t *rk, rd_kafka_message_t *rkmessage, void *ic_opaque)
on_consume() is called just prior to passing the message to the application in rd_kafka_consumer_poll...
Definition: rdkafka.h:5243
rd_kafka_flush
RD_EXPORT rd_kafka_resp_err_t rd_kafka_flush(rd_kafka_t *rk, int timeout_ms)
Wait until all outstanding produce requests, et.al, are completed. This should typically be done prio...
RD_KAFKA_RESP_ERR__PARTIAL
Definition: rdkafka.h:350
rd_kafka_begin_transaction
RD_EXPORT rd_kafka_error_t * rd_kafka_begin_transaction(rd_kafka_t *rk)
Begin a new transaction.
RD_KAFKA_ADMIN_OP__CNT
Definition: rdkafka.h:5692
rd_kafka_poll
RD_EXPORT int rd_kafka_poll(rd_kafka_t *rk, int timeout_ms)
Polls the provided kafka handle for events.
RD_KAFKA_THREAD_BACKGROUND
Definition: rdkafka.h:4567
rd_kafka_topic_partition_available
RD_EXPORT int rd_kafka_topic_partition_available(const rd_kafka_topic_t *rkt, int32_t partition)
Check if partition is available (has a leader broker).
RD_KAFKA_PRODUCER
Definition: rdkafka.h:194
rd_kafka_message_latency
RD_EXPORT int64_t rd_kafka_message_latency(const rd_kafka_message_t *rkmessage)
Returns the latency for a produced message measured from the produce() call.
rd_kafka_msg_partitioner_murmur2
RD_EXPORT int32_t rd_kafka_msg_partitioner_murmur2(const rd_kafka_topic_t *rkt, const void *key, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque)
Murmur2 partitioner (Java compatible).
rd_kafka_ConfigResource_t
struct rd_kafka_ConfigResource_s rd_kafka_ConfigResource_t
Definition: rdkafka.h:6341
rd_kafka_ConfigSource_name
RD_EXPORT const char * rd_kafka_ConfigSource_name(rd_kafka_ConfigSource_t confsource)
rd_kafka_commit_queue
RD_EXPORT rd_kafka_resp_err_t rd_kafka_commit_queue(rd_kafka_t *rk, const rd_kafka_topic_partition_list_t *offsets, rd_kafka_queue_t *rkqu, void(*cb)(rd_kafka_t *rk, rd_kafka_resp_err_t err, rd_kafka_topic_partition_list_t *offsets, void *commit_opaque), void *commit_opaque)
Commit offsets on broker for the provided list of partitions.
rd_kafka_queue_cb_event_enable
RD_EXPORT void rd_kafka_queue_cb_event_enable(rd_kafka_queue_t *rkqu, void(*event_cb)(rd_kafka_t *rk, void *qev_opaque), void *qev_opaque)
Enable callback event triggering for queue.
RD_KAFKA_RESP_ERR_INVALID_REQUEST
Definition: rdkafka.h:482
RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS
Definition: rdkafka.h:436
rd_kafka_event_config_string
RD_EXPORT const char * rd_kafka_event_config_string(rd_kafka_event_t *rkev)
rd_kafka_AdminOptions_set_opaque
RD_EXPORT void rd_kafka_AdminOptions_set_opaque(rd_kafka_AdminOptions_t *options, void *ev_opaque)
Set application opaque value that can be extracted from the result event using rd_kafka_event_opaque(...
rd_kafka_message_set_headers
RD_EXPORT void rd_kafka_message_set_headers(rd_kafka_message_t *rkmessage, rd_kafka_headers_t *hdrs)
Replace the message's current headers with a new list.
rd_kafka_conf_set_socket_cb
RD_EXPORT void rd_kafka_conf_set_socket_cb(rd_kafka_conf_t *conf, int(*socket_cb)(int domain, int type, int protocol, void *opaque))
Set socket callback.
RD_KAFKA_CONSUMER
Definition: rdkafka.h:195
rd_kafka_NewTopic_destroy_array
RD_EXPORT void rd_kafka_NewTopic_destroy_array(rd_kafka_NewTopic_t **new_topics, size_t new_topic_cnt)
Helper function to destroy all NewTopic objects in the new_topics array (of new_topic_cnt elements)...
RD_KAFKA_TIMESTAMP_CREATE_TIME
Definition: rdkafka.h:206
RD_KAFKA_RESP_ERR__ISR_INSUFF
Definition: rdkafka.h:300
RD_KAFKA_RESOURCE_BROKER
Definition: rdkafka.h:6330
rd_kafka_conf_set_events
RD_EXPORT void rd_kafka_conf_set_events(rd_kafka_conf_t *conf, int events)
Enable event sourcing. events is a bitmask of RD_KAFKA_EVENT_* of events to enable for consumption by...
rd_kafka_conf_set_dr_cb
RD_EXPORT void rd_kafka_conf_set_dr_cb(rd_kafka_conf_t *conf, void(*dr_cb)(rd_kafka_t *rk, void *payload, size_t len, rd_kafka_resp_err_t err, void *opaque, void *msg_opaque))
RD_KAFKA_RESP_ERR__TIMED_OUT
Definition: rdkafka.h:296
rd_kafka_topic_conf_dup
RD_EXPORT rd_kafka_topic_conf_t * rd_kafka_topic_conf_dup(const rd_kafka_topic_conf_t *conf)
Creates a copy/duplicate of topic configuration object conf.
RD_KAFKA_RESOURCE_GROUP
Definition: rdkafka.h:6329
RD_KAFKA_RESP_ERR_OFFSET_OUT_OF_RANGE
Definition: rdkafka.h:391
rd_kafka_ConfigEntry_t
struct rd_kafka_ConfigEntry_s rd_kafka_ConfigEntry_t
Definition: rdkafka.h:6254
rd_kafka_set_logger
RD_EXPORT RD_DEPRECATED void rd_kafka_set_logger(rd_kafka_t *rk, void(*func)(const rd_kafka_t *rk, int level, const char *fac, const char *buf))
Set logger function.
RD_KAFKA_RESP_ERR__DESTROY
Definition: rdkafka.h:269
rd_kafka_metadata_t
Metadata container.
Definition: rdkafka.h:4274
rd_kafka_message_broker_id
RD_EXPORT int32_t rd_kafka_message_broker_id(const rd_kafka_message_t *rkmessage)
Returns the broker id of the broker the message was produced to or fetched from.
RD_KAFKA_RESP_ERR_KAFKA_STORAGE_ERROR
Definition: rdkafka.h:515
rd_kafka_interceptor_f_on_thread_exit_t
rd_kafka_resp_err_t( rd_kafka_interceptor_f_on_thread_exit_t)(rd_kafka_t *rk, rd_kafka_thread_type_t thread_type, const char *thread_name, void *ic_opaque)
on_thread_exit() is called just prior to a librdkafka-managed thread exiting from the exiting thread ...
Definition: rdkafka.h:5352
RD_KAFKA_RESP_ERR__NO_OFFSET
Definition: rdkafka.h:330
rd_kafka_unsubscribe
RD_EXPORT rd_kafka_resp_err_t rd_kafka_unsubscribe(rd_kafka_t *rk)
Unsubscribe from the current subscription set.
rd_kafka_metadata_destroy
RD_EXPORT void rd_kafka_metadata_destroy(const struct rd_kafka_metadata *metadata)
Release metadata memory.
rd_kafka_produce_batch
RD_EXPORT int rd_kafka_produce_batch(rd_kafka_topic_t *rkt, int32_t partition, int msgflags, rd_kafka_message_t *rkmessages, int message_cnt)
Produce multiple messages.
rd_kafka_conf_set_open_cb
RD_EXPORT void rd_kafka_conf_set_open_cb(rd_kafka_conf_t *conf, int(*open_cb)(const char *pathname, int flags, mode_t mode, void *opaque))
Set open callback.
rd_kafka_cert_enc_t
rd_kafka_cert_enc_t
SSL certificate encoding.
Definition: rdkafka.h:2200
rd_kafka_header_remove
RD_EXPORT rd_kafka_resp_err_t rd_kafka_header_remove(rd_kafka_headers_t *hdrs, const char *name)
Remove all headers for the given key (if any).
rd_kafka_ConfigResource_type
RD_EXPORT rd_kafka_ResourceType_t rd_kafka_ConfigResource_type(const rd_kafka_ConfigResource_t *config)
RD_KAFKA_RESP_ERR_MEMBER_ID_REQUIRED
Definition: rdkafka.h:561
RD_KAFKA_RESP_ERR__STATE
Definition: rdkafka.h:322
rd_kafka_producev
RD_EXPORT rd_kafka_resp_err_t rd_kafka_producev(rd_kafka_t *rk,...)
Produce and send a single message to broker.
RD_KAFKA_RESP_ERR__FENCED
Definition: rdkafka.h:378
RD_KAFKA_RESP_ERR_NOT_CONTROLLER
Definition: rdkafka.h:480
rd_kafka_seek
RD_EXPORT rd_kafka_resp_err_t rd_kafka_seek(rd_kafka_topic_t *rkt, int32_t partition, int64_t offset, int timeout_ms)
Seek consumer for topic+partition to offset which is either an absolute or logical offset...
rd_kafka_event_CreateTopics_result
RD_EXPORT const rd_kafka_CreateTopics_result_t * rd_kafka_event_CreateTopics_result(rd_kafka_event_t *rkev)
Get CreateTopics result.
rd_kafka_topic_partition_list_add_range
RD_EXPORT void rd_kafka_topic_partition_list_add_range(rd_kafka_topic_partition_list_t *rktparlist, const char *topic, int32_t start, int32_t stop)
Add range of partitions from start to stop inclusive.
rd_kafka_event_message_count
RD_EXPORT size_t rd_kafka_event_message_count(rd_kafka_event_t *rkev)
RD_KAFKA_CONF_UNKNOWN
Definition: rdkafka.h:1553
rd_kafka_topic_partition_list_add
RD_EXPORT rd_kafka_topic_partition_t * rd_kafka_topic_partition_list_add(rd_kafka_topic_partition_list_t *rktparlist, const char *topic, int32_t partition)
Add topic+partition to list.
RD_KAFKA_RESP_ERR__INVALID_ARG
Definition: rdkafka.h:294
rd_kafka_msg_partitioner_murmur2_random
RD_EXPORT int32_t rd_kafka_msg_partitioner_murmur2_random(const rd_kafka_topic_t *rkt, const void *key, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque)
Consistent-Random Murmur2 partitioner (Java compatible).
rd_kafka_thread_type_t
rd_kafka_thread_type_t
librdkafka internal thread type.
Definition: rdkafka.h:4565
RD_KAFKA_TIMESTAMP_NOT_AVAILABLE
Definition: rdkafka.h:205
rd_kafka_interceptor_add_on_thread_start
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_thread_start(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_thread_start_t *on_thread_start, void *ic_opaque)
Append an on_thread_start() interceptor.
RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS
Definition: rdkafka.h:318
rd_kafka_ConfigEntry_is_synonym
RD_EXPORT int rd_kafka_ConfigEntry_is_synonym(const rd_kafka_ConfigEntry_t *entry)
rd_kafka_consume_batch_queue
RD_EXPORT ssize_t rd_kafka_consume_batch_queue(rd_kafka_queue_t *rkqu, int timeout_ms, rd_kafka_message_t **rkmessages, size_t rkmessages_size)
Consume batch of messages from queue.
rd_kafka_DeleteTopic_new
RD_EXPORT rd_kafka_DeleteTopic_t * rd_kafka_DeleteTopic_new(const char *topic)
Create a new DeleteTopic object. This object is later passed to rd_kafka_DeleteTopics().
rd_kafka_timestamp_type_t
rd_kafka_timestamp_type_t
Definition: rdkafka.h:204
rd_kafka_topic_opaque
RD_EXPORT void * rd_kafka_topic_opaque(const rd_kafka_topic_t *rkt)
Get the rkt_opaque pointer that was set in the topic configuration with rd_kafka_topic_conf_set_opaqu...
rd_kafka_event_opaque
RD_EXPORT void * rd_kafka_event_opaque(rd_kafka_event_t *rkev)
rd_kafka_topic_result_error_string
RD_EXPORT const char * rd_kafka_topic_result_error_string(const rd_kafka_topic_result_t *topicres)
RD_KAFKA_CERT_ENC_PKCS12
Definition: rdkafka.h:2201
rd_kafka_DeleteTopic_t
struct rd_kafka_DeleteTopic_s rd_kafka_DeleteTopic_t
Definition: rdkafka.h:6012
rd_kafka_vu_t::vtype
rd_kafka_vtype_t vtype
Definition: rdkafka.h:1068
rd_kafka_error_new
RD_EXPORT rd_kafka_error_t * rd_kafka_error_new(rd_kafka_resp_err_t code, const char *fmt,...)
Create a new error object with error code and optional human readable error string in fmt...
RD_KAFKA_RESP_ERR_FENCED_INSTANCE_ID
Definition: rdkafka.h:568
rd_kafka_error_is_fatal
RD_EXPORT int rd_kafka_error_is_fatal(const rd_kafka_error_t *error)
rd_kafka_name
RD_EXPORT const char * rd_kafka_name(const rd_kafka_t *rk)
Returns Kafka handle name.
rd_kafka_message_t
A Kafka message as returned by the rd_kafka_consume*() family of functions as well as provided to the...
Definition: rdkafka.h:1356
RD_KAFKA_RESP_ERR__WAIT_COORD
Definition: rdkafka.h:306
RD_KAFKA_RESP_ERR__FATAL
Definition: rdkafka.h:366
rd_kafka_queue_io_event_enable
RD_EXPORT void rd_kafka_queue_io_event_enable(rd_kafka_queue_t *rkqu, int fd, const void *payload, size_t size)
Enable IO event triggering for queue.
rd_kafka_topic_destroy
RD_EXPORT void rd_kafka_topic_destroy(rd_kafka_topic_t *rkt)
Loose application's topic handle refcount as previously created with rd_kafka_topic_new().
rd_kafka_message_t::partition
int32_t partition
Definition: rdkafka.h:1359
RD_KAFKA_RESP_ERR__END
Definition: rdkafka.h:383
rd_kafka_conf_interceptor_add_on_conf_set
RD_EXPORT rd_kafka_resp_err_t rd_kafka_conf_interceptor_add_on_conf_set(rd_kafka_conf_t *conf, const char *ic_name, rd_kafka_interceptor_f_on_conf_set_t *on_conf_set, void *ic_opaque)
Append an on_conf_set() interceptor.
rd_kafka_query_watermark_offsets
RD_EXPORT rd_kafka_resp_err_t rd_kafka_query_watermark_offsets(rd_kafka_t *rk, const char *topic, int32_t partition, int64_t *low, int64_t *high, int timeout_ms)
Query broker for low (oldest/beginning) and high (newest/end) offsets for partition.
rd_kafka_consume
RD_EXPORT rd_kafka_message_t * rd_kafka_consume(rd_kafka_topic_t *rkt, int32_t partition, int timeout_ms)
Consume a single message from topic rkt and partition.
RD_KAFKA_RESP_ERR__IN_PROGRESS
Definition: rdkafka.h:310
rd_kafka_consumer_poll
RD_EXPORT rd_kafka_message_t * rd_kafka_consumer_poll(rd_kafka_t *rk, int timeout_ms)
Poll the consumer for messages or events.
RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND
Definition: rdkafka.h:541
rd_kafka_assignment
RD_EXPORT rd_kafka_resp_err_t rd_kafka_assignment(rd_kafka_t *rk, rd_kafka_topic_partition_list_t **partitions)
Returns the current partition assignment.
RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION
Definition: rdkafka.h:286
rd_kafka_NewPartitions_destroy_array
RD_EXPORT void rd_kafka_NewPartitions_destroy_array(rd_kafka_NewPartitions_t **new_parts, size_t new_parts_cnt)
Helper function to destroy all NewPartitions objects in the new_parts array (of new_parts_cnt element...
rd_kafka_DeleteTopic_destroy
RD_EXPORT void rd_kafka_DeleteTopic_destroy(rd_kafka_DeleteTopic_t *del_topic)
Destroy and free a DeleteTopic object previously created with rd_kafka_DeleteTopic_new() ...
RD_KAFKA_VTYPE_HEADERS
Definition: rdkafka.h:1057
rd_kafka_group_member_info::member_id
char * member_id
Definition: rdkafka.h:4340
rd_kafka_group_list
List of groups.
Definition: rdkafka.h:4370
RD_KAFKA_RESP_ERR_SECURITY_DISABLED
Definition: rdkafka.h:511
RD_KAFKA_VTYPE_KEY
Definition: rdkafka.h:1047
rd_kafka_CreatePartitions_result_topics
RD_EXPORT const rd_kafka_topic_result_t ** rd_kafka_CreatePartitions_result_topics(const rd_kafka_CreatePartitions_result_t *result, size_t *cntp)
CreatePartitions result type and methods.
rd_kafka_err2str
RD_EXPORT const char * rd_kafka_err2str(rd_kafka_resp_err_t err)
Returns a human readable representation of a kafka error.
rd_kafka_ConfigEntry_is_sensitive
RD_EXPORT int rd_kafka_ConfigEntry_is_sensitive(const rd_kafka_ConfigEntry_t *entry)
RD_KAFKA_RESP_ERR_NON_EMPTY_GROUP
Definition: rdkafka.h:539
rd_kafka_error_code
RD_EXPORT rd_kafka_resp_err_t rd_kafka_error_code(const rd_kafka_error_t *error)
rd_kafka_topic_partition_t::metadata
void * metadata
Definition: rdkafka.h:853
rd_kafka_DescribeConfigs_result_resources
RD_EXPORT const rd_kafka_ConfigResource_t ** rd_kafka_DescribeConfigs_result_resources(const rd_kafka_DescribeConfigs_result_t *result, size_t *cntp)
DescribeConfigs result type and methods.
RD_KAFKA_CONFIG_SOURCE_UNKNOWN_CONFIG
Definition: rdkafka.h:6226
rd_kafka_interceptor_add_on_destroy
RD_EXPORT rd_kafka_resp_err_t rd_kafka_interceptor_add_on_destroy(rd_kafka_t *rk, const char *ic_name, rd_kafka_interceptor_f_on_destroy_t *on_destroy, void *ic_opaque)
Append an on_destroy() interceptor.
rd_kafka_NewPartitions_new
RD_EXPORT rd_kafka_NewPartitions_t * rd_kafka_NewPartitions_new(const char *topic, size_t new_total_cnt, char *errstr, size_t errstr_size)
Create a new NewPartitions. This object is later passed to rd_kafka_CreatePartitions() to increas the...
rd_kafka_topic_partition_t::offset
int64_t offset
Definition: rdkafka.h:852
rd_kafka_event_topic_partition_list
RD_EXPORT rd_kafka_topic_partition_list_t * rd_kafka_event_topic_partition_list(rd_kafka_event_t *rkev)
rd_kafka_errno2err
RD_EXPORT RD_DEPRECATED rd_kafka_resp_err_t rd_kafka_errno2err(int errnox)
Converts the system errno value errnox to a rd_kafka_resp_err_t error code upon failure from the foll...
RD_KAFKA_RESP_ERR__BAD_COMPRESSION
Definition: rdkafka.h:267
rd_kafka_conf_destroy
RD_EXPORT void rd_kafka_conf_destroy(rd_kafka_conf_t *conf)
Destroys a conf object.
RD_KAFKA_RESP_ERR_ELECTION_NOT_NEEDED
Definition: rdkafka.h:572
rd_kafka_header_get_all
RD_EXPORT rd_kafka_resp_err_t rd_kafka_header_get_all(const rd_kafka_headers_t *hdrs, size_t idx, const char **namep, const void **valuep, size_t *sizep)
Iterator for all headers.
RD_KAFKA_RESP_ERR__AUTHENTICATION
Definition: rdkafka.h:328
rd_kafka_DeleteTopic_destroy_array
RD_EXPORT void rd_kafka_DeleteTopic_destroy_array(rd_kafka_DeleteTopic_t **del_topics, size_t del_topic_cnt)
Helper function to destroy all DeleteTopic objects in the del_topics array (of del_topic_cnt elements...
rd_kafka_metadata_broker_t
Broker information.
Definition: rdkafka.h:4241
rd_kafka_err_desc
Error code value, name and description. Typically for use with language bindings to automatically exp...
Definition: rdkafka.h:591
RD_KAFKA_RESP_ERR_INVALID_TIMESTAMP
Definition: rdkafka.h:462
rd_kafka_ConfigEntry_value
RD_EXPORT const char * rd_kafka_ConfigEntry_value(const rd_kafka_ConfigEntry_t *entry)
RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION
Definition: rdkafka.h:442
RD_KAFKA_ADMIN_OP_CREATETOPICS
Definition: rdkafka.h:5687
rd_kafka_topic_partition_t::err
rd_kafka_resp_err_t err
Definition: rdkafka.h:856
RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED
Definition: rdkafka.h:326
rd_kafka_headers_copy
RD_EXPORT rd_kafka_headers_t * rd_kafka_headers_copy(const rd_kafka_headers_t *src)
Make a copy of headers list src.
rd_kafka_NewTopic_set_replica_assignment
RD_EXPORT rd_kafka_resp_err_t rd_kafka_NewTopic_set_replica_assignment(rd_kafka_NewTopic_t *new_topic, int32_t partition, int32_t *broker_ids, size_t broker_id_cnt, char *errstr, size_t errstr_size)
Set the replica (broker) assignment for partition to the replica set in broker_ids (of broker_id_cnt ...
rd_kafka_AlterConfigs_result_resources
RD_EXPORT const rd_kafka_ConfigResource_t ** rd_kafka_AlterConfigs_result_resources(const rd_kafka_AlterConfigs_result_t *result, size_t *cntp)
AlterConfigs result type and methods.
RD_KAFKA_RESP_ERR__READ_ONLY
Definition: rdkafka.h:352
rd_kafka_message_detach_headers
RD_EXPORT rd_kafka_resp_err_t rd_kafka_message_detach_headers(rd_kafka_message_t *rkmessage, rd_kafka_headers_t **hdrsp)
Get the message header list and detach the list from the message making the application the owner of ...
rd_kafka_NewPartitions_destroy
RD_EXPORT void rd_kafka_NewPartitions_destroy(rd_kafka_NewPartitions_t *new_parts)
Destroy and free a NewPartitions object previously created with rd_kafka_NewPartitions_new() ...
rd_kafka_topic_partition_t
Topic+Partition place holder.
Definition: rdkafka.h:849
RD_KAFKA_RESP_ERR__BAD_MSG
Definition: rdkafka.h:265
rd_kafka_default_topic_conf_dup
RD_EXPORT rd_kafka_topic_conf_t * rd_kafka_default_topic_conf_dup(rd_kafka_t *rk)
Creates a copy/duplicate of rk 's default topic configuration object.
rd_kafka_error_is_retriable
RD_EXPORT int rd_kafka_error_is_retriable(const rd_kafka_error_t *error)
RD_KAFKA_RESP_ERR__UNDERFLOW
Definition: rdkafka.h:356
rd_kafka_group_info::members
struct rd_kafka_group_member_info * members
Definition: rdkafka.h:4361
rd_kafka_topic_partition_t::metadata_size
size_t metadata_size
Definition: rdkafka.h:854
rd_kafka_topic_conf_dump
RD_EXPORT const char ** rd_kafka_topic_conf_dump(rd_kafka_topic_conf_t *conf, size_t *cntp)
Dump the topic configuration properties and values of conf to an array with "key", "value" pairs.
rd_kafka_AdminOptions_set_broker
RD_EXPORT rd_kafka_resp_err_t rd_kafka_AdminOptions_set_broker(rd_kafka_AdminOptions_t *options, int32_t broker_id, char *errstr, size_t errstr_size)
Override what broker the Admin request will be sent to.
rd_kafka_oauthbearer_set_token
RD_EXPORT rd_kafka_resp_err_t rd_kafka_oauthbearer_set_token(rd_kafka_t *rk, const char *token_value, int64_t md_lifetime_ms, const char *md_principal_name, const char **extensions, size_t extension_size, char *errstr, size_t errstr_size)
Set SASL/OAUTHBEARER token and metadata.
rd_kafka_headers_destroy
RD_EXPORT void rd_kafka_headers_destroy(rd_kafka_headers_t *hdrs)
Destroy the headers list. The object and any returned value pointers are not usable after this call...
rd_kafka_group_member_info::member_metadata_size
int member_metadata_size
Definition: rdkafka.h:4345
RD_KAFKA_ADMIN_OP_ALTERCONFIGS
Definition: rdkafka.h:5690
rd_kafka_event_message_array
RD_EXPORT size_t rd_kafka_event_message_array(rd_kafka_event_t *rkev, const rd_kafka_message_t **rkmessages, size_t size)
Extacts size message(s) from the event into the pre-allocated array rkmessages.
RD_KAFKA_VTYPE_VALUE
Definition: rdkafka.h:1046
RD_KAFKA_CONFIG_SOURCE__CNT
Definition: rdkafka.h:6242
RD_KAFKA_RESOURCE_UNKNOWN
Definition: rdkafka.h:6326
rd_kafka_msg_status_t
rd_kafka_msg_status_t
Message persistence status can be used by the application to find out if a produced message was persi...
Definition: rdkafka.h:1510
rd_kafka_type_t
rd_kafka_type_t
rd_kafka_t handle type.
Definition: rdkafka.h:193
rd_kafka_AdminOptions_set_validate_only
RD_EXPORT rd_kafka_resp_err_t rd_kafka_AdminOptions_set_validate_only(rd_kafka_AdminOptions_t *options, int true_or_false, char *errstr, size_t errstr_size)
Tell broker to only validate the request, without performing the requested operation (create topics...
rd_kafka_conf_set_stats_cb
RD_EXPORT void rd_kafka_conf_set_stats_cb(rd_kafka_conf_t *conf, int(*stats_cb)(rd_kafka_t *rk, char *json, size_t json_len, void *opaque))
Set statistics callback in provided conf object.
RD_KAFKA_RESP_ERR__NOT_CONFIGURED
Definition: rdkafka.h:376
RD_KAFKA_RESP_ERR_REQUEST_TIMED_OUT
Definition: rdkafka.h:403
rd_kafka_topic_partition_list_find
RD_EXPORT rd_kafka_topic_partition_t * rd_kafka_topic_partition_list_find(rd_kafka_topic_partition_list_t *rktparlist, const char *topic, int32_t partition)
Find element by topic and partition.
rd_kafka_topic_conf_destroy
RD_EXPORT void rd_kafka_topic_conf_destroy(rd_kafka_topic_conf_t *topic_conf)
Destroys a topic conf object.
rd_kafka_topic_partition_list_set_offset
RD_EXPORT rd_kafka_resp_err_t rd_kafka_topic_partition_list_set_offset(rd_kafka_topic_partition_list_t *rktparlist, const char *topic, int32_t partition, int64_t offset)
Set offset to offset for topic and partition.
RD_KAFKA_RESP_ERR_INVALID_PARTITIONS
Definition: rdkafka.h:472
rd_kafka_message_t::payload
void * payload
Definition: rdkafka.h:1360
RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS
Definition: rdkafka.h:5691
rd_kafka_yield
RD_EXPORT void rd_kafka_yield(rd_kafka_t *rk)
Cancels the current callback dispatcher (rd_kafka_poll(), rd_kafka_consume_callback(), etc).
RD_KAFKA_RESP_ERR_INVALID_MSG
Definition: rdkafka.h:393
rd_kafka_header_get_last
RD_EXPORT rd_kafka_resp_err_t rd_kafka_header_get_last(const rd_kafka_headers_t *hdrs, const char *name, const void **valuep, size_t *sizep)
Find last header in list hdrs matching name.
rd_kafka_event_stats
RD_EXPORT const char * rd_kafka_event_stats(rd_kafka_event_t *rkev)
Extract stats from the event.
rd_kafka_set_log_queue
RD_EXPORT rd_kafka_resp_err_t rd_kafka_set_log_queue(rd_kafka_t *rk, rd_kafka_queue_t *rkqu)
Forward librdkafka logs (and debug) to the specified queue for serving with one of the ...
rd_kafka_group_member_info::member_metadata
void * member_metadata
Definition: rdkafka.h:4343
rd_kafka_consumer_close
RD_EXPORT rd_kafka_resp_err_t rd_kafka_consumer_close(rd_kafka_t *rk)
Close down the KafkaConsumer.
rd_kafka_CreateTopics_result_topics
RD_EXPORT const rd_kafka_topic_result_t ** rd_kafka_CreateTopics_result_topics(const rd_kafka_CreateTopics_result_t *result, size_t *cntp)
CreateTopics result type and methods.
rd_kafka_conf_properties_show
RD_EXPORT void rd_kafka_conf_properties_show(FILE *fp)
Prints a table to fp of all supported configuration properties, their default values as well as a des...
rd_kafka_conf_dump_free
RD_EXPORT void rd_kafka_conf_dump_free(const char **arr, size_t cnt)
Frees a configuration dump returned from rd_kafka_conf_dump() or `rd_kafka_topic_conf_dump().
rd_kafka_message_t::_private
void * _private
Definition: rdkafka.h:1379
rd_kafka_ConfigEntry_is_default
RD_EXPORT int rd_kafka_ConfigEntry_is_default(const rd_kafka_ConfigEntry_t *entry)
RD_KAFKA_RESP_ERR__PARTITION_EOF
Definition: rdkafka.h:284
rd_kafka_topic_name
RD_EXPORT const char * rd_kafka_topic_name(const rd_kafka_topic_t *rkt)
Returns the topic name.
rd_kafka_fatal_error
RD_EXPORT rd_kafka_resp_err_t rd_kafka_fatal_error(rd_kafka_t *rk, char *errstr, size_t errstr_size)
Returns the first fatal error set on this client instance, or RD_KAFKA_RESP_ERR_NO_ERROR if no fatal ...
rd_kafka_group_info::protocol
char * protocol
Definition: rdkafka.h:4360
rd_kafka_msg_partitioner_fnv1a_random
RD_EXPORT int32_t rd_kafka_msg_partitioner_fnv1a_random(const rd_kafka_topic_t *rkt, const void *key, size_t keylen, int32_t partition_cnt, void *rkt_opaque, void *msg_opaque)
Consistent-Random FNV-1a partitioner.
rd_kafka_cert_type_t
rd_kafka_cert_type_t
SSL certificate type.
Definition: rdkafka.h:2186
RD_KAFKA_THREAD_MAIN
Definition: rdkafka.h:4566
rd_kafka_consume_queue
RD_EXPORT rd_kafka_message_t * rd_kafka_consume_queue(rd_kafka_queue_t *rkqu, int timeout_ms)
Consume from queue.
rd_kafka_last_error
RD_EXPORT rd_kafka_resp_err_t rd_kafka_last_error(void)
Returns the last error code generated by a legacy API call in the current thread. ...
rd_kafka_consume_start_queue
RD_EXPORT int rd_kafka_consume_start_queue(rd_kafka_topic_t *rkt, int32_t partition, int64_t offset, rd_kafka_queue_t *rkqu)
Same as rd_kafka_consume_start() but re-routes incoming messages to the provided queue rkqu (which mu...
rd_kafka_queue_new
RD_EXPORT rd_kafka_queue_t * rd_kafka_queue_new(rd_kafka_t *rk)
Create a new message queue.
RD_KAFKA_RESP_ERR_INVALID_RECORD
Definition: rdkafka.h:578
rd_kafka_topic_new
RD_EXPORT rd_kafka_topic_t * rd_kafka_topic_new(rd_kafka_t *rk, const char *topic, rd_kafka_topic_conf_t *conf)
Creates a new topic handle for topic named topic.
RD_KAFKA_VTYPE_HEADER
Definition: rdkafka.h:1055
rd_kafka_consume_callback
RD_EXPORT int rd_kafka_consume_callback(rd_kafka_topic_t *rkt, int32_t partition, int timeout_ms, void(*consume_cb)(rd_kafka_message_t *rkmessage, void *commit_opaque), void *commit_opaque)
Consumes messages from topic rkt and partition, calling the provided callback for each consumed messs...