github.com/rancher/longhorn-engine@v0.6.2/replica/rpc/replica.pb.go

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

package rpc

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	empty "github.com/golang/protobuf/ptypes/empty"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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 ReplicaCreateRequest struct {
	Size                 string   `protobuf:"bytes,1,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReplicaCreateRequest proto.InternalMessageInfo

func (m *ReplicaCreateRequest) GetSize() string {
	if m != nil {
		return m.Size
	}
	return ""
}

type ReplicaRevertRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Created              string   `protobuf:"bytes,2,opt,name=created,proto3" json:"created,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReplicaRevertRequest proto.InternalMessageInfo

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

func (m *ReplicaRevertRequest) GetCreated() string {
	if m != nil {
		return m.Created
	}
	return ""
}

type ReplicaSnapshotRequest struct {
	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	UserCreated          bool              `protobuf:"varint,2,opt,name=userCreated,proto3" json:"userCreated,omitempty"`
	Created              string            `protobuf:"bytes,3,opt,name=created,proto3" json:"created,omitempty"`
	Labels               map[string]string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_ReplicaSnapshotRequest proto.InternalMessageInfo

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

func (m *ReplicaSnapshotRequest) GetUserCreated() bool {
	if m != nil {
		return m.UserCreated
	}
	return false
}

func (m *ReplicaSnapshotRequest) GetCreated() string {
	if m != nil {
		return m.Created
	}
	return ""
}

func (m *ReplicaSnapshotRequest) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type DiskRemoveRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Force                bool     `protobuf:"varint,2,opt,name=force,proto3" json:"force,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DiskRemoveRequest proto.InternalMessageInfo

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

func (m *DiskRemoveRequest) GetForce() bool {
	if m != nil {
		return m.Force
	}
	return false
}

type DiskReplaceRequest struct {
	Target               string   `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	Source               string   `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DiskReplaceRequest proto.InternalMessageInfo

func (m *DiskReplaceRequest) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *DiskReplaceRequest) GetSource() string {
	if m != nil {
		return m.Source
	}
	return ""
}

type DiskPrepareRemoveRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DiskPrepareRemoveRequest proto.InternalMessageInfo

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

type DiskPrepareRemoveReply struct {
	Operations           []*PrepareRemoveAction `protobuf:"bytes,1,rep,name=operations,proto3" json:"operations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_DiskPrepareRemoveReply proto.InternalMessageInfo

func (m *DiskPrepareRemoveReply) GetOperations() []*PrepareRemoveAction {
	if m != nil {
		return m.Operations
	}
	return nil
}

type DiskMarkAsRemovedRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DiskMarkAsRemovedRequest proto.InternalMessageInfo

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

type RebuildingSetRequest struct {
	Rebuilding           bool     `protobuf:"varint,1,opt,name=rebuilding,proto3" json:"rebuilding,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RebuildingSetRequest proto.InternalMessageInfo

func (m *RebuildingSetRequest) GetRebuilding() bool {
	if m != nil {
		return m.Rebuilding
	}
	return false
}

type RevisionCounterSetRequest struct {
	Counter              int64    `protobuf:"varint,1,opt,name=counter,proto3" json:"counter,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RevisionCounterSetRequest proto.InternalMessageInfo

func (m *RevisionCounterSetRequest) GetCounter() int64 {
	if m != nil {
		return m.Counter
	}
	return 0
}

type DiskInfo struct {
	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Parent               string            `protobuf:"bytes,2,opt,name=parent,proto3" json:"parent,omitempty"`
	Children             map[string]bool   `protobuf:"bytes,3,rep,name=children,proto3" json:"children,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	Removed              bool              `protobuf:"varint,4,opt,name=removed,proto3" json:"removed,omitempty"`
	UserCreated          bool              `protobuf:"varint,5,opt,name=userCreated,proto3" json:"userCreated,omitempty"`
	Created              string            `protobuf:"bytes,6,opt,name=created,proto3" json:"created,omitempty"`
	Size                 string            `protobuf:"bytes,7,opt,name=size,proto3" json:"size,omitempty"`
	Labels               map[string]string `protobuf:"bytes,8,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

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

var xxx_messageInfo_DiskInfo proto.InternalMessageInfo

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

func (m *DiskInfo) GetParent() string {
	if m != nil {
		return m.Parent
	}
	return ""
}

func (m *DiskInfo) GetChildren() map[string]bool {
	if m != nil {
		return m.Children
	}
	return nil
}

func (m *DiskInfo) GetRemoved() bool {
	if m != nil {
		return m.Removed
	}
	return false
}

func (m *DiskInfo) GetUserCreated() bool {
	if m != nil {
		return m.UserCreated
	}
	return false
}

func (m *DiskInfo) GetCreated() string {
	if m != nil {
		return m.Created
	}
	return ""
}

func (m *DiskInfo) GetSize() string {
	if m != nil {
		return m.Size
	}
	return ""
}

func (m *DiskInfo) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type Replica struct {
	Dirty                bool                 `protobuf:"varint,1,opt,name=dirty,proto3" json:"dirty,omitempty"`
	Rebuilding           bool                 `protobuf:"varint,2,opt,name=rebuilding,proto3" json:"rebuilding,omitempty"`
	Head                 string               `protobuf:"bytes,3,opt,name=head,proto3" json:"head,omitempty"`
	Parent               string               `protobuf:"bytes,4,opt,name=parent,proto3" json:"parent,omitempty"`
	Size                 string               `protobuf:"bytes,5,opt,name=size,proto3" json:"size,omitempty"`
	SectorSize           int64                `protobuf:"varint,6,opt,name=sectorSize,proto3" json:"sectorSize,omitempty"`
	BackingFile          string               `protobuf:"bytes,7,opt,name=backingFile,proto3" json:"backingFile,omitempty"`
	State                string               `protobuf:"bytes,8,opt,name=state,proto3" json:"state,omitempty"`
	Chain                []string             `protobuf:"bytes,9,rep,name=chain,proto3" json:"chain,omitempty"`
	Disks                map[string]*DiskInfo `protobuf:"bytes,10,rep,name=disks,proto3" json:"disks,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	RemainSnapshots      int32                `protobuf:"varint,11,opt,name=remainSnapshots,proto3" json:"remainSnapshots,omitempty"`
	RevisionCounter      int64                `protobuf:"varint,12,opt,name=revisionCounter,proto3" json:"revisionCounter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Replica) Reset()         { *m = Replica{} }
func (m *Replica) String() string { return proto.CompactTextString(m) }
func (*Replica) ProtoMessage()    {}
func (*Replica) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e84aa831fb48ea1, []int{11}
}

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

var xxx_messageInfo_Replica proto.InternalMessageInfo

func (m *Replica) GetDirty() bool {
	if m != nil {
		return m.Dirty
	}
	return false
}

func (m *Replica) GetRebuilding() bool {
	if m != nil {
		return m.Rebuilding
	}
	return false
}

func (m *Replica) GetHead() string {
	if m != nil {
		return m.Head
	}
	return ""
}

func (m *Replica) GetParent() string {
	if m != nil {
		return m.Parent
	}
	return ""
}

func (m *Replica) GetSize() string {
	if m != nil {
		return m.Size
	}
	return ""
}

func (m *Replica) GetSectorSize() int64 {
	if m != nil {
		return m.SectorSize
	}
	return 0
}

func (m *Replica) GetBackingFile() string {
	if m != nil {
		return m.BackingFile
	}
	return ""
}

func (m *Replica) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *Replica) GetChain() []string {
	if m != nil {
		return m.Chain
	}
	return nil
}

func (m *Replica) GetDisks() map[string]*DiskInfo {
	if m != nil {
		return m.Disks
	}
	return nil
}

func (m *Replica) GetRemainSnapshots() int32 {
	if m != nil {
		return m.RemainSnapshots
	}
	return 0
}

func (m *Replica) GetRevisionCounter() int64 {
	if m != nil {
		return m.RevisionCounter
	}
	return 0
}

type PrepareRemoveAction struct {
	Action               string   `protobuf:"bytes,1,opt,name=action,proto3" json:"action,omitempty"`
	Source               string   `protobuf:"bytes,2,opt,name=source,proto3" json:"source,omitempty"`
	Target               string   `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrepareRemoveAction) Reset()         { *m = PrepareRemoveAction{} }
func (m *PrepareRemoveAction) String() string { return proto.CompactTextString(m) }
func (*PrepareRemoveAction) ProtoMessage()    {}
func (*PrepareRemoveAction) Descriptor() ([]byte, []int) {
	return fileDescriptor_1e84aa831fb48ea1, []int{12}
}

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

var xxx_messageInfo_PrepareRemoveAction proto.InternalMessageInfo

func (m *PrepareRemoveAction) GetAction() string {
	if m != nil {
		return m.Action
	}
	return ""
}

func (m *PrepareRemoveAction) GetSource() string {
	if m != nil {
		return m.Source
	}
	return ""
}

func (m *PrepareRemoveAction) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func init() {
	proto.RegisterType((*ReplicaCreateRequest)(nil), "rpc.ReplicaCreateRequest")
	proto.RegisterType((*ReplicaRevertRequest)(nil), "rpc.ReplicaRevertRequest")
	proto.RegisterType((*ReplicaSnapshotRequest)(nil), "rpc.ReplicaSnapshotRequest")
	proto.RegisterMapType((map[string]string)(nil), "rpc.ReplicaSnapshotRequest.LabelsEntry")
	proto.RegisterType((*DiskRemoveRequest)(nil), "rpc.DiskRemoveRequest")
	proto.RegisterType((*DiskReplaceRequest)(nil), "rpc.DiskReplaceRequest")
	proto.RegisterType((*DiskPrepareRemoveRequest)(nil), "rpc.DiskPrepareRemoveRequest")
	proto.RegisterType((*DiskPrepareRemoveReply)(nil), "rpc.DiskPrepareRemoveReply")
	proto.RegisterType((*DiskMarkAsRemovedRequest)(nil), "rpc.DiskMarkAsRemovedRequest")
	proto.RegisterType((*RebuildingSetRequest)(nil), "rpc.RebuildingSetRequest")
	proto.RegisterType((*RevisionCounterSetRequest)(nil), "rpc.RevisionCounterSetRequest")
	proto.RegisterType((*DiskInfo)(nil), "rpc.DiskInfo")
	proto.RegisterMapType((map[string]bool)(nil), "rpc.DiskInfo.ChildrenEntry")
	proto.RegisterMapType((map[string]string)(nil), "rpc.DiskInfo.LabelsEntry")
	proto.RegisterType((*Replica)(nil), "rpc.Replica")
	proto.RegisterMapType((map[string]*DiskInfo)(nil), "rpc.Replica.DisksEntry")
	proto.RegisterType((*PrepareRemoveAction)(nil), "rpc.PrepareRemoveAction")
}

func init() { proto.RegisterFile("replica.proto", fileDescriptor_1e84aa831fb48ea1) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// ReplicaServiceClient is the client API for ReplicaService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ReplicaServiceClient interface {
	ReplicaCreate(ctx context.Context, in *ReplicaCreateRequest, opts ...grpc.CallOption) (*Replica, error)
	ReplicaDelete(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error)
	ReplicaGet(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error)
	ReplicaOpen(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error)
	ReplicaClose(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error)
	ReplicaReload(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error)
	ReplicaRevert(ctx context.Context, in *ReplicaRevertRequest, opts ...grpc.CallOption) (*Replica, error)
	ReplicaSnapshot(ctx context.Context, in *ReplicaSnapshotRequest, opts ...grpc.CallOption) (*Replica, error)
	DiskRemove(ctx context.Context, in *DiskRemoveRequest, opts ...grpc.CallOption) (*Replica, error)
	DiskReplace(ctx context.Context, in *DiskReplaceRequest, opts ...grpc.CallOption) (*Replica, error)
	DiskPrepareRemove(ctx context.Context, in *DiskPrepareRemoveRequest, opts ...grpc.CallOption) (*DiskPrepareRemoveReply, error)
	DiskMarkAsRemoved(ctx context.Context, in *DiskMarkAsRemovedRequest, opts ...grpc.CallOption) (*Replica, error)
	RebuildingSet(ctx context.Context, in *RebuildingSetRequest, opts ...grpc.CallOption) (*Replica, error)
	RevisionCounterSet(ctx context.Context, in *RevisionCounterSetRequest, opts ...grpc.CallOption) (*Replica, error)
}

type replicaServiceClient struct {
	cc *grpc.ClientConn
}

func NewReplicaServiceClient(cc *grpc.ClientConn) ReplicaServiceClient {
	return &replicaServiceClient{cc}
}

func (c *replicaServiceClient) ReplicaCreate(ctx context.Context, in *ReplicaCreateRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaCreate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) ReplicaDelete(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) ReplicaGet(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) ReplicaOpen(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaOpen", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) ReplicaClose(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaClose", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) ReplicaReload(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaReload", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) ReplicaRevert(ctx context.Context, in *ReplicaRevertRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaRevert", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) ReplicaSnapshot(ctx context.Context, in *ReplicaSnapshotRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/ReplicaSnapshot", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) DiskRemove(ctx context.Context, in *DiskRemoveRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/DiskRemove", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) DiskReplace(ctx context.Context, in *DiskReplaceRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/DiskReplace", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) DiskPrepareRemove(ctx context.Context, in *DiskPrepareRemoveRequest, opts ...grpc.CallOption) (*DiskPrepareRemoveReply, error) {
	out := new(DiskPrepareRemoveReply)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/DiskPrepareRemove", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) DiskMarkAsRemoved(ctx context.Context, in *DiskMarkAsRemovedRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/DiskMarkAsRemoved", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) RebuildingSet(ctx context.Context, in *RebuildingSetRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/RebuildingSet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replicaServiceClient) RevisionCounterSet(ctx context.Context, in *RevisionCounterSetRequest, opts ...grpc.CallOption) (*Replica, error) {
	out := new(Replica)
	err := c.cc.Invoke(ctx, "/rpc.ReplicaService/RevisionCounterSet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReplicaServiceServer is the server API for ReplicaService service.
type ReplicaServiceServer interface {
	ReplicaCreate(context.Context, *ReplicaCreateRequest) (*Replica, error)
	ReplicaDelete(context.Context, *empty.Empty) (*empty.Empty, error)
	ReplicaGet(context.Context, *empty.Empty) (*Replica, error)
	ReplicaOpen(context.Context, *empty.Empty) (*Replica, error)
	ReplicaClose(context.Context, *empty.Empty) (*Replica, error)
	ReplicaReload(context.Context, *empty.Empty) (*Replica, error)
	ReplicaRevert(context.Context, *ReplicaRevertRequest) (*Replica, error)
	ReplicaSnapshot(context.Context, *ReplicaSnapshotRequest) (*Replica, error)
	DiskRemove(context.Context, *DiskRemoveRequest) (*Replica, error)
	DiskReplace(context.Context, *DiskReplaceRequest) (*Replica, error)
	DiskPrepareRemove(context.Context, *DiskPrepareRemoveRequest) (*DiskPrepareRemoveReply, error)
	DiskMarkAsRemoved(context.Context, *DiskMarkAsRemovedRequest) (*Replica, error)
	RebuildingSet(context.Context, *RebuildingSetRequest) (*Replica, error)
	RevisionCounterSet(context.Context, *RevisionCounterSetRequest) (*Replica, error)
}

// UnimplementedReplicaServiceServer can be embedded to have forward compatible implementations.
type UnimplementedReplicaServiceServer struct {
}

func (*UnimplementedReplicaServiceServer) ReplicaCreate(ctx context.Context, req *ReplicaCreateRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaCreate not implemented")
}
func (*UnimplementedReplicaServiceServer) ReplicaDelete(ctx context.Context, req *empty.Empty) (*empty.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaDelete not implemented")
}
func (*UnimplementedReplicaServiceServer) ReplicaGet(ctx context.Context, req *empty.Empty) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaGet not implemented")
}
func (*UnimplementedReplicaServiceServer) ReplicaOpen(ctx context.Context, req *empty.Empty) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaOpen not implemented")
}
func (*UnimplementedReplicaServiceServer) ReplicaClose(ctx context.Context, req *empty.Empty) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaClose not implemented")
}
func (*UnimplementedReplicaServiceServer) ReplicaReload(ctx context.Context, req *empty.Empty) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaReload not implemented")
}
func (*UnimplementedReplicaServiceServer) ReplicaRevert(ctx context.Context, req *ReplicaRevertRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaRevert not implemented")
}
func (*UnimplementedReplicaServiceServer) ReplicaSnapshot(ctx context.Context, req *ReplicaSnapshotRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReplicaSnapshot not implemented")
}
func (*UnimplementedReplicaServiceServer) DiskRemove(ctx context.Context, req *DiskRemoveRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DiskRemove not implemented")
}
func (*UnimplementedReplicaServiceServer) DiskReplace(ctx context.Context, req *DiskReplaceRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DiskReplace not implemented")
}
func (*UnimplementedReplicaServiceServer) DiskPrepareRemove(ctx context.Context, req *DiskPrepareRemoveRequest) (*DiskPrepareRemoveReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DiskPrepareRemove not implemented")
}
func (*UnimplementedReplicaServiceServer) DiskMarkAsRemoved(ctx context.Context, req *DiskMarkAsRemovedRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DiskMarkAsRemoved not implemented")
}
func (*UnimplementedReplicaServiceServer) RebuildingSet(ctx context.Context, req *RebuildingSetRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RebuildingSet not implemented")
}
func (*UnimplementedReplicaServiceServer) RevisionCounterSet(ctx context.Context, req *RevisionCounterSetRequest) (*Replica, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RevisionCounterSet not implemented")
}

func RegisterReplicaServiceServer(s *grpc.Server, srv ReplicaServiceServer) {
	s.RegisterService(&_ReplicaService_serviceDesc, srv)
}

func _ReplicaService_ReplicaCreate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplicaCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaCreate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaCreate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaCreate(ctx, req.(*ReplicaCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_ReplicaDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaDelete(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_ReplicaGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaGet(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_ReplicaOpen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaOpen(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaOpen",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaOpen(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_ReplicaClose_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaClose(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaClose",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaClose(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_ReplicaReload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaReload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaReload",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaReload(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_ReplicaRevert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplicaRevertRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaRevert(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaRevert",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaRevert(ctx, req.(*ReplicaRevertRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_ReplicaSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplicaSnapshotRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).ReplicaSnapshot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/ReplicaSnapshot",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).ReplicaSnapshot(ctx, req.(*ReplicaSnapshotRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_DiskRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiskRemoveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).DiskRemove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/DiskRemove",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).DiskRemove(ctx, req.(*DiskRemoveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_DiskReplace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiskReplaceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).DiskReplace(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/DiskReplace",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).DiskReplace(ctx, req.(*DiskReplaceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_DiskPrepareRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiskPrepareRemoveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).DiskPrepareRemove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/DiskPrepareRemove",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).DiskPrepareRemove(ctx, req.(*DiskPrepareRemoveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_DiskMarkAsRemoved_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DiskMarkAsRemovedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).DiskMarkAsRemoved(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/DiskMarkAsRemoved",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).DiskMarkAsRemoved(ctx, req.(*DiskMarkAsRemovedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_RebuildingSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RebuildingSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).RebuildingSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/RebuildingSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).RebuildingSet(ctx, req.(*RebuildingSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplicaService_RevisionCounterSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RevisionCounterSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplicaServiceServer).RevisionCounterSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/rpc.ReplicaService/RevisionCounterSet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplicaServiceServer).RevisionCounterSet(ctx, req.(*RevisionCounterSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ReplicaService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "rpc.ReplicaService",
	HandlerType: (*ReplicaServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ReplicaCreate",
			Handler:    _ReplicaService_ReplicaCreate_Handler,
		},
		{
			MethodName: "ReplicaDelete",
			Handler:    _ReplicaService_ReplicaDelete_Handler,
		},
		{
			MethodName: "ReplicaGet",
			Handler:    _ReplicaService_ReplicaGet_Handler,
		},
		{
			MethodName: "ReplicaOpen",
			Handler:    _ReplicaService_ReplicaOpen_Handler,
		},
		{
			MethodName: "ReplicaClose",
			Handler:    _ReplicaService_ReplicaClose_Handler,
		},
		{
			MethodName: "ReplicaReload",
			Handler:    _ReplicaService_ReplicaReload_Handler,
		},
		{
			MethodName: "ReplicaRevert",
			Handler:    _ReplicaService_ReplicaRevert_Handler,
		},
		{
			MethodName: "ReplicaSnapshot",
			Handler:    _ReplicaService_ReplicaSnapshot_Handler,
		},
		{
			MethodName: "DiskRemove",
			Handler:    _ReplicaService_DiskRemove_Handler,
		},
		{
			MethodName: "DiskReplace",
			Handler:    _ReplicaService_DiskReplace_Handler,
		},
		{
			MethodName: "DiskPrepareRemove",
			Handler:    _ReplicaService_DiskPrepareRemove_Handler,
		},
		{
			MethodName: "DiskMarkAsRemoved",
			Handler:    _ReplicaService_DiskMarkAsRemoved_Handler,
		},
		{
			MethodName: "RebuildingSet",
			Handler:    _ReplicaService_RebuildingSet_Handler,
		},
		{
			MethodName: "RevisionCounterSet",
			Handler:    _ReplicaService_RevisionCounterSet_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "replica.proto",
}