add reload groups

add reload namespaces

Author: JojiiOfficial

dmfs/data.go

@@ -1,6 +1,7 @@
 package dmfs
 
 import (
+	"fmt"
 	"os"
 	"time"
 
@@ -33,7 +34,8 @@ func (data *dataStruct) loadUserAttributes() error {
 	// TODO make cachhe time configureable or even create
 	// a genuius way to calculate a reasonable cachetime
 
-	if time.Now().Unix()-10 > data.lastUserAttrLoad {
+	if time.Now().Unix()-5 > data.lastUserAttrLoad {
+		fmt.Println("reload")
 		var err error
 		data.userAttributes, err = data.libdm.GetUserAttributeData()
 		if err != nil {

dmfs/dmfsRoot.go

@@ -7,15 +7,19 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/DataManager-Go/libdatamanager"
 	"github.com/hanwen/go-fuse/v2/fs"
 	"github.com/hanwen/go-fuse/v2/fuse"
 )
 
+/*
+* the root fs is supposed to load and interact
+* with the namespaces and to show them as directories
+ */
+
 type rootNode struct {
 	fs.Inode
 
-	nsMap map[string][]string
+	nsNodes map[string]*namespaceNode
 }
 
 // implement the interfaces
@@ -24,44 +28,53 @@ var _ = (fs.NodeRenamer)((*rootNode)(nil))
 var _ = (fs.NodeRmdirer)((*rootNode)(nil))
 var _ = (fs.NodeLookuper)((*rootNode)(nil))
 
-// OnAdd is called on mounting the file system. Use it to populate
-// the file system tree.
-func (root *rootNode) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
-	r := make([]fuse.DirEntry, 0)
+// Create new root Node
+func newRootNode() *rootNode {
+	rn := &rootNode{}
+	rn.nsNodes = make(map[string]*namespaceNode)
+	return rn
+}
 
+// On dir access, load namespaces and groups
+func (root *rootNode) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
+	fmt.Println("read root")
+	// Use dataStore to retrieve
+	// groups and namespaces
 	err := data.loadUserAttributes()
 	if err != nil {
 		log.Fatal(err)
-		return nil, syscall.EPERM
+		return nil, syscall.ENOENT
 	}
 
-	if root.nsMap == nil {
-		root.nsMap = make(map[string][]string, 0)
-	}
+	r := make([]fuse.DirEntry, len(data.userAttributes.Namespace))
 
 	// Loop Namespaces and add childs in as folders
-	for _, namespace := range data.userAttributes.Namespace {
+	for i, namespace := range data.userAttributes.Namespace {
 		nsName := removeNSName(namespace.Name)
 
-		_, has := root.nsMap[namespace.Name]
+		// Find namespace node
+		v, has := root.nsNodes[nsName]
 		if !has {
-			root.nsMap[namespace.Name] = namespace.Groups
+			// Create new if not exists
+			root.nsNodes[nsName] = newNamespaceNode(namespace)
+		} else {
+			// Update groups if exists
+			v.nsInfo.Groups = namespace.Groups
 		}
 
-		r = append(r, fuse.DirEntry{
+		r[i] = fuse.DirEntry{
 			Name: nsName,
 			Mode: syscall.S_IFDIR,
-		})
+		}
 	}
 
 	return fs.NewListDirStream(r), 0
 }
 
+// Lookup -> something tries to lookup a file (namespace)
 func (root *rootNode) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
-	fullNS := addNSName(name, data.mounter.Libdm.Config)
-
 	// Get cached namespaceInfo from map
-	val, has := root.nsMap[fullNS]
+	val, has := root.nsNodes[name]
 	if !has {
 		return nil, syscall.ENOENT
 	}
@@ -71,12 +84,7 @@ func (root *rootNode) Lookup(ctx context.Context, name string, out *fuse.EntryOu
 
 	// Create new child if not found
 	if child == nil {
-		child = root.NewInode(ctx, &namespaceNode{
-			nsInfo: &libdatamanager.Namespaceinfo{
-				Name:   fullNS,
-				Groups: val,
-			},
-		}, fs.StableAttr{
+		child = root.NewInode(ctx, val, fs.StableAttr{
 			Mode: syscall.S_IFDIR,
 		})
 	}

dmfs/fsNamespace.go

@@ -11,38 +11,80 @@ import (
 	"github.com/hanwen/go-fuse/v2/fuse"
 )
 
+/*
+* filesystem namespace is supposed to load and interact
+* with the groups and to show them as directories
+ */
+
 type namespaceNode struct {
 	fs.Inode
 
-	nsInfo *libdm.Namespaceinfo
+	nsInfo libdm.Namespaceinfo
 }
 
-var _ = (fs.NodeOnAdder)((*namespaceNode)(nil))
+// var _ = (fs.NodeOnAdder)((*namespaceNode)(nil))
 var _ = (fs.NodeRmdirer)((*namespaceNode)(nil))
 var _ = (fs.NodeMkdirer)((*namespaceNode)(nil))
 var _ = (fs.NodeRenamer)((*namespaceNode)(nil))
+var _ = (fs.NodeReaddirer)((*namespaceNode)(nil))
+var _ = (fs.NodeLookuper)((*namespaceNode)(nil))
 
-func (nsNode *namespaceNode) OnAdd(ctx context.Context) {
-	// Use a no_group folder for files
-	// not associated to a groud
-	if len(nsNode.nsInfo.Groups) == 0 {
-		nsNode.nsInfo.Groups = []string{"no_group"}
+func newNamespaceNode(nsInfo libdm.Namespaceinfo) *namespaceNode {
+	return &namespaceNode{
+		nsInfo: nsInfo,
 	}
+}
+
+// On Namespace dir accessed
+func (nsNode *namespaceNode) Readdir(ctx context.Context) (fs.DirStream, syscall.Errno) {
+	// TODO reload groups in dmfsRoot on reading dir
+
+	r := make([]fuse.DirEntry, len(nsNode.nsInfo.Groups))
+
+	// Load groups
+	for i := range nsNode.nsInfo.Groups {
+		r[i] = fuse.DirEntry{
+			Mode: syscall.S_IFDIR,
+			Name: nsNode.nsInfo.Groups[i],
+		}
+	}
+
+	return fs.NewListDirStream(r), 0
+}
 
-	// Add groups to namespace
-	for _, group := range nsNode.nsInfo.Groups {
-		gp := nsNode.GetChild(group)
-		if gp == nil {
-			gp = nsNode.NewInode(ctx, &groupInode{
-				group:     group,
-				namespace: nsNode.nsInfo.Name,
-			}, fs.StableAttr{
-				Mode: syscall.S_IFDIR,
-			})
-
-			nsNode.AddChild(group, gp, true)
+// On group looked up
+func (nsNode *namespaceNode) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
+	found := false
+	for gi := range nsNode.nsInfo.Groups {
+		if nsNode.nsInfo.Groups[gi] == name {
+			found = true
+			break
 		}
 	}
+
+	// Return entry not-found-error
+	// if entry wasn't found
+	if !found {
+		return nil, syscall.ENOENT
+	}
+
+	// Reuse group child
+	child := nsNode.GetChild(name)
+
+	// create child if not found
+	if child == nil {
+		v := &groupInode{
+			group:                name,
+			isNoGroupPlaceholder: name == "no_group",
+			namespace:            nsNode.nsInfo.Name,
+		}
+
+		child = nsNode.NewInode(ctx, v, fs.StableAttr{
+			Mode: syscall.S_IFDIR,
+		})
+	}
+
+	return child, 0
 }
 
 // Delete group if vfile was removed

dmfs/mount.go

@@ -57,7 +57,7 @@ func (mounter *Mounter) Mount() {
 	initData()
 
 	// Create the fs
-	root := &rootNode{}
+	root := newRootNode()
 
 	var err error