continued work on encryption

pkg/provider/crypto/file.go

@@ -4,6 +4,7 @@ import (
 	"cachefs/pkg/provider"
 	"io"
 	"io/fs"
+	"os"
 )
 
 var _ provider.File = (*file)(nil)
@@ -16,6 +17,7 @@ type file struct {
 	nonce  [NonceSize]byte
 	offset int64
 	name   string
+	stat   *stat
 	dir    bool
 }
 
@@ -41,41 +43,81 @@ func newFile(key []byte, name string, fs *FS, f provider.File, dir bool) (ef pro
 	if err != nil {
 		return
 	}
-	return &file{
+	ef = &file{
 		File: f,
 		fs:   fs,
 		w:    w,
 		r:    r,
 		name: name,
-	}, nil
+	}
+	return ef, nil
 }
 
 func (f *file) Stat() (fs.FileInfo, error) {
+	if f.stat != nil {
+		return f.stat, nil
+	}
 	fi, err := f.File.Stat()
-	return stat{FileInfo: fi, name: f.name}, err
+	if err != nil {
+		return nil, err
+	}
+	if f.dir {
+		return dir{FileInfo: fi, name: f.name}, nil
+	}
+
+	rs := RealSize(fi.Size())
+	f.stat = &stat{
+		FileInfo: fi,
+		size:     rs,
+		name:     f.name,
+	}
+	return f.stat, nil
+
+	//fmt.Println("rs", rs)
+	//_, err = f.ReadAt(nil, rs)
+	//if err != nil && err != io.EOF {
+	//	return nil, err
+	//}
+	//f.stat = &stat{
+	//	FileInfo: fi,
+	//	size:     rs - (ChunkSize - int64(len(f.r.unread))),
+	//	name:     f.name,
+	//}
+	//fmt.Println("size", f.stat.Size())
+	//f.Seek(0, io.SeekStart)
+	//return f.stat, nil
 }
 
 func (f *file) Name() string {
 	return f.name
 }
 
-func (file) Fd() uintptr {
+func (f *file) Fd() uintptr {
+	osf, ok := f.File.(*os.File)
+	if ok {
+		return osf.Fd()
+	}
 	return 0
 }
 
 type stat struct {
 	fs.FileInfo
+	size int64
 	name string
 }
 
 func (s stat) Size() int64 {
-	return RealSize(s.FileInfo.Size())
+	return s.size
 }
 
 func (s stat) Name() string {
 	return s.name
 }
 
+func (f *file) Truncate(n int64) error {
+	return f.File.Truncate(Size(n))
+}
+
 func (f *file) Close() error {
 	if f.dir {
 		return f.File.Close()
@@ -104,16 +146,23 @@ func (f *file) Seek(offset int64, whence int) (n int64, err error) {
 		_, err = f.File.Seek(f.offset, io.SeekStart)
 		n = offset
 	}
+	f.reset()
+	if err != nil {
+		return
+	}
 	f.nonce = [NonceSize]byte{}
 	inc(&f.nonce, cn)
 	f.r.nonce = f.nonce
-	f.r.off = roff
-	f.r.err = nil
 	f.w.nonce = f.nonce
-	f.r.unread = f.r.unread[:0]
+	f.r.off = roff
 	return
 }
 
+func (f *file) reset() {
+	f.r.err = nil
+	f.r.unread = f.r.unread[:0]
+}
+
 func (f *file) Read(p []byte) (n int, err error) {
 	n, err = f.r.Read(p)
 	return
@@ -125,21 +174,28 @@ func (f *file) Write(p []byte) (n int, err error) {
 }
 
 func (f *file) ReadAt(p []byte, pos int64) (n int, err error) {
-	_, _, roff := align(pos)
-	//cn, off, roff := align(pos)
-	f.Seek(pos, io.SeekStart)
-	//fmt.Println("readAt:", cn, off+KDFNonceSize, roff, pos)
-	_, err = f.r.readChunk()
-	if err != nil {
-		return
+	cn, _, roff := align(pos)
+	var last bool
+	if f.r.cn != cn {
+		_, err = f.Seek(pos, io.SeekStart)
+		if err != nil {
+			return
+		}
+		last, err = f.r.readChunk()
+		if err != nil {
+			return
+		}
+		f.r.cn = cn
 	}
 	n = copy(p, f.r.unread[roff:])
+	if last && len(f.r.unread) == n+int(roff) {
+		err = io.EOF
+	}
 	return
 }
 
 func (f *file) WriteAt(data []byte, pos int64) (n int, err error) {
 	cn, off, woff := align(pos)
-	//fmt.Println("writeAt:", cn, off+KDFNonceSize, woff, pos)
 	c, ok := f.w.cm[cn]
 	if !ok {
 		c = &chunkWriter{offset: off + KDFNonceSize, w: f.w, cn: cn}
@@ -153,8 +209,11 @@ func (f *file) WriteAt(data []byte, pos int64) (n int, err error) {
 	}
 	n, err = c.writeAt(data, woff)
 	if c.full() {
-		_, err = c.flush(notLastChunk)
-		//fmt.Println("flush:", cn)
+		// async flush
+		go func() {
+			//_, err = c.flush(notLastChunk)
+			c.flush(notLastChunk)
+		}()
 		delete(f.w.cm, cn)
 	}
 	return
@@ -171,7 +230,7 @@ func (f *file) Readdir(n int) ([]fs.FileInfo, error) {
 		if err != nil {
 			return nil, err
 		}
-		fio[i] = dir{FileInfo: fi, name: name}
+		fio[i] = stat{FileInfo: fi, size: RealSize(fi.Size()), name: name}
 	}
 	return fio, nil
 }