Golang EC2.DescribeSubnets方法代码示例

func getAzFromSubnetId(subnetId string, conn *ec2.EC2) (string, error) {
	input := ec2.DescribeSubnetsInput{
		SubnetIds: []*string{aws.String(subnetId)},
	}
	out, err := conn.DescribeSubnets(&input)
	if err != nil {
		return "", err
	}

	if l := len(out.Subnets); l != 1 {
		return "", fmt.Errorf("Expected exactly 1 subnet returned for %q, got: %d", subnetId, l)
	}

	return *out.Subnets[0].AvailabilityZone, nil
}

// Gets a slice of subnets from the API for the specified VPC
func getSubnetsInVPC(vpcid string, ec2client *ec2.EC2) ([]*ec2.Subnet, error) {
	subnetReq := ec2.DescribeSubnetsInput{
		Filters: []*ec2.Filter{
			{
				Name: aws.String("vpc-id"),
				Values: []*string{
					aws.String(vpcid),
				},
			},
		},
	}

	subnetResp, err := ec2client.DescribeSubnets(&subnetReq)
	if err != nil {
		return []*ec2.Subnet{}, err
	}

	return subnetResp.Subnets, nil
}

func validateSubnet(ec2Client *ec2.EC2, subnet *providers.Subnet, providerConfig *providers.JSONObject, createIfNotFound bool) (success bool, warnings []string, err []error) {
	//Query for Subnet by Name
	filters := []*ec2.Filter{newEc2Filter("tag:"+nameTag, subnet.SubnetName)}
	params := &ec2.DescribeSubnetsInput{Filters: filters}
	subnetDescribeOutput, callErr := ec2Client.DescribeSubnets(params)
	if callErr != nil {
		err = append(err, callErr)
		success = false
	} else {
		if len(subnetDescribeOutput.Subnets) == 0 {
			//Subnet does not exists
			if createIfNotFound {
				//create subnet
				createSubnetSuccess, createSubnetWarnings, createSubnetErrors := addSubnet(ec2Client, subnet, providerConfig)
				if createSubnetSuccess {
					success = true
					for w := range createSubnetWarnings {
						warnings = append(warnings, createSubnetWarnings[w])
					}
				} else {
					success = false
					for e := range createSubnetErrors {
						err = append(err, createSubnetErrors[e])
					}
				}
			} else {
				err = append(err, errors.New("Subnet does not exist and create if not found is false"))
				success = false
			}
		} else {
			//subnet exists
			success = true
		}
	}

	return success, warnings, err
}

// SubnetStateRefreshFunc returns a resource.StateRefreshFunc that is used to watch a Subnet.
func SubnetStateRefreshFunc(conn *ec2.EC2, id string) resource.StateRefreshFunc {
	return func() (interface{}, string, error) {
		resp, err := conn.DescribeSubnets(&ec2.DescribeSubnetsInput{
			SubnetIds: []*string{aws.String(id)},
		})
		if err != nil {
			if ec2err, ok := err.(awserr.Error); ok && ec2err.Code() == "InvalidSubnetID.NotFound" {
				resp = nil
			} else {
				log.Printf("Error on SubnetStateRefresh: %s", err)
				return nil, "", err
			}
		}

		if resp == nil {
			// Sometimes AWS just has consistency issues and doesn't see
			// our instance yet. Return an empty state.
			return nil, "", nil
		}

		subnet := resp.Subnets[0]
		return subnet, *subnet.State, nil
	}
}

func verifyAndCreateVPC(c *ec2.EC2, config *Config) error {

	dvi := &ec2.DescribeVpcsInput{}
	dvo, err := c.DescribeVpcs(dvi)
	if err != nil {
		return err
	}

	vpc := &ec2.Vpc{}
	vpcexists := false
	for i := range dvo.Vpcs {
		if *dvo.Vpcs[i].CidrBlock == config.VPC {
			vpc = dvo.Vpcs[i]
			vpcexists = true
			config.VpcId = *dvo.Vpcs[i].VpcId
			//fmt.Println("VPC already exists.")
		}
	}

	if vpcexists {

		err = createSecurityGroups(c, config)
		if err != nil {
			fmt.Println("Failed to create security groups.")
			panic(err)
		}

		/*
			sgids := getSecurityGroupIds(c,config,
			err = applySecurityGroups(c, config)
			if err != nil {
				fmt.Println("Failed to apply security groups.")
				panic(err)
			}
		*/

		dsi := &ec2.DescribeSubnetsInput{}
		dso, err := c.DescribeSubnets(dsi)
		if err != nil {
			panic(err)
		}

		haspriv := false
		haspub := false
		for i := range dso.Subnets {
			if *dso.Subnets[i].CidrBlock == config.PublicNet {
				//fmt.Println("Subnet for public VPC already exists.")
				config.PublicSubnetId = *dso.Subnets[i].SubnetId
				haspub = true
				continue
			}

			if *dso.Subnets[i].CidrBlock == config.PrivateNet {
				//fmt.Println("Subnet for private VPC already exists.")
				config.PrivateSubnetId = *dso.Subnets[i].SubnetId
				haspriv = true
				continue
			}
		}

		if haspub && haspriv {
			return nil
		}

		cso1, cso2, err := createSubnets(c, config)
		if err != nil {
			panic(err)
		}
		config.PublicSubnetId = *cso1.Subnet.SubnetId
		config.PrivateSubnetId = *cso2.Subnet.SubnetId

		_, err = createPrivateRouteTable(c, config)
		if err != nil {
			panic(err)
		}

		return createGateway(c, vpc, cso1.Subnet.SubnetId)

	}

	cvi := &ec2.CreateVpcInput{CidrBlock: &config.VPC}
	cvo, err := c.CreateVpc(cvi)

	if err != nil {
		return err
	}
	config.VpcId = *cvo.Vpc.VpcId
	fmt.Println("Created new VPC: " + config.VpcId)

	//fmt.Println(cvo)
	err = createSecurityGroups(c, config)
	if err != nil {
		fmt.Println("Failed to create security groups.")
		panic(err)
	}

	/*
		err = applySecurityGroups(c, config)
		if err != nil {
			fmt.Println("Failed to apply security groups.")
//.........这里部分代码省略.........