zrepl/replication/logic/pdu/pdu.proto

syntax = "proto3";
option go_package = ".;pdu";

service Replication {
  rpc Ping(PingReq) returns (PingRes);
  rpc ListFilesystems(ListFilesystemReq) returns (ListFilesystemRes);
  rpc ListFilesystemVersions(ListFilesystemVersionsReq)
      returns (ListFilesystemVersionsRes);
  rpc DestroySnapshots(DestroySnapshotsReq) returns (DestroySnapshotsRes);
  rpc ReplicationCursor(ReplicationCursorReq) returns (ReplicationCursorRes);
  rpc SendDry(SendReq) returns (SendRes);
  rpc SendCompleted(SendCompletedReq) returns (SendCompletedRes);
  // for Send and Recv, see package rpc
}

message ListFilesystemReq {}

message ListFilesystemRes { repeated Filesystem Filesystems = 1; }

message Filesystem {
  string Path = 1;
  string ResumeToken = 2;
  bool IsPlaceholder = 3;
}

message ListFilesystemVersionsReq { string Filesystem = 1; }

message ListFilesystemVersionsRes { repeated FilesystemVersion Versions = 1; }

message FilesystemVersion {
  enum VersionType {
    Snapshot = 0;
    Bookmark = 1;
  }
  VersionType Type = 1;
  string Name = 2;
  uint64 Guid = 3;
  uint64 CreateTXG = 4;
  string Creation = 5; // RFC 3339
}

message SendReq {
  string Filesystem = 1;
  // May be empty / null to request a full transfer of To
  FilesystemVersion From = 2;
  FilesystemVersion To = 3;

  // If ResumeToken is not empty, the resume token that CAN be used for 'zfs
  // send' by the sender. The sender MUST indicate use of ResumeToken in the
  // reply message 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.
  string ResumeToken = 4;

  ReplicationConfig ReplicationConfig = 6;
}

message ReplicationConfig {
  ReplicationConfigProtection protection = 1;
}


message ReplicationConfigProtection {
  ReplicationGuaranteeKind Initial = 1;
  ReplicationGuaranteeKind Incremental = 2;
}

enum ReplicationGuaranteeKind {
  GuaranteeInvalid = 0;
  GuaranteeResumability = 1;
  GuaranteeIncrementalReplication = 2;
  GuaranteeNothing = 3; 
}

message Property {
  string Name = 1;
  string Value = 2;
}

message SendRes {
  // Whether the resume token provided in the request has been used or not.
  // If the SendReq.ResumeToken == "", this field MUST be false.
  bool UsedResumeToken = 1;

  // Expected stream size determined by dry run, not exact.
  // 0 indicates that for the given SendReq, no size estimate could be made.
  uint64 ExpectedSize = 2;
}

message SendCompletedReq {
  SendReq OriginalReq = 2;
}

message SendCompletedRes {}

message ReceiveReq {
  string Filesystem = 1;
  FilesystemVersion To = 2;

  // If true, the receiver should clear the resume token before performing the
  // zfs recv of the stream in the request
  bool ClearResumeToken = 3;

  ReplicationConfig ReplicationConfig = 4;
}

message ReceiveRes {}

message DestroySnapshotsReq {
  string Filesystem = 1;
  // Path to filesystem, snapshot or bookmark to be destroyed
  repeated FilesystemVersion Snapshots = 2;
}

message DestroySnapshotRes {
  FilesystemVersion Snapshot = 1;
  string Error = 2;
}

message DestroySnapshotsRes { repeated DestroySnapshotRes Results = 1; }

message ReplicationCursorReq { string Filesystem = 1; }

message ReplicationCursorRes {
  oneof Result {
    uint64 Guid = 1;
    bool Notexist = 2;
  }
}

message PingReq { string Message = 1; }

message PingRes {
  // Echo must be PingReq.Message
  string Echo = 1;
}