arozos/storage.go

package main

import (
	"errors"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"strings"

	"imuslab.com/arozos/mod/filesystem/fsdef"
	"imuslab.com/arozos/mod/permission"
	"imuslab.com/arozos/mod/storage/bridge"

	fs "imuslab.com/arozos/mod/filesystem"
	storage "imuslab.com/arozos/mod/storage"
)

var (
	baseStoragePool *storage.StoragePool //base storage pool, all user can access these virtual roots
	//fsHandlers      []*fs.FileSystemHandler //All File system handlers. All opened handles must be registered in here
	//storagePools    []*storage.StoragePool  //All Storage pool opened
	bridgeManager *bridge.Record //Manager to handle bridged FSH
)

func StorageInit() {
	//Load the default handler for the user storage root
	if !fs.FileExists(filepath.Clean(*root_directory) + "/") {
		os.MkdirAll(filepath.Clean(*root_directory)+"/", 0755)
	}

	//Start loading the base storage pool
	err := LoadBaseStoragePool()
	if err != nil {
		panic(err)
	}

	//Create a brdige record manager
	bm := bridge.NewBridgeRecord("system/bridge.json")
	bridgeManager = bm

}

func LoadBaseStoragePool() error {
	//All fsh for the base pool
	fsHandlers := []*fs.FileSystemHandler{}
	//Use for Debian buster local file system
	localFileSystem := "ext4"
	if runtime.GOOS == "windows" {
		localFileSystem = "ntfs"
	}

	baseHandler, err := fs.NewFileSystemHandler(fs.FileSystemOption{
		Name:       "User",
		Uuid:       "user",
		Path:       filepath.ToSlash(filepath.Clean(*root_directory)) + "/",
		Hierarchy:  "user",
		Automount:  false,
		Filesystem: localFileSystem,
	})

	if err != nil {
		log.Println("Failed to initiate user root storage directory: "+*root_directory, err.Error())
		return err
	}
	fsHandlers = append(fsHandlers, baseHandler)

	//Load the tmp folder as storage unit
	tmpHandler, err := fs.NewFileSystemHandler(fs.FileSystemOption{
		Name:       "tmp",
		Uuid:       "tmp",
		Path:       filepath.ToSlash(filepath.Clean(*tmp_directory)) + "/",
		Hierarchy:  "user",
		Automount:  false,
		Filesystem: localFileSystem,
	})

	if err != nil {
		log.Println("Failed to initiate tmp storage directory: "+*tmp_directory, err.Error())
		return err
	}
	fsHandlers = append(fsHandlers, tmpHandler)

	//Load all the storage config from file
	rawConfig, err := ioutil.ReadFile(*storage_config_file)
	if err != nil {
		//File not found. Use internal storage only
		log.Println("Storage configuration file not found. Using internal storage only.")
	} else {
		//Configuration loaded. Initializing handler
		externalHandlers, err := fs.NewFileSystemHandlersFromJSON(rawConfig)
		if err != nil {
			log.Println("Failed to load storage configuration: " + err.Error() + " -- Skipping")
		} else {
			for _, thisHandler := range externalHandlers {
				fsHandlers = append(fsHandlers, thisHandler)
				log.Println(thisHandler.Name + " Mounted as " + thisHandler.UUID + ":/")
			}

		}
	}

	//Create a base storage pool for all users
	sp, err := storage.NewStoragePool(fsHandlers, "system")
	if err != nil {
		log.Println("Failed to create base Storaeg Pool")
		return err
	}

	//Update the storage pool permission to readwrite
	sp.OtherPermission = fsdef.FsReadWrite
	baseStoragePool = sp

	return nil
}

//Initialize group storage pool
func GroupStoragePoolInit() {
	//Mount permission groups
	for _, pg := range permissionHandler.PermissionGroups {
		//For each group, check does this group has a config file
		err := LoadStoragePoolForGroup(pg)
		if err != nil {
			continue
		}

		//Do something else, WIP
	}

	//Start editing interface for Storage Pool Editor
	StoragePoolEditorInit()
}

func LoadStoragePoolForGroup(pg *permission.PermissionGroup) error {
	expectedConfigPath := "./system/storage/" + pg.Name + ".json"
	if fs.FileExists(expectedConfigPath) {
		//Read the config file
		pgStorageConfig, err := os.ReadFile(expectedConfigPath)
		if err != nil {
			log.Println("Failed to read config for " + pg.Name + ": " + err.Error())
			return errors.New("Failed to read config for " + pg.Name + ": " + err.Error())
		}

		//Generate fsHandler form json
		thisGroupFsHandlers, err := fs.NewFileSystemHandlersFromJSON(pgStorageConfig)
		if err != nil {
			log.Println("Failed to load storage configuration: " + err.Error())
			return errors.New("Failed to load storage configuration: " + err.Error())
		}

		//Show debug message
		for _, thisHandler := range thisGroupFsHandlers {
			log.Println(thisHandler.Name + " Mounted as " + thisHandler.UUID + ":/ for group " + pg.Name)
		}

		//Create a storage pool from these handlers
		sp, err := storage.NewStoragePool(thisGroupFsHandlers, pg.Name)
		if err != nil {
			log.Println("Failed to create storage pool for " + pg.Name)
			return errors.New("Failed to create storage pool for " + pg.Name)
		}

		//Set other permission to denied by default
		sp.OtherPermission = fsdef.FsDenied

		//Assign storage pool to group
		pg.StoragePool = sp

	} else {
		//Storage configuration not exists. Fill in the basic information and move to next storage pool

		//Create a new empty storage pool for this group
		sp, err := storage.NewStoragePool([]*fs.FileSystemHandler{}, pg.Name)
		if err != nil {
			log.Println("Failed to create empty storage pool for group: ", pg.Name)
		}
		pg.StoragePool = sp
		pg.StoragePool.OtherPermission = fsdef.FsDenied
	}

	return nil
}

//Check if a storage pool exists by its group owner name
func StoragePoolExists(poolOwner string) bool {
	_, err := GetStoragePoolByOwner(poolOwner)
	return err == nil
}

func GetAllStoragePools() []*storage.StoragePool {
	//Append the base pool
	results := []*storage.StoragePool{baseStoragePool}

	//Add each permissionGroup's pool
	for _, pg := range permissionHandler.PermissionGroups {
		results = append(results, pg.StoragePool)
	}

	return results
}

func GetStoragePoolByOwner(owner string) (*storage.StoragePool, error) {
	sps := GetAllStoragePools()
	for _, pool := range sps {
		if pool.Owner == owner {
			return pool, nil
		}
	}
	return nil, errors.New("Storage pool owned by " + owner + " not found")
}

func GetFSHandlerSubpathFromVpath(vpath string) (*fs.FileSystemHandler, string, error) {
	VirtualRootID, subpath, err := fs.GetIDFromVirtualPath(vpath)
	if err != nil {
		return nil, "", errors.New("Unable to resolve requested path: " + err.Error())
	}

	fsh, err := GetFsHandlerByUUID(VirtualRootID)
	if err != nil {
		return nil, "", errors.New("Unable to resolve requested path: " + err.Error())
	}

	if fsh == nil || fsh.FileSystemAbstraction == nil {
		return nil, "", errors.New("Unable to resolve requested path: " + err.Error())
	}

	return fsh, subpath, nil
}

func GetFsHandlerByUUID(uuid string) (*fs.FileSystemHandler, error) {
	//Filter out the :/ fropm uuid if exists
	if strings.Contains(uuid, ":") {
		uuid = strings.Split(uuid, ":")[0]
	}
	var resultFsh *fs.FileSystemHandler = nil
	allFsh := GetAllLoadedFsh()
	for _, fsh := range allFsh {
		if fsh.UUID == uuid && !fsh.Closed {
			resultFsh = fsh
		}
	}
	if resultFsh == nil {
		return nil, errors.New("Filesystem handler with given UUID not found")
	} else {
		return resultFsh, nil
	}
}

func GetAllLoadedFsh() []*fs.FileSystemHandler {
	fshTmp := map[string]*fs.FileSystemHandler{}
	allFsh := []*fs.FileSystemHandler{}
	allStoragePools := GetAllStoragePools()
	for _, thisSP := range allStoragePools {
		for _, thisFsh := range thisSP.Storages {
			fshPointer := thisFsh
			fshTmp[thisFsh.UUID] = fshPointer
		}
	}

	//Restructure the map to slice
	for _, fsh := range fshTmp {
		allFsh = append(allFsh, fsh)
	}

	return allFsh
}

func RegisterStorageSettings() {
	//Storage Pool Configuration
	registerSetting(settingModule{
		Name:         "Storage Pools",
		Desc:         "Storage Pool Mounting Configuration",
		IconPath:     "SystemAO/disk/smart/img/small_icon.png",
		Group:        "Disk",
		StartDir:     "SystemAO/storage/poolList.html",
		RequireAdmin: true,
	})

}

//CloseAllStorages Close all storage database
func CloseAllStorages() {
	allFsh := GetAllLoadedFsh()
	for _, fsh := range allFsh {
		fsh.FilesystemDatabase.Close()
	}
}

func closeAllStoragePools() {
	for _, sp := range GetAllStoragePools() {
		sp.Close()
	}
}