github.com/glide-im/glide@v1.6.0/pkg/store/kafka_store_producer.go (about)

     1  package store
     2  
     3  import (
     4  	"encoding/json"
     5  	"github.com/Shopify/sarama"
     6  	"github.com/glide-im/glide/pkg/messages"
     7  	"github.com/glide-im/glide/pkg/subscription"
     8  	"time"
     9  )
    10  
    11  const (
    12  	KafkaChatMessageTopic        = "getaway_chat_message"
    13  	KafkaChatOfflineMessageTopic = "getaway_chat_offline_message"
    14  	KafkaChannelMessageTopic     = "gateway_channel_message"
    15  )
    16  
    17  var _ MessageStore = &KafkaMessageStore{}
    18  var _ SubscriptionStore = &KafkaMessageStore{}
    19  
    20  type KafkaMessageStore struct {
    21  	producer sarama.AsyncProducer
    22  }
    23  
    24  func NewKafkaProducer(address []string) (*KafkaMessageStore, error) {
    25  
    26  	config := sarama.NewConfig()
    27  	config.Producer.RequiredAcks = sarama.WaitForAll
    28  	config.Producer.Partitioner = sarama.NewRandomPartitioner
    29  	//config.Producer.Return.Successes = true
    30  
    31  	producer, err := sarama.NewAsyncProducer(address, config)
    32  
    33  	if err != nil {
    34  		return nil, err
    35  	}
    36  
    37  	return &KafkaMessageStore{
    38  		producer: producer,
    39  	}, nil
    40  }
    41  
    42  func (k *KafkaMessageStore) Close() error {
    43  	return k.producer.Close()
    44  }
    45  
    46  type msg struct {
    47  	data []byte
    48  }
    49  
    50  func (m *msg) Encode() ([]byte, error) {
    51  	return m.data, nil
    52  }
    53  
    54  func (m *msg) Length() int {
    55  	return len(m.data)
    56  }
    57  
    58  func (k *KafkaMessageStore) StoreOffline(message *messages.ChatMessage) error {
    59  	msgBytes, err := json.Marshal(message)
    60  	if err != nil {
    61  		return err
    62  	}
    63  
    64  	cm := &sarama.ProducerMessage{
    65  		Topic:     KafkaChatOfflineMessageTopic,
    66  		Value:     &msg{data: msgBytes},
    67  		Headers:   nil,
    68  		Metadata:  nil,
    69  		Offset:    0,
    70  		Partition: 0,
    71  		Timestamp: time.Now(),
    72  	}
    73  	k.producer.Input() <- cm
    74  	return nil
    75  }
    76  
    77  func (k *KafkaMessageStore) NextSegmentSequence(id subscription.ChanID, info subscription.ChanInfo) (int64, int64, error) {
    78  	//TODO implement me
    79  	return 0, 0, nil
    80  }
    81  
    82  func (k *KafkaMessageStore) StoreChannelMessage(ch subscription.ChanID, m *messages.ChatMessage) error {
    83  	msgBytes, err := json.Marshal(m)
    84  	if err != nil {
    85  		return err
    86  	}
    87  
    88  	cm := &sarama.ProducerMessage{
    89  		Topic:     KafkaChannelMessageTopic,
    90  		Value:     &msg{data: msgBytes},
    91  		Headers:   nil,
    92  		Metadata:  nil,
    93  		Offset:    0,
    94  		Partition: 0,
    95  		Timestamp: time.Now(),
    96  	}
    97  	k.producer.Input() <- cm
    98  	return nil
    99  }
   100  
   101  func (k *KafkaMessageStore) StoreMessage(message *messages.ChatMessage) error {
   102  
   103  	msgBytes, err := json.Marshal(message)
   104  	if err != nil {
   105  		return err
   106  	}
   107  
   108  	cm := &sarama.ProducerMessage{
   109  		Topic:     KafkaChatMessageTopic,
   110  		Value:     &msg{data: msgBytes},
   111  		Headers:   nil,
   112  		Metadata:  nil,
   113  		Offset:    0,
   114  		Partition: 0,
   115  		Timestamp: time.Now(),
   116  	}
   117  	k.producer.Input() <- cm
   118  	return nil
   119  }