extern/zrepl
1
0
Fork 0
mirror of https://github.com/zrepl/zrepl.git synced 2024-11-22 00:13:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

do dry runs in planning stage to estimate size of all sends

Browse Source
This commit is contained in:
Anton Schirg 2018-08-30 12:52:08 +02:00
parent 47d8a5a7cd
commit b5957aca37
5 changed files with 138 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
endpoint/endpoint.go
View File

@ -75,16 +75,19 @@ func (p *Sender) Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, io.Rea
return nil, nil, replication.NewFilteredError(r.Filesystem)
}
size, err := zfs.ZFSSendDry(r.Filesystem, r.From, r.To)
if err != nil {
return nil, nil, err
if r.DryRun {
size, err := zfs.ZFSSendDry(r.Filesystem, r.From, r.To)
if err != nil {
return nil, nil, err
}
return &pdu.SendRes{ExpectedSize: size}, nil, nil
} else {
stream, err := zfs.ZFSSend(r.Filesystem, r.From, r.To)
if err != nil {
return nil, nil, err
}
return &pdu.SendRes{}, stream, nil
}
stream, err := zfs.ZFSSend(r.Filesystem, r.From, r.To)
if err != nil {
return nil, nil, err
}
return &pdu.SendRes{ExpectedSize: size}, stream, nil
}
func (p *Sender) DestroySnapshots(ctx context.Context, req *pdu.DestroySnapshotsReq) (*pdu.DestroySnapshotsRes, error) {

66
replication/fsrep/fsfsm.go
View File

@ -40,7 +40,7 @@ func getLogger(ctx context.Context) Logger {
type Sender interface {
// If a non-nil io.ReadCloser is returned, it is guaranteed to be closed before
// any next call to the parent github.com/zrepl/zrepl/replication.Endpoint.
// returned int64 is the expected size of the stream
// If the send request is for dry run the io.ReadCloser will be nil
Send(ctx context.Context, r *pdu.SendReq) (*pdu.SendRes, io.ReadCloser, error)
SnapshotReplicationStatus(ctx context.Context, r *pdu.SnapshotReplicationStatusReq) (*pdu.SnapshotReplicationStatusRes, error)
}
@ -105,6 +105,17 @@ func (f *Replication) State() State {
return f.state
}
func (f *Replication) UpdateSizeEsitmate(ctx context.Context, sender Sender) error {
f.lock.Lock()
defer f.lock.Unlock()
for _, e := range f.pending {
if err := e.updateSizeEstimate(ctx, sender); err != nil {
return err
}
}
return nil
}
type ReplicationBuilder struct {
r *Replication
}
@ -344,19 +355,7 @@ func (s *ReplicationStep) doReplication(ctx context.Context, sender Sender, rece
return s.state
}
var sr *pdu.SendReq
if s.from == nil {
sr = &pdu.SendReq{
Filesystem: fs,
From: s.to.RelName(), // FIXME fix protocol to use To, like zfs does internally
}
} else {
sr = &pdu.SendReq{
Filesystem: fs,
From: s.from.RelName(),
To: s.to.RelName(),
}
}
sr := s.buildSendRequest(false)
log.WithField("request", sr).Debug("initiate send request")
sres, sstream, err := sender.Send(ctx, sr)
@ -369,7 +368,6 @@ func (s *ReplicationStep) doReplication(ctx context.Context, sender Sender, rece
return updateStateError(err)
}
s.expectedSize = sres.ExpectedSize
s.byteCounter = util.NewByteCounterReader(sstream)
sstream = s.byteCounter
@ -442,6 +440,44 @@ func (s *ReplicationStep) doMarkReplicated(ctx context.Context, sender Sender) S
return updateStateCompleted()
}
func (s *ReplicationStep) updateSizeEstimate(ctx context.Context, sender Sender) error {
fs := s.parent.fs
log := getLogger(ctx).
WithField("filesystem", fs).
WithField("step", s.String())
sr := s.buildSendRequest(true)
log.WithField("request", sr).Debug("initiate dry run send request")
sres, _, err := sender.Send(ctx, sr)
if err != nil {
log.WithError(err).Error("dry run send request failed")
}
s.expectedSize = sres.ExpectedSize
return nil
}
func (s *ReplicationStep) buildSendRequest(dryRun bool) (sr *pdu.SendReq) {
fs := s.parent.fs
if s.from == nil {
sr = &pdu.SendReq{
Filesystem: fs,
From: s.to.RelName(), // FIXME fix protocol to use To, like zfs does internally
DryRun: dryRun,
}
} else {
sr = &pdu.SendReq{
Filesystem: fs,
From: s.from.RelName(),
To: s.to.RelName(),
DryRun: dryRun,
}
}
return sr
}
func (s *ReplicationStep) String() string {
if s.from == nil { // FIXME: ZFS semantics are that to is nil on non-incremental send
return fmt.Sprintf("%s%s (full)", s.parent.fs, s.to.RelName())

4
replication/mainfsm.go
View File

@ -266,6 +266,10 @@ func statePlanning(ctx context.Context, sender Sender, receiver Receiver, u upda
}
}
qitem := fsrfsm.Done()
if err = qitem.UpdateSizeEsitmate(ctx, sender); err != nil {
log.WithError(err).Error("cannot get size estimate")
return handlePlanningError(err)
}
q.Add(qitem)
}

129
replication/pdu/pdu.pb.go
View File

@ -38,7 +38,7 @@ func (x FilesystemVersion_VersionType) String() string {
return proto.EnumName(FilesystemVersion_VersionType_name, int32(x))
}
func (FilesystemVersion_VersionType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{5, 0}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{5, 0}
}
type SnapshotReplicationStatusReq_Op int32
@ -61,7 +61,7 @@ func (x SnapshotReplicationStatusReq_Op) String() string {
return proto.EnumName(SnapshotReplicationStatusReq_Op_name, int32(x))
}
func (SnapshotReplicationStatusReq_Op) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{14, 0}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{14, 0}
}
type ListFilesystemReq struct {
@ -74,7 +74,7 @@ func (m *ListFilesystemReq) Reset() { *m = ListFilesystemReq{} }
func (m *ListFilesystemReq) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemReq) ProtoMessage() {}
func (*ListFilesystemReq) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{0}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{0}
}
func (m *ListFilesystemReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListFilesystemReq.Unmarshal(m, b)
@ -105,7 +105,7 @@ func (m *ListFilesystemRes) Reset() { *m = ListFilesystemRes{} }
func (m *ListFilesystemRes) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemRes) ProtoMessage() {}
func (*ListFilesystemRes) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{1}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{1}
}
func (m *ListFilesystemRes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListFilesystemRes.Unmarshal(m, b)
@ -144,7 +144,7 @@ func (m *Filesystem) Reset() { *m = Filesystem{} }
func (m *Filesystem) String() string { return proto.CompactTextString(m) }
func (*Filesystem) ProtoMessage() {}
func (*Filesystem) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{2}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{2}
}
func (m *Filesystem) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Filesystem.Unmarshal(m, b)
@ -189,7 +189,7 @@ func (m *ListFilesystemVersionsReq) Reset() { *m = ListFilesystemVersion
func (m *ListFilesystemVersionsReq) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemVersionsReq) ProtoMessage() {}
func (*ListFilesystemVersionsReq) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{3}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{3}
}
func (m *ListFilesystemVersionsReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListFilesystemVersionsReq.Unmarshal(m, b)
@ -227,7 +227,7 @@ func (m *ListFilesystemVersionsRes) Reset() { *m = ListFilesystemVersion
func (m *ListFilesystemVersionsRes) String() string { return proto.CompactTextString(m) }
func (*ListFilesystemVersionsRes) ProtoMessage() {}
func (*ListFilesystemVersionsRes) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{4}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{4}
}
func (m *ListFilesystemVersionsRes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ListFilesystemVersionsRes.Unmarshal(m, b)
@ -269,7 +269,7 @@ func (m *FilesystemVersion) Reset() { *m = FilesystemVersion{} }
func (m *FilesystemVersion) String() string { return proto.CompactTextString(m) }
func (*FilesystemVersion) ProtoMessage() {}
func (*FilesystemVersion) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{5}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{5}
}
func (m *FilesystemVersion) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_FilesystemVersion.Unmarshal(m, b)
@ -339,6 +339,7 @@ type SendReq struct {
ResumeToken string `protobuf:"bytes,4,opt,name=ResumeToken,proto3" json:"ResumeToken,omitempty"`
Compress bool `protobuf:"varint,5,opt,name=Compress,proto3" json:"Compress,omitempty"`
Dedup bool `protobuf:"varint,6,opt,name=Dedup,proto3" json:"Dedup,omitempty"`
DryRun bool `protobuf:"varint,7,opt,name=DryRun,proto3" json:"DryRun,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -348,7 +349,7 @@ func (m *SendReq) Reset() { *m = SendReq{} }
func (m *SendReq) String() string { return proto.CompactTextString(m) }
func (*SendReq) ProtoMessage() {}
func (*SendReq) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{6}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{6}
}
func (m *SendReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SendReq.Unmarshal(m, b)
@ -410,6 +411,13 @@ func (m *SendReq) GetDedup() bool {
return false
}
func (m *SendReq) GetDryRun() bool {
if m != nil {
return m.DryRun
}
return false
}
type Property struct {
Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
Value string `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"`
@ -422,7 +430,7 @@ func (m *Property) Reset() { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage() {}
func (*Property) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{7}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{7}
}
func (m *Property) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Property.Unmarshal(m, b)
@ -471,7 +479,7 @@ func (m *SendRes) Reset() { *m = SendRes{} }
func (m *SendRes) String() string { return proto.CompactTextString(m) }
func (*SendRes) ProtoMessage() {}
func (*SendRes) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{8}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{8}
}
func (m *SendRes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SendRes.Unmarshal(m, b)
@ -525,7 +533,7 @@ func (m *ReceiveReq) Reset() { *m = ReceiveReq{} }
func (m *ReceiveReq) String() string { return proto.CompactTextString(m) }
func (*ReceiveReq) ProtoMessage() {}
func (*ReceiveReq) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{9}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{9}
}
func (m *ReceiveReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReceiveReq.Unmarshal(m, b)
@ -569,7 +577,7 @@ func (m *ReceiveRes) Reset() { *m = ReceiveRes{} }
func (m *ReceiveRes) String() string { return proto.CompactTextString(m) }
func (*ReceiveRes) ProtoMessage() {}
func (*ReceiveRes) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{10}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{10}
}
func (m *ReceiveRes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_ReceiveRes.Unmarshal(m, b)
@ -602,7 +610,7 @@ func (m *DestroySnapshotsReq) Reset() { *m = DestroySnapshotsReq{} }
func (m *DestroySnapshotsReq) String() string { return proto.CompactTextString(m) }
func (*DestroySnapshotsReq) ProtoMessage() {}
func (*DestroySnapshotsReq) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{11}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{11}
}
func (m *DestroySnapshotsReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DestroySnapshotsReq.Unmarshal(m, b)
@ -648,7 +656,7 @@ func (m *DestroySnapshotRes) Reset() { *m = DestroySnapshotRes{} }
func (m *DestroySnapshotRes) String() string { return proto.CompactTextString(m) }
func (*DestroySnapshotRes) ProtoMessage() {}
func (*DestroySnapshotRes) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{12}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{12}
}
func (m *DestroySnapshotRes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DestroySnapshotRes.Unmarshal(m, b)
@ -693,7 +701,7 @@ func (m *DestroySnapshotsRes) Reset() { *m = DestroySnapshotsRes{} }
func (m *DestroySnapshotsRes) String() string { return proto.CompactTextString(m) }
func (*DestroySnapshotsRes) ProtoMessage() {}
func (*DestroySnapshotsRes) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{13}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{13}
}
func (m *DestroySnapshotsRes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_DestroySnapshotsRes.Unmarshal(m, b)
@ -733,7 +741,7 @@ func (m *SnapshotReplicationStatusReq) Reset() { *m = SnapshotReplicatio
func (m *SnapshotReplicationStatusReq) String() string { return proto.CompactTextString(m) }
func (*SnapshotReplicationStatusReq) ProtoMessage() {}
func (*SnapshotReplicationStatusReq) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{14}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{14}
}
func (m *SnapshotReplicationStatusReq) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SnapshotReplicationStatusReq.Unmarshal(m, b)
@ -785,7 +793,7 @@ func (m *SnapshotReplicationStatusRes) Reset() { *m = SnapshotReplicatio
func (m *SnapshotReplicationStatusRes) String() string { return proto.CompactTextString(m) }
func (*SnapshotReplicationStatusRes) ProtoMessage() {}
func (*SnapshotReplicationStatusRes) Descriptor() ([]byte, []int) {
return fileDescriptor_pdu_cc43fc3f9f8b50e6, []int{15}
return fileDescriptor_pdu_ae88208ed9690d0f, []int{15}
}
func (m *SnapshotReplicationStatusRes) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_SnapshotReplicationStatusRes.Unmarshal(m, b)
@ -833,47 +841,48 @@ func init() {
proto.RegisterEnum("pdu.SnapshotReplicationStatusReq_Op", SnapshotReplicationStatusReq_Op_name, SnapshotReplicationStatusReq_Op_value)
}
func init() { proto.RegisterFile("pdu.proto", fileDescriptor_pdu_cc43fc3f9f8b50e6) }
func init() { proto.RegisterFile("pdu.proto", fileDescriptor_pdu_ae88208ed9690d0f) }
var fileDescriptor_pdu_cc43fc3f9f8b50e6 = []byte{
// 616 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xdb, 0x6e, 0x13, 0x3d,
0x10, 0xfe, 0x77, 0x37, 0x6d, 0x37, 0x93, 0x1e, 0x52, 0xb7, 0xfa, 0x59, 0xaa, 0x0a, 0x45, 0x16,
0x17, 0x01, 0x89, 0x48, 0x84, 0x8a, 0x1b, 0x24, 0x2e, 0x7a, 0xe4, 0x02, 0xd1, 0xca, 0x09, 0x55,
0xaf, 0x90, 0x96, 0xee, 0x48, 0x5d, 0x25, 0x1b, 0xbb, 0xb6, 0x17, 0x11, 0x1e, 0x80, 0xf7, 0xe0,
0x15, 0x78, 0x1a, 0x1e, 0x07, 0xd9, 0xd9, 0x83, 0x9b, 0x94, 0x28, 0x57, 0xeb, 0xf9, 0xe6, 0xdb,
0x99, 0x6f, 0x66, 0x3c, 0x86, 0xa6, 0x48, 0xf2, 0x9e, 0x90, 0x5c, 0x73, 0x12, 0x88, 0x24, 0xa7,
0x7b, 0xb0, 0xfb, 0x31, 0x55, 0xfa, 0x3c, 0x1d, 0xa3, 0x9a, 0x2a, 0x8d, 0x19, 0xc3, 0x7b, 0x7a,
0xbe, 0x08, 0x2a, 0xf2, 0x1a, 0x5a, 0x35, 0xa0, 0x22, 0xaf, 0x13, 0x74, 0x5b, 0xfd, 0x9d, 0x9e,
0x89, 0xe7, 0x10, 0x5d, 0x0e, 0x3d, 0x06, 0xa8, 0x4d, 0x42, 0xa0, 0x71, 0x15, 0xeb, 0xbb, 0xc8,
0xeb, 0x78, 0xdd, 0x26, 0xb3, 0x67, 0xd2, 0x81, 0x16, 0x43, 0x95, 0x67, 0x38, 0xe4, 0x23, 0x9c,
0x44, 0xbe, 0x75, 0xb9, 0x10, 0x7d, 0x07, 0x4f, 0x1f, 0x6a, 0xb9, 0x46, 0xa9, 0x52, 0x3e, 0x51,
0x0c, 0xef, 0xc9, 0x33, 0x37, 0x41, 0x11, 0xd8, 0x41, 0xe8, 0xe5, 0xbf, 0x7f, 0x56, 0xa4, 0x0f,
0x61, 0x69, 0x16, 0xd5, 0xfc, 0x3f, 0x57, 0x4d, 0xe1, 0x66, 0x15, 0x8f, 0xfe, 0xf1, 0x60, 0x77,
0xc1, 0x4f, 0xde, 0x42, 0x63, 0x38, 0x15, 0x68, 0x05, 0x6c, 0xf7, 0xe9, 0xe3, 0x51, 0x7a, 0xc5,
0xd7, 0x30, 0x99, 0xe5, 0x9b, 0x8e, 0x7c, 0x8a, 0x33, 0x2c, 0xca, 0xb6, 0x67, 0x83, 0x5d, 0xe4,
0x69, 0x12, 0x05, 0x1d, 0xaf, 0xdb, 0x60, 0xf6, 0x4c, 0x0e, 0xa1, 0x79, 0x22, 0x31, 0xd6, 0x38,
0xbc, 0xb9, 0x88, 0x1a, 0xd6, 0x51, 0x03, 0xe4, 0x00, 0x42, 0x6b, 0xa4, 0x7c, 0x12, 0xad, 0xd9,
0x48, 0x95, 0x4d, 0x5f, 0x40, 0xcb, 0x49, 0x4b, 0x36, 0x21, 0x1c, 0x4c, 0x62, 0xa1, 0xee, 0xb8,
0x6e, 0xff, 0x67, 0xac, 0x63, 0xce, 0x47, 0x59, 0x2c, 0x47, 0x6d, 0x8f, 0xfe, 0xf2, 0x60, 0x63,
0x80, 0x93, 0x64, 0x85, 0xbe, 0x1a, 0x91, 0xe7, 0x92, 0x67, 0xa5, 0x70, 0x73, 0x26, 0xdb, 0xe0,
0x0f, 0xb9, 0x95, 0xdd, 0x64, 0xfe, 0x90, 0xcf, 0x8f, 0xb6, 0xb1, 0x30, 0x5a, 0x2b, 0x9c, 0x67,
0x42, 0xa2, 0x52, 0x56, 0x78, 0xc8, 0x2a, 0x9b, 0xec, 0xc3, 0xda, 0x29, 0x26, 0xb9, 0x88, 0xd6,
0xad, 0x63, 0x66, 0xd0, 0x23, 0x08, 0xaf, 0x24, 0x17, 0x28, 0xf5, 0xb4, 0x6a, 0x9e, 0xe7, 0x34,
0x6f, 0x1f, 0xd6, 0xae, 0xe3, 0x71, 0x5e, 0x76, 0x74, 0x66, 0xd0, 0x9f, 0x55, 0x65, 0x8a, 0x74,
0x61, 0xe7, 0xb3, 0xc2, 0xc4, 0x55, 0xe6, 0xd9, 0x0c, 0xf3, 0x30, 0xa1, 0xb0, 0x79, 0xf6, 0x5d,
0xe0, 0xad, 0xc6, 0x64, 0x90, 0xfe, 0x98, 0x85, 0x0c, 0xd8, 0x03, 0x8c, 0xbc, 0x02, 0x28, 0xf4,
0xa4, 0xa8, 0xa2, 0xc0, 0x5e, 0xa2, 0x2d, 0x3b, 0xfe, 0x52, 0x26, 0x73, 0x08, 0xf4, 0x06, 0x80,
0xe1, 0x2d, 0xa6, 0xdf, 0x70, 0x95, 0x26, 0xbf, 0x84, 0xf6, 0xc9, 0x18, 0x63, 0x39, 0xbf, 0x20,
0x21, 0x5b, 0xc0, 0xe9, 0xa6, 0x13, 0x59, 0xd1, 0x11, 0xec, 0x9d, 0xa2, 0xd2, 0x92, 0x4f, 0xcb,
0x69, 0xaf, 0xb2, 0x2d, 0xe4, 0x08, 0x9a, 0x15, 0x3f, 0xf2, 0x97, 0x6e, 0x44, 0x4d, 0xa4, 0x5f,
0x80, 0xcc, 0x25, 0x2b, 0x96, 0xab, 0x34, 0x6d, 0xa6, 0x25, 0xcb, 0x55, 0xf2, 0xcc, 0xf4, 0xce,
0xa4, 0xe4, 0xb2, 0x9c, 0x9e, 0x35, 0xe8, 0x87, 0xc7, 0x8a, 0x31, 0xcf, 0xd1, 0x86, 0x69, 0xc0,
0x58, 0x97, 0xcb, 0xfb, 0xc4, 0xc6, 0x5f, 0x94, 0xc2, 0x4a, 0x1e, 0xfd, 0xed, 0xc1, 0x61, 0xed,
0x10, 0xe3, 0xf4, 0xd6, 0x2e, 0xc9, 0x40, 0xc7, 0x3a, 0x5f, 0xa9, 0x41, 0x07, 0x4e, 0x51, 0x33,
0x8d, 0xb5, 0xf8, 0x23, 0xf0, 0xb9, 0xb0, 0xd7, 0x7f, 0xbb, 0xff, 0xdc, 0x4a, 0x59, 0x96, 0xaa,
0x77, 0x29, 0x98, 0xcf, 0x05, 0xed, 0x80, 0x7f, 0x29, 0xc8, 0x06, 0x04, 0x17, 0x68, 0x36, 0x72,
0x17, 0xb6, 0x06, 0x58, 0xfd, 0x80, 0x49, 0xdb, 0xa3, 0xef, 0x97, 0x6a, 0x56, 0x46, 0x73, 0xcd,
0x2f, 0xee, 0xb2, 0x83, 0x7c, 0x5d, 0xb7, 0x8f, 0xfd, 0x9b, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff,
0x47, 0xbd, 0x08, 0x65, 0xf9, 0x05, 0x00, 0x00,
var fileDescriptor_pdu_ae88208ed9690d0f = []byte{
// 627 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x55, 0xdb, 0x6e, 0x13, 0x31,
0x10, 0x65, 0x37, 0x69, 0x93, 0x4c, 0x7a, 0x49, 0xdd, 0xaa, 0x2c, 0x55, 0x85, 0x22, 0x8b, 0x87,
0x80, 0x44, 0x24, 0x42, 0xc5, 0x0b, 0x12, 0x0f, 0xbd, 0xf2, 0x80, 0x68, 0xe5, 0x84, 0xaa, 0x4f,
0x48, 0x4b, 0x77, 0xa4, 0xae, 0x72, 0xb1, 0x6b, 0xef, 0x22, 0xc2, 0x07, 0xf0, 0x41, 0xbc, 0xf1,
0x27, 0x7c, 0x0e, 0xf2, 0x64, 0x2f, 0x6e, 0x52, 0xa2, 0x3c, 0xd5, 0xe7, 0xcc, 0xd9, 0x99, 0x33,
0x63, 0x4f, 0x03, 0x0d, 0x15, 0xa5, 0x5d, 0xa5, 0x65, 0x22, 0x59, 0x45, 0x45, 0x29, 0xdf, 0x85,
0x9d, 0x4f, 0xb1, 0x49, 0xce, 0xe3, 0x11, 0x9a, 0xa9, 0x49, 0x70, 0x2c, 0xf0, 0x9e, 0x9f, 0x2f,
0x92, 0x86, 0xbd, 0x81, 0x66, 0x49, 0x98, 0xc0, 0x6b, 0x57, 0x3a, 0xcd, 0xde, 0x76, 0xd7, 0xe6,
0x73, 0x84, 0xae, 0x86, 0x1f, 0x03, 0x94, 0x90, 0x31, 0xa8, 0x5e, 0x85, 0xc9, 0x5d, 0xe0, 0xb5,
0xbd, 0x4e, 0x43, 0xd0, 0x99, 0xb5, 0xa1, 0x29, 0xd0, 0xa4, 0x63, 0x1c, 0xc8, 0x21, 0x4e, 0x02,
0x9f, 0x42, 0x2e, 0xc5, 0xdf, 0xc3, 0xb3, 0x87, 0x5e, 0xae, 0x51, 0x9b, 0x58, 0x4e, 0x8c, 0xc0,
0x7b, 0xf6, 0xdc, 0x2d, 0x90, 0x25, 0x76, 0x18, 0x7e, 0xf9, 0xff, 0x8f, 0x0d, 0xeb, 0x41, 0x3d,
0x87, 0x59, 0x37, 0xfb, 0x73, 0xdd, 0x64, 0x61, 0x51, 0xe8, 0xf8, 0x5f, 0x0f, 0x76, 0x16, 0xe2,
0xec, 0x1d, 0x54, 0x07, 0x53, 0x85, 0x64, 0x60, 0xab, 0xc7, 0x1f, 0xcf, 0xd2, 0xcd, 0xfe, 0x5a,
0xa5, 0x20, 0xbd, 0x9d, 0xc8, 0xe7, 0x70, 0x8c, 0x59, 0xdb, 0x74, 0xb6, 0xdc, 0x45, 0x1a, 0x47,
0x41, 0xa5, 0xed, 0x75, 0xaa, 0x82, 0xce, 0xec, 0x10, 0x1a, 0x27, 0x1a, 0xc3, 0x04, 0x07, 0x37,
0x17, 0x41, 0x95, 0x02, 0x25, 0xc1, 0x0e, 0xa0, 0x4e, 0x20, 0x96, 0x93, 0x60, 0x8d, 0x32, 0x15,
0x98, 0xbf, 0x84, 0xa6, 0x53, 0x96, 0x6d, 0x40, 0xbd, 0x3f, 0x09, 0x95, 0xb9, 0x93, 0x49, 0xeb,
0x89, 0x45, 0xc7, 0x52, 0x0e, 0xc7, 0xa1, 0x1e, 0xb6, 0x3c, 0xfe, 0xc7, 0x83, 0x5a, 0x1f, 0x27,
0xd1, 0x0a, 0x73, 0xb5, 0x26, 0xcf, 0xb5, 0x1c, 0xe7, 0xc6, 0xed, 0x99, 0x6d, 0x81, 0x3f, 0x90,
0x64, 0xbb, 0x21, 0xfc, 0x81, 0x9c, 0xbf, 0xda, 0xea, 0xc2, 0xd5, 0x92, 0x71, 0x39, 0x56, 0x1a,
0x8d, 0x21, 0xe3, 0x75, 0x51, 0x60, 0xb6, 0x07, 0x6b, 0xa7, 0x18, 0xa5, 0x2a, 0x58, 0xa7, 0xc0,
0x0c, 0xb0, 0x7d, 0x58, 0x3f, 0xd5, 0x53, 0x91, 0x4e, 0x82, 0x1a, 0xd1, 0x19, 0xe2, 0x47, 0x50,
0xbf, 0xd2, 0x52, 0xa1, 0x4e, 0xa6, 0xc5, 0x50, 0x3d, 0x67, 0xa8, 0x7b, 0xb0, 0x76, 0x1d, 0x8e,
0xd2, 0x7c, 0xd2, 0x33, 0xc0, 0x7f, 0x15, 0x1d, 0x1b, 0xd6, 0x81, 0xed, 0x2f, 0x06, 0x23, 0xd7,
0xb1, 0x47, 0x25, 0xe6, 0x69, 0xc6, 0x61, 0xe3, 0xec, 0x87, 0xc2, 0xdb, 0x04, 0xa3, 0x7e, 0xfc,
0x73, 0x96, 0xb2, 0x22, 0x1e, 0x70, 0xec, 0x35, 0x40, 0xe6, 0x27, 0x46, 0x13, 0x54, 0xe8, 0x71,
0x6d, 0xd2, 0xb3, 0xc8, 0x6d, 0x0a, 0x47, 0xc0, 0x6f, 0x00, 0x04, 0xde, 0x62, 0xfc, 0x1d, 0x57,
0x19, 0xfe, 0x2b, 0x68, 0x9d, 0x8c, 0x30, 0xd4, 0xf3, 0x8b, 0x53, 0x17, 0x0b, 0x3c, 0xdf, 0x70,
0x32, 0x1b, 0x3e, 0x84, 0xdd, 0x53, 0x34, 0x89, 0x96, 0xd3, 0xfc, 0x15, 0xac, 0xb2, 0x45, 0xec,
0x08, 0x1a, 0x85, 0x3e, 0xf0, 0x97, 0x6e, 0x4a, 0x29, 0xe4, 0x5f, 0x81, 0xcd, 0x15, 0xcb, 0x96,
0x2e, 0x87, 0x54, 0x69, 0xc9, 0xd2, 0xe5, 0x3a, 0x7b, 0x7b, 0x67, 0x5a, 0x4b, 0x9d, 0xdf, 0x1e,
0x01, 0xfe, 0xf1, 0xb1, 0x66, 0xec, 0xbf, 0xa9, 0x9a, 0x1d, 0xc0, 0x28, 0xc9, 0x97, 0xfa, 0x29,
0xe5, 0x5f, 0xb4, 0x22, 0x72, 0x1d, 0xff, 0xed, 0xc1, 0x61, 0x19, 0x50, 0xa3, 0xf8, 0x96, 0x96,
0xa7, 0x9f, 0x84, 0x49, 0xba, 0xd2, 0x80, 0x0e, 0x9c, 0xa6, 0x66, 0x1e, 0x4b, 0xf3, 0x47, 0xe0,
0x4b, 0x45, 0x6b, 0xb1, 0xd5, 0x7b, 0x41, 0x56, 0x96, 0x95, 0xea, 0x5e, 0x2a, 0xe1, 0x4b, 0xc5,
0xdb, 0xe0, 0x5f, 0x2a, 0x56, 0x83, 0xca, 0x05, 0xda, 0x4d, 0xdd, 0x81, 0xcd, 0x3e, 0x16, 0x1f,
0x60, 0xd4, 0xf2, 0xf8, 0x87, 0xa5, 0x9e, 0x8d, 0xf5, 0x5c, 0xea, 0xb3, 0xb7, 0xec, 0x30, 0xdf,
0xd6, 0xe9, 0x47, 0xe0, 0xed, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf0, 0xc1, 0x08, 0xf6, 0x11,
0x06, 0x00, 0x00,
}

2
replication/pdu/pdu.proto
View File

@ -50,6 +50,8 @@ message SendReq {
string ResumeToken = 4;
bool Compress = 5;
bool Dedup = 6;
bool DryRun = 7;
}
message Property {