JCS-pub/jcsctl/cmd/userspace/update.go

package userspace

import (
	"fmt"
	"strconv"
	"strings"

	"github.com/chzyer/readline"
	"github.com/spf13/cobra"
	cliapi "gitlink.org.cn/cloudream/jcs-pub/client/sdk/api/v1"
	jcstypes "gitlink.org.cn/cloudream/jcs-pub/common/types"
	"gitlink.org.cn/cloudream/jcs-pub/jcsctl/cmd"
)

type UserSpaceUpdate struct {
	cliapi.UserSpaceUpdate
}

func init() {
	cmd := cobra.Command{
		Use:   "update",
		Short: "update a new cloud storage",
		Run: func(c *cobra.Command, args []string) {
			ctx := cmd.GetCmdCtx(c)
			update(c, ctx)
		},
	}
	UserSpaceCmd.AddCommand(&cmd)
}

func update(c *cobra.Command, ctx *cmd.CommandContext) {
	rl, err := readline.New("> ")
	if err != nil {
		fmt.Printf("\033[31m初始化命令行失败: %v\033[0m\n", err)
		return
	}
	defer rl.Close()

	rl.SetPrompt("\033[36m请输入云存储ID(ID): \033[0m")
	idInput, err := rl.Readline()
	if err != nil || idInput == "" {
		return
	}

	id, err := strconv.ParseInt(strings.TrimSpace(idInput), 10, 64)
	if err != nil {
		fmt.Printf("\033[31mID 格式错误: %v\033[0m\n", err)
		return
	}

	resp, err := ctx.Client.UserSpace().Get(cliapi.UserSpaceGet{
		UserSpaceID: jcstypes.UserSpaceID(id),
	})
	if err != nil {
		fmt.Printf("\033[31m云存储id=%d 不存在: %v\033[0m\n", id, err)
		return
	}

	rl.SetPrompt("\033[36m请输入修改后的存储服务名称(Name): \033[0m")
	name, err := rl.Readline()
	if err != nil {
		return
	}

	var userSpaceUpdate UserSpaceUpdate
	userSpaceUpdate.UserSpaceID = jcstypes.UserSpaceID(id)
	userSpaceUpdate.Name = name

	storageType := resp.UserSpace.Storage.GetStorageType()
	switch storageType {
	case "Local":
		err = userSpaceUpdate.collectLocalConfig(rl)
	case "OBS":
		err = userSpaceUpdate.collectObsConfig(rl)
	case "OSS":
		err = userSpaceUpdate.collectOssConfig(rl)
	case "COS":
		err = userSpaceUpdate.collectCosConfig(rl)
	case "EFile":
		err = userSpaceUpdate.collectEfileConfig(rl)
	case "S3":
		err = userSpaceUpdate.collectS3Config(rl)
	}
	if err != nil {
		return
	}

	_, err = ctx.Client.UserSpace().Update(userSpaceUpdate.UserSpaceUpdate)
	if err != nil {
		fmt.Printf("\033[31m更新配置失败: %v\033[0m", err)
		return
	}
	fmt.Println("\033[32m配置更新成功!\033[0m")
}

func (userSpace *UserSpaceUpdate) collectLocalConfig(rl *readline.Instance) error {
	rl.SetPrompt("\033[36m请输入RootDir: \033[0m")
	rootDir, err := rl.Readline()
	if err != nil {
		return err
	}

	userSpace.Credential = &jcstypes.LocalCred{
		Type:    "Local",
		RootDir: rootDir,
	}
	return nil
}

func (userSpace *UserSpaceUpdate) collectObsConfig(rl *readline.Instance) error {
	rl.SetPrompt("\033[36m请输入AccessKeyID: \033[0m")
	accessKey, err := rl.Readline()
	if err != nil {
		return err
	}

	secretBytes, err := rl.ReadPassword("\033[36m请输入AccessKeySecret: \033[0m")
	if err != nil {
		return err
	}
	secretKey := string(secretBytes)

	userSpace.Credential = &jcstypes.OBSCred{
		Type: "OBS",
		AK:   accessKey,
		SK:   secretKey,
	}

	for {
		rl.SetPrompt("\033[36m是否支持存储服务间直传文件？(y/n): \033[0m")
		input, err := rl.Readline()
		if err != nil {
			return err
		}

		switch strings.ToLower(strings.TrimSpace(input)) {
		case "y", "yes":
			userSpace.Features = append(userSpace.Features, &jcstypes.S2STransferFeature{
				Type: "S2STransfer",
			})
			return nil
		case "n", "no":
			userSpace.Features = nil
			return nil
		default:
			fmt.Println("\033[31m无效输入！请输入 y/n 或 yes/no \033[0m")
		}
	}
}

func (userSpace *UserSpaceUpdate) collectOssConfig(rl *readline.Instance) error {
	rl.SetPrompt("\033[36m请输入AccessKeyID: \033[0m")
	accessKey, err := rl.Readline()
	if err != nil {
		return err
	}

	secretBytes, err := rl.ReadPassword("\033[36m请输入AccessKeySecret: \033[0m")
	if err != nil {
		return err
	}
	secretKey := string(secretBytes)

	userSpace.Credential = &jcstypes.OSSCred{
		Type: "OSS",
		AK:   accessKey,
		SK:   secretKey,
	}
	return nil
}

func (userSpace *UserSpaceUpdate) collectCosConfig(rl *readline.Instance) error {
	rl.SetPrompt("\033[36m请输入AccessKeyID: \033[0m")
	accessKey, err := rl.Readline()
	if err != nil {
		return err
	}

	secretBytes, err := rl.ReadPassword("\033[36m请输入AccessKeySecret: \033[0m")
	if err != nil {
		return err
	}
	secretKey := string(secretBytes)

	userSpace.Credential = &jcstypes.COSCred{
		Type: "COS",
		AK:   accessKey,
		SK:   secretKey,
	}
	return nil
}

func (userSpace *UserSpaceUpdate) collectEfileConfig(rl *readline.Instance) error {
	rl.SetPrompt("\033[36m请输入TokenURL: \033[0m")
	tokenURL, err := rl.Readline()
	if err != nil {
		return err
	}

	rl.SetPrompt("\033[36m请输入APIURL: \033[0m")
	apiURL, err := rl.Readline()
	if err != nil {
		return err
	}

	tokenExpire := 0
	for {
		rl.SetPrompt("\033[36m请输入TokenExpire: \033[0m")
		valueInt, err := rl.Readline()
		if err != nil {
			return err
		}
		if strings.TrimSpace(valueInt) == "" {
			fmt.Println("\033[31m错误：输入不能为空，请输入正整数\033[0m")
			continue
		}
		num, err := strconv.ParseInt(valueInt, 10, 64)
		if err != nil {
			fmt.Printf("\033[31m错误：'%s' 不是有效整数，请输入正整数\033[0m\n", valueInt)
			continue
		}
		if num <= 0 {
			fmt.Printf("\033[31m错误：%d 不是正整数，请输入大于 0 的整数\033[0m\n", num)
			continue
		}
		tokenExpire = int(num)
		break
	}

	rl.SetPrompt("\033[36m请输入User: \033[0m")
	user, err := rl.Readline()
	if err != nil {
		return err
	}

	passwordBytes, err := rl.ReadPassword("\033[36m请输入Password: \033[0m")
	if err != nil {
		return err
	}
	password := string(passwordBytes)

	rl.SetPrompt("\033[36m请输入OrgID: \033[0m")
	orgID, err := rl.Readline()
	if err != nil {
		return err
	}

	userSpace.Credential = &jcstypes.EFileCred{
		Type:        "EFile",
		TokenURL:    tokenURL,
		APIURL:      apiURL,
		TokenExpire: tokenExpire,
		User:        user,
		Password:    password,
		OrgID:       orgID,
	}

	for {
		rl.SetPrompt("\033[36m是否提供能进行EC计算的接口？(y/n): \033[0m")
		input, err := rl.Readline()
		if err != nil {
			return err
		}

		switch strings.ToLower(strings.TrimSpace(input)) {
		case "y", "yes":
			userSpace.Features = append(userSpace.Features, &jcstypes.ECMultiplierFeature{
				Type: "ECMultiplier",
			})
			return nil
		case "n", "no":
			userSpace.Features = nil
			return nil
		default:
			fmt.Println("\033[31m无效输入！请输入 y/n 或 yes/no \033[0m")
		}
	}
}

func (userSpace *UserSpaceUpdate) collectS3Config(rl *readline.Instance) error {
	rl.SetPrompt("\033[36m请输入AccessKeyID: \033[0m")
	accessKey, err := rl.Readline()
	if err != nil {
		return err
	}

	secretBytes, err := rl.ReadPassword("\033[36m请输入AccessKeySecret: \033[0m")
	if err != nil {
		return err
	}
	secretKey := string(secretBytes)

	userSpace.Credential = &jcstypes.S3Cred{
		Type: "S3",
		AK:   accessKey,
		SK:   secretKey,
	}

	for {
		rl.SetPrompt("\033[36m是否支持分段上传？(y/n): \033[0m")
		input, err := rl.Readline()
		if err != nil {
			return err
		}

		switch strings.ToLower(strings.TrimSpace(input)) {
		case "y", "yes":
			userSpace.Features = append(userSpace.Features, &jcstypes.MultipartUploadFeature{
				Type: "MultipartUpload",
			})
			return nil
		case "n", "no":
			userSpace.Features = nil
			return nil
		default:
			fmt.Println("\033[31m无效输入！请输入 y/n 或 yes/no \033[0m")
		}
	}
}