marshal

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

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

type ConsumerOptions struct {
	// FastReclaim instructs the consumer to attempt to reclaim any partitions
	// that are presently claimed by the ClientID/GroupID we have. This is useful
	// for situations where your ClientID is predictable/stable and you want to
	// minimize churn during restarts. This is dangerous if you have two copies
	// of your application running with the same ClientID/GroupID.
	// TODO: Create an instance ID for Marshaler such that we can detect when
	// someone else has decided to use our Client/Group.
	//
	// Note that this option ignores MaximumClaims, so it is possible to
	// exceed the claim limit if the ClientID previously held more claims.
	FastReclaim bool

	// ClaimEntireTopic makes Marshal handle claims on the entire topic rather than
	// on a per-partition basis. This is used with sharded produce/consume setups.
	// Defaults to false.
	ClaimEntireTopic bool

	// GreedyClaims indicates whether we should attempt to claim all unclaimed
	// partitions on start. This is appropriate in low QPS type environments.
	// Defaults to false/off.
	GreedyClaims bool

	// ReleaseClaimsIfBehind indicates whether to release a claim if a consumer
	// is consuming at a rate slower than the partition is being produced to.
	ReleaseClaimsIfBehind bool

	// The maximum number of claims this Consumer is allowed to hold simultaneously.
	// MaximumClaims indicates the maximum number of partitions to be claimed when
	// ClaimEntireTopic is set to false. Otherwise, it indicates the maximum number
	// of topics to claim.
	// Set to 0 (default) to allow an unlimited number of claims.
	//
	// Using this option will leave some partitions/topics completely unclaimed
	// if the number of Consumers in this GroupID falls below the number of
	// partitions/topics that exist.
	//
	// Note this limit does not apply to claims made via FastReclaim.
	MaximumClaims int
}

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

type MarshalOptions struct {
	// BrokerConnectionLimit is used to set the maximum simultaneous number of connections
	// that can be made to each broker.
	// Default: 30.
	BrokerConnectionLimit int

	// ConsumeRequestTimeout sets the time that we ask Kafka to wait before returning any
	// data to us. Setting this high uses more connections and can lead to some latency
	// but keeps the load on Kafka minimal. Use this to balance QPS against latency.
	//
	// Default: 1 millisecond.
	ConsumeRequestTimeout time.Duration

	// MarshalRequestTimeout is used for our coordination requests. This should be reasonable
	// at default, but is left as a tunable in case you have clients that are claiming an
	// extremely large number of partitions and are too slow. The overall Marshal latency
	// is impacted by this value as well as the MarshalRequestRetryWait below.
	//
	// Default: 1 millisecond.
	MarshalRequestTimeout time.Duration

	// MarshalRequestRetryWait is the time between consume requests Marshal generates. This
	// should be set to balance the above timeouts to prevent hammering the server.
	//
	// Default: 500 milliseconds.
	MarshalRequestRetryWait time.Duration

	// MaxMessageSize is the maximum size in bytes of messages that can be returned. This
	// must be set to the size of the largest messages your cluster is allowed to store,
	// else you will end up with stalled streams. I.e., Kafka will never send you a message
	// if the message is larger than this value but we can't detect that, we just think
	// there is no data.
	//
	// Default: 2,000,000 bytes.
	MaxMessageSize int32

	// MaxMessageQueue is the number of messages to retrieve from Kafka and store in-memory
	// waiting for consumption. This is per-Consumer and independent of message size so you
	// should adjust this for your consumption patterns.
	//
	// Default: 1000 messages.
	MaxMessageQueue int
}

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

type Message proto.Message

type PartitionClaim struct {
	InstanceID    string
	ClientID      string
	GroupID       string
	LastRelease   int64
	LastHeartbeat int64
	CurrentOffset int64
	// contains filtered or unexported fields
}

type PartitionOffsets struct {
	Current   int64
	Earliest  int64
	Latest    int64
	Committed int64
}