package main

import (
    "fmt"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
    "os"
    "time"
)
// 第一步:获取所有需要转换的实例，详见 describeAllInstances getInstancesNum函数
// 第二步:转化公网IP为按量付费，详见 reduceNetwork 函数
// 第三步:将按量公网IP转化为弹性IP，详见 convertToEIP 函数
// 第四步：主函数调用，详见 main 函数

// 选取运行状态为Running 的实例
var STATUS = "Running"
// 设置实例列表接口分页查询每页 50 个
var PAGE_SIZE = "50"
// 灰度处理，仅对指定数量的实例进行转化
var TOTAL_SIZE = 2

// 网络付费类型为按量付费
var NETWORK_CHARGE_TYPE = "PayByTraffic"

func main() {
    // 生成 ecs 的操作工具，临时 access token 会在 Cloud Shell 中自动生成，可通过环境变量获取
    client, err := ecs.NewClientWithAccessKey("cn-beijing", os.Getenv("ACCESS_KEY_ID"), os.Getenv("ACCESS_KEY_SECRET"))
    if err != nil {
        fmt.Print(err.Error())
    }
    var instances []MyInstance
    // 取出所有需要转化的实例
    instances = describeAllInstances(client)
    // 手动设置一个实例进行转换
    //instances = append(instances, MyInstance{"iZ2ze9j5p0uyrr0iz3aq2nZ", 1})
    fmt.Printf("Number of instances processed : %d\n", len(instances))
    cutInstances := instances
    // 灰度处理，仅对指定数量的实例进行转化
    if TOTAL_SIZE > 0 && TOTAL_SIZE < len(instances){
        cutInstances = instances[:TOTAL_SIZE]
    }
    fmt.Printf("Number of instances actually processed : %d\n", len(cutInstances))
    reduceNetwork(client, cutInstances)
    time.Sleep(time.Duration(1)*time.Second)
    convertToEIP(client, cutInstances)
}

// 接受实例列表，将指定实例的公网IP转为弹性 IP
func convertToEIP(client *ecs.Client, instances []MyInstance) {
    for _, instance := range instances {
        request := ecs.CreateConvertNatPublicIpToEipRequest()
        request.Scheme = "https"
        request.InstanceId = instance.id
        response, err := client.ConvertNatPublicIpToEip(request)
        if err != nil {
            // 失败重试
            response, err = client.ConvertNatPublicIpToEip(request)
            if err != nil {
                fmt.Println(err.Error())
                // 再重试 
                time.Sleep(time.Duration(1)*time.Second)
                response, err = client.ConvertNatPublicIpToEip(request)
            }
        }
        fmt.Printf("The result status of converting to eip is %v, the instance\'s id is [%s]\n", response.IsSuccess(), instance.id)
    }
}
// 接受实例列表，将实例转为指定网络付费类型，与指定带宽值（对于按量，是带宽峰值）
func reduceNetwork(client *ecs.Client, instances []MyInstance) {
    for _, instance := range instances {
        request := ecs.CreateModifyInstanceNetworkSpecRequest()
        request.Scheme = "https"
        // 设置公网出口带宽
        request.InternetMaxBandwidthOut = requests.NewInteger(instance.bandWidth)
        // 设置要修改的实例id，每次只能修改一个
        request.InstanceId = instance.id
        // 设置公网付费类型
        request.NetworkChargeType = NETWORK_CHARGE_TYPE
        // 发起请求
        response, err := client.ModifyInstanceNetworkSpec(request)
        if err != nil {
            // 失败重试
            response, err = client.ModifyInstanceNetworkSpec(request)
            if err != nil {
                fmt.Print(err.Error())
                time.Sleep(time.Duration(1)*time.Second)
                // 再重试
                response, err = client.ModifyInstanceNetworkSpec(request)
            }
        }
        fmt.Printf("The result status of reducing instance\'s bandwidth is %v, the instance\'s id is [%s]\n", response.IsSuccess(), instance.id)
    }
}

// 根据固定好的条件查询所有相应实例，返回其实例 id 与公网带宽出口值
func describeAllInstances(client *ecs.Client) []MyInstance{
    num := getInstancesNum(client)
    fmt.Printf("total instance count: %d\n", num)
    // 存放所需的所有实例的id与带宽信息
    var shouldConvertInstance []MyInstance
    // 用于记录分页查询到了第几页
    var pageCount int
    // 分页查询所有实例
    for true {
        pageCount++
        
        request := ecs.CreateDescribeInstancesRequest()
        // 设置过滤条件
        request.Status = STATUS
        // 设置分页查询信息
        request.PageNumber = requests.NewInteger(pageCount)
        request.PageSize = requests.Integer(PAGE_SIZE)
        request.Scheme = "https"
        // 执行查询
        response, err := client.DescribeInstances(request)
        if err != nil {
            fmt.Print(err.Error())
        }
        // 取出实例列表
        instances := response.Instances.Instance

        if len(instances) == 0 {
            break
        }
        // 从本分页过滤并取出所需实例信息
        for _, instance := range instances {
            if len(instance.PublicIpAddress.IpAddress) == 0 {
                continue
            }
            shouldConvertInstance = append(shouldConvertInstance, MyInstance{instance.InstanceId, instance.InternetMaxBandwidthOut})
        }
        time.Sleep(time.Duration(2)*time.Second)
    }
    return shouldConvertInstance
}
// 获取实例正在运行的总数量
func getInstancesNum(client *ecs.Client) int {
    request := ecs.CreateDescribeInstancesRequest()
    request.Status = STATUS
    request.PageNumber = "1"
    request.PageSize = "1"
    request.Scheme = "https"
    response, err := client.DescribeInstances(request)
    if err != nil {
        fmt.Print(err.Error())
    }
    time.Sleep(time.Duration(2)*time.Second)
    return response.TotalCount
}

type MyInstance struct{
    id string
    bandWidth int
}