gitlab.nesad.fit.vutbr.cz/blended/libblended@v0.0.0-20221202124402-2bee159339df/catalog/catalog.go

package catalog

import (
	shell "github.com/ipfs/go-ipfs-api"
	"github.com/jinzhu/gorm"
	"gitlab.nesad.fit.vutbr.cz/blended/libblended/catalog/models"
	"gitlab.nesad.fit.vutbr.cz/blended/libblended/errors"
	"gitlab.nesad.fit.vutbr.cz/blended/libblended/ipfs"
	"path/filepath"
	"strings"
)

type Catalog struct {
	db   Database
	ipfs ipfs.IpfsClient
}

func NewCatalogClient(db Database, ipfs ipfs.IpfsClient) *Catalog {
	c := new(Catalog)
	c.db = db
	c.ipfs = ipfs

	return c
}
func (c *Catalog) Add(catalogPath string, filesystemPath string, override bool, ignoreLock bool, progressCallback func(event ipfs.ProgressEvent)) (*models.Resource, error) {
	if catalogPath != "" {
		if !override {
			exists, err := c.catalogPathExists(catalogPath)
			if err != nil {
				return nil, err
			}
			if exists {
				return nil, errors.Newf("Path %s already exists. Use override flag to replace it.", catalogPath)
			}
		}

		// lock resource if it is already in catalog.
		name, _ := c.splitPathToNameAndPath(catalogPath)
		exists, err := c.resourceExists(name)
		if err != nil {
			return nil, err
		}

		if exists {
			err = c.tryLockResource(name, ignoreLock)
			if err != nil {
				return nil, err
			}
			defer c.unlockResource(name)
		}
	}

	// upload file/dir to IPFS and get its hash
	result, err := c.ipfs.Add(filesystemPath, progressCallback)
	if err != nil {
		return nil, err
	}

	var resource *models.Resource
	// adding to catalog subfolder
	if catalogPath != "" {
		resource, err = c.move(catalogPath, result.Hash, override)
		if err != nil {
			return nil, err
		}
	} else {
		// adding to the catalog root
		// create new resource or update old one if exists
		exists, err := c.resourceExists(result.Name)
		if err != nil {
			return nil, err
		}

		if exists {
			resource, err = c.getDbModelByName(result.Name)
			if err != nil {
				return nil, err
			}
			resource.Hash = result.Hash
			resource.Size = result.Size
			err = c.db.Update(&resource)
		} else {
			stat, err := c.ipfs.Stat(result.Hash)
			if err != nil {
				return nil, err
			}

			resource = &models.Resource{Name: result.Name, Hash: result.Hash, Size: result.Size, Type: stat.GetType()}
			err = c.db.Create(&resource)
		}

		if err != nil {
			return nil, err
		}
	}
	err = c.ipfs.Shell.Pin(resource.Hash)
	if err != nil {
		return nil, err
	}

	return resource, nil
}

func (c *Catalog) Link(catalogPath string, ipfsHash string, override bool, ignoreLock bool) (*models.Resource, error) {
	// lock resource if it is already in catalog.
	name, _ := c.splitPathToNameAndPath(catalogPath)
	exists, err := c.resourceExists(name)
	if err != nil {
		return nil, err
	}

	if exists {
		err = c.tryLockResource(name, ignoreLock)
		if err != nil {
			return nil, err
		}
		defer c.unlockResource(name)
	}

	return c.move(catalogPath, ipfsHash, override)
}

func (c *Catalog) move(catalogPath string, ipfsHash string, override bool) (*models.Resource, error) {
	name, path := c.splitPathToNameAndPath(catalogPath)

	exists, err := c.resourceExists(name)
	if err != nil {
		return nil, err
	}

	var resource *models.Resource
	// nothing with that name is in catalog yet
	if !exists {
		emptyFolderHash, err := c.ipfs.CreateEmptyFolder()
		if err != nil {
			return nil, err
		}

		hash, err := c.ipfs.Move(emptyFolderHash, path, ipfsHash)
		if err != nil {
			return nil, err
		}

		stat, err := c.ipfs.Stat(ipfsHash)
		if err != nil {
			return nil, err
		}

		// create new resource
		if name == "" {
			name = hash
		}
		resource = &models.Resource{Name: name, Hash: hash, Size: int64(stat.CumulativeSize), Type: stat.GetType()}
		err = c.db.Create(resource)
	} else {
		resource, err = c.getDbModelByName(name)
		if err != nil {
			return nil, err
		}

		// resource with that name already exists. Add path to its hash.
		if !override {
			exists, err := c.catalogPathExists(catalogPath)
			if err != nil {
				return nil, err
			}
			if exists {
				return nil, errors.Newf("Path %s already exists. Use override flag to replace it.", catalogPath)
			}
		}

		hash, err := c.ipfs.Move(resource.Hash, path, ipfsHash)
		if err != nil {
			return nil, err
		}

		_ = c.ipfs.Shell.Unpin(resource.Hash)

		// update the resource hash. Do not create new resource
		resource.Hash = hash
		err = c.db.Update(resource)
	}

	return resource, err

}

func (c *Catalog) Remove(path string, ignoreLock bool) (*models.Resource, error) {
	ipfsPath, err := c.getIpfsPathFromCatalogPath(path)
	if err != nil {
		return nil, err
	}

	// lock resource
	name, _ := c.splitPathToNameAndPath(path)
	exists, err := c.resourceExists(name)
	if err != nil {
		return nil, err
	}

	if exists {
		err = c.tryLockResource(name, ignoreLock)
		if err != nil {
			return nil, err
		}
		defer c.unlockResource(name)
	}

	newHash, err := c.ipfs.Remove(ipfsPath)
	if err != nil {
		return nil, err
	}

	resource, err := c.getDbModelByName(name)
	if err != nil {
		return nil, err
	}

	_ = c.ipfs.Shell.Unpin(resource.Hash)

	// removed from catalog root - need to delete whole resource record
	if newHash == "" {
		err = c.db.Delete(resource)
		return nil, err
	} else {
		// removed from catalog subfolder - need to update resource hash

		err = c.ipfs.Shell.Pin(newHash)
		if err != nil {
			return nil, err
		}

		resource.Hash = newHash
		err = c.db.Update(resource)
		return resource, err
	}
}

func (c *Catalog) Download(name string, outdir string, progressCallback func(event ipfs.ProgressEvent)) error {
	hash, err := c.getIpfsPathFromCatalogPath(name)
	if err != nil {
		return err
	}
	return c.ipfs.Download(hash, outdir, progressCallback)
}

func (c *Catalog) Ls(name string) ([]*shell.LsLink, error) {
	if name == "" {
		var results []*shell.LsLink
		_, err := c.db.Query(func(db *gorm.DB) *gorm.DB {
			return db.Find(&[]models.Resource{}).Scan(&results)
		})
		if err != nil {
			return nil, err
		}

		return results, nil

	} else {
		hash, err := c.getIpfsPathFromCatalogPath(name)
		if err != nil {
			return nil, err
		}
		links, err := c.ipfs.Ls(hash)
		if err != nil {
			return nil, err
		}

		return links, nil
	}
}

func (c *Catalog) getIpfsPathFromCatalogPath(path string) (string, error) {
	if path == "" {
		return "", errors.New("Empty catalog path")
	}
	catalogName, restOfIpfsPath := c.splitPathToNameAndPath(path)

	resource, err := c.getDbModelByName(catalogName)
	if err != nil {
		return "", err
	}

	return filepath.ToSlash(c.ipfs.JoinPaths(resource.Hash, restOfIpfsPath)), nil
}

func (c *Catalog) getDbModelByName(name string) (*models.Resource, error) {
	var result models.Resource
	_, err := c.db.Query(func(db *gorm.DB) *gorm.DB {
		return db.Where("name = ?", name).First(&result)
	})

	if err != nil {
		return nil, err
	}

	return &result, nil
}

func (c *Catalog) resourceExists(name string) (bool, error) {
	_, err := c.getDbModelByName(name)
	if err != nil {
		if gorm.IsRecordNotFoundError(err) {
			return false, nil
		}
		return false, err
	}

	return true, nil
}

func (c *Catalog) catalogPathExists(path string) (bool, error) {
	// check if path already exists
	name, _ := c.splitPathToNameAndPath(path)
	exists, err := c.resourceExists(name)
	if err != nil {
		return false, err
	}

	if exists {
		ipfsPath, err := c.getIpfsPathFromCatalogPath(path)
		if err != nil {
			return false, err
		}

		_, err = c.ipfs.Stat(ipfsPath)
		if err == nil {
			return true, nil
		}
	}
	return false, nil
}

// set locked flag to the resource
func (c *Catalog) tryLockResource(name string, ignoreAlreadyLockError bool) error {
	locked, err := c.isResourceLocked(name)
	if err != nil {
		return err
	}
	if locked && !ignoreAlreadyLockError {
		return errors.Newf("Resource %s is locked. Some other user is currently modifying it. You can use ignore-lock flag to suppress this error.", name)
	}
	_, err = c.db.Query(func(db *gorm.DB) *gorm.DB {
		return db.Model(models.Resource{}).Where("name = ?", name).Update(models.Resource{Locked: true})
	})
	if err != nil {
		return err
	}
	return nil
}

// remove locked flag from the resource
func (c *Catalog) unlockResource(name string) error {
	_, err := c.db.Query(func(db *gorm.DB) *gorm.DB {
		// WARNING when update with struct, GORM will only update those fields that with non blank value
		// If we use models.Resource{Locked: false}, nothing will be updated as false is blank value of bool
		return db.Model(models.Resource{}).Where("name = ?", name).Update("locked", false)
	})
	if err != nil {
		return err
	}
	return nil
}

// determines if the resource is locked
func (c *Catalog) isResourceLocked(name string) (bool, error) {
	var result models.Resource
	_, err := c.db.Query(func(db *gorm.DB) *gorm.DB {
		return db.Where("name = ?", name).First(&result)
	})

	if err != nil {
		return false, err
	}

	return result.Locked, nil
}

// Splits catalog path to catalog name and rest of the path
// Example: /a/b/c/d -> a , b/c/d
// 			/a/ -> a , ""
func (c *Catalog) splitPathToNameAndPath(catalogPath string) (string, string) {
	nameAndPath := strings.SplitN(catalogPath, "/", 2)
	if len(nameAndPath) > 1 {
		return nameAndPath[0], nameAndPath[1]
	} else {
		return nameAndPath[0], ""
	}
}