share.go

// Copyright 2021 Synology Inc.

package webapi

import (
	"encoding/json"
	"fmt"
	"net/url"
	"strconv"
	"time"

	log "github.com/sirupsen/logrus"
	"github.com/SynologyOpenSource/synology-csi/pkg/utils"
	"github.com/SynologyOpenSource/synology-csi/pkg/logger"
)

type ShareInfo struct {
	Name                string `json:"name"`                        // required
	VolPath             string `json:"vol_path"`                    // required
	Desc                string `json:"desc"`
	EnableShareCow      bool   `json:"enable_share_cow"`            // field for create
	EnableRecycleBin    bool   `json:"enable_recycle_bin"`
	RecycleBinAdminOnly bool   `json:"recycle_bin_admin_only"`
	Encryption          int    `json:"encryption"`                  // field for create
	QuotaForCreate      *int64 `json:"share_quota,omitempty"`
	QuotaValueInMB      int64  `json:"quota_value"`                 // field for get
	SupportSnapshot     bool   `json:"support_snapshot"`            // field for get
	Uuid                string `json:"uuid"`                        // field for get
	NameOrg             string `json:"name_org"`                    // required for clone
}

type ShareUpdateInfo struct {
	Name                string `json:"name"`                        // required
	VolPath             string `json:"vol_path"`                    // required
	QuotaForCreate      *int64 `json:"share_quota,omitempty"`
	// Add properties you want to update to shares here
}

type ShareSnapshotInfo struct {
	Uuid             string `json:"ruuid"`
	Time             string `json:"time"`
	Desc             string `json:"desc"`
	SnapSize         string `json:"snap_size"` // the complete size of the snapshot
	Lock             bool   `json:"lock"`
	ScheduleSnapshot bool   `json:"schedule_snapshot"`
}

type ShareCreateSpec struct {
	Name      string
	ShareInfo ShareInfo
}

type ShareCloneSpec struct {
	Name      string
	Snapshot  string
	ShareInfo ShareInfo
}

type ShareSnapshotCreateSpec struct {
	ShareName string
	Desc      string
	IsLocked  bool
}

type SharePermissionSetSpec struct {
	Name          string
	UserGroupType string            // "local_user"/"local_group"/"system"
	Permissions   []*SharePermission
}

type SharePermission struct {
	Name       string `json:"name"`
	IsReadonly bool   `json:"is_readonly"`
	IsWritable bool   `json:"is_writable"`
	IsDeny     bool   `json:"is_deny"`
	IsCustom   bool   `json:"is_custom,omitempty"`
	IsAdmin    bool   `json:"is_admin,omitempty"` // field for list
}

type NfsInfo struct {
	EnableNfs           bool   `json:"enable_nfs"`
	EnableNfsV4         bool   `json:"enable_nfs_v4"`
	NfsV4Domain         string `json:"nfs_v4_domain"`
	ReadSize            int    `json:"read_size"`
	SupportEncryptShare int    `json:"support_encrypt_share"`
	SupportMajorVer     int    `json:"support_major_ver"`
	SupportMinorVer     int    `json:"support_minor_ver"`
	UnixPriEnable       bool   `json:"unix_pri_enable"`
	WriteSize           int    `json:"write_size"`
}

func shareErrCodeMapping(errCode int, oriErr error) error {
	switch errCode {
	case 402: // No such share
		return utils.NoSuchShareError("")
	case 403: // Invalid input value
		return utils.BadParametersError("")
	case 3301: // already exists
		return utils.AlreadyExistError("")
	case 3309:
		return utils.ShareReachMaxCountError("")
	case 3328:
		return utils.ShareSystemBusyError("")
	}

	if errCode >= 3300 {
		return utils.ShareDefaultError{errCode}
	}
	return oriErr
}

// ----------------------- Share APIs -----------------------
func (dsm *DSM) ShareGet(shareName string) (ShareInfo, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share")
	params.Add("method", "get")
	params.Add("version", "1")
	params.Add("additional", "[\"encryption\", \"enable_share_cow\", \"recyclebin\", \"support_snapshot\", \"share_quota\"]")
	params.Add("name", strconv.Quote(shareName))

	info := ShareInfo{}

	resp, err := dsm.sendRequest("", &info, params, "webapi/entry.cgi")

	return info, shareErrCodeMapping(resp.ErrorCode, err)
}

func (dsm *DSM) ShareList() ([]ShareInfo, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share")
	params.Add("method", "list")
	params.Add("version", "1")
	params.Add("additional", "[\"encryption\", \"enable_share_cow\", \"recyclebin\", \"support_snapshot\", \"share_quota\"]")

	type ShareInfos struct {
		Shares []ShareInfo `json:"shares"`
	}

	resp, err := dsm.sendRequest("", &ShareInfos{}, params, "webapi/entry.cgi")
	if err != nil {
		return nil, shareErrCodeMapping(resp.ErrorCode, err)
	}

	infos, ok := resp.Data.(*ShareInfos)
	if !ok {
		return nil, fmt.Errorf("Failed to assert response to %T", &ShareInfos{})
	}

	return infos.Shares, nil
}

func (dsm *DSM) ShareCreate(spec ShareCreateSpec) error {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share")
	params.Add("method", "create")
	params.Add("version", "1")
	params.Add("name", strconv.Quote(spec.Name))

	js, err := json.Marshal(spec.ShareInfo)
	if err != nil {
		return err
	}
	params.Add("shareinfo", string(js))

	resp, err := dsm.sendRequest("", &struct{}{}, params, "webapi/entry.cgi")

	return shareErrCodeMapping(resp.ErrorCode, err)
}

func (dsm *DSM) ShareClone(spec ShareCloneSpec) (string, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share")
	params.Add("method", "clone")
	params.Add("version", "1")
	params.Add("name", strconv.Quote(spec.Name))

	// if clone from snapshot, the NameOrg must be the parent of the snapshot, or the webapi will return 3300
	// if the snapshot doesn't exist, it will return 3300 too.
	if spec.ShareInfo.NameOrg == "" {
		return "", fmt.Errorf("Clone failed. The source name can't be empty.")
	}

	if spec.Snapshot != "" {
		params.Add("snapshot", strconv.Quote(spec.Snapshot))
	}

	js, err := json.Marshal(spec.ShareInfo)
	if err != nil {
		return "", err
	}
	params.Add("shareinfo", string(js))

	type ShareCreateResp struct {
		Name string `json:"name"`
	}

	resp, err := dsm.sendRequest("", &ShareCreateResp{}, params, "webapi/entry.cgi")
	if err != nil {
		return "", shareErrCodeMapping(resp.ErrorCode, err)
	}

	shareResp, ok := resp.Data.(*ShareCreateResp)
	if !ok {
		return "", fmt.Errorf("Failed to assert response to %T", &ShareCreateResp{})
	}

	return shareResp.Name, nil
}

func (dsm *DSM) ShareDelete(shareName string) error {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share")
	params.Add("method", "delete")
	params.Add("version", "1")
	params.Add("name", fmt.Sprintf("[%s]", strconv.Quote(shareName)))

	resp, err := dsm.sendRequest("", &struct{}{}, params, "webapi/entry.cgi")

	return shareErrCodeMapping(resp.ErrorCode, err)
}

func (dsm *DSM) ShareSet(shareName string, updateInfo ShareUpdateInfo) error {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share")
	params.Add("method", "set")
	params.Add("version", "1")
	params.Add("name", strconv.Quote(shareName))

	js, err := json.Marshal(updateInfo)
	if err != nil {
		return err
	}
	params.Add("shareinfo", string(js))

	if logger.WebapiDebug {
		log.Debugln(params)
	}

	resp, err := dsm.sendRequest("", &struct{}{}, params, "webapi/entry.cgi")

	return shareErrCodeMapping(resp.ErrorCode, err)
}

func (dsm *DSM) SetShareQuota(shareInfo ShareInfo, newSizeInMB int64) error {
	updateInfo := ShareUpdateInfo{
		Name:           shareInfo.Name,
		VolPath:        shareInfo.VolPath,
		QuotaForCreate: &newSizeInMB,
	}
	return dsm.ShareSet(shareInfo.Name, updateInfo)
}

// ----------------------- Share Snapshot APIs -----------------------
func (dsm *DSM) ShareSnapshotCreate(spec ShareSnapshotCreateSpec) (string, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share.Snapshot")
	params.Add("method", "create")
	params.Add("version", "1")
	params.Add("name", strconv.Quote(spec.ShareName))

	type SnapInfo struct {
		Desc     string `json:"desc"`
		IsLocked bool   `json:"lock"` // default true
	}

	snapinfo := SnapInfo{
		Desc:     spec.Desc,
		IsLocked: spec.IsLocked,
	}
	js, err := json.Marshal(snapinfo)
	if err != nil {
		return "", err
	}
	params.Add("snapinfo", string(js))

	var snapTime string
	resp, err := dsm.sendRequest("", &snapTime, params, "webapi/entry.cgi")
	if err != nil {
		return "", shareErrCodeMapping(resp.ErrorCode, err)
	}

	return snapTime, nil // "GMT+08-2022.01.14-19.18.29"
}

func (dsm *DSM) ShareSnapshotList(name string) ([]ShareSnapshotInfo, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share.Snapshot")
	params.Add("method", "list")
	params.Add("version", "2")
	params.Add("name", strconv.Quote(name))
	params.Add("additional", "[\"desc\", \"lock\", \"schedule_snapshot\", \"ruuid\", \"snap_size\"]")

	type Infos struct {
		Snapshots []ShareSnapshotInfo `json:"snapshots"`
		Total     int                 `json:"total"`
	}

	resp, err := dsm.sendRequest("", &Infos{}, params, "webapi/entry.cgi")
	if err != nil {
		return nil, shareErrCodeMapping(resp.ErrorCode, err)
	}

	infos, ok := resp.Data.(*Infos)
	if !ok {
		return nil, fmt.Errorf("Failed to assert response to %T", &Infos{})
	}

	return infos.Snapshots, nil
}

func (dsm *DSM) ShareSnapshotDelete(snapTime string, shareName string) error {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share.Snapshot")
	params.Add("method", "delete")
	params.Add("version", "1")
	params.Add("name", strconv.Quote(shareName))
	params.Add("snapshots", fmt.Sprintf("[%s]", strconv.Quote(snapTime))) // ["GMT+08-2022.01.14-19.18.29"]

	var objmap []map[string]interface{}
	resp, err := dsm.sendRequest("", &objmap, params, "webapi/entry.cgi")
	if err != nil {
		return shareErrCodeMapping(resp.ErrorCode, err)
	}

	if len(objmap) > 0 {
		return fmt.Errorf("Failed to delete snapshot, API common error. snapshot: %s", snapTime)
	}

	return nil
}

// ----------------------- Share Permission APIs -----------------------
func (dsm *DSM) SharePermissionSet(spec SharePermissionSetSpec) error {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share.Permission")
	params.Add("method", "set")
	params.Add("version", "1")
	params.Add("name", strconv.Quote(spec.Name))
	params.Add("user_group_type", strconv.Quote(spec.UserGroupType))

	js, err := json.Marshal(spec.Permissions)
	if err != nil {
		return err
	}
	params.Add("permissions", string(js))

	if logger.WebapiDebug {
		log.Debugln(params)
	}

	resp, err := dsm.sendRequest("", &struct{}{}, params, "webapi/entry.cgi")

	return shareErrCodeMapping(resp.ErrorCode, err)
}

func (dsm *DSM) SharePermissionList(shareName string, userGroupType string) ([]SharePermission, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.Share.Permission")
	params.Add("method", "list")
	params.Add("version", "1")
	params.Add("name", strconv.Quote(shareName))
	params.Add("user_group_type", strconv.Quote(userGroupType))

	type SharePermissions struct {
		Permissions []SharePermission `json:"items"`
	}

	resp, err := dsm.sendRequest("", &SharePermissions{}, params, "webapi/entry.cgi")
	if err != nil {
		return nil, shareErrCodeMapping(resp.ErrorCode, err)
	}

	infos, ok := resp.Data.(*SharePermissions)
	if !ok {
		return nil, fmt.Errorf("Failed to assert response to %T", &SharePermissions{})
	}

	return infos.Permissions, nil
}

// ----------------------- FileServ NFS SharePrivilege APIs -----------------------
type SecurityFlavor struct {
	Kerbros          bool `json:"kerberos"`
	KerbrosIntegrity bool `json:"kerberos_integrity"`
	KerbrosPrivacy   bool `json:"kerberos_privacy"`
	Sys              bool `json:"sys"`
}

type PrivilegeRule struct {
	Async          bool           `json:"async"`
	Client         string         `json:"client"`
	Crossmnt       bool           `json:"crossmnt"`
	Insecure       bool           `json:"insecure"`
	Privilege      string         `json:"privilege"`
	RootSquash     string         `json:"root_squash"`
	SecurityFlavor SecurityFlavor `json:"security_flavor"`
}

type SharePrivilege struct {
	ShareName string          `json:"share_name"`
	Rule      []PrivilegeRule `json:"rule"`
}

func (dsm *DSM) ShareNfsPrivilegeSave(privilege SharePrivilege) error {
	params := url.Values{}
	params.Add("api", "SYNO.Core.FileServ.NFS.SharePrivilege")
	params.Add("method", "save")
	params.Add("share_name", strconv.Quote(privilege.ShareName))
	params.Add("version", "1")

	js, err := json.Marshal(privilege.Rule)
	if err != nil {
		return err
	}
	params.Add("rule", string(js))

	// DSM error 2370 means the NFS subsystem is temporarily busy.
	// Under concurrent PVC creation (e.g. Kasten K10 restore) the NFS
	// subsystem serialises updates and can transiently reject calls.
	// Retry with exponential back-off (capped at 10s) before giving up.
	// NodeStageVolume has a multi-minute Kubernetes timeout so we have
	// enough headroom to wait ~45s total across 8 attempts.
	const maxRetries = 11
	const maxDelay = 10 * time.Second
	delay := 500 * time.Millisecond
	for attempt := 1; attempt <= maxRetries; attempt++ {
		resp, reqErr := dsm.sendRequest("", &struct{}{}, params, "webapi/entry.cgi")
		if reqErr == nil {
			return nil
		}
		if resp.ErrorCode == 2370 {
			if attempt == maxRetries {
				break
			}
			log.Warnf("NFS subsystem busy for share [%s] (attempt %d/%d), retrying in %v",
				privilege.ShareName, attempt, maxRetries, delay)
			time.Sleep(delay)
			delay *= 2
			if delay > maxDelay {
				delay = maxDelay
			}
			continue
		}
		return reqErr
	}
	return utils.NfsSystemBusyError(
		fmt.Sprintf("share [%s]: NFS subsystem still busy after %d attempts", privilege.ShareName, maxRetries),
	)
}

func (dsm *DSM) ShareNfsPrivilegeLoad(shareName string) (SharePrivilege, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.FileServ.NFS.SharePrivilege")
	params.Add("method", "load")
	params.Add("share_name", strconv.Quote(shareName))
	params.Add("version", "1")

	info := SharePrivilege{}
	_, err := dsm.sendRequest("", &info, params, "webapi/entry.cgi")
	if err != nil {
		return SharePrivilege{}, err
	}

	return info, nil
}

func (dsm *DSM) NfsGet() (NfsInfo, error) {
	params := url.Values{}
	params.Add("api", "SYNO.Core.FileServ.NFS")
	params.Add("method", "get")
	params.Add("version", "2")

	info := NfsInfo{}
	_, err := dsm.sendRequest("", &info, params, "webapi/entry.cgi")
	if err != nil {
		return NfsInfo{}, err
	}

	return info, nil
}

func (dsm *DSM) NfsSet(enableV3 bool, enableV4 bool, enabledMinorVer int) error {
	params := url.Values{}
	params.Add("api", "SYNO.Core.FileServ.NFS")
	params.Add("method", "set")
	params.Add("version", "2")

	params.Add("enable_nfs", strconv.FormatBool(enableV3))
	params.Add("enable_nfs_v4", strconv.FormatBool(enableV4))
	params.Add("enabled_minor_ver", strconv.Itoa(enabledMinorVer))

	_, err := dsm.sendRequest("", &struct{}{}, params, "webapi/entry.cgi")
	if err != nil {
		return err
	}

	return nil
}