new features: {resumable,encrypted,hold-protected} send-recv, last-received-hold
- **Resumable Send & Recv Support**
No knobs required, automatically used where supported.
- **Hold-Protected Send & Recv**
Automatic ZFS holds to ensure that we can always resume a replication step.
- **Encrypted Send & Recv Support** for OpenZFS native encryption.
Configurable at the job level, i.e., for all filesystems a job is responsible for.
- **Receive-side hold on last received dataset**
The counterpart to the replication cursor bookmark on the send-side.
Ensures that incremental replication will always be possible between a sender and receiver.
Design Doc
----------
`replication/design.md` doc describes how we use ZFS holds and bookmarks to ensure that a single replication step is always resumable.
The replication algorithm described in the design doc introduces the notion of job IDs (please read the details on this design doc).
We reuse the job names for job IDs and use `JobID` type to ensure that a job name can be embedded into hold tags, bookmark names, etc.
This might BREAK CONFIG on upgrade.
Protocol Version Bump
---------------------
This commit makes backwards-incompatible changes to the replication/pdu protobufs.
Thus, bump the version number used in the protocol handshake.
Replication Cursor Format Change
--------------------------------
The new replication cursor bookmark format is: `#zrepl_CURSOR_G_${this.GUID}_J_${jobid}`
Including the GUID enables transaction-safe moving-forward of the cursor.
Including the job id enables that multiple sending jobs can send the same filesystem without interfering.
The `zrepl migrate replication-cursor:v1-v2` subcommand can be used to safely destroy old-format cursors once zrepl has created new-format cursors.
Changes in This Commit
----------------------
- package zfs
- infrastructure for holds
- infrastructure for resume token decoding
- implement a variant of OpenZFS's `entity_namecheck` and use it for validation in new code
- ZFSSendArgs to specify a ZFS send operation
- validation code protects against malicious resume tokens by checking that the token encodes the same send parameters that the send-side would use if no resume token were available (i.e. same filesystem, `fromguid`, `toguid`)
- RecvOptions support for `recv -s` flag
- convert a bunch of ZFS operations to be idempotent
- achieved through more differentiated error message scraping / additional pre-/post-checks
- package replication/pdu
- add field for encryption to send request messages
- add fields for resume handling to send & recv request messages
- receive requests now contain `FilesystemVersion To` in addition to the filesystem into which the stream should be `recv`d into
- can use `zfs recv $root_fs/$client_id/path/to/dataset@${To.Name}`, which enables additional validation after recv (i.e. whether `To.Guid` matched what we received in the stream)
- used to set `last-received-hold`
- package replication/logic
- introduce `PlannerPolicy` struct, currently only used to configure whether encrypted sends should be requested from the sender
- integrate encryption and resume token support into `Step` struct
- package endpoint
- move the concepts that endpoint builds on top of ZFS to a single file `endpoint/endpoint_zfs.go`
- step-holds + step-bookmarks
- last-received-hold
- new replication cursor + old replication cursor compat code
- adjust `endpoint/endpoint.go` handlers for
- encryption
- resumability
- new replication cursor
- last-received-hold
- client subcommand `zrepl holds list`: list all holds and hold-like bookmarks that zrepl thinks belong to it
- client subcommand `zrepl migrate replication-cursor:v1-v2`
This commit is contained in:
Christian Schwarz
@@ -0,0 +1,71 @@
|
||||
package zfs
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"github.com/pkg/errors"
|
||||
|
||||
"github.com/zrepl/zrepl/util/envconst"
|
||||
)
|
||||
|
||||
var encryptionCLISupport struct {
|
||||
once sync.Once
|
||||
supported bool
|
||||
err error
|
||||
}
|
||||
|
||||
func EncryptionCLISupported(ctx context.Context) (bool, error) {
|
||||
encryptionCLISupport.once.Do(func() {
|
||||
// "feature discovery"
|
||||
cmd := exec.Command("zfs", "load-key")
|
||||
output, err := cmd.CombinedOutput()
|
||||
if ee, ok := err.(*exec.ExitError); !ok || ok && !ee.Exited() {
|
||||
encryptionCLISupport.err = errors.Wrap(err, "native encryption cli support feature check failed")
|
||||
}
|
||||
def := strings.Contains(string(output), "load-key") && strings.Contains(string(output), "keylocation")
|
||||
encryptionCLISupport.supported = envconst.Bool("ZREPL_EXPERIMENTAL_ZFS_ENCRYPTION_CLI_SUPPORTED", def)
|
||||
debug("encryption cli feature check complete %#v", &encryptionCLISupport)
|
||||
})
|
||||
return encryptionCLISupport.supported, encryptionCLISupport.err
|
||||
}
|
||||
|
||||
// returns false, nil if encryption is not supported
|
||||
func ZFSGetEncryptionEnabled(ctx context.Context, fs string) (enabled bool, err error) {
|
||||
defer func(e *error) {
|
||||
if *e != nil {
|
||||
*e = fmt.Errorf("zfs get encryption enabled fs=%q: %s", fs, *e)
|
||||
}
|
||||
}(&err)
|
||||
if supp, err := EncryptionCLISupported(ctx); err != nil {
|
||||
return false, err
|
||||
} else if !supp {
|
||||
return false, nil
|
||||
}
|
||||
|
||||
if err := validateZFSFilesystem(fs); err != nil {
|
||||
return false, err
|
||||
}
|
||||
|
||||
props, err := zfsGet(fs, []string{"encryption"}, sourceAny)
|
||||
if err != nil {
|
||||
return false, errors.Wrap(err, "cannot get `encryption` property")
|
||||
}
|
||||
val := props.Get("encryption")
|
||||
switch val {
|
||||
case "":
|
||||
panic("zfs get should return a value for `encryption`")
|
||||
case "-":
|
||||
return false, errors.New("`encryption` property should never be \"-\"")
|
||||
case "off":
|
||||
return false, nil
|
||||
default:
|
||||
// we don't want to hardcode the cipher list, and we checked for != 'off'
|
||||
// ==> assume any other value means encryption is enabled
|
||||
// TODO add test to OpenZFS test suite
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
+307
@@ -0,0 +1,307 @@
|
||||
package zfs
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
|
||||
"github.com/pkg/errors"
|
||||
|
||||
"github.com/zrepl/zrepl/util/envconst"
|
||||
)
|
||||
|
||||
// no need for feature tests, holds have been around forever
|
||||
|
||||
func validateNotEmpty(field, s string) error {
|
||||
if s == "" {
|
||||
return fmt.Errorf("`%s` must not be empty", field)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// returned err != nil is guaranteed to represent invalid hold tag
|
||||
func ValidHoldTag(tag string) error {
|
||||
maxlen := envconst.Int("ZREPL_ZFS_MAX_HOLD_TAG_LEN", 256-1) // 256 include NULL byte, from module/zfs/dsl_userhold.c
|
||||
if len(tag) > maxlen {
|
||||
return fmt.Errorf("hold tag %q exceeds max length of %d", tag, maxlen)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Idemptotent: does not return an error if the tag already exists
|
||||
func ZFSHold(ctx context.Context, fs string, v ZFSSendArgVersion, tag string) error {
|
||||
if err := v.ValidateInMemory(fs); err != nil {
|
||||
return errors.Wrap(err, "invalid version")
|
||||
}
|
||||
if !v.IsSnapshot() {
|
||||
return errors.Errorf("can only hold snapshots, got %s", v.RelName)
|
||||
}
|
||||
|
||||
if err := validateNotEmpty("tag", tag); err != nil {
|
||||
return err
|
||||
}
|
||||
fullPath := v.FullPath(fs)
|
||||
output, err := exec.CommandContext(ctx, "zfs", "hold", tag, fullPath).CombinedOutput()
|
||||
if err != nil {
|
||||
if bytes.Contains(output, []byte("tag already exists on this dataset")) {
|
||||
goto success
|
||||
}
|
||||
return &ZFSError{output, errors.Wrapf(err, "cannot hold %q", fullPath)}
|
||||
}
|
||||
success:
|
||||
return nil
|
||||
}
|
||||
|
||||
func ZFSHolds(ctx context.Context, fs, snap string) ([]string, error) {
|
||||
if err := validateZFSFilesystem(fs); err != nil {
|
||||
return nil, errors.Wrap(err, "`fs` is not a valid filesystem path")
|
||||
}
|
||||
if snap == "" {
|
||||
return nil, fmt.Errorf("`snap` must not be empty")
|
||||
}
|
||||
dp := fmt.Sprintf("%s@%s", fs, snap)
|
||||
output, err := exec.CommandContext(ctx, "zfs", "holds", "-H", dp).CombinedOutput()
|
||||
if err != nil {
|
||||
return nil, &ZFSError{output, errors.Wrap(err, "zfs holds failed")}
|
||||
}
|
||||
scan := bufio.NewScanner(bytes.NewReader(output))
|
||||
var tags []string
|
||||
for scan.Scan() {
|
||||
// NAME TAG TIMESTAMP
|
||||
comps := strings.SplitN(scan.Text(), "\t", 3)
|
||||
if len(comps) != 3 {
|
||||
return nil, fmt.Errorf("zfs holds: unexpected output\n%s", output)
|
||||
}
|
||||
if comps[0] != dp {
|
||||
return nil, fmt.Errorf("zfs holds: unexpected output: expecting %q as first component, got %q\n%s", dp, comps[0], output)
|
||||
}
|
||||
tags = append(tags, comps[1])
|
||||
}
|
||||
return tags, nil
|
||||
}
|
||||
|
||||
// Idempotent: if the hold doesn't exist, this is not an error
|
||||
func ZFSRelease(ctx context.Context, tag string, snaps ...string) error {
|
||||
cumLens := make([]int, len(snaps))
|
||||
for i := 1; i < len(snaps); i++ {
|
||||
cumLens[i] = cumLens[i-1] + len(snaps[i])
|
||||
}
|
||||
maxInvocationLen := 12 * os.Getpagesize()
|
||||
var noSuchTagLines, otherLines []string
|
||||
for i := 0; i < len(snaps); {
|
||||
var j = i
|
||||
for ; j < len(snaps); j++ {
|
||||
if cumLens[j]-cumLens[i] > maxInvocationLen {
|
||||
break
|
||||
}
|
||||
}
|
||||
args := []string{"release", tag}
|
||||
args = append(args, snaps[i:j]...)
|
||||
output, err := exec.CommandContext(ctx, "zfs", args...).CombinedOutput()
|
||||
if pe, ok := err.(*os.PathError); err != nil && ok && pe.Err == syscall.E2BIG {
|
||||
maxInvocationLen = maxInvocationLen / 2
|
||||
continue
|
||||
}
|
||||
maxInvocationLen = maxInvocationLen + os.Getpagesize()
|
||||
i = j
|
||||
|
||||
// even if release fails for datasets where there's no hold with the tag
|
||||
// the hold is still released on datasets which have a hold with the tag
|
||||
// FIXME verify this in a platformtest
|
||||
// => screen-scrape
|
||||
scan := bufio.NewScanner(bytes.NewReader(output))
|
||||
for scan.Scan() {
|
||||
line := scan.Text()
|
||||
if strings.Contains(line, "no such tag on this dataset") {
|
||||
noSuchTagLines = append(noSuchTagLines, line)
|
||||
} else {
|
||||
otherLines = append(otherLines, line)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
if debugEnabled {
|
||||
debug("zfs release: no such tag lines=%v otherLines=%v", noSuchTagLines, otherLines)
|
||||
}
|
||||
if len(otherLines) > 0 {
|
||||
return fmt.Errorf("unknown zfs error while releasing hold with tag %q: unidentified stderr lines\n%s", tag, strings.Join(otherLines, "\n"))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Idempotent: if the hold doesn't exist, this is not an error
|
||||
func ZFSReleaseAllOlderAndIncludingGUID(ctx context.Context, fs string, snapOrBookmarkGuid uint64, tag string) error {
|
||||
return doZFSReleaseAllOlderAndIncOrExcludingGUID(ctx, fs, snapOrBookmarkGuid, tag, true)
|
||||
}
|
||||
|
||||
// Idempotent: if the hold doesn't exist, this is not an error
|
||||
func ZFSReleaseAllOlderThanGUID(ctx context.Context, fs string, snapOrBookmarkGuid uint64, tag string) error {
|
||||
return doZFSReleaseAllOlderAndIncOrExcludingGUID(ctx, fs, snapOrBookmarkGuid, tag, false)
|
||||
}
|
||||
|
||||
type zfsReleaseAllOlderAndIncOrExcludingGUIDZFSListLine struct {
|
||||
entityType EntityType
|
||||
name string
|
||||
createtxg uint64
|
||||
guid uint64
|
||||
userrefs uint64 // always 0 for bookmarks
|
||||
}
|
||||
|
||||
func doZFSReleaseAllOlderAndIncOrExcludingGUID(ctx context.Context, fs string, snapOrBookmarkGuid uint64, tag string, includeGuid bool) error {
|
||||
// TODO channel program support still unreleased but
|
||||
// might be a huge performance improvement
|
||||
// https://github.com/zfsonlinux/zfs/pull/7902/files
|
||||
|
||||
if err := validateZFSFilesystem(fs); err != nil {
|
||||
return errors.Wrap(err, "`fs` is not a valid filesystem path")
|
||||
}
|
||||
if tag == "" {
|
||||
return fmt.Errorf("`tag` must not be empty`")
|
||||
}
|
||||
|
||||
output, err := exec.CommandContext(ctx,
|
||||
"zfs", "list", "-o", "type,name,createtxg,guid,userrefs",
|
||||
"-H", "-t", "snapshot,bookmark", "-r", "-d", "1", fs).CombinedOutput()
|
||||
if err != nil {
|
||||
return &ZFSError{output, errors.Wrap(err, "cannot list snapshots and their userrefs")}
|
||||
}
|
||||
|
||||
lines, err := doZFSReleaseAllOlderAndIncOrExcludingGUIDParseListOutput(output)
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "unexpected ZFS output")
|
||||
}
|
||||
|
||||
releaseSnaps, err := doZFSReleaseAllOlderAndIncOrExcludingGUIDFindSnapshots(snapOrBookmarkGuid, includeGuid, lines)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if len(releaseSnaps) == 0 {
|
||||
return nil
|
||||
}
|
||||
return ZFSRelease(ctx, tag, releaseSnaps...)
|
||||
}
|
||||
|
||||
func doZFSReleaseAllOlderAndIncOrExcludingGUIDParseListOutput(output []byte) ([]zfsReleaseAllOlderAndIncOrExcludingGUIDZFSListLine, error) {
|
||||
|
||||
scan := bufio.NewScanner(bytes.NewReader(output))
|
||||
|
||||
var lines []zfsReleaseAllOlderAndIncOrExcludingGUIDZFSListLine
|
||||
|
||||
for scan.Scan() {
|
||||
const numCols = 5
|
||||
comps := strings.SplitN(scan.Text(), "\t", numCols)
|
||||
if len(comps) != numCols {
|
||||
return nil, fmt.Errorf("not %d columns\n%s", numCols, output)
|
||||
}
|
||||
dstype := comps[0]
|
||||
name := comps[1]
|
||||
|
||||
var entityType EntityType
|
||||
switch dstype {
|
||||
case "snapshot":
|
||||
entityType = EntityTypeSnapshot
|
||||
case "bookmark":
|
||||
entityType = EntityTypeBookmark
|
||||
default:
|
||||
return nil, fmt.Errorf("column 0 is %q, expecting \"snapshot\" or \"bookmark\"", dstype)
|
||||
}
|
||||
|
||||
createtxg, err := strconv.ParseUint(comps[2], 10, 64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("cannot parse createtxg %q: %s\n%s", comps[2], err, output)
|
||||
}
|
||||
|
||||
guid, err := strconv.ParseUint(comps[3], 10, 64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("cannot parse guid %q: %s\n%s", comps[3], err, output)
|
||||
}
|
||||
|
||||
var userrefs uint64
|
||||
switch entityType {
|
||||
case EntityTypeBookmark:
|
||||
if comps[4] != "-" {
|
||||
return nil, fmt.Errorf("entity type \"bookmark\" should have userrefs=\"-\", got %q", comps[4])
|
||||
}
|
||||
userrefs = 0
|
||||
case EntityTypeSnapshot:
|
||||
userrefs, err = strconv.ParseUint(comps[4], 10, 64) // shadow
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("cannot parse userrefs %q: %s\n%s", comps[4], err, output)
|
||||
}
|
||||
default:
|
||||
panic(entityType)
|
||||
}
|
||||
|
||||
lines = append(lines, zfsReleaseAllOlderAndIncOrExcludingGUIDZFSListLine{
|
||||
entityType: entityType,
|
||||
name: name,
|
||||
createtxg: createtxg,
|
||||
guid: guid,
|
||||
userrefs: userrefs,
|
||||
})
|
||||
}
|
||||
|
||||
return lines, nil
|
||||
|
||||
}
|
||||
|
||||
func doZFSReleaseAllOlderAndIncOrExcludingGUIDFindSnapshots(snapOrBookmarkGuid uint64, includeGuid bool, lines []zfsReleaseAllOlderAndIncOrExcludingGUIDZFSListLine) (releaseSnaps []string, err error) {
|
||||
|
||||
// sort lines by createtxg,(snap < bookmark)
|
||||
// we cannot do this using zfs list -s because `type` is not a
|
||||
sort.Slice(lines, func(i, j int) (less bool) {
|
||||
if lines[i].createtxg == lines[j].createtxg {
|
||||
iET := func(t EntityType) int {
|
||||
switch t {
|
||||
case EntityTypeSnapshot:
|
||||
return 0
|
||||
case EntityTypeBookmark:
|
||||
return 1
|
||||
default:
|
||||
panic("unepxected entity type " + t.String())
|
||||
}
|
||||
}
|
||||
return iET(lines[i].entityType) < iET(lines[j].entityType)
|
||||
}
|
||||
return lines[i].createtxg < lines[j].createtxg
|
||||
})
|
||||
|
||||
// iterate over snapshots oldest to newest and collect snapshots that have holds and
|
||||
// are older than (inclusive or exclusive, depends on includeGuid) a snapshot or bookmark
|
||||
// with snapOrBookmarkGuid
|
||||
foundGuid := false
|
||||
for _, line := range lines {
|
||||
if line.guid == snapOrBookmarkGuid {
|
||||
foundGuid = true
|
||||
}
|
||||
if line.userrefs > 0 {
|
||||
if !foundGuid || (foundGuid && includeGuid) {
|
||||
// only snapshots have userrefs > 0, no need to check entityType
|
||||
releaseSnaps = append(releaseSnaps, line.name)
|
||||
}
|
||||
}
|
||||
if foundGuid {
|
||||
// The secondary key in sorting (snap < bookmark) guarantees that we
|
||||
// A) either found the snapshot with snapOrBoomkarkGuid
|
||||
// B) or no snapshot with snapGuid exists, but one or more bookmarks of it exists
|
||||
// In the case of A, we already added the snapshot to releaseSnaps if includeGuid requests it,
|
||||
// and can ignore possible subsequent bookmarks of the snapshot.
|
||||
// In the case of B, there is nothing to add to releaseSnaps.
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if !foundGuid {
|
||||
return nil, fmt.Errorf("cannot find snapshot or bookmark with guid %v", snapOrBookmarkGuid)
|
||||
}
|
||||
|
||||
return releaseSnaps, nil
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
package zfs
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/kr/pretty"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestDoZFSReleaseAllOlderAndIncOrExcludingGUIDFindSnapshots(t *testing.T) {
|
||||
|
||||
// what we test here: sort bookmark #3 before @3
|
||||
// => assert that the function doesn't stop at the first guid match
|
||||
// (which might be a bookmark, depending on zfs list ordering)
|
||||
// but instead considers the entire stride of boomarks and snapshots with that guid
|
||||
//
|
||||
// also, throw in unordered createtxg for good measure
|
||||
list, err := doZFSReleaseAllOlderAndIncOrExcludingGUIDParseListOutput(
|
||||
[]byte("snapshot\tfoo@1\t1\t1013001\t1\n" +
|
||||
"snapshot\tfoo@2\t2\t2013002\t1\n" +
|
||||
"bookmark\tfoo#3\t3\t7013003\t-\n" +
|
||||
"snapshot\tfoo@6\t6\t5013006\t1\n" +
|
||||
"snapshot\tfoo@3\t3\t7013003\t1\n" +
|
||||
"snapshot\tfoo@4\t3\t6013004\t1\n" +
|
||||
""),
|
||||
)
|
||||
require.NoError(t, err)
|
||||
t.Log(pretty.Sprint(list))
|
||||
require.Equal(t, 6, len(list))
|
||||
require.Equal(t, EntityTypeBookmark, list[2].entityType)
|
||||
|
||||
releaseSnaps, err := doZFSReleaseAllOlderAndIncOrExcludingGUIDFindSnapshots(7013003, true, list)
|
||||
t.Logf("releasedSnaps = %#v", releaseSnaps)
|
||||
assert.NoError(t, err)
|
||||
|
||||
assert.Equal(t, []string{"foo@1", "foo@2", "foo@3"}, releaseSnaps)
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
package zfs
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strings"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
const MaxDatasetNameLen = 256 - 1
|
||||
|
||||
type EntityType string
|
||||
|
||||
const (
|
||||
EntityTypeFilesystem EntityType = "filesystem"
|
||||
EntityTypeVolume EntityType = "volume"
|
||||
EntityTypeSnapshot EntityType = "snapshot"
|
||||
EntityTypeBookmark EntityType = "bookmark"
|
||||
)
|
||||
|
||||
func (e EntityType) Validate() error {
|
||||
switch e {
|
||||
case EntityTypeFilesystem:
|
||||
return nil
|
||||
case EntityTypeVolume:
|
||||
return nil
|
||||
case EntityTypeSnapshot:
|
||||
return nil
|
||||
case EntityTypeBookmark:
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf("invalid entity type %q", string(e))
|
||||
}
|
||||
}
|
||||
|
||||
func (e EntityType) MustValidate() {
|
||||
if err := e.Validate(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
func (e EntityType) String() string {
|
||||
e.MustValidate()
|
||||
return string(e)
|
||||
}
|
||||
|
||||
var componentValidChar = regexp.MustCompile(`^[0-9a-zA-Z-_\.: ]+$`)
|
||||
|
||||
// From module/zcommon/zfs_namecheck.c
|
||||
//
|
||||
// Snapshot names must be made up of alphanumeric characters plus the following
|
||||
// characters:
|
||||
//
|
||||
// [-_.: ]
|
||||
//
|
||||
func ComponentNamecheck(datasetPathComponent string) error {
|
||||
if len(datasetPathComponent) == 0 {
|
||||
return fmt.Errorf("path component must not be empty")
|
||||
}
|
||||
if len(datasetPathComponent) > MaxDatasetNameLen {
|
||||
return fmt.Errorf("path component must not be longer than %d chars", MaxDatasetNameLen)
|
||||
}
|
||||
|
||||
if !(isASCII(datasetPathComponent)) {
|
||||
return fmt.Errorf("path component must be ASCII")
|
||||
}
|
||||
|
||||
if !componentValidChar.MatchString(datasetPathComponent) {
|
||||
return fmt.Errorf("path component must only contain alphanumeric chars and any in %q", "-_.: ")
|
||||
}
|
||||
|
||||
if datasetPathComponent == "." || datasetPathComponent == ".." {
|
||||
return fmt.Errorf("path component must not be '%s'", datasetPathComponent)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type PathValidationError struct {
|
||||
path string
|
||||
entityType EntityType
|
||||
msg string
|
||||
}
|
||||
|
||||
func (e *PathValidationError) Path() string { return e.path }
|
||||
|
||||
func (e *PathValidationError) Error() string {
|
||||
return fmt.Sprintf("invalid %s %q: %s", e.entityType, e.path, e.msg)
|
||||
}
|
||||
|
||||
// combines
|
||||
//
|
||||
// lib/libzfs/libzfs_dataset.c: zfs_validate_name
|
||||
// module/zcommon/zfs_namecheck.c: entity_namecheck
|
||||
//
|
||||
// The '%' character is not allowed because it's reserved for zfs-internal use
|
||||
func EntityNamecheck(path string, t EntityType) (err *PathValidationError) {
|
||||
pve := func(msg string) *PathValidationError {
|
||||
return &PathValidationError{path: path, entityType: t, msg: msg}
|
||||
}
|
||||
|
||||
t.MustValidate()
|
||||
|
||||
// delimiter checks
|
||||
if t != EntityTypeSnapshot && strings.Contains(path, "@") {
|
||||
return pve("snapshot delimiter '@' is not expected here")
|
||||
}
|
||||
if t == EntityTypeSnapshot && !strings.Contains(path, "@") {
|
||||
return pve("missing '@' delimiter in snapshot name")
|
||||
}
|
||||
if t != EntityTypeBookmark && strings.Contains(path, "#") {
|
||||
return pve("bookmark delimiter '#' is not expected here")
|
||||
}
|
||||
if t == EntityTypeBookmark && !strings.Contains(path, "#") {
|
||||
return pve("missing '#' delimiter in bookmark name")
|
||||
}
|
||||
|
||||
// EntityTypeVolume and EntityTypeFilesystem are already covered above
|
||||
|
||||
if strings.Contains(path, "%") {
|
||||
return pve("invalid character '%' in name")
|
||||
}
|
||||
|
||||
// mimic module/zcommon/zfs_namecheck.c: entity_namecheck
|
||||
|
||||
if len(path) > MaxDatasetNameLen {
|
||||
return pve("name too long")
|
||||
}
|
||||
|
||||
if len(path) == 0 {
|
||||
return pve("must not be empty")
|
||||
}
|
||||
|
||||
if !isASCII(path) {
|
||||
return pve("must be ASCII")
|
||||
}
|
||||
|
||||
slashComps := bytes.Split([]byte(path), []byte("/"))
|
||||
bookmarkOrSnapshotDelims := 0
|
||||
for compI, comp := range slashComps {
|
||||
|
||||
snapCount := bytes.Count(comp, []byte("@"))
|
||||
bookCount := bytes.Count(comp, []byte("#"))
|
||||
|
||||
if !(snapCount*bookCount == 0) {
|
||||
panic("implementation error: delimiter checks before this loop must ensure this cannot happen")
|
||||
}
|
||||
bookmarkOrSnapshotDelims += snapCount + bookCount
|
||||
if bookmarkOrSnapshotDelims > 1 {
|
||||
return pve("multiple delimiters '@' or '#' are not allowed")
|
||||
}
|
||||
if bookmarkOrSnapshotDelims == 1 && compI != len(slashComps)-1 {
|
||||
return pve("snapshot or bookmark must not contain '/'")
|
||||
}
|
||||
|
||||
if bookmarkOrSnapshotDelims == 0 {
|
||||
// hot path, all but last component
|
||||
if err := ComponentNamecheck(string(comp)); err != nil {
|
||||
return pve(err.Error())
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
subComps := bytes.FieldsFunc(comp, func(r rune) bool {
|
||||
return r == '#' || r == '@'
|
||||
})
|
||||
if len(subComps) > 2 {
|
||||
panic("implementation error: delimiter checks above should ensure a single bookmark or snapshot delimiter per component")
|
||||
}
|
||||
if len(subComps) != 2 {
|
||||
return pve("empty component, bookmark or snapshot name not allowed")
|
||||
}
|
||||
|
||||
for _, comp := range subComps {
|
||||
if err := ComponentNamecheck(string(comp)); err != nil {
|
||||
return pve(err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func isASCII(s string) bool {
|
||||
for i := 0; i < len(s); i++ {
|
||||
if s[i] > unicode.MaxASCII {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
package zfs
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestEntityNamecheck(t *testing.T) {
|
||||
|
||||
type testcase struct {
|
||||
input string
|
||||
entityType EntityType
|
||||
ok bool
|
||||
}
|
||||
|
||||
tcs := []testcase{
|
||||
{"/", EntityTypeFilesystem, false},
|
||||
{"/foo", EntityTypeFilesystem, false},
|
||||
{"/foo@bar", EntityTypeSnapshot, false},
|
||||
{"foo", EntityTypeBookmark, false},
|
||||
{"foo", EntityTypeSnapshot, false},
|
||||
{"foo@bar", EntityTypeBookmark, false},
|
||||
{"foo#bar", EntityTypeSnapshot, false},
|
||||
{"foo#book", EntityTypeBookmark, true},
|
||||
{"foo#book@bar", EntityTypeBookmark, false},
|
||||
{"foo/book@bar", EntityTypeSnapshot, true},
|
||||
{"foo/book#bar", EntityTypeBookmark, true},
|
||||
{"foo/for%idden", EntityTypeFilesystem, false},
|
||||
{"foo/bår", EntityTypeFilesystem, false},
|
||||
{"", EntityTypeFilesystem, false},
|
||||
{"foo/bar@", EntityTypeSnapshot, false},
|
||||
{"foo/bar#", EntityTypeBookmark, false},
|
||||
{"foo/bar#@blah", EntityTypeBookmark, false},
|
||||
{"foo bar/baz bar@blah foo", EntityTypeSnapshot, true},
|
||||
{"foo bar/baz bar@#lah foo", EntityTypeSnapshot, false},
|
||||
{"foo bar/baz bar@@lah foo", EntityTypeSnapshot, false},
|
||||
{"foo bar/baz bar##lah foo", EntityTypeBookmark, false},
|
||||
{"foo bar/baz@blah/foo", EntityTypeSnapshot, false},
|
||||
{"foo bar/baz@blah/foo", EntityTypeFilesystem, false},
|
||||
{"foo/b\tr@ba\tz", EntityTypeSnapshot, false},
|
||||
{"foo/b\tr@baz", EntityTypeSnapshot, false},
|
||||
{"foo/bar@ba\tz", EntityTypeSnapshot, false},
|
||||
{"foo/./bar", EntityTypeFilesystem, false},
|
||||
{"foo/../bar", EntityTypeFilesystem, false},
|
||||
{"foo/bar@..", EntityTypeFilesystem, false},
|
||||
{"foo/bar@.", EntityTypeFilesystem, false},
|
||||
{strings.Repeat("a", MaxDatasetNameLen), EntityTypeFilesystem, true},
|
||||
{strings.Repeat("a", MaxDatasetNameLen) + "a", EntityTypeFilesystem, false},
|
||||
{strings.Repeat("a", MaxDatasetNameLen-2) + "/a", EntityTypeFilesystem, true},
|
||||
{strings.Repeat("a", MaxDatasetNameLen-4) + "/a@b", EntityTypeSnapshot, true},
|
||||
{strings.Repeat("a", MaxDatasetNameLen) + "/a@b", EntityTypeSnapshot, false},
|
||||
}
|
||||
|
||||
for idx := range tcs {
|
||||
t.Run(tcs[idx].input, func(t *testing.T) {
|
||||
tc := tcs[idx]
|
||||
err := EntityNamecheck(tc.input, tc.entityType)
|
||||
if !((err == nil && tc.ok) || (err != nil && !tc.ok)) {
|
||||
t.Errorf("expecting ok=%v but got err=%v", tc.ok, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
package zfs
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
const ReplicationCursorBookmarkName = "zrepl_replication_cursor"
|
||||
|
||||
// may return nil for both values, indicating there is no cursor
|
||||
func ZFSGetReplicationCursor(fs *DatasetPath) (*FilesystemVersion, error) {
|
||||
versions, err := ZFSListFilesystemVersions(fs, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, v := range versions {
|
||||
if v.Type == Bookmark && v.Name == ReplicationCursorBookmarkName {
|
||||
return &v, nil
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func ZFSSetReplicationCursor(fs *DatasetPath, snapname string) (guid uint64, err error) {
|
||||
snapPath := fmt.Sprintf("%s@%s", fs.ToString(), snapname)
|
||||
debug("replication cursor: snap path %q", snapPath)
|
||||
snapProps, err := ZFSGetCreateTXGAndGuid(snapPath)
|
||||
if err != nil {
|
||||
return 0, errors.Wrapf(err, "get properties of %q", snapPath)
|
||||
}
|
||||
bookmarkPath := fmt.Sprintf("%s#%s", fs.ToString(), ReplicationCursorBookmarkName)
|
||||
propsBookmark, err := ZFSGetCreateTXGAndGuid(bookmarkPath)
|
||||
_, bookmarkNotExistErr := err.(*DatasetDoesNotExist)
|
||||
if err != nil && !bookmarkNotExistErr {
|
||||
return 0, errors.Wrap(err, "zfs: replication cursor: get bookmark txg")
|
||||
}
|
||||
if err == nil {
|
||||
if snapProps.CreateTXG < propsBookmark.CreateTXG {
|
||||
return 0, errors.New("zfs: replication cursor: can only be advanced, not set back")
|
||||
}
|
||||
if err := ZFSDestroy(bookmarkPath); err != nil { // FIXME make safer by using new temporary bookmark, then rename, possible with channel programs
|
||||
return 0, errors.Wrap(err, "zfs: replication cursor: destroy current cursor")
|
||||
}
|
||||
}
|
||||
if err := ZFSBookmark(fs, snapname, ReplicationCursorBookmarkName); err != nil {
|
||||
return 0, errors.Wrapf(err, "zfs: replication cursor: create bookmark")
|
||||
}
|
||||
return snapProps.Guid, nil
|
||||
}
|
||||
+171
-9
@@ -2,17 +2,26 @@ package zfs
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/pkg/errors"
|
||||
|
||||
"github.com/zrepl/zrepl/util/envconst"
|
||||
)
|
||||
|
||||
// NOTE: Update ZFSSendARgs.Validate when changning fields (potentially SECURITY SENSITIVE)
|
||||
type ResumeToken struct {
|
||||
HasFromGUID, HasToGUID bool
|
||||
FromGUID, ToGUID uint64
|
||||
// no support for other fields
|
||||
HasFromGUID, HasToGUID bool
|
||||
FromGUID, ToGUID uint64
|
||||
ToName string
|
||||
HasCompressOK, CompressOK bool
|
||||
HasRawOk, RawOK bool
|
||||
}
|
||||
|
||||
var resumeTokenNVListRE = regexp.MustCompile(`\t(\S+) = (.*)`)
|
||||
@@ -23,11 +32,134 @@ var ResumeTokenCorruptError = errors.New("resume token is corrupt")
|
||||
var ResumeTokenDecodingNotSupported = errors.New("zfs binary does not allow decoding resume token or zrepl cannot scrape zfs output")
|
||||
var ResumeTokenParsingError = errors.New("zrepl cannot parse resume token values")
|
||||
|
||||
var resumeSendSupportedCheck struct {
|
||||
once sync.Once
|
||||
supported bool
|
||||
err error
|
||||
}
|
||||
|
||||
func ResumeSendSupported() (bool, error) {
|
||||
resumeSendSupportedCheck.once.Do(func() {
|
||||
// "feature discovery"
|
||||
cmd := exec.Command("zfs", "send")
|
||||
output, err := cmd.CombinedOutput()
|
||||
if ee, ok := err.(*exec.ExitError); !ok || ok && !ee.Exited() {
|
||||
resumeSendSupportedCheck.err = errors.Wrap(err, "resumable send cli support feature check failed")
|
||||
}
|
||||
def := strings.Contains(string(output), "receive_resume_token")
|
||||
resumeSendSupportedCheck.supported = envconst.Bool("ZREPL_EXPERIMENTAL_ZFS_SEND_RESUME_SUPPORTED", def)
|
||||
debug("resume send feature check complete %#v", &resumeSendSupportedCheck)
|
||||
})
|
||||
return resumeSendSupportedCheck.supported, resumeSendSupportedCheck.err
|
||||
}
|
||||
|
||||
var resumeRecvPoolSupportRecheckTimeout = envconst.Duration("ZREPL_ZFS_RESUME_RECV_POOL_SUPPORT_RECHECK_TIMEOUT", 30*time.Second)
|
||||
|
||||
type resumeRecvPoolSupportedResult struct {
|
||||
lastCheck time.Time
|
||||
supported bool
|
||||
err error
|
||||
}
|
||||
|
||||
var resumeRecvSupportedCheck struct {
|
||||
mtx sync.RWMutex
|
||||
flagSupport struct {
|
||||
checked bool
|
||||
supported bool
|
||||
err error
|
||||
}
|
||||
poolSupported map[string]resumeRecvPoolSupportedResult
|
||||
}
|
||||
|
||||
// fs == nil only checks for CLI support
|
||||
func ResumeRecvSupported(ctx context.Context, fs *DatasetPath) (bool, error) {
|
||||
sup := &resumeRecvSupportedCheck
|
||||
sup.mtx.RLock()
|
||||
defer sup.mtx.RUnlock()
|
||||
upgradeWhile := func(cb func()) {
|
||||
sup.mtx.RUnlock()
|
||||
defer sup.mtx.RLock()
|
||||
sup.mtx.Lock()
|
||||
defer sup.mtx.Unlock()
|
||||
cb()
|
||||
}
|
||||
|
||||
if !sup.flagSupport.checked {
|
||||
output, err := exec.CommandContext(ctx, "zfs", "receive").CombinedOutput()
|
||||
upgradeWhile(func() {
|
||||
sup.flagSupport.checked = true
|
||||
if ee, ok := err.(*exec.ExitError); err != nil && (!ok || ok && !ee.Exited()) {
|
||||
sup.flagSupport.err = err
|
||||
} else {
|
||||
sup.flagSupport.supported = strings.Contains(string(output), "-A <filesystem|volume>")
|
||||
}
|
||||
debug("resume recv cli flag feature check result: %#v", sup.flagSupport)
|
||||
})
|
||||
// fallthrough
|
||||
}
|
||||
|
||||
if sup.flagSupport.err != nil {
|
||||
return false, errors.Wrap(sup.flagSupport.err, "zfs recv feature check for resumable send & recv failed")
|
||||
} else if !sup.flagSupport.supported || fs == nil {
|
||||
return sup.flagSupport.supported, nil
|
||||
}
|
||||
|
||||
// Flag is supported and pool-support is request
|
||||
// Now check for pool support
|
||||
|
||||
pool, err := fs.Pool()
|
||||
if err != nil {
|
||||
return false, errors.Wrap(err, "resume recv check requires pool of dataset")
|
||||
}
|
||||
|
||||
if sup.poolSupported == nil {
|
||||
upgradeWhile(func() {
|
||||
sup.poolSupported = make(map[string]resumeRecvPoolSupportedResult)
|
||||
})
|
||||
}
|
||||
|
||||
var poolSup resumeRecvPoolSupportedResult
|
||||
var ok bool
|
||||
if poolSup, ok = sup.poolSupported[pool]; !ok || // shadow
|
||||
(!poolSup.supported && time.Since(poolSup.lastCheck) > resumeRecvPoolSupportRecheckTimeout) {
|
||||
|
||||
output, err := exec.CommandContext(ctx, "zpool", "get", "-H", "-p", "-o", "value", "feature@extensible_dataset", pool).CombinedOutput()
|
||||
if err != nil {
|
||||
debug("resume recv pool support check result: %#v", sup.flagSupport)
|
||||
poolSup.supported = false
|
||||
poolSup.err = err
|
||||
} else {
|
||||
poolSup.err = nil
|
||||
o := strings.TrimSpace(string(output))
|
||||
poolSup.supported = o == "active" || o == "enabled"
|
||||
}
|
||||
poolSup.lastCheck = time.Now()
|
||||
|
||||
// we take the lock late, so two updaters might check simultaneously, but that shouldn't hurt
|
||||
upgradeWhile(func() {
|
||||
sup.poolSupported[pool] = poolSup
|
||||
})
|
||||
// fallthrough
|
||||
}
|
||||
|
||||
if poolSup.err != nil {
|
||||
return false, errors.Wrapf(poolSup.err, "pool %q check for feature@extensible_dataset feature failed", pool)
|
||||
}
|
||||
|
||||
return poolSup.supported, nil
|
||||
}
|
||||
|
||||
// Abuse 'zfs send' to decode the resume token
|
||||
//
|
||||
// FIXME: implement nvlist unpacking in Go and read through libzfs_sendrecv.c
|
||||
func ParseResumeToken(ctx context.Context, token string) (*ResumeToken, error) {
|
||||
|
||||
if supported, err := ResumeSendSupported(); err != nil {
|
||||
return nil, err
|
||||
} else if !supported {
|
||||
return nil, ResumeTokenDecodingNotSupported
|
||||
}
|
||||
|
||||
// Example resume tokens:
|
||||
//
|
||||
// From a non-incremental send
|
||||
@@ -48,8 +180,6 @@ func ParseResumeToken(ctx context.Context, token string) (*ResumeToken, error) {
|
||||
// toname = pool1/test@b
|
||||
//cannot resume send: 'pool1/test@b' used in the initial send no longer exists
|
||||
|
||||
ctx, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
|
||||
defer cancel()
|
||||
cmd := exec.CommandContext(ctx, ZFS_BINARY, "send", "-nvt", string(token))
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
@@ -94,6 +224,20 @@ func ParseResumeToken(ctx context.Context, token string) (*ResumeToken, error) {
|
||||
return nil, ResumeTokenParsingError
|
||||
}
|
||||
rt.HasToGUID = true
|
||||
case "toname":
|
||||
rt.ToName = val
|
||||
case "rawok":
|
||||
rt.HasRawOk = true
|
||||
rt.RawOK, err = strconv.ParseBool(val)
|
||||
if err != nil {
|
||||
return nil, ResumeTokenParsingError
|
||||
}
|
||||
case "compressok":
|
||||
rt.HasCompressOK = true
|
||||
rt.CompressOK, err = strconv.ParseBool(val)
|
||||
if err != nil {
|
||||
return nil, ResumeTokenParsingError
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -105,17 +249,35 @@ func ParseResumeToken(ctx context.Context, token string) (*ResumeToken, error) {
|
||||
|
||||
}
|
||||
|
||||
func ZFSGetReceiveResumeToken(fs *DatasetPath) (string, error) {
|
||||
// if string is empty and err == nil, the feature is not supported
|
||||
func ZFSGetReceiveResumeTokenOrEmptyStringIfNotSupported(ctx context.Context, fs *DatasetPath) (string, error) {
|
||||
if supported, err := ResumeRecvSupported(ctx, fs); err != nil {
|
||||
return "", errors.Wrap(err, "cannot determine zfs recv resume support")
|
||||
} else if !supported {
|
||||
return "", nil
|
||||
}
|
||||
const prop_receive_resume_token = "receive_resume_token"
|
||||
props, err := ZFSGet(fs, []string{prop_receive_resume_token})
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
res := props.m[prop_receive_resume_token]
|
||||
res := props.Get(prop_receive_resume_token)
|
||||
debug("%q receive_resume_token=%q", fs.ToString(), res)
|
||||
if res == "-" {
|
||||
return "", nil
|
||||
} else {
|
||||
return res, nil
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func (t *ResumeToken) ToNameSplit() (fs *DatasetPath, snapName string, err error) {
|
||||
comps := strings.SplitN(t.ToName, "@", 2)
|
||||
if len(comps) != 2 {
|
||||
return nil, "", fmt.Errorf("resume token field `toname` does not contain @: %q", t.ToName)
|
||||
}
|
||||
dp, err := NewDatasetPath(comps[0])
|
||||
if err != nil {
|
||||
return nil, "", errors.Wrap(err, "resume token field `toname` dataset path invalid")
|
||||
}
|
||||
return dp, comps[1], nil
|
||||
}
|
||||
|
||||
@@ -1,68 +0,0 @@
|
||||
package zfs_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
|
||||
"github.com/zrepl/zrepl/zfs"
|
||||
)
|
||||
|
||||
type ResumeTokenTest struct {
|
||||
Msg string
|
||||
Token string
|
||||
ExpectToken *zfs.ResumeToken
|
||||
ExpectError error
|
||||
}
|
||||
|
||||
func (rtt *ResumeTokenTest) Test(t *testing.T) {
|
||||
t.Log(rtt.Msg)
|
||||
res, err := zfs.ParseResumeToken(context.TODO(), rtt.Token)
|
||||
|
||||
if rtt.ExpectError != nil {
|
||||
assert.EqualValues(t, rtt.ExpectError, err)
|
||||
return
|
||||
}
|
||||
if rtt.ExpectToken != nil {
|
||||
assert.Nil(t, err)
|
||||
assert.EqualValues(t, rtt.ExpectToken, res)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseResumeToken(t *testing.T) {
|
||||
|
||||
t.SkipNow() // FIXME not compatible with docker
|
||||
|
||||
tbl := []ResumeTokenTest{
|
||||
{
|
||||
Msg: "normal send (non-incremental)",
|
||||
Token: `1-bf31b879a-b8-789c636064000310a500c4ec50360710e72765a5269740f80cd8e4d3d28a534b18e00024cf86249f5459925acc802a8facbf243fbd3433858161f5ddb9ab1ae7c7466a20c97382e5f312735319180af2f3730cf58166953824c2cc0200cde81651`,
|
||||
ExpectToken: &zfs.ResumeToken{
|
||||
HasToGUID: true,
|
||||
ToGUID: 0x595d9f81aa9dddab,
|
||||
},
|
||||
},
|
||||
{
|
||||
Msg: "normal send (incremental)",
|
||||
Token: `1-c49b979a2-e0-789c636064000310a501c49c50360710a715e5e7a69766a63040c1eabb735735ce8f8d5400b2d991d4e52765a5269740f82080219f96569c5ac2000720793624f9a4ca92d46206547964fd25f91057f09e37babb88c9bf5503499e132c9f97989bcac050909f9f63a80f34abc421096616007c881d4c`,
|
||||
ExpectToken: &zfs.ResumeToken{
|
||||
HasToGUID: true,
|
||||
ToGUID: 0x854f02a2dd32cf0d,
|
||||
HasFromGUID: true,
|
||||
FromGUID: 0x595d9f81aa9dddab,
|
||||
},
|
||||
},
|
||||
{
|
||||
Msg: "corrupted token",
|
||||
Token: `1-bf31b879a-b8-789c636064000310a500c4ec50360710e72765a5269740f80cd8e4d3d28a534b18e00024cf86249f5459925acc802a8facbf243fbd3433858161f5ddb9ab1ae7c7466a20c97382e5f312735319180af2f3730cf58166953824c2cc0200cd12345`,
|
||||
ExpectError: zfs.ResumeTokenCorruptError,
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tbl {
|
||||
test.Test(t)
|
||||
}
|
||||
|
||||
}
|
||||
@@ -88,6 +88,19 @@ type FilesystemVersionFilter interface {
|
||||
Filter(t VersionType, name string) (accept bool, err error)
|
||||
}
|
||||
|
||||
type closureFilesystemVersionFilter struct {
|
||||
cb func(t VersionType, name string) (accept bool, err error)
|
||||
}
|
||||
|
||||
func (f *closureFilesystemVersionFilter) Filter(t VersionType, name string) (accept bool, err error) {
|
||||
return f.cb(t, name)
|
||||
}
|
||||
|
||||
func FilterFromClosure(cb func(t VersionType, name string) (accept bool, err error)) FilesystemVersionFilter {
|
||||
return &closureFilesystemVersionFilter{cb}
|
||||
}
|
||||
|
||||
// returned versions are sorted by createtxg
|
||||
func ZFSListFilesystemVersions(fs *DatasetPath, filter FilesystemVersionFilter) (res []FilesystemVersion, err error) {
|
||||
listResults := make(chan ZFSListResult)
|
||||
|
||||
|
||||
+560
-64
@@ -3,20 +3,19 @@ package zfs
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"os/exec"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"context"
|
||||
"regexp"
|
||||
"strconv"
|
||||
|
||||
"github.com/pkg/errors"
|
||||
"github.com/prometheus/client_golang/prometheus"
|
||||
|
||||
@@ -113,6 +112,14 @@ func (p *DatasetPath) UnmarshalJSON(b []byte) error {
|
||||
return json.Unmarshal(b, &p.comps)
|
||||
}
|
||||
|
||||
func (p *DatasetPath) Pool() (string, error) {
|
||||
if len(p.comps) < 1 {
|
||||
return "", fmt.Errorf("dataset path does not have a pool component")
|
||||
}
|
||||
return p.comps[0], nil
|
||||
|
||||
}
|
||||
|
||||
func NewDatasetPath(s string) (p *DatasetPath, err error) {
|
||||
p = &DatasetPath{}
|
||||
if s == "" {
|
||||
@@ -287,17 +294,7 @@ func ZFSListChan(ctx context.Context, out chan ZFSListResult, properties []strin
|
||||
}
|
||||
}
|
||||
|
||||
func validateRelativeZFSVersion(s string) error {
|
||||
if len(s) <= 1 {
|
||||
return errors.New("version must start with a delimiter char followed by at least one character")
|
||||
}
|
||||
if !(s[0] == '#' || s[0] == '@') {
|
||||
return errors.New("version name starts with invalid delimiter char")
|
||||
}
|
||||
// FIXME whitespace check...
|
||||
return nil
|
||||
}
|
||||
|
||||
// FIXME replace with EntityNamecheck
|
||||
func validateZFSFilesystem(fs string) error {
|
||||
if len(fs) < 1 {
|
||||
return errors.New("filesystem path must have length > 0")
|
||||
@@ -305,31 +302,40 @@ func validateZFSFilesystem(fs string) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
func absVersion(fs, v string) (full string, err error) {
|
||||
// v must not be nil and be already validated
|
||||
func absVersion(fs string, v *ZFSSendArgVersion) (full string, err error) {
|
||||
if err := validateZFSFilesystem(fs); err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err := validateRelativeZFSVersion(v); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return fmt.Sprintf("%s%s", fs, v), nil
|
||||
return fmt.Sprintf("%s%s", fs, v.RelName), nil
|
||||
}
|
||||
|
||||
func buildCommonSendArgs(fs string, from, to string, token string) ([]string, error) {
|
||||
// tok is allowed to be nil
|
||||
// a must already be validated
|
||||
//
|
||||
// SECURITY SENSITIVE because Raw must be handled correctly
|
||||
func (a ZFSSendArgs) buildCommonSendArgs() ([]string, error) {
|
||||
|
||||
args := make([]string, 0, 3)
|
||||
if token != "" {
|
||||
args = append(args, "-t", token)
|
||||
// ResumeToken takes precedence, we assume that it has been validated to reflect
|
||||
// what is described by the other fields in ZFSSendArgs
|
||||
if a.ResumeToken != "" {
|
||||
args = append(args, "-t", a.ResumeToken)
|
||||
return args, nil
|
||||
}
|
||||
|
||||
toV, err := absVersion(fs, to)
|
||||
if a.Encrypted.B {
|
||||
args = append(args, "-w")
|
||||
}
|
||||
|
||||
toV, err := absVersion(a.FS, a.To)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
fromV := ""
|
||||
if from != "" {
|
||||
fromV, err = absVersion(fs, from)
|
||||
if a.From != nil {
|
||||
fromV, err = absVersion(a.FS, a.From)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -513,17 +519,317 @@ func (s *sendStream) killAndWait(precedingReadErr error) error {
|
||||
return s.opErr
|
||||
}
|
||||
|
||||
// NOTE: When updating this struct, make sure to update funcs Validate ValidateCorrespondsToResumeToken
|
||||
type ZFSSendArgVersion struct {
|
||||
RelName string
|
||||
GUID uint64
|
||||
}
|
||||
|
||||
func (v ZFSSendArgVersion) ValidateInMemory(fs string) error {
|
||||
if fs == "" {
|
||||
panic(fs)
|
||||
}
|
||||
if len(v.RelName) == 0 {
|
||||
return errors.New("`RelName` must not be empty")
|
||||
}
|
||||
|
||||
var et EntityType
|
||||
switch v.RelName[0] {
|
||||
case '@':
|
||||
et = EntityTypeSnapshot
|
||||
case '#':
|
||||
et = EntityTypeBookmark
|
||||
default:
|
||||
return fmt.Errorf("`RelName` field must start with @ or #, got %q", v.RelName)
|
||||
}
|
||||
|
||||
full := v.fullPathUnchecked(fs)
|
||||
if err := EntityNamecheck(full, et); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (v ZFSSendArgVersion) mustValidateInMemory(fs string) {
|
||||
if err := v.ValidateInMemory(fs); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
// fs must be not empty
|
||||
func (a ZFSSendArgVersion) ValidateExistsAndGetCheckedProps(ctx context.Context, fs string) (ZFSPropCreateTxgAndGuidProps, error) {
|
||||
|
||||
if err := a.ValidateInMemory(fs); err != nil {
|
||||
return ZFSPropCreateTxgAndGuidProps{}, nil
|
||||
}
|
||||
|
||||
realProps, err := ZFSGetCreateTXGAndGuid(a.FullPath(fs))
|
||||
if err != nil {
|
||||
return ZFSPropCreateTxgAndGuidProps{}, err
|
||||
}
|
||||
|
||||
if realProps.Guid != a.GUID {
|
||||
return ZFSPropCreateTxgAndGuidProps{}, fmt.Errorf("`GUID` field does not match real dataset's GUID: %q != %q", realProps.Guid, a.GUID)
|
||||
}
|
||||
|
||||
return realProps, nil
|
||||
}
|
||||
|
||||
func (a ZFSSendArgVersion) ValidateExists(ctx context.Context, fs string) error {
|
||||
_, err := a.ValidateExistsAndGetCheckedProps(ctx, fs)
|
||||
return err
|
||||
}
|
||||
|
||||
func (v ZFSSendArgVersion) FullPath(fs string) string {
|
||||
v.mustValidateInMemory(fs)
|
||||
return v.fullPathUnchecked(fs)
|
||||
}
|
||||
|
||||
func (v ZFSSendArgVersion) fullPathUnchecked(fs string) string {
|
||||
return fmt.Sprintf("%s%s", fs, v.RelName)
|
||||
}
|
||||
|
||||
func (v ZFSSendArgVersion) IsSnapshot() bool {
|
||||
v.mustValidateInMemory("unimportant")
|
||||
return v.RelName[0] == '@'
|
||||
}
|
||||
|
||||
func (v ZFSSendArgVersion) MustBeBookmark() {
|
||||
v.mustValidateInMemory("unimportant")
|
||||
if v.RelName[0] != '#' {
|
||||
panic(fmt.Sprintf("must be bookmark, got %q", v.RelName))
|
||||
}
|
||||
}
|
||||
|
||||
type NilBool struct{ B bool }
|
||||
|
||||
func (n *NilBool) Validate() error {
|
||||
if n == nil {
|
||||
return fmt.Errorf("must explicitly set `true` or `false`")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (n *NilBool) String() string {
|
||||
if n == nil {
|
||||
return "unset"
|
||||
}
|
||||
return fmt.Sprintf("%v", n.B)
|
||||
}
|
||||
|
||||
// When updating this struct, check Validate and ValidateCorrespondsToResumeToken (Potentiall SECURITY SENSITIVE)
|
||||
type ZFSSendArgs struct {
|
||||
FS string
|
||||
From, To *ZFSSendArgVersion // From may be nil
|
||||
Encrypted *NilBool
|
||||
|
||||
// Prefereed if not empty
|
||||
ResumeToken string // if not nil, must match what is specified in From, To (covered by ValidateCorrespondsToResumeToken)
|
||||
}
|
||||
|
||||
type zfsSendArgsValidationContext struct {
|
||||
encEnabled *NilBool
|
||||
}
|
||||
|
||||
type ZFSSendArgsValidationErrorCode int
|
||||
|
||||
const (
|
||||
ZFSSendArgsGenericValidationError ZFSSendArgsValidationErrorCode = 1 + iota
|
||||
ZFSSendArgsEncryptedSendRequestedButFSUnencrypted
|
||||
ZFSSendArgsFSEncryptionCheckFail
|
||||
ZFSSendArgsResumeTokenMismatch
|
||||
)
|
||||
|
||||
type ZFSSendArgsValidationError struct {
|
||||
Args ZFSSendArgs
|
||||
What ZFSSendArgsValidationErrorCode
|
||||
Msg error
|
||||
}
|
||||
|
||||
func newValidationError(sendArgs ZFSSendArgs, what ZFSSendArgsValidationErrorCode, cause error) *ZFSSendArgsValidationError {
|
||||
return &ZFSSendArgsValidationError{sendArgs, what, cause}
|
||||
}
|
||||
|
||||
func newGenericValidationError(sendArgs ZFSSendArgs, cause error) *ZFSSendArgsValidationError {
|
||||
return &ZFSSendArgsValidationError{sendArgs, ZFSSendArgsGenericValidationError, cause}
|
||||
}
|
||||
|
||||
func (e ZFSSendArgsValidationError) Error() string {
|
||||
return e.Msg.Error()
|
||||
}
|
||||
|
||||
// - Recursively call Validate on each field.
|
||||
// - Make sure that if ResumeToken != "", it reflects the same operation as the other paramters would.
|
||||
//
|
||||
// This function is not pure because GUIDs are checked against the local host's datasets.
|
||||
func (a ZFSSendArgs) Validate(ctx context.Context) error {
|
||||
if dp, err := NewDatasetPath(a.FS); err != nil || dp.Length() == 0 {
|
||||
return newGenericValidationError(a, fmt.Errorf("`FS` must be a valid non-zero dataset path"))
|
||||
}
|
||||
|
||||
if a.To == nil {
|
||||
return newGenericValidationError(a, fmt.Errorf("`To` must not be nil"))
|
||||
}
|
||||
if err := a.To.ValidateExists(ctx, a.FS); err != nil {
|
||||
return newGenericValidationError(a, errors.Wrap(err, "`To` invalid"))
|
||||
}
|
||||
|
||||
if a.From != nil {
|
||||
if err := a.From.ValidateExists(ctx, a.FS); err != nil {
|
||||
return newGenericValidationError(a, errors.Wrap(err, "`From` invalid"))
|
||||
}
|
||||
// falthrough
|
||||
}
|
||||
|
||||
if err := a.Encrypted.Validate(); err != nil {
|
||||
return newGenericValidationError(a, errors.Wrap(err, "`Raw` invalid"))
|
||||
}
|
||||
|
||||
valCtx := &zfsSendArgsValidationContext{}
|
||||
fsEncrypted, err := ZFSGetEncryptionEnabled(ctx, a.FS)
|
||||
if err != nil {
|
||||
return newValidationError(a, ZFSSendArgsFSEncryptionCheckFail,
|
||||
errors.Wrapf(err, "cannot check whether filesystem %q is encrypted", a.FS))
|
||||
}
|
||||
valCtx.encEnabled = &NilBool{fsEncrypted}
|
||||
|
||||
if a.Encrypted.B && !fsEncrypted {
|
||||
return newValidationError(a, ZFSSendArgsEncryptedSendRequestedButFSUnencrypted,
|
||||
errors.Errorf("encrypted send requested, but filesystem %q is not encrypted", a.FS))
|
||||
}
|
||||
|
||||
if a.ResumeToken != "" {
|
||||
if err := a.validateCorrespondsToResumeToken(ctx, valCtx); err != nil {
|
||||
return newValidationError(a, ZFSSendArgsResumeTokenMismatch, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
type ZFSSendArgsResumeTokenMismatchError struct {
|
||||
What ZFSSendArgsResumeTokenMismatchErrorCode
|
||||
Err error
|
||||
}
|
||||
|
||||
func (e *ZFSSendArgsResumeTokenMismatchError) Error() string { return e.Err.Error() }
|
||||
|
||||
type ZFSSendArgsResumeTokenMismatchErrorCode int
|
||||
|
||||
// The format is ZFSSendArgsResumeTokenMismatch+WhatIsWrongInToken
|
||||
const (
|
||||
ZFSSendArgsResumeTokenMismatchGeneric ZFSSendArgsResumeTokenMismatchErrorCode = 1 + iota
|
||||
ZFSSendArgsResumeTokenMismatchEncryptionNotSet // encryption not set in token but required by send args
|
||||
ZFSSendArgsResumeTokenMismatchEncryptionSet // encryption not set in token but not required by send args
|
||||
ZFSSendArgsResumeTokenMismatchFilesystem
|
||||
)
|
||||
|
||||
func (c ZFSSendArgsResumeTokenMismatchErrorCode) fmt(format string, args ...interface{}) *ZFSSendArgsResumeTokenMismatchError {
|
||||
return &ZFSSendArgsResumeTokenMismatchError{
|
||||
What: c,
|
||||
Err: fmt.Errorf(format, args...),
|
||||
}
|
||||
}
|
||||
|
||||
// This is SECURITY SENSITIVE and requires exhaustive checking of both side's values
|
||||
// An attacker requesting a Send with a crafted ResumeToken may encode different parameters in the resume token than expected:
|
||||
// for example, they may specify another file system (e.g. the filesystem with secret data) or request unencrypted send instead of encrypted raw send.
|
||||
func (a ZFSSendArgs) validateCorrespondsToResumeToken(ctx context.Context, valCtx *zfsSendArgsValidationContext) error {
|
||||
|
||||
if a.ResumeToken == "" {
|
||||
return nil // nothing to do
|
||||
}
|
||||
|
||||
debug("decoding resume token %q", a.ResumeToken)
|
||||
t, err := ParseResumeToken(ctx, a.ResumeToken)
|
||||
debug("decode resumee token result: %#v %T %v", t, err, err)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
tokenFS, _, err := t.ToNameSplit()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
gen := ZFSSendArgsResumeTokenMismatchGeneric
|
||||
|
||||
if a.FS != tokenFS.ToString() {
|
||||
return ZFSSendArgsResumeTokenMismatchFilesystem.fmt(
|
||||
"filesystem in resume token field `toname` = %q does not match expected value %q", tokenFS.ToString(), a.FS)
|
||||
}
|
||||
|
||||
if (a.From != nil) != t.HasFromGUID { // existence must be same
|
||||
if t.HasFromGUID {
|
||||
return gen.fmt("resume token not expected to be incremental, but `fromguid` = %q", t.FromGUID)
|
||||
} else {
|
||||
return gen.fmt("resume token expected to be incremental, but `fromguid` not present")
|
||||
}
|
||||
} else if t.HasFromGUID { // if exists (which is same, we checked above), they must match
|
||||
if t.FromGUID != a.From.GUID {
|
||||
return gen.fmt("resume token `fromguid` != expected: %q != %q", t.FromGUID, a.From.GUID)
|
||||
}
|
||||
} else {
|
||||
_ = struct{}{} // both empty, ok
|
||||
}
|
||||
|
||||
// To must never be empty
|
||||
if !t.HasToGUID {
|
||||
return gen.fmt("resume token does not have `toguid`")
|
||||
}
|
||||
if t.ToGUID != a.To.GUID { // a.To != nil because Validate checks for that
|
||||
return gen.fmt("resume token `toguid` != expected: %q != %q", t.ToGUID, a.To.GUID)
|
||||
}
|
||||
|
||||
if a.Encrypted.B {
|
||||
if !(t.RawOK && t.CompressOK) {
|
||||
return ZFSSendArgsResumeTokenMismatchEncryptionNotSet.fmt(
|
||||
"resume token must have `rawok` and `compressok` = true but got %v %v", t.RawOK, t.CompressOK)
|
||||
}
|
||||
// fallthrough
|
||||
} else {
|
||||
if t.RawOK || t.CompressOK {
|
||||
return ZFSSendArgsResumeTokenMismatchEncryptionSet.fmt(
|
||||
"resume token must not have `rawok` or `compressok` set but got %v %v", t.RawOK, t.CompressOK)
|
||||
}
|
||||
// fallthrough
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
var zfsSendStderrCaptureMaxSize = envconst.Int("ZREPL_ZFS_SEND_STDERR_MAX_CAPTURE_SIZE", 1<<15)
|
||||
|
||||
var ErrEncryptedSendNotSupported = fmt.Errorf("raw sends which are required for encrypted zfs send are not supported")
|
||||
|
||||
// if token != "", then send -t token is used
|
||||
// otherwise send [-i from] to is used
|
||||
// (if from is "" a full ZFS send is done)
|
||||
func ZFSSend(ctx context.Context, fs string, from, to string, token string) (*ReadCloserCopier, error) {
|
||||
//
|
||||
// Returns ErrEncryptedSendNotSupported if encrypted send is requested but not supported by CLI
|
||||
func ZFSSend(ctx context.Context, sendArgs ZFSSendArgs) (*ReadCloserCopier, error) {
|
||||
|
||||
args := make([]string, 0)
|
||||
args = append(args, "send")
|
||||
|
||||
sargs, err := buildCommonSendArgs(fs, from, to, token)
|
||||
// pre-validation of sendArgs for plain ErrEncryptedSendNotSupported error
|
||||
// TODO go1.13: push this down to sendArgs.Validate
|
||||
if encryptedSendValid := sendArgs.Encrypted.Validate(); encryptedSendValid == nil && sendArgs.Encrypted.B {
|
||||
supported, err := EncryptionCLISupported(ctx)
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(err, "cannot determine CLI native encryption support")
|
||||
}
|
||||
if !supported {
|
||||
return nil, ErrEncryptedSendNotSupported
|
||||
}
|
||||
}
|
||||
|
||||
if err := sendArgs.Validate(ctx); err != nil {
|
||||
return nil, err // do not wrap, part of API, tested by platformtest
|
||||
}
|
||||
|
||||
sargs, err := sendArgs.buildCommonSendArgs()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -651,28 +957,32 @@ func (s *DrySendInfo) unmarshalInfoLine(l string) (regexMatched bool, err error)
|
||||
return true, nil
|
||||
}
|
||||
|
||||
// from may be "", in which case a full ZFS send is done
|
||||
// to may be "", in which case a full ZFS send is done
|
||||
// May return BookmarkSizeEstimationNotSupported as err if from is a bookmark.
|
||||
func ZFSSendDry(fs string, from, to string, token string) (_ *DrySendInfo, err error) {
|
||||
func ZFSSendDry(ctx context.Context, sendArgs ZFSSendArgs) (_ *DrySendInfo, err error) {
|
||||
|
||||
if strings.Contains(from, "#") {
|
||||
if err := sendArgs.Validate(ctx); err != nil {
|
||||
return nil, errors.Wrap(err, "cannot validate send args")
|
||||
}
|
||||
|
||||
if sendArgs.From != nil && strings.Contains(sendArgs.From.RelName, "#") {
|
||||
/* TODO:
|
||||
* ZFS at the time of writing does not support dry-run send because size-estimation
|
||||
* uses fromSnap's deadlist. However, for a bookmark, that deadlist no longer exists.
|
||||
* Redacted send & recv will bring this functionality, see
|
||||
* https://github.com/openzfs/openzfs/pull/484
|
||||
*/
|
||||
fromAbs, err := absVersion(fs, from)
|
||||
fromAbs, err := absVersion(sendArgs.FS, sendArgs.From)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error building abs version for 'from': %s", err)
|
||||
}
|
||||
toAbs, err := absVersion(fs, to)
|
||||
toAbs, err := absVersion(sendArgs.FS, sendArgs.To)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error building abs version for 'to': %s", err)
|
||||
}
|
||||
return &DrySendInfo{
|
||||
Type: DrySendTypeIncremental,
|
||||
Filesystem: fs,
|
||||
Filesystem: sendArgs.FS,
|
||||
From: fromAbs,
|
||||
To: toAbs,
|
||||
SizeEstimate: -1}, nil
|
||||
@@ -680,7 +990,7 @@ func ZFSSendDry(fs string, from, to string, token string) (_ *DrySendInfo, err e
|
||||
|
||||
args := make([]string, 0)
|
||||
args = append(args, "send", "-n", "-v", "-P")
|
||||
sargs, err := buildCommonSendArgs(fs, from, to, token)
|
||||
sargs, err := sendArgs.buildCommonSendArgs()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -689,7 +999,7 @@ func ZFSSendDry(fs string, from, to string, token string) (_ *DrySendInfo, err e
|
||||
cmd := exec.Command(ZFS_BINARY, args...)
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, &ZFSError{output, err}
|
||||
}
|
||||
var si DrySendInfo
|
||||
if err := si.unmarshalZFSOutput(output); err != nil {
|
||||
@@ -720,13 +1030,35 @@ type RecvOptions struct {
|
||||
// Rollback to the oldest snapshot, destroy it, then perform `recv -F`.
|
||||
// Note that this doesn't change property values, i.e. an existing local property value will be kept.
|
||||
RollbackAndForceRecv bool
|
||||
// Set -s flag used for resumable send & recv
|
||||
SavePartialRecvState bool
|
||||
}
|
||||
|
||||
func ZFSRecv(ctx context.Context, fs string, streamCopier StreamCopier, opts RecvOptions) (err error) {
|
||||
type ErrRecvResumeNotSupported struct {
|
||||
FS string
|
||||
CheckErr error
|
||||
}
|
||||
|
||||
if err := validateZFSFilesystem(fs); err != nil {
|
||||
return err
|
||||
func (e *ErrRecvResumeNotSupported) Error() string {
|
||||
var buf strings.Builder
|
||||
fmt.Fprintf(&buf, "zfs resumable recv into %q: ", e.FS)
|
||||
if e.CheckErr != nil {
|
||||
fmt.Fprint(&buf, e.CheckErr.Error())
|
||||
} else {
|
||||
fmt.Fprintf(&buf, "not supported by ZFS or pool")
|
||||
}
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func ZFSRecv(ctx context.Context, fs string, v *ZFSSendArgVersion, streamCopier StreamCopier, opts RecvOptions) (err error) {
|
||||
|
||||
if err := v.ValidateInMemory(fs); err != nil {
|
||||
return errors.Wrap(err, "invalid version")
|
||||
}
|
||||
if !v.IsSnapshot() {
|
||||
return errors.New("must receive into a snapshot")
|
||||
}
|
||||
|
||||
fsdp, err := NewDatasetPath(fs)
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -773,7 +1105,13 @@ func ZFSRecv(ctx context.Context, fs string, streamCopier StreamCopier, opts Rec
|
||||
if opts.RollbackAndForceRecv {
|
||||
args = append(args, "-F")
|
||||
}
|
||||
args = append(args, fs)
|
||||
if opts.SavePartialRecvState {
|
||||
if supported, err := ResumeRecvSupported(ctx, fsdp); err != nil || !supported {
|
||||
return &ErrRecvResumeNotSupported{FS: fs, CheckErr: err}
|
||||
}
|
||||
args = append(args, "-s")
|
||||
}
|
||||
args = append(args, v.FullPath(fs))
|
||||
|
||||
ctx, cancelCmd := context.WithCancel(ctx)
|
||||
defer cancelCmd()
|
||||
@@ -816,13 +1154,17 @@ func ZFSRecv(ctx context.Context, fs string, streamCopier StreamCopier, opts Rec
|
||||
copierErrChan <- streamCopier.WriteStreamTo(stdinWriter)
|
||||
stdinWriter.Close()
|
||||
}()
|
||||
waitErrChan := make(chan *ZFSError)
|
||||
waitErrChan := make(chan error)
|
||||
go func() {
|
||||
defer close(waitErrChan)
|
||||
if err = cmd.Wait(); err != nil {
|
||||
waitErrChan <- &ZFSError{
|
||||
Stderr: stderr.Bytes(),
|
||||
WaitErr: err,
|
||||
if rtErr := tryRecvErrorWithResumeToken(ctx, stderr.String()); rtErr != nil {
|
||||
waitErrChan <- rtErr
|
||||
} else {
|
||||
waitErrChan <- &ZFSError{
|
||||
Stderr: stderr.Bytes(),
|
||||
WaitErr: err,
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -846,6 +1188,33 @@ func ZFSRecv(ctx context.Context, fs string, streamCopier StreamCopier, opts Rec
|
||||
return copierErr // if it's not a write error, the copier error is more interesting
|
||||
}
|
||||
|
||||
type RecvFailedWithResumeTokenErr struct {
|
||||
Msg string
|
||||
ResumeTokenRaw string
|
||||
ResumeTokenParsed *ResumeToken
|
||||
}
|
||||
|
||||
var recvErrorResumeTokenRE = regexp.MustCompile(`A resuming stream can be generated on the sending system by running:\s+zfs send -t\s(\S+)`)
|
||||
|
||||
func tryRecvErrorWithResumeToken(ctx context.Context, stderr string) *RecvFailedWithResumeTokenErr {
|
||||
if match := recvErrorResumeTokenRE.FindStringSubmatch(stderr); match != nil {
|
||||
parsed, err := ParseResumeToken(ctx, match[1])
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return &RecvFailedWithResumeTokenErr{
|
||||
Msg: stderr,
|
||||
ResumeTokenRaw: match[1],
|
||||
ResumeTokenParsed: parsed,
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (e *RecvFailedWithResumeTokenErr) Error() string {
|
||||
return fmt.Sprintf("receive failed, resume token available: %s\n%#v", e.ResumeTokenRaw, e.ResumeTokenParsed)
|
||||
}
|
||||
|
||||
type ClearResumeTokenError struct {
|
||||
ZFSOutput []byte
|
||||
CmdError error
|
||||
@@ -934,6 +1303,55 @@ func ZFSGet(fs *DatasetPath, props []string) (*ZFSProperties, error) {
|
||||
return zfsGet(fs.ToString(), props, sourceAny)
|
||||
}
|
||||
|
||||
// The returned error includes requested filesystem and version as quoted strings in its error message
|
||||
func ZFSGetGUID(fs string, version string) (g uint64, err error) {
|
||||
defer func(e *error) {
|
||||
if *e != nil {
|
||||
*e = fmt.Errorf("zfs get guid fs=%q version=%q: %s", fs, version, *e)
|
||||
}
|
||||
}(&err)
|
||||
if err := validateZFSFilesystem(fs); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if len(version) == 0 {
|
||||
return 0, errors.New("version must have non-zero length")
|
||||
}
|
||||
if strings.IndexAny(version[0:1], "@#") != 0 {
|
||||
return 0, errors.New("version does not start with @ or #")
|
||||
}
|
||||
path := fmt.Sprintf("%s%s", fs, version)
|
||||
props, err := zfsGet(path, []string{"guid"}, sourceAny) // always local
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return strconv.ParseUint(props.Get("guid"), 10, 64)
|
||||
}
|
||||
|
||||
type GetMountpointOutput struct {
|
||||
Mounted bool
|
||||
Mountpoint string
|
||||
}
|
||||
|
||||
func ZFSGetMountpoint(fs string) (*GetMountpointOutput, error) {
|
||||
if err := EntityNamecheck(fs, EntityTypeFilesystem); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
props, err := zfsGet(fs, []string{"mountpoint", "mounted"}, sourceAny)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
o := &GetMountpointOutput{}
|
||||
o.Mounted = props.Get("mounted") == "yes"
|
||||
o.Mountpoint = props.Get("mountpoint")
|
||||
if o.Mountpoint == "none" {
|
||||
o.Mountpoint = ""
|
||||
}
|
||||
if o.Mounted && o.Mountpoint == "" {
|
||||
panic("unexpected zfs get output")
|
||||
}
|
||||
return o, nil
|
||||
}
|
||||
|
||||
func ZFSGetRawAnySource(path string, props []string) (*ZFSProperties, error) {
|
||||
return zfsGet(path, props, sourceAny)
|
||||
}
|
||||
@@ -946,6 +1364,15 @@ type DatasetDoesNotExist struct {
|
||||
|
||||
func (d *DatasetDoesNotExist) Error() string { return fmt.Sprintf("dataset %q does not exist", d.Path) }
|
||||
|
||||
func tryDatasetDoesNotExist(expectPath string, stderr []byte) error {
|
||||
if sm := zfsGetDatasetDoesNotExistRegexp.FindSubmatch(stderr); sm != nil {
|
||||
if string(sm[1]) == expectPath {
|
||||
return &DatasetDoesNotExist{expectPath}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type zfsPropertySource uint
|
||||
|
||||
const (
|
||||
@@ -993,10 +1420,8 @@ func zfsGet(path string, props []string, allowedSources zfsPropertySource) (*ZFS
|
||||
if exitErr, ok := err.(*exec.ExitError); ok {
|
||||
if exitErr.Exited() {
|
||||
// screen-scrape output
|
||||
if sm := zfsGetDatasetDoesNotExistRegexp.FindSubmatch(exitErr.Stderr); sm != nil {
|
||||
if string(sm[1]) == path {
|
||||
return nil, &DatasetDoesNotExist{path}
|
||||
}
|
||||
if ddne := tryDatasetDoesNotExist(path, exitErr.Stderr); ddne != nil {
|
||||
return nil, ddne
|
||||
}
|
||||
}
|
||||
return nil, &ZFSError{
|
||||
@@ -1090,6 +1515,10 @@ func (e *DestroySnapshotsError) Error() string {
|
||||
|
||||
var destroySnapshotsErrorRegexp = regexp.MustCompile(`^cannot destroy snapshot ([^@]+)@(.+): (.*)$`) // yes, datasets can contain `:`
|
||||
|
||||
var destroyOneOrMoreSnapshotsNoneExistedErrorRegexp = regexp.MustCompile(`^could not find any snapshots to destroy; check snapshot names.`)
|
||||
|
||||
var destroyBookmarkDoesNotExist = regexp.MustCompile(`^bookmark '([^']+)' does not exist`)
|
||||
|
||||
func tryParseDestroySnapshotsError(arg string, stderr []byte) *DestroySnapshotsError {
|
||||
|
||||
argComps := strings.SplitN(arg, "@", 2)
|
||||
@@ -1161,7 +1590,14 @@ func ZFSDestroy(arg string) (err error) {
|
||||
Stderr: stderr.Bytes(),
|
||||
WaitErr: err,
|
||||
}
|
||||
if dserr := tryParseDestroySnapshotsError(arg, stderr.Bytes()); dserr != nil {
|
||||
|
||||
if destroyOneOrMoreSnapshotsNoneExistedErrorRegexp.Match(stderr.Bytes()) {
|
||||
err = &DatasetDoesNotExist{arg}
|
||||
} else if match := destroyBookmarkDoesNotExist.FindStringSubmatch(stderr.String()); match != nil && match[1] == arg {
|
||||
err = &DatasetDoesNotExist{arg}
|
||||
} else if dsNotExistErr := tryDatasetDoesNotExist(filesystem, stderr.Bytes()); dsNotExistErr != nil {
|
||||
err = dsNotExistErr
|
||||
} else if dserr := tryParseDestroySnapshotsError(arg, stderr.Bytes()); dserr != nil {
|
||||
err = dserr
|
||||
}
|
||||
|
||||
@@ -1171,12 +1607,12 @@ func ZFSDestroy(arg string) (err error) {
|
||||
|
||||
}
|
||||
|
||||
func zfsBuildSnapName(fs *DatasetPath, name string) string { // TODO defensive
|
||||
return fmt.Sprintf("%s@%s", fs.ToString(), name)
|
||||
}
|
||||
|
||||
func zfsBuildBookmarkName(fs *DatasetPath, name string) string { // TODO defensive
|
||||
return fmt.Sprintf("%s#%s", fs.ToString(), name)
|
||||
func ZFSDestroyIdempotent(path string) error {
|
||||
err := ZFSDestroy(path)
|
||||
if _, ok := err.(*DatasetDoesNotExist); ok {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func ZFSSnapshot(fs *DatasetPath, name string, recursive bool) (err error) {
|
||||
@@ -1184,7 +1620,10 @@ func ZFSSnapshot(fs *DatasetPath, name string, recursive bool) (err error) {
|
||||
promTimer := prometheus.NewTimer(prom.ZFSSnapshotDuration.WithLabelValues(fs.ToString()))
|
||||
defer promTimer.ObserveDuration()
|
||||
|
||||
snapname := zfsBuildSnapName(fs, name)
|
||||
snapname := fmt.Sprintf("%s@%s", fs.ToString(), name)
|
||||
if err := EntityNamecheck(snapname, EntityTypeSnapshot); err != nil {
|
||||
return errors.Wrap(err, "zfs snapshot")
|
||||
}
|
||||
cmd := exec.Command(ZFS_BINARY, "snapshot", snapname)
|
||||
|
||||
stderr := bytes.NewBuffer(make([]byte, 0, 1024))
|
||||
@@ -1205,13 +1644,46 @@ func ZFSSnapshot(fs *DatasetPath, name string, recursive bool) (err error) {
|
||||
|
||||
}
|
||||
|
||||
func ZFSBookmark(fs *DatasetPath, snapshot, bookmark string) (err error) {
|
||||
var zfsBookmarkExistsRegex = regexp.MustCompile("^cannot create bookmark '[^']+': bookmark exists")
|
||||
|
||||
promTimer := prometheus.NewTimer(prom.ZFSBookmarkDuration.WithLabelValues(fs.ToString()))
|
||||
type BookmarkExists struct {
|
||||
zfsMsg string
|
||||
fs, bookmark string
|
||||
bookmarkOrigin ZFSSendArgVersion
|
||||
bookGuid uint64
|
||||
}
|
||||
|
||||
func (e *BookmarkExists) Error() string {
|
||||
return fmt.Sprintf("bookmark %s (guid=%v) with #%s: bookmark #%s exists but has different guid (%v)",
|
||||
e.bookmarkOrigin.FullPath(e.fs), e.bookmarkOrigin.GUID, e.bookmark, e.bookmark, e.bookGuid,
|
||||
)
|
||||
}
|
||||
|
||||
var ErrBookmarkCloningNotSupported = fmt.Errorf("bookmark cloning feature is not yet supported by ZFS")
|
||||
|
||||
// idempotently create bookmark of the given version v
|
||||
//
|
||||
// v must be validated by the caller
|
||||
//
|
||||
// does not destroy an existing bookmark, returns
|
||||
//
|
||||
func ZFSBookmark(fs string, v ZFSSendArgVersion, bookmark string) (err error) {
|
||||
|
||||
promTimer := prometheus.NewTimer(prom.ZFSBookmarkDuration.WithLabelValues(fs))
|
||||
defer promTimer.ObserveDuration()
|
||||
|
||||
snapname := zfsBuildSnapName(fs, snapshot)
|
||||
bookmarkname := zfsBuildBookmarkName(fs, bookmark)
|
||||
if !v.IsSnapshot() {
|
||||
return ErrBookmarkCloningNotSupported // TODO This is work in progress: https://github.com/zfsonlinux/zfs/pull/9571
|
||||
}
|
||||
|
||||
snapname := v.FullPath(fs)
|
||||
if err := EntityNamecheck(snapname, EntityTypeSnapshot); err != nil {
|
||||
return err
|
||||
}
|
||||
bookmarkname := fmt.Sprintf("%s#%s", fs, bookmark)
|
||||
if err := EntityNamecheck(bookmarkname, EntityTypeBookmark); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
debug("bookmark: %q %q", snapname, bookmarkname)
|
||||
|
||||
@@ -1225,13 +1697,37 @@ func ZFSBookmark(fs *DatasetPath, snapshot, bookmark string) (err error) {
|
||||
}
|
||||
|
||||
if err = cmd.Wait(); err != nil {
|
||||
err = &ZFSError{
|
||||
Stderr: stderr.Bytes(),
|
||||
WaitErr: err,
|
||||
|
||||
if ddne := tryDatasetDoesNotExist(snapname, stderr.Bytes()); err != nil {
|
||||
return ddne
|
||||
} else if zfsBookmarkExistsRegex.Match(stderr.Bytes()) {
|
||||
|
||||
// check if this was idempotent
|
||||
bookGuid, err := ZFSGetGUID(fs, "#"+bookmark)
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "bookmark idempotency check") // guid error expressive enough
|
||||
}
|
||||
|
||||
if v.GUID == bookGuid {
|
||||
debug("bookmark: %q %q was idempotent: {snap,book}guid %d == %d", snapname, bookmarkname, v.GUID, bookGuid)
|
||||
return nil
|
||||
}
|
||||
return &BookmarkExists{
|
||||
fs: fs, bookmarkOrigin: v, bookmark: bookmark,
|
||||
zfsMsg: stderr.String(),
|
||||
bookGuid: bookGuid,
|
||||
}
|
||||
|
||||
} else {
|
||||
return &ZFSError{
|
||||
Stderr: stderr.Bytes(),
|
||||
WaitErr: err,
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user