consumergroup

type Config struct {
	*sarama.Config

	Zookeeper *kazoo.Config

	Offsets struct {
		// The initial offset to use if the consumer has no previously stored offset.
		// Must be either sarama.OffsetOldest (default) or sarama.OffsetNewest.
		Initial int64

		// Resets the offsets for the consumer group so that it won't resume
		// from where it left off previously.
		ResetOffsets bool

		// Time to wait for all the offsets for a partition to be processed
		// after stopping to consume from it.
		ProcessingTimeout time.Duration

		// The interval between which the processed offsets are commited.
		CommitInterval time.Duration
	}

	// If NoDup is true, consumer group will automatically discard the duplicated message.
	NoDup bool

	// If not PermitStandby, consumer group will emit ErrTooManyConsumers through error channel
	// to let client close the consumer group.
	PermitStandby bool

	// If OneToOne is true, a single consumer group can only consumer a single topic.
	OneToOne bool
}

type ConsumerGroup struct {
	// contains filtered or unexported fields
}

type OffsetManager interface {

	// InitializePartition is called when the consumergroup is starting to consume a
	// partition. It should return the last processed offset for this partition. Note:
	// the same partition can be initialized multiple times during a single run of a
	// consumer group due to other consumer instances coming online and offline.
	InitializePartition(topic string, partition int32) (int64, error)

	// MarkAsProcessed tells the offset manager that a certain message has been successfully
	// processed by the consumer, and should be committed. The implementation does not have
	// to store this offset right away, but should return true if it intends to do this at
	// some point.
	//
	// Offsets should generally be increasing if the consumer
	// processes events serially, but this cannot be guaranteed if the consumer does any
	// asynchronous processing. This can be handled in various ways, e.g. by only accepting
	// offsets that are higehr than the offsets seen before for the same partition.
	MarkAsProcessed(topic string, partition int32, offset int64) error

	MarkAsConsumed(topic string, partition int32, offset int64) error

	// FinalizePartition is called when the consumergroup is done consuming a
	// partition. In this method, the offset manager can flush any remaining offsets to its
	// backend store. It should return an error if it was not able to commit the offset.
	// Note: it's possible that the consumergroup instance will start to consume the same
	// partition again after this function is called.
	FinalizePartition(topic string, partition int32, lastOffset int64, timeout time.Duration) error

	// Close is called when the consumergroup is shutting down. In normal circumstances, all
	// offsets are committed because FinalizePartition is called for all the running partition
	// consumers. You may want to check for this to be true, and try to commit any outstanding
	// offsets. If this doesn't succeed, it should return an error.
	Close() error
}

type OffsetManagerConfig struct {
	CommitInterval time.Duration // Interval between offset flushes to the backend store.
	VerboseLogging bool          // Whether to enable verbose logging.
}