github.com/gogf/gkafka@v1.0.1-0.20190702070843-033a14468069/gkafka.go

// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.

// Package gkafka provides producer and consumer client for kafka server.
package gkafka

import (
    "fmt"
    "github.com/gogf/gkafka/third/github.com/Shopify/sarama"
    "github.com/gogf/gkafka/third/github.com/johngcn/sarama-cluster"
    "os"
    "strings"
    "time"
)

var (
    // 当使用Topics方法获取所有topic后，进行过滤忽略的topic，多个以','号分隔
    ignoreTopics = map[string]bool {
        "__consumer_offsets" : true,
    }
)

// Kafka client config based on sarama.Config
type Config struct {
    sarama.Config
    GroupId        string // group id for consumer.
    Servers        string // server list, multiple servers joined by ','.
    Topics         string // topic list, multiple topics joined by ','.
    AutoMarkOffset bool   // auto mark message read after consumer message from server
}

// Kafka Client(Consumer/SyncProducer/AsyncProducer)
type Client struct {
    Config        *Config
    consumer      *cluster.Consumer
    rawConsumer   sarama.Consumer
    syncProducer  sarama.SyncProducer
    asyncProducer sarama.AsyncProducer
}

// Kafka Message.
type Message struct {
    Value          []byte
    Key            []byte
    Topic          string
    Partition      int
    Offset         int
    client         *Client
    consumerMsg    *sarama.ConsumerMessage
}


// New a kafka client.
func NewClient(config *Config) *Client {
    return &Client {
        Config : config,
    }
}

// NewConfig creates and returns a default configuration object.
func NewConfig() *Config {
    config       := &Config{}
    config.Config = *sarama.NewConfig()

    // default config for consumer
    config.Consumer.Return.Errors          = true
    config.Consumer.Offsets.Initial        = sarama.OffsetOldest
    config.Consumer.Offsets.CommitInterval = 1 * time.Second

    // default config for producer
    config.Producer.Return.Errors          = true
    config.Producer.Return.Successes       = true
    config.Producer.Timeout                = 5 * time.Second

    config.AutoMarkOffset                  = true
    return config
}

// Close closes the client.
func (client *Client) Close() {
    if client.rawConsumer != nil {
        client.rawConsumer.Close()
    }
    if client.consumer != nil {
        client.consumer.Close()
    }
    if client.syncProducer != nil {
        client.syncProducer.Close()
    }
    if client.asyncProducer != nil {
        client.asyncProducer.Close()
    }
}

// Topics returns all topics from kafka server.
func (client *Client) Topics() ([]string, error) {
    if c, err := sarama.NewConsumer(strings.Split(client.Config.Servers, ","), &client.Config.Config); err != nil {
        return nil, err
    } else {
        if topics, err := c.Topics(); err == nil {
            for k, v := range topics {
                if _, ok := ignoreTopics[v]; ok {
                    topics = append(topics[ : k], topics[k + 1 : ]...)
                }
            }
            c.Close()
            return topics, nil
        } else {
            return nil, err
        }
    }
}

// initConsumer initializes the client.
func (client *Client) initConsumer() error {
    if client.consumer == nil {
        config       := cluster.NewConfig()
        config.Config = client.Config.Config
        config.Group.Return.Notifications = false
        c, err := cluster.NewConsumer(strings.Split(client.Config.Servers, ","), client.Config.GroupId, strings.Split(client.Config.Topics, ","), config)
        if err != nil {
            return err
        } else {
            client.consumer = c
        }
    }
    return nil
}

// MarkOffset marks the start offset for consumer.
func (client *Client) MarkOffset(topic string, partition int, offset int, metadata...string) error {
    if err := client.initConsumer(); err != nil {
        return err
    }
    meta := ""
    if len(metadata) > 0 {
        meta = metadata[0]
    }
    client.consumer.MarkPartitionOffset(topic, int32(partition), int64(offset), meta)
    return nil
}


// Receive receives message from kafka from specified topics in config, in BLOCKING way.
// It will handle offset tracking automatically.
func (client *Client) Receive() (*Message, error) {
    if err := client.initConsumer(); err != nil {
        return nil, err
    }
    errorsChan  := client.consumer.Errors()
    notifyChan  := client.consumer.Notifications()
    messageChan := client.consumer.Messages()
    for {
        select {
            case msg := <- messageChan:
                if client.Config.AutoMarkOffset {
                    client.consumer.MarkOffset(msg, "")
                }
                return &Message {
                    Value       : msg.Value,
                    Key         : msg.Key,
                    Topic       : msg.Topic,
                    Partition   : int(msg.Partition),
                    Offset      : int(msg.Offset),
                    client      : client,
                    consumerMsg : msg,
                }, nil

            case err := <-errorsChan:
                if err != nil {
                    return nil, err
                }

            case <-notifyChan:
        }
    }
}

// SyncSend sends data to kafka in synchronized way.
func (client *Client) SyncSend(message *Message) error {
    if client.syncProducer == nil {
        if p, err := sarama.NewSyncProducer(strings.Split(client.Config.Servers, ","), &client.Config.Config); err != nil {
            return err
        } else {
            client.syncProducer = p
        }
    }
    for _, topic := range strings.Split(client.Config.Topics, ",") {
        msg := messageToProducerMessage(message)
        msg.Topic = topic
        if _, _, err := client.syncProducer.SendMessage(msg); err != nil {
            return err
        }
    }
    return nil
}

// AsyncSend sends data to kafka in asynchronized way(concurrent safe).
func (client *Client) AsyncSend(message *Message) error {
    if client.asyncProducer == nil {
        if p, err := sarama.NewAsyncProducer(strings.Split(client.Config.Servers, ","), &client.Config.Config); err != nil {
            return err
        } else {
            client.asyncProducer = p
            go func(p sarama.AsyncProducer) {
               errors  := p.Errors()
               success := p.Successes()
               for {
                   select {
                       case err := <-errors:
                           if err != nil {
                               fmt.Fprintln(os.Stderr, err)
                           }
                       case <-success:
                   }
               }
            }(client.asyncProducer)
        }
    }

    for _, topic := range strings.Split(client.Config.Topics, ",") {
        msg      := messageToProducerMessage(message)
        msg.Topic = topic
        client.asyncProducer.Input() <- msg
    }
    return nil
}

// messageToProducerMessage converts *gkafka.Message to *sarama.ProducerMessage
func messageToProducerMessage(message *Message) *sarama.ProducerMessage {
    return &sarama.ProducerMessage {
        Topic     : message.Topic,
        Key       : sarama.ByteEncoder(message.Key),
        Value     : sarama.ByteEncoder(message.Value),
        Partition : int32(message.Partition),
        Offset    : int64(message.Offset),
    }
}