added fs encryption overlay

pkg/fs/chunk.go

@@ -1,59 +0,0 @@
-// Copyright (C) 2022 Marius Schellenberger
-
-package fs
-
-import (
-	"golang.org/x/exp/slices"
-)
-
-type Chunk [2]int64
-
-type Chunks []Chunk
-
-func (Chunks) Less(i, j Chunk) bool { return i[0] < j[0] }
-
-func (cs Chunks) Exists(off int64, n int, size int64) bool {
-	end := off + int64(n)
-	if end > size {
-		end = size
-	}
-	for _, c := range cs {
-		if c[0] <= off && c[1] > off && c[1] >= end {
-			return true
-		}
-	}
-	return false
-}
-
-func (cs *Chunks) Add(off int64, n int) {
-	*cs = append(*cs, Chunk{off, off + int64(n)})
-	cs.merge()
-}
-
-func (cs Chunks) Size() (sum int64) {
-	for _, c := range cs {
-		sum += (c[1] - c[0])
-	}
-	return
-}
-
-func (cs *Chunks) merge() {
-	c := *cs
-	if len(c) < 2 {
-		return
-	}
-	slices.SortFunc(c, c.Less)
-	for i := 0; i < len(c); i++ {
-		if i+1 == len(c) {
-			break
-		}
-		if c[i][1] >= c[i+1][0] {
-			if c[i+1][1] > c[i][1] {
-				c[i][1] = c[i+1][1]
-			}
-			c = slices.Delete(c, i+1, i+2)
-			i--
-		}
-	}
-	*cs = c
-}

pkg/fs/file.go

@@ -49,6 +49,7 @@ func (p *preload) Read(data []byte) (n int, err error) {
 
 func (f *File) Preload(ctx context.Context, unlock func()) {
 	log := f.log
+	defer f.Close()
 	defer unlock()
 	if f.offline {
 		log.V(2).Error(errors.New("no preload in offline mode"), "error preloading file")
@@ -68,6 +69,7 @@ func (f *File) Preload(ctx context.Context, unlock func()) {
 	if err != nil && err != io.EOF {
 		log.Error(err, "error preloading file")
 	}
+	f.md.Close()
 	log.V(2).Info("preload finished", "skipped", p.skipped, "written", p.written)
 }
 

pkg/fs/fs.go

@@ -6,6 +6,7 @@ import (
 	"cachefs/pkg/provider"
 	"cachefs/pkg/provider/parse"
 	"context"
+	"encoding/hex"
 	"errors"
 	"fmt"
 	stdfs "io/fs"
@@ -31,15 +32,28 @@ type FS struct {
 	ph *PreloadHandler
 }
 
-func NewFS(quota int64, max int, src, dst, metadata string, log logr.Logger) (fs *FS, err error) {
+func NewFS(quota int64, max int, src, srckey, dst, dstkey, metadata string, log logr.Logger) (fs *FS, err error) {
 	if src == dst {
 		return nil, errors.New("src and dst path can not be equal")
 	}
-	srcfs, err := parse.FS(src)
+	var srck, dstk []byte
+	if srckey != "" {
+		srck, err = hex.DecodeString(srckey)
+		if err != nil {
+			return nil, fmt.Errorf("srckey: %w", err)
+		}
+	}
+	if dstkey != "" {
+		dstk, err = hex.DecodeString(dstkey)
+		if err != nil {
+			return nil, fmt.Errorf("dstkey: %w", err)
+		}
+	}
+	srcfs, err := parse.FS(src, srck)
 	if err != nil {
 		return nil, fmt.Errorf("srcfs: %w", err)
 	}
-	dstfs, err := parse.FS(dst)
+	dstfs, err := parse.FS(dst, dstk)
 	if err != nil {
 		return nil, fmt.Errorf("dstfs: %w", err)
 	}

pkg/fs/metadata.go

@@ -3,6 +3,7 @@
 package fs
 
 import (
+	"cachefs/pkg/chunk"
 	"cachefs/pkg/provider"
 	"context"
 	"encoding/json"
@@ -80,7 +81,7 @@ func MetadataGenerator(file string, dst provider.FS) error {
 		if size <= blocks*512 {
 			md[strings.TrimPrefix(path, dst.Root())] = &Metadata{
 				Size:   size,
-				Chunks: Chunks{{0, size}},
+				Chunks: chunk.Chunks{{0, size}},
 			}
 		}
 		return nil
@@ -328,13 +329,21 @@ type Metadata struct {
 	name   string        `json:"-"`
 	Size   int64         `json:"s"`
 	Atime  int64         `json:"a"`
-	Chunks Chunks        `json:"c"`
+	Chunks chunk.Chunks  `json:"c"`
+}
+
+func (md *Metadata) Close() error {
+	md.mu.Lock()
+	defer md.mu.Unlock()
+	err := md.f.Close()
+	md.f = nil
+	return err
 }
 
 func (md *Metadata) Delete() error {
 	md.mu.Lock()
 	defer md.mu.Unlock()
-	md.Chunks = Chunks{}
+	md.Chunks = chunk.Chunks{}
 	md.f.Close()
 	md.f = nil
 	atomic.StoreInt64(&md.Atime, now())

pkg/fs/preload.go

@@ -130,8 +130,6 @@ func (ph *PreloadHandler) preload(ctx context.Context) {
 		p.cancel = cancel
 		ph.mu.Unlock()
 		go f.Preload(ctx, func() {
-			file := f
-			file.Close()
 			ph.fin <- name
 		})
 	}