.

wcfs/internal/xbtree/treediff.go

@@ -956,7 +956,7 @@ func zgetNodeOrNil(ctx context.Context, zconn *zodb.Connection, oid zodb.Oid) (n
 	defer xerr.Contextf(&err, "getnode %s@%s", oid, zconn.At())
 	xnode, err := xzodb.ZGetOrNil(ctx, zconn, oid)
 	if xnode == nil || err != nil {
-		return node, err
+		return nil, err
 	}
 
 	node, ok := xnode.(Node)

wcfs/internal/xbtree/δbtail.go

@@ -874,6 +874,11 @@ func (δBtail *ΔBtail) ΔZtail() /*readonly*/*zodb.ΔTail {
 	return δBtail.δZtail
 }
 
+// DB returns database handle that δBtail is using to access ZODB.
+func (δBtail *ΔBtail) DB() *zodb.DB {
+	return δBtail.db
+}
+
 
 func tracefΔBtail(format string, argv ...interface{}) {
 	if traceΔBtail {

wcfs/internal/zdata/δftail.go

@@ -24,6 +24,7 @@ import (
 	"fmt"
 
 	"lab.nexedi.com/kirr/go123/xerr"
+	"lab.nexedi.com/kirr/neo/go/transaction"
 	"lab.nexedi.com/kirr/neo/go/zodb"
 	"lab.nexedi.com/kirr/neo/go/zodb/btree"
 
@@ -213,6 +214,8 @@ func (δFtail *ΔFtail) Update(δZ *zodb.EventCommit) (_ ΔF, err error) {
 	// XXX verify zhead.At() == δFtail.Head()
 	// XXX locking
 
+	headOld := δFtail.Head()
+
 	δB, err := δFtail.δBtail.Update(δZ)
 	if err != nil {
 		return ΔF{}, err
@@ -283,6 +286,14 @@ func (δFtail *ΔFtail) Update(δZ *zodb.EventCommit) (_ ΔF, err error) {
 			// TODO check that .blksize and .blktab (it is only
 			// persistent reference) do not change. XXX -> EPOCH
 
+			δ, err := zfilediff(δFtail.δBtail.DB(), oid, headOld, δZ.Tid)
+			if err != nil {
+				return ΔF{}, err
+			}
+
+			// XXX
+			fmt.Printf("δZBigFile: %v\n", δ)
+
 			return ΔF{}, fmt.Errorf("ZBigFile<%s> changed @%s", oid, δZ.Tid)
 		}
 
@@ -509,12 +520,37 @@ func (δFtail *ΔFtail) LastBlkRev(ctx context.Context, zf *ZBigFile, blk int64,
 }
 
 
+// ----------------------------------------
 
-// diffF computes direct differece in between two ZBigFile objects.
+
+// zfilediff ... XXX
 type _ΔZBigFile struct {
 	blksizeOld, blksizeNew int64
 	blktabOld,  blktabNew  zodb.Oid
 }
+func zfilediff(db *zodb.DB, foid zodb.Oid, old, new zodb.Tid) (δ *_ΔZBigFile, err error) {
+	txn, ctx := transaction.New(context.TODO()) // XXX - merge in ctx arg?
+	defer txn.Abort()
+	zconnOld, err := db.Open(ctx, &zodb.ConnOptions{At: old})
+	if err != nil {
+		return nil, err
+	}
+	zconnNew, err := db.Open(ctx, &zodb.ConnOptions{At: new})
+	if err != nil {
+		return nil, err
+	}
+
+	a, err1 := zgetFileOrNil(ctx, zconnOld, foid)
+	b, err2 := zgetFileOrNil(ctx, zconnNew, foid)
+	err = xerr.Merge(err1, err2)
+	if err != nil {
+		return nil, err
+	}
+
+	return diffF(ctx, a, b)
+}
+
+// diffF computes direct difference in between two ZBigFile objects.
 func diffF(ctx context.Context, a, b *ZBigFile) (δ *_ΔZBigFile, err error) {
 	defer xerr.Contextf(&err, "diffF %s %s", xzodb.XidOf(a), xzodb.XidOf(b))
 
@@ -542,3 +578,20 @@ func diffF(ctx context.Context, a, b *ZBigFile) (δ *_ΔZBigFile, err error) {
 	// XXX return δ=nil if no change?
 	return δ, nil
 }
+
+
+// zgetFileOrNil returns ZBigFile corresponding to zconn.Get(oid) .
+// if the file does not exist, (nil, ok) is returned.
+func zgetFileOrNil(ctx context.Context, zconn *zodb.Connection, oid zodb.Oid) (zfile *ZBigFile, err error) {
+	defer xerr.Contextf(&err, "getfile %s@%s", oid, zconn.At())
+	xfile, err := xzodb.ZGetOrNil(ctx, zconn, oid)
+	if xfile == nil || err != nil {
+		return nil, err
+	}
+
+	zfile, ok := xfile.(*ZBigFile)
+	if !ok {
+		return nil, fmt.Errorf("unexpected type: %s", zodb.ClassOf(xfile))
+	}
+	return zfile, nil
+}