zrepl/cmd/replication/pdu.pb.go

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

/*
Package replication is a generated protocol buffer package.

It is generated from these files:
	pdu.proto

It has these top-level messages:
	ListFilesystemReq
	ListFilesystemRes
	Filesystem
	ListFilesystemVersionsReq
	ListFilesystemVersionsRes
	FilesystemVersion
	SendReq
	Property
	SendRes
	ReceiveReq
	ReceiveRes
*/
package replication

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import 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.ProtoPackageIsVersion2 // please upgrade the proto package

type FilesystemVersion_VersionType int32

const (
	FilesystemVersion_Snapshot FilesystemVersion_VersionType = 0
	FilesystemVersion_Bookmark FilesystemVersion_VersionType = 1
)

var FilesystemVersion_VersionType_name = map[int32]string{
	0: "Snapshot",
	1: "Bookmark",
}
var FilesystemVersion_VersionType_value = map[string]int32{
	"Snapshot": 0,
	"Bookmark": 1,
}

func (x FilesystemVersion_VersionType) String() string {
	return proto.EnumName(FilesystemVersion_VersionType_name, int32(x))
}
func (FilesystemVersion_VersionType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{5, 0}
}

type ListFilesystemReq struct {
}

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

type ListFilesystemRes struct {
	Filesystems []*Filesystem `protobuf:"bytes,1,rep,name=Filesystems" json:"Filesystems,omitempty"`
}

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

func (m *ListFilesystemRes) GetFilesystems() []*Filesystem {
	if m != nil {
		return m.Filesystems
	}
	return nil
}

type Filesystem struct {
	Path        string `protobuf:"bytes,1,opt,name=Path" json:"Path,omitempty"`
	ResumeToken string `protobuf:"bytes,2,opt,name=ResumeToken" json:"ResumeToken,omitempty"`
}

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

func (m *Filesystem) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *Filesystem) GetResumeToken() string {
	if m != nil {
		return m.ResumeToken
	}
	return ""
}

type ListFilesystemVersionsReq struct {
	Filesystem string `protobuf:"bytes,1,opt,name=Filesystem" json:"Filesystem,omitempty"`
}

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

func (m *ListFilesystemVersionsReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

type ListFilesystemVersionsRes struct {
	Versions []*FilesystemVersion `protobuf:"bytes,1,rep,name=Versions" json:"Versions,omitempty"`
}

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

func (m *ListFilesystemVersionsRes) GetVersions() []*FilesystemVersion {
	if m != nil {
		return m.Versions
	}
	return nil
}

type FilesystemVersion struct {
	Type      FilesystemVersion_VersionType `protobuf:"varint,1,opt,name=Type,enum=replication.FilesystemVersion_VersionType" json:"Type,omitempty"`
	Name      string                        `protobuf:"bytes,2,opt,name=Name" json:"Name,omitempty"`
	Guid      uint64                        `protobuf:"varint,3,opt,name=Guid" json:"Guid,omitempty"`
	CreateTXG uint64                        `protobuf:"varint,4,opt,name=CreateTXG" json:"CreateTXG,omitempty"`
	Creation  string                        `protobuf:"bytes,5,opt,name=Creation" json:"Creation,omitempty"`
}

func (m *FilesystemVersion) Reset()                    { *m = FilesystemVersion{} }
func (m *FilesystemVersion) String() string            { return proto.CompactTextString(m) }
func (*FilesystemVersion) ProtoMessage()               {}
func (*FilesystemVersion) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }

func (m *FilesystemVersion) GetType() FilesystemVersion_VersionType {
	if m != nil {
		return m.Type
	}
	return FilesystemVersion_Snapshot
}

func (m *FilesystemVersion) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *FilesystemVersion) GetGuid() uint64 {
	if m != nil {
		return m.Guid
	}
	return 0
}

func (m *FilesystemVersion) GetCreateTXG() uint64 {
	if m != nil {
		return m.CreateTXG
	}
	return 0
}

func (m *FilesystemVersion) GetCreation() string {
	if m != nil {
		return m.Creation
	}
	return ""
}

type SendReq struct {
	Filesystem string `protobuf:"bytes,1,opt,name=Filesystem" json:"Filesystem,omitempty"`
	From       string `protobuf:"bytes,2,opt,name=From" json:"From,omitempty"`
	To         string `protobuf:"bytes,3,opt,name=To" json:"To,omitempty"`
	// If ResumeToken is not empty, the resume token that CAN be tried for 'zfs send' by the sender.
	// The sender MUST indicate in SendRes.UsedResumeToken
	// If it does not work, the sender SHOULD clear the resume token on their side
	// and use From and To instead
	// If ResumeToken is not empty, the GUIDs of From and To
	// MUST correspond to those encoded in the ResumeToken.
	// Otherwise, the Sender MUST return an error.
	ResumeToken string `protobuf:"bytes,4,opt,name=ResumeToken" json:"ResumeToken,omitempty"`
	Compress    bool   `protobuf:"varint,5,opt,name=Compress" json:"Compress,omitempty"`
	Dedup       bool   `protobuf:"varint,6,opt,name=Dedup" json:"Dedup,omitempty"`
}

func (m *SendReq) Reset()                    { *m = SendReq{} }
func (m *SendReq) String() string            { return proto.CompactTextString(m) }
func (*SendReq) ProtoMessage()               {}
func (*SendReq) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }

func (m *SendReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *SendReq) GetFrom() string {
	if m != nil {
		return m.From
	}
	return ""
}

func (m *SendReq) GetTo() string {
	if m != nil {
		return m.To
	}
	return ""
}

func (m *SendReq) GetResumeToken() string {
	if m != nil {
		return m.ResumeToken
	}
	return ""
}

func (m *SendReq) GetCompress() bool {
	if m != nil {
		return m.Compress
	}
	return false
}

func (m *SendReq) GetDedup() bool {
	if m != nil {
		return m.Dedup
	}
	return false
}

type Property struct {
	Name  string `protobuf:"bytes,1,opt,name=Name" json:"Name,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=Value" json:"Value,omitempty"`
}

func (m *Property) Reset()                    { *m = Property{} }
func (m *Property) String() string            { return proto.CompactTextString(m) }
func (*Property) ProtoMessage()               {}
func (*Property) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }

func (m *Property) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Property) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type SendRes struct {
	// Whether the resume token provided in the request has been used or not.
	UsedResumeToken bool        `protobuf:"varint,1,opt,name=UsedResumeToken" json:"UsedResumeToken,omitempty"`
	Properties      []*Property `protobuf:"bytes,2,rep,name=Properties" json:"Properties,omitempty"`
}

func (m *SendRes) Reset()                    { *m = SendRes{} }
func (m *SendRes) String() string            { return proto.CompactTextString(m) }
func (*SendRes) ProtoMessage()               {}
func (*SendRes) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }

func (m *SendRes) GetUsedResumeToken() bool {
	if m != nil {
		return m.UsedResumeToken
	}
	return false
}

func (m *SendRes) GetProperties() []*Property {
	if m != nil {
		return m.Properties
	}
	return nil
}

type ReceiveReq struct {
	Filesystem string `protobuf:"bytes,1,opt,name=Filesystem" json:"Filesystem,omitempty"`
	// If true, the receiver should clear the resume token before perfoming the zfs recv of the stream in the request
	ClearResumeToken bool `protobuf:"varint,2,opt,name=ClearResumeToken" json:"ClearResumeToken,omitempty"`
}

func (m *ReceiveReq) Reset()                    { *m = ReceiveReq{} }
func (m *ReceiveReq) String() string            { return proto.CompactTextString(m) }
func (*ReceiveReq) ProtoMessage()               {}
func (*ReceiveReq) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }

func (m *ReceiveReq) GetFilesystem() string {
	if m != nil {
		return m.Filesystem
	}
	return ""
}

func (m *ReceiveReq) GetClearResumeToken() bool {
	if m != nil {
		return m.ClearResumeToken
	}
	return false
}

type ReceiveRes struct {
}

func (m *ReceiveRes) Reset()                    { *m = ReceiveRes{} }
func (m *ReceiveRes) String() string            { return proto.CompactTextString(m) }
func (*ReceiveRes) ProtoMessage()               {}
func (*ReceiveRes) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }

func init() {
	proto.RegisterType((*ListFilesystemReq)(nil), "replication.ListFilesystemReq")
	proto.RegisterType((*ListFilesystemRes)(nil), "replication.ListFilesystemRes")
	proto.RegisterType((*Filesystem)(nil), "replication.Filesystem")
	proto.RegisterType((*ListFilesystemVersionsReq)(nil), "replication.ListFilesystemVersionsReq")
	proto.RegisterType((*ListFilesystemVersionsRes)(nil), "replication.ListFilesystemVersionsRes")
	proto.RegisterType((*FilesystemVersion)(nil), "replication.FilesystemVersion")
	proto.RegisterType((*SendReq)(nil), "replication.SendReq")
	proto.RegisterType((*Property)(nil), "replication.Property")
	proto.RegisterType((*SendRes)(nil), "replication.SendRes")
	proto.RegisterType((*ReceiveReq)(nil), "replication.ReceiveReq")
	proto.RegisterType((*ReceiveRes)(nil), "replication.ReceiveRes")
	proto.RegisterEnum("replication.FilesystemVersion_VersionType", FilesystemVersion_VersionType_name, FilesystemVersion_VersionType_value)
}

func init() { proto.RegisterFile("pdu.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 454 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4d, 0x6f, 0xd3, 0x40,
	0x10, 0x65, 0x53, 0xa7, 0x38, 0xe3, 0xaa, 0xa4, 0x4b, 0x11, 0x06, 0xa1, 0x2a, 0xda, 0x53, 0xe8,
	0x21, 0x87, 0x02, 0x07, 0x40, 0xe2, 0xd0, 0xa2, 0xf6, 0x82, 0xaa, 0x6a, 0x6b, 0x4a, 0xaf, 0xa6,
	0x1e, 0xa9, 0x4b, 0x62, 0xaf, 0xbb, 0x63, 0x23, 0xe5, 0xe7, 0xf0, 0xcf, 0xf8, 0x29, 0xc8, 0x53,
	0x3b, 0xd9, 0x26, 0x2a, 0xca, 0xc9, 0xf3, 0xde, 0x7c, 0xbd, 0x7d, 0xeb, 0x85, 0x41, 0x99, 0xd5,
	0x93, 0xd2, 0xd9, 0xca, 0xca, 0xc8, 0x61, 0x39, 0x33, 0x37, 0x69, 0x65, 0x6c, 0xa1, 0x9e, 0xc3,
	0xde, 0x37, 0x43, 0xd5, 0xa9, 0x99, 0x21, 0xcd, 0xa9, 0xc2, 0x5c, 0xe3, 0x9d, 0x3a, 0x5f, 0x27,
	0x49, 0x7e, 0x84, 0x68, 0x49, 0x50, 0x2c, 0x46, 0x5b, 0xe3, 0xe8, 0xe8, 0xe5, 0xc4, 0x1b, 0x36,
	0xf1, 0x1a, 0xfc, 0x5a, 0x75, 0x0c, 0xb0, 0x84, 0x52, 0x42, 0x70, 0x91, 0x56, 0xb7, 0xb1, 0x18,
	0x89, 0xf1, 0x40, 0x73, 0x2c, 0x47, 0x10, 0x69, 0xa4, 0x3a, 0xc7, 0xc4, 0x4e, 0xb1, 0x88, 0x7b,
	0x9c, 0xf2, 0x29, 0xf5, 0x19, 0x5e, 0x3d, 0xd4, 0x74, 0x85, 0x8e, 0x8c, 0x2d, 0x48, 0xe3, 0x9d,
	0x3c, 0xf0, 0x17, 0xb4, 0x83, 0x3d, 0x46, 0xfd, 0x78, 0xbc, 0x99, 0xe4, 0x27, 0x08, 0x3b, 0xd8,
	0x9e, 0xea, 0xe0, 0x91, 0x53, 0xb5, 0x65, 0x7a, 0x51, 0xaf, 0xfe, 0x0a, 0xd8, 0x5b, 0xcb, 0xcb,
	0x2f, 0x10, 0x24, 0xf3, 0x12, 0x59, 0xc8, 0xee, 0xd1, 0xe1, 0xff, 0xa7, 0x4d, 0xda, 0x6f, 0xd3,
	0xa1, 0xb9, 0xaf, 0x71, 0xe8, 0x3c, 0xcd, 0xb1, 0xb5, 0x81, 0xe3, 0x86, 0x3b, 0xab, 0x4d, 0x16,
	0x6f, 0x8d, 0xc4, 0x38, 0xd0, 0x1c, 0xcb, 0x37, 0x30, 0x38, 0x71, 0x98, 0x56, 0x98, 0x5c, 0x9f,
	0xc5, 0x01, 0x27, 0x96, 0x84, 0x7c, 0x0d, 0x21, 0x03, 0x63, 0x8b, 0xb8, 0xcf, 0x93, 0x16, 0x58,
	0xbd, 0x85, 0xc8, 0x5b, 0x2b, 0x77, 0x20, 0xbc, 0x2c, 0xd2, 0x92, 0x6e, 0x6d, 0x35, 0x7c, 0xd2,
	0xa0, 0x63, 0x6b, 0xa7, 0x79, 0xea, 0xa6, 0x43, 0xa1, 0xfe, 0x08, 0x78, 0x7a, 0x89, 0x45, 0xb6,
	0x81, 0xcf, 0x8d, 0xc8, 0x53, 0x67, 0xf3, 0x4e, 0x78, 0x13, 0xcb, 0x5d, 0xe8, 0x25, 0x96, 0x65,
	0x0f, 0x74, 0x2f, 0xb1, 0xab, 0x57, 0x1d, 0xac, 0x5d, 0x35, 0x0b, 0xb7, 0x79, 0xe9, 0x90, 0x88,
	0x85, 0x87, 0x7a, 0x81, 0xe5, 0x3e, 0xf4, 0xbf, 0x62, 0x56, 0x97, 0xf1, 0x36, 0x27, 0xee, 0x81,
	0x7a, 0x0f, 0xe1, 0x85, 0xb3, 0x25, 0xba, 0x6a, 0xbe, 0x30, 0x4f, 0x78, 0xe6, 0xed, 0x43, 0xff,
	0x2a, 0x9d, 0xd5, 0x9d, 0xa3, 0xf7, 0x40, 0xfd, 0xea, 0x0e, 0x46, 0x72, 0x0c, 0xcf, 0xbe, 0x13,
	0x66, 0xbe, 0x30, 0xc1, 0x0b, 0x56, 0x69, 0xf9, 0x01, 0xa0, 0x5d, 0x65, 0x90, 0xe2, 0x1e, 0xff,
	0x2f, 0x2f, 0x1e, 0xdc, 0x70, 0xa7, 0x44, 0x7b, 0x85, 0xea, 0x1a, 0x40, 0xe3, 0x0d, 0x9a, 0xdf,
	0xb8, 0x89, 0x8f, 0x87, 0x30, 0x3c, 0x99, 0x61, 0xea, 0x56, 0xdf, 0x44, 0xa8, 0xd7, 0x78, 0xb5,
	0xe3, 0x4d, 0xa6, 0x9f, 0xdb, 0xfc, 0xc6, 0xdf, 0xfd, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xa4, 0x5a,
	0xf6, 0xa7, 0xf0, 0x03, 0x00, 0x00,
}