tests pass

replicator/driver.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"net/url"
 	"path"
+	"strconv"
 	"time"
 )
 
@@ -51,10 +52,15 @@ func NewDriver(ctx context.Context, driver url.URL) (Driver, error) {
 	}
 }
 
-func (version Version) ToTime() (time.Time, error) {
-	panic(nil) // TODO
+func (version Version) AsTime() (time.Time, error) {
+	if len(version) == 0 {
+		return time.Time{}, nil
+	}
+	n, err := strconv.ParseInt(string(version), 10, 64)
+	return time.Unix(0, n), err
 }
 
-func VersionFromTime(t time.Time) Version {
-	panic(nil) // TODO
+func TimeAsVersion(t time.Time) Version {
+	n := t.UnixNano()
+	return []byte(strconv.FormatInt(n, 10))
 }

replicator/driver_test.go

@@ -17,7 +17,8 @@ func testDriver(t *testing.T, d Driver) {
 	defer can()
 
 	key := Key{Namespace: "x/y", Key: "z"}
-	value := ValueVersion{Value: []byte(t.Name()), Version: []byte("1")}
+	version := TimeAsVersion(time.Now())
+	value := Value([]byte(t.Name()))
 
 	t.Run("get does not exist", func(t *testing.T) {
 		v, err := d.Get(ctx, key)
@@ -30,7 +31,7 @@ func testDriver(t *testing.T, d Driver) {
 	})
 
 	t.Run("404 set get", func(t *testing.T) {
-		if err := d.Set(ctx, key, value.Value, value.Version); err != nil {
+		if err := d.Set(ctx, key, value, version); err != nil {
 			t.Fatal(err)
 		}
 
@@ -38,11 +39,11 @@ func testDriver(t *testing.T, d Driver) {
 		if err != nil {
 			t.Errorf("getting key returned an err: %v", err)
 		}
-		if !bytes.Equal(v.Value, value.Value) {
-			t.Errorf("value didnt match set-get: want %q, got %q", value.Value, v.Value)
+		if !bytes.Equal(v.Value, value) {
+			t.Errorf("value didnt match set-get: want %q, got %q", value, v.Value)
 		}
-		if !bytes.Equal(v.Version, value.Version) {
-			t.Errorf("version didnt match set-get: want %q, got %q", value.Version, v.Version)
+		if !bytes.Equal(v.Version, version) {
+			t.Errorf("version didnt match set-get: want %q, got %q", version, v.Version)
 		}
 
 		if err := d.Del(ctx, key, nil); err != nil {
@@ -61,7 +62,7 @@ func testDriver(t *testing.T, d Driver) {
 	})
 
 	t.Run("keys of one key", func(t *testing.T) {
-		if err := d.Set(ctx, key, value.Value, value.Version); err != nil {
+		if err := d.Set(ctx, key, value, version); err != nil {
 			t.Fatal(err)
 		}
 		defer d.Del(ctx, key, nil)
@@ -72,7 +73,7 @@ func testDriver(t *testing.T, d Driver) {
 			n += 1
 			if got.Key != key {
 				t.Error(got)
-			} else if !bytes.Equal(got.Version, value.Version) {
+			} else if !bytes.Equal(got.Version, version) {
 				t.Error(got)
 			}
 		}
@@ -83,4 +84,178 @@ func testDriver(t *testing.T, d Driver) {
 			t.Error(*err)
 		}
 	})
+
+	t.Run("conditional set vs nothing", func(t *testing.T) {
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+	})
+
+	t.Run("conditional set vs older", func(t *testing.T) {
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, oldValue) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, oldVersion) {
+			t.Error(got)
+		}
+
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+	})
+
+	t.Run("conditional set vs equal", func(t *testing.T) {
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, oldValue) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, oldVersion) {
+			t.Error(got)
+		}
+
+		if err := d.Set(ctx, key, value, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, oldVersion) {
+			t.Error(got)
+		}
+	})
+
+	t.Run("conditional set vs newer", func(t *testing.T) {
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+	})
+
+	t.Run("conditional del vs nothing", func(t *testing.T) {
+		if err := d.Del(ctx, key, version); err != nil {
+			t.Fatal(err)
+		}
+	})
+
+	t.Run("conditional del vs older", func(t *testing.T) {
+		oldValue := []byte("teehee")
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, oldValue, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if err := d.Del(ctx, key, version); err != nil {
+			t.Fatal(err)
+		}
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if got.Value != nil {
+			t.Error(got)
+		} else if got.Version != nil {
+			t.Error(got)
+		}
+	})
+
+	t.Run("conditional del vs equal", func(t *testing.T) {
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if err := d.Del(ctx, key, version); err != nil {
+			t.Fatal(err)
+		}
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if got.Value != nil {
+			t.Error(got)
+		} else if got.Version != nil {
+			t.Error(got)
+		}
+	})
+
+	t.Run("conditional del vs newer", func(t *testing.T) {
+		oldVersion := TimeAsVersion(time.Now().Add(-1 * time.Minute))
+		if err := d.Set(ctx, key, value, version); err != nil {
+			t.Fatal(err)
+		}
+		defer d.Del(ctx, key, nil)
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+
+		if err := d.Del(ctx, key, oldVersion); err != nil {
+			t.Fatal(err)
+		}
+
+		if got, err := d.Get(ctx, key); err != nil {
+			t.Fatal(err)
+		} else if !bytes.Equal(got.Value, value) {
+			t.Error(got)
+		} else if !bytes.Equal(got.Version, version) {
+			t.Error(got)
+		}
+	})
 }

replicator/filetree.go

@@ -118,7 +118,13 @@ func (tree FileTree) Del(ctx context.Context, key Key, version Version) error {
 		}
 	}
 
-	return os.Remove(tree.realpath(key))
+	if err := os.Remove(tree.realpath(key)); os.IsNotExist(err) {
+		return nil
+	} else if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (tree FileTree) realpath(key Key) string {
@@ -132,12 +138,12 @@ func (tree FileTree) realpath(key Key) string {
 	return path.Join(string(tree), namespace, key.Key+".bin")
 }
 
-func (tree FileTree) getVersion(key Key) ([]byte, error) {
+func (tree FileTree) getVersion(key Key) (Version, error) {
 	v, err := tree._getVersion(key)
 	if v == (time.Time{}) {
 		return nil, err
 	}
-	return []byte(strconv.FormatInt(v.UnixNano(), 10)), err
+	return TimeAsVersion(v), err
 }
 
 func (tree FileTree) _getVersion(key Key) (time.Time, error) {
@@ -151,7 +157,7 @@ func (tree FileTree) _getVersion(key Key) (time.Time, error) {
 	return info.ModTime(), nil
 }
 
-func (tree FileTree) fromVersion(v []byte) (time.Time, error) {
+func (tree FileTree) fromVersion(v Version) (time.Time, error) {
 	if len(v) == 0 {
 		return time.Time{}, nil
 	}

replicator/main.go

@@ -0,0 +1,10 @@
+package replicator
+
+import (
+	"context"
+	"errors"
+)
+
+func Main(ctx context.Context) error {
+	return errors.New("not impl")
+}

replicator/map.go

@@ -49,9 +49,9 @@ func (m Map) Set(_ context.Context, key Key, value Value, version Version) error
 
 	if version != nil {
 		if was, ok := m.m[key]; !ok {
-		} else if wasVersion, err := was.Version.ToTime(); err != nil {
+		} else if wasVersion, err := was.Version.AsTime(); err != nil {
 			return err
-		} else if wantVersion, err := version.ToTime(); err != nil {
+		} else if wantVersion, err := version.AsTime(); err != nil {
 			return err
 		} else if wantVersion.Before(wasVersion) {
 			return nil // conflict
@@ -69,9 +69,9 @@ func (m Map) Del(_ context.Context, k Key, v Version) error {
 	if v != nil {
 		if was, ok := m.m[k]; !ok {
 			return nil
-		} else if wasVersion, err := was.Version.ToTime(); err != nil {
+		} else if wasVersion, err := was.Version.AsTime(); err != nil {
 			return err
-		} else if wantVersion, err := v.ToTime(); err != nil {
+		} else if wantVersion, err := v.AsTime(); err != nil {
 			return err
 		} else if wantVersion.Before(wasVersion) {
 			return nil // conflict

replicator/replicator.go

@@ -2,9 +2,21 @@ package replicator
 
 import (
 	"context"
-	"errors"
+	"io"
 )
 
-func Main(ctx context.Context) error {
-	return errors.New("not impl")
+type Replicator struct {
+	Src  Driver
+	Dest Driver
+}
+
+func NewReplicator(src, dest Driver) Replicator {
+	return Replicator{
+		Src:  src,
+		Dest: dest,
+	}
+}
+
+func (r Replicator) Stream(ctx context.Context) error {
+	return io.EOF
 }