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

package userspace

import (
	"fmt"

	"github.com/chzyer/readline"
	"github.com/inhies/go-bytesize"
	"github.com/spf13/cobra"
	"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"
)

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

func create(c *cobra.Command, ctx *cmd.CommandContext) {

	rl, err := readline.New("> ")
	if err != nil {
		fmt.Printf("初始化命令行失败: %v\n", err)
		return
	}
	defer rl.Close()

	var blder UserSpaceBuilder

	blder.Name = cmd.ReadString(rl, "请输入存储服务名称(Name)")

	stgTypes := []string{"Local", "OBS", "OSS", "COS", "EFile", "S3", "PubShards"}
	idx := cmd.SelectOne(rl, "请选择存储类型(StorageType)", stgTypes)

	switch stgTypes[idx] {
	case "Local":
		blder.AskLocal(rl)
	case "OBS":
		blder.AskOBS(rl)
	case "OSS":
		blder.AskOSS(rl)
	case "COS":
		blder.AskCOS(rl)
	case "EFile":
		blder.AskEFile(rl)
	case "S3":
		blder.AskS3(rl)
	case "PubShards":
		blder.AskPubShards(rl)
	}

	blder.AskShardStore(rl, false)

	blder.AskWorkingDir(rl)

	_, err = ctx.Client.UserSpace().Create(blder.UserSpaceCreate)
	if err != nil {
		fmt.Printf("\033[31m保存配置失败: %v\033[0m", err)
		return
	}
	fmt.Println("\033[32m配置保存成功!\033[0m")
}

type UserSpaceBuilder struct {
	api.UserSpaceCreate
}

func (b *UserSpaceBuilder) AskLocal(rl *readline.Instance) {
	b.Storage = &jcstypes.LocalType{
		Type: "Local",
		Location: jcstypes.Location{
			StorageName: cmd.ReadString(rl, "StorageName"),
			Location:    cmd.ReadString(rl, "Location"),
		},
	}
	b.Credential = &jcstypes.LocalCred{
		Type:    "Local",
		RootDir: cmd.ReadString(rl, "RootDir"),
	}
}

func (b *UserSpaceBuilder) AskOBS(rl *readline.Instance) {
	b.Storage = &jcstypes.OBSType{
		Type:      "OBS",
		Region:    cmd.ReadString(rl, "Region"),
		Endpoint:  cmd.ReadString(rl, "Endpoint"),
		Bucket:    cmd.ReadString(rl, "Bucket"),
		ProjectID: cmd.ReadString(rl, "ProjectID"),
	}
	b.Credential = &jcstypes.OBSCred{
		Type: "OBS",
		AK:   cmd.ReadString(rl, "AccessKeyID"),
		SK:   string(cmd.ReadPassword(rl, "AccessKeySecret")),
	}

	if cmd.ReadBool(rl, "是否支持存储服务间直传文件?") {
		b.Features = append(b.Features, &jcstypes.S2STransferFeature{
			Type: "S2STransfer",
		})
	}
}

func (b *UserSpaceBuilder) AskOSS(rl *readline.Instance) {
	b.Storage = &jcstypes.OSSType{
		Type:     "OSS",
		Region:   cmd.ReadString(rl, "Region"),
		Endpoint: cmd.ReadString(rl, "Endpoint"),
		Bucket:   cmd.ReadString(rl, "Bucket"),
	}
	b.Credential = &jcstypes.OSSCred{
		Type: "OSS",
		AK:   cmd.ReadString(rl, "AccessKeyID"),
		SK:   string(cmd.ReadPassword(rl, "SecretAccessKey")),
	}
}

func (b *UserSpaceBuilder) AskCOS(rl *readline.Instance) {
	b.Storage = &jcstypes.COSType{
		Type:     "COS",
		Region:   cmd.ReadString(rl, "Region"),
		Endpoint: cmd.ReadString(rl, "Endpoint"),
		Bucket:   cmd.ReadString(rl, "Bucket"),
	}
	b.Credential = &jcstypes.COSCred{
		Type: "COS",
		AK:   cmd.ReadString(rl, "AccessKeyID"),
		SK:   string(cmd.ReadPassword(rl, "SecretAccessKey")),
	}
}

func (b *UserSpaceBuilder) AskEFile(rl *readline.Instance) {
	b.Storage = &jcstypes.EFileType{
		Type:      "EFile",
		ClusterID: cmd.ReadString(rl, "ClusterID"),
	}
	b.Credential = &jcstypes.EFileCred{
		Type:        "EFile",
		TokenURL:    cmd.ReadString(rl, "TokenURL"),
		APIURL:      cmd.ReadString(rl, "APIURL"),
		TokenExpire: cmd.ReadIntRanged(rl, "TokenExpire", 60, 3600),
		User:        cmd.ReadString(rl, "User"),
		Password:    string(cmd.ReadPassword(rl, "Password")),
		OrgID:       cmd.ReadString(rl, "OrgID"),
	}

	if cmd.ReadBool(rl, "是否提供能进行EC计算的接口?") {
		b.Features = append(b.Features, &jcstypes.ECMultiplierFeature{
			Type: "ECMultiplier",
		})
	}
}

func (b *UserSpaceBuilder) AskS3(rl *readline.Instance) {
	b.Storage = &jcstypes.S3Type{
		Type:     "S3",
		Region:   cmd.ReadString(rl, "Region"),
		Endpoint: cmd.ReadString(rl, "Endpoint"),
		Bucket:   cmd.ReadString(rl, "Bucket"),
	}
	b.Credential = &jcstypes.S3Cred{
		Type: "S3",
		AK:   cmd.ReadString(rl, "AccessKeyID"),
		SK:   string(cmd.ReadPassword(rl, "SecretAccessKey")),
	}

	if cmd.ReadBool(rl, "是否支持分段上传?") {
		b.Features = append(b.Features, &jcstypes.MultipartUploadFeature{
			Type: "MultipartUpload",
		})
	}
}

func (u *UserSpaceBuilder) AskPubShards(rl *readline.Instance) {
	u.Storage = &jcstypes.PubShardsType{
		PubShardsID: jcstypes.PubShardsID(cmd.ReadString(rl, "共享分片存储ID")),
		Password:    string(cmd.ReadPassword(rl, "共享分片存储密码")),
	}
}

func (b *UserSpaceBuilder) AskShardStore(rl *readline.Instance, must bool) {
	if !must && !cmd.ReadBool(rl, "是否开启分片存储功能?") {
		return
	}

	var size bytesize.ByteSize
	cmd.ReadStringValue(rl, "分片存储最大容量", &size)
	b.ShardStore = &jcstypes.ShardStoreUserConfig{
		MaxSize: int64(size),
	}
}

func (b *UserSpaceBuilder) AskWorkingDir(rl *readline.Instance) {
	b.WorkingDir = cmd.ReadStringDef(rl, "工作目录", "jcs")
}