requests

Taocloud block storage api sdk (fass-sdk)

操作对象

示例

初始化配置

var (
    port           = 8000
    backoff        = 0
    retryCount     = 3
    readTimeout    = 30
    connectTimeout = 1
    endpointList   = []string{"172.18.165.200", "172.18.165.201", "172.18.165.202"}
)

fassSDK.InitConfig(
    &endpointList,
    &port,
    &readTimeout,
    &connectTimeout,
    &backoff,
    &retryCount,
)

获取存储池信息

package pool

import (    
    "fmt"
    
    "github.com/google/uuid"
    
    fassSDK "github.com/Vanishvei/fass-sdk"
    parameters "github.com/Vanishvei/fass-sdk-parameters"
    _ "github.com/Vanishvei/fass-sdk-responses"
    _ "github.com/Vanishvei/fass-sdk/test"
)

func RetrievePool() {
    parameter := parameters.RetrievePool{}
    parameter.SetPoolName(poolName)
    
    resp, err := fassSDK.RetrievePool(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s", err.Error())
        return
    }        
	
    fmt.Printf("%s\n", resp.Name)
    fmt.Printf("%v", resp)
}

创建subsys

func CreateSubsys() {
    parameter := parameters.CreateSubsys{}
    parameter.SetName("subsys001")
    parameter.SetPoolName("fast_pool")
    parameter.SetVolumeName("volume001")
    parameter.SetIops(2000)
    parameter.SetBpsMB(1000)
    parameter.SetCapacityGB(10)
    parameter.SetStripeWidth4Shift128k()
    parameter.SetSectorSize4096()
    parameter.SetFormatROW()
    parameter.EnableISCSI()

    resp, err := fassSDK.CreateSubsys(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s", err.Error())
        return
    }

    fmt.Printf("%s\n", resp.SubsysName)
    fmt.Printf("%v\n", resp)
}

获取subsys详细信息

func RetrieveSubsys() {
    parameter := parameters.RetrieveSubsys{}
    parameter.SetSubsysName(subsysName)

    resp, err := fassSDK.RetrieveSubsys(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s", err.Error())
        return 
    }
	
    fmt.Printf("%v\n", resp)
}

从快照创建subsys

func CreateSubsysFromSnapshot() {
    parameter := parameters.CreateSubsysFromSnapshot{}
    parameter.SetName("subsys002")
    parameter.SetPoolName("fast_pool")
    parameter.SetSrcVolumeName("volume001")
    parameter.SetSrcSnapshotName("snapshot001")
    parameter.InheritQos()
    parameter.EnableISCSI()

    resp, err := fassSDK.CreateSubsysFromSnapshot(&parameter, requestId)
    if err != nil {
        fmt.Printf("%s\n", err.Error())
        return
    }
    
    fmt.Printf("%v\n", resp)
}

subsys导出协议

func ExportSubsys() {
    parameter := parameters.ExportSubsys{}
    parameter.SetSubsysName("subsys001")
    parameter.ExportISCSI()

    err := fassSDK.ExportSubsys(&parameter, uuid.New().String())
    if err != nil {
    	fmt.Printf("%s", err.Error())
    	return
    }
}

subsys取消导出协议

func UnexportSubsys() {
	parameter := parameters.UnexportSubsys{}
	parameter.SetSubsysName("subsys001")
	parameter.UnexportISCSI()

	err := fassSDK.UnexportSubsys(&parameter, uuid.New().String())
    if err != nil {
    	fmt.Printf("%s", err.Error())
    	return
    }
}

删除subsys

func DeleteSubsys() error {
    parameter := parameters.DeleteSubsys{}
    parameter.SetSubsysName("subsys001")
    parameter.DeleteVolume()
    parameter.ForceDelete()

    err := fassSDK.DeleteSubsys(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s\n", err.Error())
    }
}

创建快照

func CreateSnapshot() {
    parameter := parameters.CreateSnapshot{}
    parameter.SetVolumeName("volume001)
    parameter.SetSnapshotName("snapshot001")
	
    resp, err := fassSDK.CreateSnapshot(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s", err.Error())
        return
    }
	
    fmt.Printf("%v\n", resp)
}

删除快照

func DeleteSnapshot() {
    parameter := parameters.DeleteSnapshot{}
    parameter.SetVolumeName("volume001")
    parameter.SetSnapshotName("snapshot001")
	
    err := fassSDK.DeleteSnapshot(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s\n", err.Error())
    }
}

设置卷的流控

func SetQosOfVolume() {
    parameter := parameters.SetQosOfVolume{}
    parameter.SetVolumeName("volume001")
    parameter.SetBpsMB(100)
    parameter.SetIops(1000)
    
    err := fassSDK.SetQosOfVolume(&parameter, uuid.New().String())
    if err != nil) {
    	fmt.Printf("%s\n", err.Error())
    }
}

卷扩容

func ExpandVolume() {
    parameter := parameters.ExpandVolume{}
    parameter.SetVolumeName("volume001")
    parameter.SetNewCapacityGB(20)

    err := fassSDK.ExpandVolume(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s", err.Error())
        return
    }
}

分离卷(仅对使用快照创建出来的卷和使用卷创建出来的卷可用)

func flattenVolume(volumeName string) (*responses.FlattenVolume, error) {
    parameter := parameters.FlattenVolume{}
    parameter.SetVolumeName("volume002")

    data, err := fassSDK.FlattenVolume(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s\n", err.Error())
    }
    
    fmt.Printf("task_id: %s\n", data.TaskId)    

查询卷分离进度

func FlattenVolumeProgress() {
    parameter := parameters.GetFlattenVolumeProgress{}
    parameter.SetTaskId(taskId)

    data, err := fassSDK.FlattenVolumeProgress(&parameter, uuid.New().String())
    if err != nil {
    	fmt.Printf("%s", err.Error())
    	return
    }
    
    if data.IsDone() {
    	fmt.Printf("volume flatten complete\n")
    	return
    }
    
    fmt.Printf("%s\n". data.Status)
}

停止卷分离

func StopFlattenVolume() {
    data, err := flattenVolume("volume002")
    if !reflect.DeepEqual(err, nil) {
    	fmt.Printf("%s", err.Error())
    	return 
    }

    parameter := parameters.StopFlattenVolume{}
    parameter.SetTaskId(data.TaskId)

    err := fassSDK.StopFlattenVolume(&parameter, uuid.New().String())
    if err != nil {
        fmt.Printf("%s", err.Error())
    	return 
    }
}

错误码