WIP state-machine based replication

cmd/replication.v2/replication.go

@@ -0,0 +1,137 @@
+package replication
+
+import (
+	"context"
+	"fmt"
+	"github.com/zrepl/zrepl/logger"
+	"io"
+)
+
+type ReplicationEndpoint interface {
+	// Does not include placeholder filesystems
+	ListFilesystems(ctx context.Context) ([]*Filesystem, error)
+	ListFilesystemVersions(ctx context.Context, fs string) ([]*FilesystemVersion, error) // fix depS
+	Send(ctx context.Context, r *SendReq) (*SendRes, io.ReadCloser, error)
+	Receive(ctx context.Context, r *ReceiveReq, sendStream io.ReadCloser) error
+}
+
+type FilteredError struct{ fs string }
+
+func NewFilteredError(fs string) FilteredError {
+	return FilteredError{fs}
+}
+
+func (f FilteredError) Error() string { return "endpoint does not allow access to filesystem " + f.fs }
+
+type ReplicationMode int
+
+const (
+	ReplicationModePull ReplicationMode = iota
+	ReplicationModePush
+)
+
+type EndpointPair struct {
+	a, b ReplicationEndpoint
+	m    ReplicationMode
+}
+
+func NewEndpointPairPull(sender, receiver ReplicationEndpoint) EndpointPair {
+	return EndpointPair{sender, receiver, ReplicationModePull}
+}
+
+func NewEndpointPairPush(sender, receiver ReplicationEndpoint) EndpointPair {
+	return EndpointPair{receiver, sender, ReplicationModePush}
+}
+
+func (p EndpointPair) Sender() ReplicationEndpoint {
+	switch p.m {
+	case ReplicationModePull:
+		return p.a
+	case ReplicationModePush:
+		return p.b
+	}
+	panic("should not be reached")
+	return nil
+}
+
+func (p EndpointPair) Receiver() ReplicationEndpoint {
+	switch p.m {
+	case ReplicationModePull:
+		return p.b
+	case ReplicationModePush:
+		return p.a
+	}
+	panic("should not be reached")
+	return nil
+}
+
+func (p EndpointPair) Mode() ReplicationMode {
+	return p.m
+}
+
+type contextKey int
+
+const (
+	contextKeyLog contextKey = iota
+)
+
+//type Logger interface {
+//	Infof(fmt string, args ...interface{})
+//	Errorf(fmt string, args ...interface{})
+//}
+
+//var _ Logger = nullLogger{}
+
+//type nullLogger struct{}
+//
+//func (nullLogger) Infof(fmt string, args ...interface{}) {}
+//func (nullLogger) Errorf(fmt string, args ...interface{}) {}
+
+type Logger = logger.Logger
+
+func ContextWithLogger(ctx context.Context, l Logger) context.Context {
+	return context.WithValue(ctx, contextKeyLog, l)
+}
+
+func getLogger(ctx context.Context) Logger {
+	l, ok := ctx.Value(contextKeyLog).(Logger)
+	if !ok {
+		l = logger.NewNullLogger()
+	}
+	return l
+}
+
+func resolveConflict(conflict error) (path []*FilesystemVersion, msg string) {
+	if noCommonAncestor, ok := conflict.(*ConflictNoCommonAncestor); ok {
+		if len(noCommonAncestor.SortedReceiverVersions) == 0 {
+			// FIXME hard-coded replication policy: most recent
+			// snapshot as source
+			var mostRecentSnap *FilesystemVersion
+			for n := len(noCommonAncestor.SortedSenderVersions) - 1; n >= 0; n-- {
+				if noCommonAncestor.SortedSenderVersions[n].Type == FilesystemVersion_Snapshot {
+					mostRecentSnap = noCommonAncestor.SortedSenderVersions[n]
+					break
+				}
+			}
+			if mostRecentSnap == nil {
+				return nil, "no snapshots available on sender side"
+			}
+			return []*FilesystemVersion{mostRecentSnap}, fmt.Sprintf("start replication at most recent snapshot %s", mostRecentSnap.RelName())
+		}
+	}
+	return nil, "no automated way to handle conflict type"
+}
+
+// Replicate replicates filesystems from ep.Sender() to ep.Receiver().
+//
+// All filesystems presented by the sending side are replicated,
+// unless the receiver rejects a Receive request with a *FilteredError.
+//
+// If an error occurs when replicating a filesystem, that error is logged to the logger in ctx.
+// Replicate continues with the replication of the remaining file systems.
+// Depending on the type of error, failed replications are retried in an unspecified order (currently FIFO).
+func Replicate(ctx context.Context, ep EndpointPair, retryNow chan struct{}) {
+	r := Replication{}
+	r.Drive(ctx, ep, retryNow)
+}
+