refactor
This commit is contained in:
parent
d056ac1167
commit
bd75492b02
81 changed files with 822 additions and 1098 deletions
src/host/vfs
|
@ -1,365 +0,0 @@
|
|||
package vfs
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"log/slog"
|
||||
"path"
|
||||
"reflect"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.kmsign.ru/royalcat/tstor/pkg/rlog"
|
||||
"go.opentelemetry.io/otel/attribute"
|
||||
"go.opentelemetry.io/otel/trace"
|
||||
"golang.org/x/exp/maps"
|
||||
)
|
||||
|
||||
type ResolverFS struct {
|
||||
rootFS Filesystem
|
||||
resolver *Resolver
|
||||
|
||||
log *rlog.Logger
|
||||
}
|
||||
|
||||
func NewResolveFS(rootFs Filesystem, factories map[string]FsFactory) *ResolverFS {
|
||||
return &ResolverFS{
|
||||
rootFS: rootFs,
|
||||
resolver: NewResolver(factories),
|
||||
log: rlog.Component("fs.resolverfs"),
|
||||
}
|
||||
}
|
||||
|
||||
// ModTime implements Filesystem.
|
||||
func (r *ResolverFS) ModTime() time.Time {
|
||||
return time.Time{}
|
||||
}
|
||||
|
||||
// Mode implements Filesystem.
|
||||
func (r *ResolverFS) Mode() fs.FileMode {
|
||||
return fs.ModeDir
|
||||
}
|
||||
|
||||
// Size implements Filesystem.
|
||||
func (r *ResolverFS) Size() int64 {
|
||||
return 0
|
||||
}
|
||||
|
||||
// Sys implements Filesystem.
|
||||
func (r *ResolverFS) Sys() any {
|
||||
return nil
|
||||
}
|
||||
|
||||
// FsName implements Filesystem.
|
||||
func (r *ResolverFS) FsName() string {
|
||||
return "resolverfs"
|
||||
}
|
||||
|
||||
func (fs *ResolverFS) traceAttrs(add ...attribute.KeyValue) trace.SpanStartOption {
|
||||
return trace.WithAttributes(append([]attribute.KeyValue{
|
||||
attribute.String("fs", fs.FsName()),
|
||||
}, add...)...)
|
||||
}
|
||||
|
||||
func (r *ResolverFS) ResolvablesExtensions() []string {
|
||||
return maps.Keys(r.resolver.factories)
|
||||
}
|
||||
|
||||
// Open implements Filesystem.
|
||||
func (r *ResolverFS) Open(ctx context.Context, filename string) (File, error) {
|
||||
ctx, span := tracer.Start(ctx, "Open",
|
||||
r.traceAttrs(attribute.String("filename", filename)),
|
||||
)
|
||||
defer span.End()
|
||||
|
||||
if path.Clean(filename) == Separator {
|
||||
return NewDirFile(r.Name()), nil
|
||||
}
|
||||
|
||||
fsPath, nestedFs, nestedFsPath, err := r.resolver.ResolvePath(ctx, filename, r.rootFS.Open)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if nestedFs != nil {
|
||||
return nestedFs.Open(ctx, nestedFsPath)
|
||||
}
|
||||
|
||||
return r.rootFS.Open(ctx, fsPath)
|
||||
}
|
||||
|
||||
// ReadDir implements Filesystem.
|
||||
func (r *ResolverFS) ReadDir(ctx context.Context, dir string) ([]fs.DirEntry, error) {
|
||||
ctx, span := tracer.Start(ctx, "ReadDir",
|
||||
r.traceAttrs(attribute.String("name", dir)),
|
||||
)
|
||||
defer span.End()
|
||||
|
||||
fsPath, nestedFs, nestedFsPath, err := r.resolver.ResolvePath(ctx, dir, r.rootFS.Open)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if nestedFs != nil {
|
||||
return nestedFs.ReadDir(ctx, nestedFsPath)
|
||||
}
|
||||
|
||||
entries, err := r.rootFS.ReadDir(ctx, fsPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out := make([]fs.DirEntry, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
if r.resolver.IsNestedFs(e.Name()) {
|
||||
filepath := path.Join("/", dir, e.Name())
|
||||
file, err := r.Open(ctx, filepath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer file.Close(ctx)
|
||||
|
||||
err = func() error {
|
||||
factoryCtx, cancel := subTimeout(ctx)
|
||||
defer cancel()
|
||||
nestedfs, err := r.resolver.NestedFs(factoryCtx, filepath, file)
|
||||
if err != nil {
|
||||
if errors.Is(err, context.DeadlineExceeded) {
|
||||
r.log.Error(ctx, "creating fs timed out",
|
||||
slog.String("filename", e.Name()),
|
||||
)
|
||||
return nil
|
||||
}
|
||||
|
||||
return err
|
||||
}
|
||||
out = append(out, nestedfs)
|
||||
return nil
|
||||
}()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
} else {
|
||||
out = append(out, e)
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Stat implements Filesystem.
|
||||
func (r *ResolverFS) Stat(ctx context.Context, filename string) (fs.FileInfo, error) {
|
||||
ctx, span := tracer.Start(ctx, "Stat",
|
||||
r.traceAttrs(attribute.String("filename", filename)),
|
||||
)
|
||||
defer span.End()
|
||||
|
||||
if IsRoot(filename) {
|
||||
return r, nil
|
||||
}
|
||||
|
||||
fsPath, nestedFs, nestedFsPath, err := r.resolver.ResolvePath(ctx, filename, r.rootFS.Open)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
span.SetAttributes(attribute.String("fsPath", fsPath), attribute.String("nestedFsPath", nestedFsPath))
|
||||
|
||||
if nestedFs != nil {
|
||||
span.AddEvent("calling nested fs")
|
||||
return nestedFs.Stat(ctx, nestedFsPath)
|
||||
}
|
||||
|
||||
return r.rootFS.Stat(ctx, fsPath)
|
||||
}
|
||||
|
||||
// Unlink implements Filesystem.
|
||||
func (r *ResolverFS) Unlink(ctx context.Context, filename string) error {
|
||||
fsPath, nestedFs, nestedFsPath, err := r.resolver.ResolvePath(ctx, filename, r.rootFS.Open)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if nestedFs != nil {
|
||||
return nestedFs.Unlink(ctx, nestedFsPath)
|
||||
}
|
||||
|
||||
return r.rootFS.Unlink(ctx, fsPath)
|
||||
}
|
||||
|
||||
// Info implements Filesystem.
|
||||
func (r *ResolverFS) Info() (fs.FileInfo, error) {
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// IsDir implements Filesystem.
|
||||
func (r *ResolverFS) IsDir() bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// Name implements Filesystem.
|
||||
func (r *ResolverFS) Name() string {
|
||||
return r.rootFS.Name()
|
||||
}
|
||||
|
||||
// Type implements Filesystem.
|
||||
func (r *ResolverFS) Type() fs.FileMode {
|
||||
return fs.ModeDir
|
||||
}
|
||||
|
||||
var _ Filesystem = &ResolverFS{}
|
||||
|
||||
type FsFactory func(ctx context.Context, f File) (Filesystem, error)
|
||||
|
||||
func NewResolver(factories map[string]FsFactory) *Resolver {
|
||||
return &Resolver{
|
||||
factories: factories,
|
||||
fsmap: map[string]Filesystem{},
|
||||
}
|
||||
}
|
||||
|
||||
type Resolver struct {
|
||||
m sync.Mutex
|
||||
factories map[string]FsFactory
|
||||
fsmap map[string]Filesystem // filesystem cache
|
||||
// TODO: add fsmap clean
|
||||
}
|
||||
|
||||
type openFile func(ctx context.Context, path string) (File, error)
|
||||
|
||||
func (r *Resolver) IsNestedFs(f string) bool {
|
||||
for ext := range r.factories {
|
||||
if strings.HasSuffix(f, ext) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (r *Resolver) NestedFs(ctx context.Context, fsPath string, file File) (Filesystem, error) {
|
||||
for ext, nestFactory := range r.factories {
|
||||
if !strings.HasSuffix(fsPath, ext) {
|
||||
continue
|
||||
}
|
||||
|
||||
if nestedFs, ok := r.fsmap[fsPath]; ok {
|
||||
return nestedFs, nil
|
||||
}
|
||||
|
||||
nestedFs, err := nestFactory(ctx, file)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error creating filesystem from file: %s with error: %w", fsPath, err)
|
||||
}
|
||||
r.fsmap[fsPath] = nestedFs
|
||||
|
||||
return nestedFs, nil
|
||||
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// open requeue raw open, without resolver call
|
||||
func (r *Resolver) ResolvePath(ctx context.Context, name string, rawOpen openFile) (fsPath string, nestedFs Filesystem, nestedFsPath string, err error) {
|
||||
ctx, span := tracer.Start(ctx, "resolvePath")
|
||||
defer span.End()
|
||||
|
||||
name = path.Clean(name)
|
||||
name = strings.TrimPrefix(name, Separator)
|
||||
parts := strings.Split(name, Separator)
|
||||
|
||||
nestOn := -1
|
||||
var nestFactory FsFactory
|
||||
|
||||
PARTS_LOOP:
|
||||
for i, part := range parts {
|
||||
for ext, factory := range r.factories {
|
||||
if strings.HasSuffix(part, ext) {
|
||||
nestOn = i + 1
|
||||
nestFactory = factory
|
||||
break PARTS_LOOP
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if nestOn == -1 {
|
||||
return AbsPath(name), nil, "", nil
|
||||
}
|
||||
|
||||
fsPath = AbsPath(path.Join(parts[:nestOn]...))
|
||||
|
||||
nestedFsPath = AbsPath(path.Join(parts[nestOn:]...))
|
||||
|
||||
// we dont need lock until now
|
||||
// it must be before fsmap read to exclude race condition:
|
||||
// read -> write
|
||||
// read -> write
|
||||
r.m.Lock()
|
||||
defer r.m.Unlock()
|
||||
|
||||
if nestedFs, ok := r.fsmap[fsPath]; ok {
|
||||
span.AddEvent("fs loaded from cache", trace.WithAttributes(attribute.String("nestedFs", reflect.TypeOf(nestedFs).Name())))
|
||||
return fsPath, nestedFs, nestedFsPath, nil
|
||||
} else {
|
||||
ctx, span := tracer.Start(ctx, "CreateFS")
|
||||
defer span.End()
|
||||
|
||||
fsFile, err := rawOpen(ctx, fsPath)
|
||||
if err != nil {
|
||||
return "", nil, "", fmt.Errorf("error opening filesystem file: %s with error: %w", fsPath, err)
|
||||
}
|
||||
nestedFs, err := nestFactory(ctx, fsFile)
|
||||
if err != nil {
|
||||
return "", nil, "", fmt.Errorf("error creating filesystem from file: %s with error: %w", fsPath, err)
|
||||
}
|
||||
r.fsmap[fsPath] = nestedFs
|
||||
|
||||
span.AddEvent("fs created", trace.WithAttributes(attribute.String("nestedFs", reflect.TypeOf(nestedFs).Name())))
|
||||
|
||||
return fsPath, nestedFs, nestedFsPath, nil
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
var ErrNotExist = fs.ErrNotExist
|
||||
|
||||
func GetFile[F File](m map[string]F, name string) (File, error) {
|
||||
if name == Separator {
|
||||
return NewDirFile(name), nil
|
||||
}
|
||||
|
||||
f, ok := m[name]
|
||||
if ok {
|
||||
return f, nil
|
||||
}
|
||||
|
||||
for p := range m {
|
||||
if strings.HasPrefix(p, name) {
|
||||
return NewDirFile(name), nil
|
||||
}
|
||||
}
|
||||
|
||||
return nil, ErrNotExist
|
||||
}
|
||||
|
||||
func ListDirFromFiles[F File](m map[string]F, name string) ([]fs.DirEntry, error) {
|
||||
out := make([]fs.DirEntry, 0, len(m))
|
||||
name = AddTrailSlash(path.Clean(name))
|
||||
for p, f := range m {
|
||||
if strings.HasPrefix(p, name) {
|
||||
parts := strings.Split(trimRelPath(p, name), Separator)
|
||||
if len(parts) == 1 {
|
||||
out = append(out, NewFileInfo(parts[0], f.Size()))
|
||||
} else {
|
||||
out = append(out, newDirInfo(parts[0]))
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
slices.SortStableFunc(out, func(de1, de2 fs.DirEntry) int {
|
||||
return strings.Compare(de1.Name(), de2.Name())
|
||||
})
|
||||
out = slices.CompactFunc(out, func(de1, de2 fs.DirEntry) bool {
|
||||
return de1.Name() == de2.Name()
|
||||
})
|
||||
|
||||
return out, nil
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue