// Code generated by protoc-gen-go. DO NOT EDIT.
// source: orderer/kafka.proto

package orderer

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type KafkaMessageRegular_Class int32

const (
	KafkaMessageRegular_UNKNOWN KafkaMessageRegular_Class = 0
	KafkaMessageRegular_NORMAL  KafkaMessageRegular_Class = 1
	KafkaMessageRegular_CONFIG  KafkaMessageRegular_Class = 2
)

var KafkaMessageRegular_Class_name = map[int32]string{
	0: "UNKNOWN",
	1: "NORMAL",
	2: "CONFIG",
}

var KafkaMessageRegular_Class_value = map[string]int32{
	"UNKNOWN": 0,
	"NORMAL":  1,
	"CONFIG":  2,
}

func (x KafkaMessageRegular_Class) String() string {
	return proto.EnumName(KafkaMessageRegular_Class_name, int32(x))
}

func (KafkaMessageRegular_Class) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_44ca1a6a801d36ec, []int{1, 0}
}

// KafkaMessage is a wrapper type for the messages
// that the Kafka-based orderer deals with.
type KafkaMessage struct {
	// Types that are valid to be assigned to Type:
	//	*KafkaMessage_Regular
	//	*KafkaMessage_TimeToCut
	//	*KafkaMessage_Connect
	Type                 isKafkaMessage_Type `protobuf_oneof:"Type"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *KafkaMessage) Reset()         { *m = KafkaMessage{} }
func (m *KafkaMessage) String() string { return proto.CompactTextString(m) }
func (*KafkaMessage) ProtoMessage()    {}
func (*KafkaMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_44ca1a6a801d36ec, []int{0}
}

func (m *KafkaMessage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KafkaMessage.Unmarshal(m, b)
}
func (m *KafkaMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KafkaMessage.Marshal(b, m, deterministic)
}
func (m *KafkaMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KafkaMessage.Merge(m, src)
}
func (m *KafkaMessage) XXX_Size() int {
	return xxx_messageInfo_KafkaMessage.Size(m)
}
func (m *KafkaMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_KafkaMessage.DiscardUnknown(m)
}

var xxx_messageInfo_KafkaMessage proto.InternalMessageInfo

type isKafkaMessage_Type interface {
	isKafkaMessage_Type()
}

type KafkaMessage_Regular struct {
	Regular *KafkaMessageRegular `protobuf:"bytes,1,opt,name=regular,proto3,oneof"`
}

type KafkaMessage_TimeToCut struct {
	TimeToCut *KafkaMessageTimeToCut `protobuf:"bytes,2,opt,name=time_to_cut,json=timeToCut,proto3,oneof"`
}

type KafkaMessage_Connect struct {
	Connect *KafkaMessageConnect `protobuf:"bytes,3,opt,name=connect,proto3,oneof"`
}

func (*KafkaMessage_Regular) isKafkaMessage_Type() {}

func (*KafkaMessage_TimeToCut) isKafkaMessage_Type() {}

func (*KafkaMessage_Connect) isKafkaMessage_Type() {}

func (m *KafkaMessage) GetType() isKafkaMessage_Type {
	if m != nil {
		return m.Type
	}
	return nil
}

func (m *KafkaMessage) GetRegular() *KafkaMessageRegular {
	if x, ok := m.GetType().(*KafkaMessage_Regular); ok {
		return x.Regular
	}
	return nil
}

func (m *KafkaMessage) GetTimeToCut() *KafkaMessageTimeToCut {
	if x, ok := m.GetType().(*KafkaMessage_TimeToCut); ok {
		return x.TimeToCut
	}
	return nil
}

func (m *KafkaMessage) GetConnect() *KafkaMessageConnect {
	if x, ok := m.GetType().(*KafkaMessage_Connect); ok {
		return x.Connect
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*KafkaMessage) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*KafkaMessage_Regular)(nil),
		(*KafkaMessage_TimeToCut)(nil),
		(*KafkaMessage_Connect)(nil),
	}
}

// KafkaMessageRegular wraps a marshalled envelope.
type KafkaMessageRegular struct {
	Payload              []byte                    `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	ConfigSeq            uint64                    `protobuf:"varint,2,opt,name=config_seq,json=configSeq,proto3" json:"config_seq,omitempty"`
	Class                KafkaMessageRegular_Class `protobuf:"varint,3,opt,name=class,proto3,enum=orderer.KafkaMessageRegular_Class" json:"class,omitempty"`
	OriginalOffset       int64                     `protobuf:"varint,4,opt,name=original_offset,json=originalOffset,proto3" json:"original_offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *KafkaMessageRegular) Reset()         { *m = KafkaMessageRegular{} }
func (m *KafkaMessageRegular) String() string { return proto.CompactTextString(m) }
func (*KafkaMessageRegular) ProtoMessage()    {}
func (*KafkaMessageRegular) Descriptor() ([]byte, []int) {
	return fileDescriptor_44ca1a6a801d36ec, []int{1}
}

func (m *KafkaMessageRegular) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KafkaMessageRegular.Unmarshal(m, b)
}
func (m *KafkaMessageRegular) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KafkaMessageRegular.Marshal(b, m, deterministic)
}
func (m *KafkaMessageRegular) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KafkaMessageRegular.Merge(m, src)
}
func (m *KafkaMessageRegular) XXX_Size() int {
	return xxx_messageInfo_KafkaMessageRegular.Size(m)
}
func (m *KafkaMessageRegular) XXX_DiscardUnknown() {
	xxx_messageInfo_KafkaMessageRegular.DiscardUnknown(m)
}

var xxx_messageInfo_KafkaMessageRegular proto.InternalMessageInfo

func (m *KafkaMessageRegular) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *KafkaMessageRegular) GetConfigSeq() uint64 {
	if m != nil {
		return m.ConfigSeq
	}
	return 0
}

func (m *KafkaMessageRegular) GetClass() KafkaMessageRegular_Class {
	if m != nil {
		return m.Class
	}
	return KafkaMessageRegular_UNKNOWN
}

func (m *KafkaMessageRegular) GetOriginalOffset() int64 {
	if m != nil {
		return m.OriginalOffset
	}
	return 0
}

// KafkaMessageTimeToCut is used to signal to the orderers
// that it is time to cut block <block_number>.
type KafkaMessageTimeToCut struct {
	BlockNumber          uint64   `protobuf:"varint,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KafkaMessageTimeToCut) Reset()         { *m = KafkaMessageTimeToCut{} }
func (m *KafkaMessageTimeToCut) String() string { return proto.CompactTextString(m) }
func (*KafkaMessageTimeToCut) ProtoMessage()    {}
func (*KafkaMessageTimeToCut) Descriptor() ([]byte, []int) {
	return fileDescriptor_44ca1a6a801d36ec, []int{2}
}

func (m *KafkaMessageTimeToCut) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KafkaMessageTimeToCut.Unmarshal(m, b)
}
func (m *KafkaMessageTimeToCut) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KafkaMessageTimeToCut.Marshal(b, m, deterministic)
}
func (m *KafkaMessageTimeToCut) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KafkaMessageTimeToCut.Merge(m, src)
}
func (m *KafkaMessageTimeToCut) XXX_Size() int {
	return xxx_messageInfo_KafkaMessageTimeToCut.Size(m)
}
func (m *KafkaMessageTimeToCut) XXX_DiscardUnknown() {
	xxx_messageInfo_KafkaMessageTimeToCut.DiscardUnknown(m)
}

var xxx_messageInfo_KafkaMessageTimeToCut proto.InternalMessageInfo

func (m *KafkaMessageTimeToCut) GetBlockNumber() uint64 {
	if m != nil {
		return m.BlockNumber
	}
	return 0
}

// KafkaMessageConnect is posted by an orderer upon booting up.
// It is used to prevent the panic that would be caused if we
// were to consume an empty partition. It is ignored by all
// orderers when processing the partition.
type KafkaMessageConnect struct {
	Payload              []byte   `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *KafkaMessageConnect) Reset()         { *m = KafkaMessageConnect{} }
func (m *KafkaMessageConnect) String() string { return proto.CompactTextString(m) }
func (*KafkaMessageConnect) ProtoMessage()    {}
func (*KafkaMessageConnect) Descriptor() ([]byte, []int) {
	return fileDescriptor_44ca1a6a801d36ec, []int{3}
}

func (m *KafkaMessageConnect) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KafkaMessageConnect.Unmarshal(m, b)
}
func (m *KafkaMessageConnect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KafkaMessageConnect.Marshal(b, m, deterministic)
}
func (m *KafkaMessageConnect) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KafkaMessageConnect.Merge(m, src)
}
func (m *KafkaMessageConnect) XXX_Size() int {
	return xxx_messageInfo_KafkaMessageConnect.Size(m)
}
func (m *KafkaMessageConnect) XXX_DiscardUnknown() {
	xxx_messageInfo_KafkaMessageConnect.DiscardUnknown(m)
}

var xxx_messageInfo_KafkaMessageConnect proto.InternalMessageInfo

func (m *KafkaMessageConnect) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

// KafkaMetadata is encoded into the ORDERER block to keep track of
// Kafka-related metadata associated with this block.
type KafkaMetadata struct {
	// LastOffsetPersisted is the encoded value for the Metadata message
	// which is encoded in the ORDERER block metadata index for the case
	// of the Kafka-based orderer.
	LastOffsetPersisted int64 `protobuf:"varint,1,opt,name=last_offset_persisted,json=lastOffsetPersisted,proto3" json:"last_offset_persisted,omitempty"`
	// LastOriginalOffsetProcessed is used to keep track of the newest
	// offset processed if a message is re-validated and re-ordered.
	// This value is used to deduplicate re-submitted messages from
	// multiple orderer so that we don't bother re-processing it again.
	LastOriginalOffsetProcessed int64 `protobuf:"varint,2,opt,name=last_original_offset_processed,json=lastOriginalOffsetProcessed,proto3" json:"last_original_offset_processed,omitempty"`
	// LastResubmittedConfigOffset is used to capture the newest offset of
	// CONFIG kafka message, which is revalidated and resubmitted. By comparing
	// this with LastOriginalOffsetProcessed, we could detemine whether there
	// are still CONFIG messages that have been resubmitted but NOT processed
	// yet. It's used as condition to block ingress messages, so we could reduce
	// the overhead of repeatedly resubmitting messages as config seq keeps
	// advancing.
	LastResubmittedConfigOffset int64    `protobuf:"varint,3,opt,name=last_resubmitted_config_offset,json=lastResubmittedConfigOffset,proto3" json:"last_resubmitted_config_offset,omitempty"`
	XXX_NoUnkeyedLiteral        struct{} `json:"-"`
	XXX_unrecognized            []byte   `json:"-"`
	XXX_sizecache               int32    `json:"-"`
}

func (m *KafkaMetadata) Reset()         { *m = KafkaMetadata{} }
func (m *KafkaMetadata) String() string { return proto.CompactTextString(m) }
func (*KafkaMetadata) ProtoMessage()    {}
func (*KafkaMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_44ca1a6a801d36ec, []int{4}
}

func (m *KafkaMetadata) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KafkaMetadata.Unmarshal(m, b)
}
func (m *KafkaMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KafkaMetadata.Marshal(b, m, deterministic)
}
func (m *KafkaMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KafkaMetadata.Merge(m, src)
}
func (m *KafkaMetadata) XXX_Size() int {
	return xxx_messageInfo_KafkaMetadata.Size(m)
}
func (m *KafkaMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_KafkaMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_KafkaMetadata proto.InternalMessageInfo

func (m *KafkaMetadata) GetLastOffsetPersisted() int64 {
	if m != nil {
		return m.LastOffsetPersisted
	}
	return 0
}

func (m *KafkaMetadata) GetLastOriginalOffsetProcessed() int64 {
	if m != nil {
		return m.LastOriginalOffsetProcessed
	}
	return 0
}

func (m *KafkaMetadata) GetLastResubmittedConfigOffset() int64 {
	if m != nil {
		return m.LastResubmittedConfigOffset
	}
	return 0
}

func init() {
	proto.RegisterEnum("orderer.KafkaMessageRegular_Class", KafkaMessageRegular_Class_name, KafkaMessageRegular_Class_value)
	proto.RegisterType((*KafkaMessage)(nil), "orderer.KafkaMessage")
	proto.RegisterType((*KafkaMessageRegular)(nil), "orderer.KafkaMessageRegular")
	proto.RegisterType((*KafkaMessageTimeToCut)(nil), "orderer.KafkaMessageTimeToCut")
	proto.RegisterType((*KafkaMessageConnect)(nil), "orderer.KafkaMessageConnect")
	proto.RegisterType((*KafkaMetadata)(nil), "orderer.KafkaMetadata")
}

func init() { proto.RegisterFile("orderer/kafka.proto", fileDescriptor_44ca1a6a801d36ec) }

var fileDescriptor_44ca1a6a801d36ec = []byte{
	// 479 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xd1, 0x6e, 0xd3, 0x30,
	0x14, 0x86, 0x9b, 0xb5, 0x6b, 0xb5, 0xd3, 0x32, 0x2a, 0x57, 0x93, 0x2a, 0x01, 0xd3, 0x88, 0x84,
	0xd8, 0x05, 0x4b, 0xa4, 0x72, 0x33, 0x71, 0x05, 0x8b, 0x04, 0x43, 0x63, 0xe9, 0x64, 0x8a, 0x40,
	0xdc, 0x44, 0x4e, 0x72, 0x92, 0x45, 0x4d, 0xe2, 0xcc, 0x76, 0x2e, 0xfa, 0x8e, 0xf0, 0x0c, 0xbc,
	0x0a, 0x8a, 0x9d, 0xb0, 0x55, 0x2a, 0xbb, 0x8b, 0x7f, 0x7f, 0xbf, 0xcf, 0x39, 0xff, 0x51, 0x60,
	0xc6, 0x45, 0x8c, 0x02, 0x85, 0xbb, 0x66, 0xc9, 0x9a, 0x39, 0x95, 0xe0, 0x8a, 0x93, 0x51, 0x2b,
	0xda, 0xbf, 0x2c, 0x98, 0x5c, 0x35, 0x17, 0xd7, 0x28, 0x25, 0x4b, 0x91, 0x9c, 0xc3, 0x48, 0x60,
	0x5a, 0xe7, 0x4c, 0xcc, 0xad, 0x13, 0xeb, 0x74, 0xbc, 0x78, 0xee, 0xb4, 0xac, 0xf3, 0x90, 0xa3,
	0x86, 0xb9, 0xec, 0xd1, 0x0e, 0x27, 0xef, 0x61, 0xac, 0xb2, 0x02, 0x03, 0xc5, 0x83, 0xa8, 0x56,
	0xf3, 0x3d, 0xed, 0x3e, 0xde, 0xe9, 0x5e, 0x65, 0x05, 0xae, 0xb8, 0x57, 0xab, 0xcb, 0x1e, 0x3d,
	0x50, 0xdd, 0xa1, 0xa9, 0x1d, 0xf1, 0xb2, 0xc4, 0x48, 0xcd, 0xfb, 0x8f, 0xd4, 0xf6, 0x0c, 0xd3,
	0xd4, 0x6e, 0xf1, 0x8b, 0x21, 0x0c, 0x56, 0x9b, 0x0a, 0xed, 0x3f, 0x16, 0xcc, 0x76, 0xb4, 0x49,
	0xe6, 0x30, 0xaa, 0xd8, 0x26, 0xe7, 0x2c, 0xd6, 0x53, 0x4d, 0x68, 0x77, 0x24, 0x2f, 0x00, 0x22,
	0x5e, 0x26, 0x59, 0x1a, 0x48, 0xbc, 0xd3, 0x4d, 0x0f, 0xe8, 0x81, 0x51, 0xbe, 0xe2, 0x1d, 0x39,
	0x87, 0xfd, 0x28, 0x67, 0x52, 0xea, 0x86, 0x0e, 0x17, 0xf6, 0x63, 0x61, 0x38, 0x5e, 0x43, 0x52,
	0x63, 0x20, 0xaf, 0xe1, 0x29, 0x17, 0x59, 0x9a, 0x95, 0x2c, 0x0f, 0x78, 0x92, 0x48, 0x54, 0xf3,
	0xc1, 0x89, 0x75, 0xda, 0xa7, 0x87, 0x9d, 0xbc, 0xd4, 0xaa, 0xfd, 0x06, 0xf6, 0xb5, 0x91, 0x8c,
	0x61, 0xf4, 0xcd, 0xbf, 0xf2, 0x97, 0xdf, 0xfd, 0x69, 0x8f, 0x00, 0x0c, 0xfd, 0x25, 0xbd, 0xfe,
	0xf0, 0x65, 0x6a, 0x35, 0xdf, 0xde, 0xd2, 0xff, 0xf8, 0xf9, 0xd3, 0x74, 0xcf, 0x7e, 0x07, 0x47,
	0x3b, 0x93, 0x24, 0x2f, 0x61, 0x12, 0xe6, 0x3c, 0x5a, 0x07, 0x65, 0x5d, 0x84, 0x68, 0xb6, 0x37,
	0xa0, 0x63, 0xad, 0xf9, 0x5a, 0xb2, 0xdd, 0xed, 0x70, 0xda, 0x1c, 0xff, 0x1f, 0x8e, 0xfd, 0xdb,
	0x82, 0x27, 0xad, 0x43, 0xb1, 0x98, 0x29, 0x46, 0x16, 0x70, 0x94, 0x33, 0xa9, 0xda, 0x89, 0x82,
	0x0a, 0x85, 0xcc, 0xa4, 0x42, 0xe3, 0xec, 0xd3, 0x59, 0x73, 0x69, 0xe6, 0xba, 0xe9, 0xae, 0x88,
	0x07, 0xc7, 0xc6, 0xb3, 0x1d, 0x47, 0x50, 0x09, 0x1e, 0xa1, 0x94, 0x18, 0xeb, 0xd8, 0xfb, 0xf4,
	0x99, 0x36, 0x6f, 0x85, 0x73, 0xd3, 0x21, 0xff, 0x1e, 0x11, 0x28, 0xeb, 0xb0, 0xc8, 0x94, 0xc2,
	0x38, 0x68, 0x17, 0xd7, 0xa6, 0xdb, 0xbf, 0x7f, 0x84, 0xde, 0x43, 0x9e, 0x66, 0xcc, 0x6b, 0x17,
	0x3f, 0xe0, 0x15, 0x17, 0xa9, 0x73, 0xbb, 0xa9, 0x50, 0xe4, 0x18, 0xa7, 0x28, 0x9c, 0x84, 0x85,
	0x22, 0x8b, 0xcc, 0x6f, 0x21, 0xbb, 0xed, 0xfe, 0x74, 0xd3, 0x4c, 0xdd, 0xd6, 0xa1, 0x13, 0xf1,
	0xc2, 0x7d, 0x40, 0xbb, 0x86, 0x3e, 0x33, 0xf4, 0x59, 0xca, 0xdd, 0xd6, 0x10, 0x0e, 0xb5, 0xf4,
	0xf6, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5a, 0xdf, 0x29, 0x90, 0x6e, 0x03, 0x00, 0x00,
}
