• 转载：kafka c接口librdkafka介绍之二：生产者接口

    转载：from:http://www.verydemo.com/demo_c92_i210679.html

    这个程序虽然我调试过，也分析过，但是没有记录笔记，发现下边这篇文章分析直接透彻，拿来借用，聊以自省，开发一直要研究透彻源码，学习其中的处理手段！

    kafka c接口librdkafka介绍之二：生产者接口

    librdkafka当前版本可以从github上获取：https://github.com/edenhill/librdkafka
    一、librdkafka基本信息：
     源码结构：
    kafka/
    ├── examples
    │   ├── Makefile
    │   ├── rdkafka_example
    │   ├── rdkafka_example.c
    │   ├── rdkafka_performance
    │   └── rdkafka_performance.c
    ├── librdkafka.a
    ├── librdkafka.conf
    ├── librdkafka.so
    ├── librdkafka.so.0 -> librdkafka.so
    ├── LICENSE
    ├── LICENSE.pycrc
    ├── Makefile
    ├── rdaddr.c
    ├── rdaddr.d
    ├── rdaddr.h
    ├── rdaddr.o
    ├── rd.c
    ├── rdcrc32.c
    ├── rdcrc32.d
    ├── rdcrc32.h
    ├── rdcrc32.o
    ├── rdfile.c
    ├── rdfile.d
    ├── rdfile.h
    ├── rdfile.o
    ├── rdgz.c
    ├── rdgz.d
    ├── rdgz.h
    ├── rdgz.o
    ├── rd.h
    ├── rdkafka.c
    ├── rdkafka.d
    ├── rdkafka.h
    ├── rdkafka.o
    ├── rdrand.c
    ├── rdrand.d
    ├── rdrand.h
    ├── rdrand.o
    ├── rdtime.h
    ├── rdtypes.h
    ├── README.md
    └── rpm
        ├── librdkafka-build.sh
        ├── librdkafka.spec.in
        └── librdkafka-VER.txt

    文件数：
    find . -name "*.[h|c]" | wc -l
    18

    代码行数：
    find . -name "*.[h|c]" | xargs wc -l
        89 ./rdtime.h
       246 ./examples/rdkafka_example.c
       351 ./examples/rdkafka_performance.c
       109 ./rd.h
        47 ./rdtypes.h
       183 ./rdaddr.h
        37 ./rd.c
       201 ./rdaddr.c
       139 ./rdfile.c
        42 ./rdgz.h
       103 ./rdcrc32.h
        50 ./rdrand.c
       121 ./rdgz.c
        45 ./rdrand.h
       520 ./rdkafka.h
      1334 ./rdkafka.c
        88 ./rdfile.h
       133 ./rdcrc32.c
      3838 total

    核心代码：
    rdkafka.h
    rdkafka.c

    二、生产者接口分析
     librdkafka 生产者接口支持应用程序向kafka推送数据，这可以满足一大类通过网络向kafka直接传送数据的需求。
     推送流程：
    这里通过librdkafka自带的例子来说明（例子可参考前文kafka c接口librdkafka介绍之一）
    发送的关键两步：
    step 1)  创建kafka实例

    点击(此处)折叠或打开

    1. rk = rd_kafka_new(RD_KAFKA_PRODUCER, broker, NULL)
    step 2)发送数据

    点击(此处)折叠或打开

    1. rd_kafka_produce(rk, topic, partition, RD_KAFKA_OP_F_FREE, opbuf, len)

    下面就看看这两步背后librdkafka做了什么？
    先看看rd_kafka_new做了什么

    点击(此处)折叠或打开

    1. rd_kafka_t *rd_kafka_new (rd_kafka_type_t type, const char *broker,
    2.              const rd_kafka_conf_t *conf) {
    3.     rd_kafka_t *rk;
    4.     rd_sockaddr_list_t *rsal;
    5.     const char *errstr;
    6.     static int rkid = 0;
    7.     int err;
    9.     /* If broker is NULL, default it to localhost. */
    10.     if (!broker)
    11.         broker = "localhost";
    12.     
    13.     /* 获取broker的地址信息 */
    14.     if (!(rsal = rd_getaddrinfo(broker, RD_KAFKA_PORT_STR, AI_ADDRCONFIG,
    15.                  AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP,
    16.                  &errstr))) {
    17.         rd_kafka_log(NULL, LOG_ERR, "GETADDR",
    18.              "getaddrinfo failed for '%s': %s",
    19.              broker, errstr);
    20.         return NULL;
    21.     }
    22.             
    23.     /*
    24.      * Set up the handle.
    25.      */
    26.     rk = calloc(1, sizeof(*rk));
    28.     rk->rk_type = type;
    29.     rk->rk_broker.rsal = rsal;
    30.     rk->rk_broker.s = -1;
    32.     if (conf)
    33.         rk->rk_conf = *conf;
    34.     else
    35.         rk->rk_conf = rd_kafka_defaultconf;
    37.     rk->rk_refcnt = 2; /* One for caller, one for us. */
    39.     if (rk->rk_type == RD_KAFKA_CONSUMER)
    40.         rk->rk_refcnt++; /* Add another refcount for recv thread */
    42.     /* 设置kafka初始状态为DOWN */
    43.     rd_kafka_set_state(rk, RD_KAFKA_STATE_DOWN);
    45.     pthread_mutex_init(&rk->rk_lock, NULL);
    47.     /* 初始化生产者消息队列 */
    48.     rd_kafka_q_init(&rk->rk_op);
    49.     /* 初始化消费者和错误消息队列 */
    50.     rd_kafka_q_init(&rk->rk_rep);
    52.     /* 花开两朵，各表一枝，这里讨论生产者 */
    53.     switch (rk->rk_type)
    54.     {
    55.     case RD_KAFKA_CONSUMER:
    56.         /* Set up consumer specifics. */
    58.         rk->rk_consumer.offset_file_fd = -1;
    59.         assert(rk->rk_conf.consumer.topic);
    60.         rk->rk_consumer.topic =    strdup(rk->rk_conf.consumer.topic);
    61.         rk->rk_consumer.partition = rk->rk_conf.consumer.partition;
    62.         rk->rk_consumer.offset = rk->rk_conf.consumer.offset;
    63.         rk->rk_consumer.app_offset = rk->rk_conf.consumer.offset;
    65.         /* File-based load&store of offset. */
    66.         if (rk->rk_conf.consumer.offset_file) {
    67.             char buf[32];
    68.             int r;
    69.             char *tmp;
    70.             mode_t mode;
    72.             /* If path is a directory we need to generate the
    73.              * filename (which is a good idea). */
    74.             mode = rd_file_mode(rk->rk_conf.consumer.offset_file);
    75.             if (mode == 0) {
    76.                 /* Error: bail out. */
    77.                 int errno_save = errno;
    78.                 rd_kafka_destroy0(rk);
    79.                 errno = errno_save;
    80.                 return NULL;
    81.             }
    83.             if (S_ISDIR(mode))
    84.                 rk->rk_conf.consumer.offset_file =
    85.                     rd_tsprintf("%s/%s-%"PRIu32,
    86.                          rk->rk_conf.consumer.
    87.                          offset_file,
    88.                          rk->rk_consumer.topic,
    89.                          rk->rk_consumer.partition);
    91.             rk->rk_conf.consumer.offset_file =
    92.                 strdup(rk->rk_conf.consumer.offset_file);
    94.             /* Open file, or create it. */
    95.             if ((rk->rk_consumer.offset_file_fd =
    96.              open(rk->rk_conf.consumer.offset_file,
    97.                  O_CREAT|O_RDWR |
    98.                  (rk->rk_conf.consumer.offset_file_flags &
    99.                  RD_KAFKA_OFFSET_FILE_FLAGMASK),
    100.                  0640)) == -1) {
    101.                 rd_kafka_destroy0(rk);
    102.                 return NULL;
    103.             }
    105.             /* Read current offset from file, or default to 0. */
    106.             r = read(rk->rk_consumer.offset_file_fd,
    107.                  buf, sizeof(buf)-1);
    108.             if (r == -1) {
    109.                 rd_kafka_destroy0(rk);
    110.                 return NULL;
    111.             }
    113.             buf[r] = '';
    115.             rk->rk_consumer.offset = strtoull(buf, &tmp, 10);
    116.             if (tmp == buf) /* empty or not an integer */
    117.                 rk->rk_consumer.offset = 0;
    118.             else
    119.                 rd_kafka_dbg(rk, "OFFREAD",
    120.                      "Read offset %"PRIu64" from "
    121.                      "file %s",
    122.                      rk->rk_consumer.offset,
    123.                      rk->rk_conf.consumer.offset_file);
    124.         }
    126.         break;
    127.     case RD_KAFKA_PRODUCER:
    128.         break;
    129.     }
    132.     /* Construct a conveniant name for this handle. */
    133.     /* 为broker命名 */
    134.     snprintf(rk->rk_broker.name, sizeof(rk->rk_broker.name), "%s#%s-%i",
    135.          broker, rd_kafka_type2str(rk->rk_type), rkid++);
    137.     /* Start the Kafka thread. */
    138.     /* 最关键部分，为生产者/消费者启动了单独的线程，线程函数是rd_kafka_thread_main */
    139.     if ((err = pthread_create(&rk->rk_thread, NULL,
    140.                  rd_kafka_thread_main, rk))) {
    141.         rd_sockaddr_list_destroy(rk->rk_broker.rsal);
    142.         free(rk);
    143.         return NULL;
    144.     }
    147.     return rk;
    148. }
    接下来看看rd_kafka_thread_main里面做了什么？

    点击(此处)折叠或打开

    1. static void *rd_kafka_thread_main (void *arg) {
    2.     rd_kafka_t *rk = arg;
    4.     /* 根据kafka接口状态的不同选择不同的动作 */
    5.     while (!rk->rk_terminate) {
    6.         switch (rk->rk_state)
    7.         {
    8.         case RD_KAFKA_STATE_DOWN:
    9.             /* ..connect() will block until done (or failure) */
    10.             if (rd_kafka_connect(rk) == -1)
    11.                 sleep(1); /*Sleep between connection attempts*/
    12.             break;
    13.         case RD_KAFKA_STATE_CONNECTING:
    14.             break;
    15.         case RD_KAFKA_STATE_UP:
    16.             /* .._wait_*() blocks for as long as the
    17.              * state remains UP. */
    18.             if (rk->rk_type == RD_KAFKA_PRODUCER)
    19.                 rd_kafka_wait_op(rk);/* 对于生产者，需要执行rd_kafka_wait_op操作 */
    20.             else
    21.                 rd_kafka_consumer_wait_io(rk);
    22.             break;
    23.         }
    24.     }
    26.     rd_kafka_destroy(rk);
    28.     return NULL;
    29. }
    继续追踪rd_kafka_wait_op函数。

    点击(此处)折叠或打开

    1. /**
    2.  * Producer: Wait for PRODUCE events from application.
    3.  *
    4.  * Locality: Kafka thread
    5.  */
    6. static void rd_kafka_wait_op (rd_kafka_t *rk) {
    7.     
    8.     /* 循环取消息，发送消息，销毁消息 */
    9.     while (!rk->rk_terminate && rk->rk_state == RD_KAFKA_STATE_UP) {
    10.         rd_kafka_op_t *rko =
    11.             rd_kafka_q_pop(&rk->rk_op, RD_POLL_INFINITE);
    12.         
    13.             rd_kafka_produce_send(rk, rko);
    15.            rd_kafka_op_destroy(rk, rko);
    16.     }
    17. }
    至此，一个异步的消息处理接口已经活生生的展现在大家的面前：

    应用程序中的线程负责向队列扔消息，接口启动的线程负责循环从队列里取消息并向kafka broker发送消息。

    既然有了多线程对队列的操作，异步操作，自然就会有了锁、条件变量的身影。

    创建工作完成了，接下来就是应用生产消息了，这里没有特别之处，就是向队列里扔数据。

    点击(此处)折叠或打开

    1. /**
    2.  * Produce one single message and send it off to the broker.
    3.  *
    4.  * See rdkafka.h for 'msgflags'.
    5.  *
    6.  * Locality: application thread
    7.  */
    8. void rd_kafka_produce (rd_kafka_t *rk, char *topic, uint32_t partition,
    9.          int msgflags,
    10.          char *payload, size_t len) {
    11.     rd_kafka_op_t *rko;
    13.     /* 分配空间 */
    14.     rko = calloc(1, sizeof(*rko));
    16.     rko->rko_type = RD_KAFKA_OP_PRODUCE;
    17.     rko->rko_topic = topic;
    18.     rko->rko_partition = partition;
    19.     rko->rko_flags |= msgflags;
    20.     rko->rko_payload = payload;
    21.     rko->rko_len = len;
    23.     /* 消息入队 */
    24.     rd_kafka_q_enq(&rk->rk_op, rko);
    25. }
    入队操作也是常规操作：

    点击(此处)折叠或打开

    1. /**
    2.  * Enqueue the 'rko' op at the tail of the queue 'rkq'.
    3.  *
    4.  * Locality: any thread.
    5.  */
    6. static inline void rd_kafka_q_enq (rd_kafka_q_t *rkq, rd_kafka_op_t *rko) {
    7.     /* 上面讲到过，入队和出队是不同的线程来完成的，因此需要加锁 */
    8.     pthread_mutex_lock(&rkq->rkq_lock);
    9.     TAILQ_INSERT_TAIL(&rkq->rkq_q, rko, rko_link);
    10.     (void)rd_atomic_add(&rkq->rkq_qlen, 1);
    11.     /* 有数据入队了，通知等待线程 */
    12.     pthread_cond_signal(&rkq->rkq_cond);
    13.     pthread_mutex_unlock(&rkq->rkq_lock);
    14. }

    三、消息处理的细节
    3.1 消息存储
    尾队列存储

    3.2 消息操作接口
    入队：

    点击(此处)折叠或打开

    1. /**
    2.  * Enqueue the 'rko' op at the tail of the queue 'rkq'.
    3.  *
    4.  * Locality: any thread.
    5.  */
    6. static inline void rd_kafka_q_enq (rd_kafka_q_t *rkq, rd_kafka_op_t *rko) {
    7.     pthread_mutex_lock(&rkq->rkq_lock);
    8.     TAILQ_INSERT_TAIL(&rkq->rkq_q, rko, rko_link);
    9.     (void)rd_atomic_add(&rkq->rkq_qlen, 1);
    10.     pthread_cond_signal(&rkq->rkq_cond);
    11.     pthread_mutex_unlock(&rkq->rkq_lock);
    12. }
    出队：

    点击(此处)折叠或打开

    1. /**
    2.  * Pop an op from a queue.
    3.  *
    4.  * Locality: any thread.
    5.  */
    6. static rd_kafka_op_t *rd_kafka_q_pop (rd_kafka_q_t *rkq, int timeout_ms) {
    7.     rd_kafka_op_t *rko;
    8.     rd_ts_t last;
    10.     pthread_mutex_lock(&rkq->rkq_lock);
    11.     
    12.     while (!(rko = TAILQ_FIRST(&rkq->rkq_q)) &&
    13.      (timeout_ms == RD_POLL_INFINITE || timeout_ms > 0)) {
    15.         if (timeout_ms != RD_POLL_INFINITE) {
    16.             last = rd_clock();
    17.             if (pthread_cond_timedwait_ms(&rkq->rkq_cond,
    18.                          &rkq->rkq_lock,
    19.                          timeout_ms) ==
    20.              ETIMEDOUT) {
    21.                 pthread_mutex_unlock(&rkq->rkq_lock);
    22.                 return NULL;
    23.             }
    24.             timeout_ms -= (rd_clock() - last) / 1000;
    25.         } else
    26.             pthread_cond_wait(&rkq->rkq_cond, &rkq->rkq_lock);
    27.     }
    29.     if (rko) {
    30.         TAILQ_REMOVE(&rkq->rkq_q, rko, rko_link);
    31.         (void)rd_atomic_sub(&rkq->rkq_qlen, 1);
    32.     }
    34.     pthread_mutex_unlock(&rkq->rkq_lock);
    36.     return rko;
    37. }
    3.3 入队、出队同步
    pthread_mutex_lock/unlock
    pthread_cond_wait

    3.4 消息发送
    rd_kafka_produce_send->rd_kafka_send_request->rd_kafka_send
    在rd_kafka_send中最终调用了sendmsg系统调用

    点击(此处)折叠或打开

    1. static int rd_kafka_send (rd_kafka_t *rk, const struct msghdr *msg) {
    2.     int r;
    4.     r = sendmsg(rk->rk_broker.s, msg, 0);
    5.     if (r == -1) {
    6.         rd_kafka_fail(rk, "Send failed: %s", strerror(errno));
    7.         return -1;
    8.     }
    10.     rk->rk_broker.stats.tx_bytes += r;
    11.     rk->rk_broker.stats.tx++;
    12.     return r;
    13. }

    四、生产者接口存在的问题与解决办法
    从上面的分析可以看出，librdkafka c接口接收消息和处理消息是异步的，换句话说，生产者接口存在
    问题1： 应用程序调用生产者接口时，是无法马上得知消息是否发送成功的。
    另外，如果kafka broker出现了不可用等情况，kafka c接口依然会不断接收数据，存入队列，但队列没有消费者，导致OOM的风险
    问题2：当kafka broker不可用时，kafka c接口的消息队列不断扩大，内存消耗一直增长。

    受限于kafka当前的通信协议，应用程序暂时无法得知消息是否发送成功的，但我们还是有办法来解决这个问题（不优雅的解决办法）
    生产者接口最终都是通过调用rd_kafka_send来发送消息的。
    点击(此处)折叠或打开
    1. static int rd_kafka_send (rd_kafka_t *rk, const struct msghdr *msg) {
    2.     int r;
    4.     r = sendmsg(rk->rk_broker.s, msg, 0);
    5.     if (r == -1) {
    6.         rd_kafka_fail(rk, "Send failed: %s", strerror(errno));
    7.         return -1;
    8.     }
    10.     rk->rk_broker.stats.tx_bytes += r;
    11.     rk->rk_broker.stats.tx++;
    12.     return r;
    13. }
    当发送消息失败时，会调用rd_kafka_fail函数来处理发送失败的情况。

    点击(此处)折叠或打开

    1. /**
    2.  * Failure propagation to application.
    3.  * Will tear down connection to broker and trigger a reconnect.
    4.  *
    5.  * If 'fmt' is NULL nothing will be logged or propagated to the application.
    6.  * 
    7.  * Locality: Kafka thread
    8.  */
    9. static void rd_kafka_fail (rd_kafka_t *rk, const char *fmt, ...) {
    10.     va_list ap;
    12.     pthread_mutex_lock(&rk->rk_lock);
    14.     rk->rk_err.err = errno;
    16.     rd_kafka_set_state(rk, RD_KAFKA_STATE_DOWN);
    18.     if (rk->rk_broker.s != -1) {
    19.         close(rk->rk_broker.s);
    20.         rk->rk_broker.s = -1;
    21.     }
    23.     if (fmt) {
    24.         va_start(ap, fmt);
    25.         vsnprintf(rk->rk_err.msg, sizeof(rk->rk_err.msg), fmt, ap);
    26.         va_end(ap);
    28.         rd_kafka_log(rk, LOG_ERR, "FAIL", "%s", rk->rk_err.msg);
    30.         /* Send ERR op back to application for processing. */
    31.         rd_kafka_op_reply(rk, RD_KAFKA_OP_ERR,
    32.                  RD_KAFKA_RESP_ERR__FAIL, 0,
    33.                  strdup(rk->rk_err.msg),
    34.                  strlen(rk->rk_err.msg), 0);
    35.     }
    37.     pthread_mutex_unlock(&rk->rk_lock);
    38. }
    从这里可以看到，当发送消息失败时，接口会通过rd_kafka_set_state函数设置kafka为RD_KAFKA_STATE_DOWN状态。
    在应用程序中通过判断rk的状态可以得知kafka的当前状态。c接口封装好了访问当前状态的宏。

    点击(此处)折叠或打开

    1. #define rd_kafka_state(rk) ((rk)->rk_state)
    当应用程序检测到kafka状态为DOWN时，就不再通过c接口向kafka发送消息，这样就可以保证不出现OOM的问题。
    这样是否解决了所有问题了呢？
    答案是否定的。在实施过程中，笔者发现如果kafka broker不可用时，c接口在第一次获知这个不幸之前（通过sendmsg失败？），依然会向broker发送数据，而向一个已经关闭的socket发送数据，会收到对方的rst信号，这将在应用程序中产生SIGPIPE信号，如果不处理，应用程序也会异常退出！！！
    比较简单粗暴的处理办法是：

    点击(此处)折叠或打开

    1. sigemptyset(&set);
    2.  sigaddset(&set, SIGPIPE);
    3.  sigprocmask(SIG_BLOCK, &set, NULL);
  • 相关阅读:
    Thomas Hobbes: Leviathan
    10 Easy Steps to a Complete Understanding of SQL
    day3心得
    py编码终极版
    day2 作业
    Python 中的比较：is 与 ==
    day2-心得
    day1--心得
    day1作业
    python--open用法
  • 原文地址：https://www.cnblogs.com/the-tops/p/6426057.html
Copyright © 2020-2023  润新知