package kafka
import (
“errors”
“github.com/Shopify/sarama”
“github.com/luslin/webs/src/server1/conf”
“github.com/luslin/webs/src/server1/dbsource/redis”
“github.com/prometheus/common/log”
“sync”
)
var (
err error
client sarama.Client
producer sarama.AsyncProducer
wg sync.WaitGroup
kfLock sync.Mutex
producerInstance *Producer
)
type Producer struct {
producer sarama.AsyncProducer
showDebug bool
}
func init() {
_ = Instance()
}
func Instance() *Producer {
if producerInstance != nil {
return producerInstance
}
kfLock.Lock()
defer kfLock.Unlock()
if producerInstance != nil {
return producerInstance
}
producerInstance = NewProducere(conf.Enviroment.KAFKA_ADDR, conf.Enviroment.SHOW_DEBUG)
return producerInstance
}
func NewProducere(kafka_addr []string, showDebug bool) *Producer {
config := sarama.NewConfig()
config.Producer.Partitioner = sarama.NewRandomPartitioner
config.Producer.Return.Errors = true
client, err = sarama.NewClient(kafka_addr, config)
if err != nil {
panic_err(err)
}
producer, err = sarama.NewAsyncProducerFromClient(client)
if err != nil {
panic_err(err)
}
wg.Add(1)
go func() {
wg.Done()
// config.Producer.Return.Errors = true 後一定要監聽這個chan，默認大小256 如果滿了就阻塞掉
for err := range producer.Errors() {
log.Errorf("[kafka] [error] err=%s", err)
}
}()
instance := &Producer{
producer: producer,
showDebug: showDebug,
}
return instance
}
func (p *Producer) NewMessage(topic string, value interface{}) error {
var k_value sarama.Encoder
if p.showDebug {
log.Infof("[kafka] [info] topic=%s, value = %v", topic, value)
}
switch value.(type) {
case string:
k_value = sarama.StringEncoder(value.(string))
case int:
k_value = sarama.ByteEncoder{byte(value.(int))}
case byte:
k_value = sarama.ByteEncoder{value.(byte)}
default:
return errors.New(“value type error”)
}
message := &sarama.ProducerMessage{Topic: topic, Value: k_value}
producer.Input() <- message
return nil
}
func (p *Producer) ShowDebug() {
p.showDebug = true
}
func (p *Producer) Close() {
p.producer.AsyncClose()
}