go-gophercloud-test

package main

import (
	"errors"
	"fmt"
	"log"

	"github.com/gophercloud/gophercloud"
	"github.com/gophercloud/gophercloud/openstack"
	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/keypairs"
	"github.com/gophercloud/gophercloud/openstack/compute/v2/flavors"
	"github.com/gophercloud/gophercloud/openstack/compute/v2/images"
	"github.com/gophercloud/gophercloud/openstack/compute/v2/servers"
	"github.com/gophercloud/gophercloud/openstack/networking/v2/networks"
)

func GetIDByName(client *gophercloud.ServiceClient, Type string, Name string) (string, error) {

	switch Type {
	case "flavor":
		pages, err := flavors.ListDetail(client, nil).AllPages()
		if err != nil {
			return "", err
		}
		flavorList, err := flavors.ExtractFlavors(pages)
		for _, flavor := range flavorList {
			if flavor.Name == Name {
				return flavor.ID, nil
			}
		}
	case "image":
		pages, err := images.ListDetail(client, images.ListOpts{Name: Name}).AllPages()
		if err != nil {
			return "", err
		}
		imageList, err := images.ExtractImages(pages)
		if err != nil {
			return "", err
		}
		if len(imageList) > 1 {
			return "", errors.New(fmt.Sprintf("multiple images with name : %s", Name))
		} else if len(imageList) == 0 {
			return "", errors.New(fmt.Sprintf("not found with name : %s", Name))
		}
		return imageList[0].ID, nil
	case "server":
		pages, err := servers.List(client, nil).AllPages()
		if err != nil {
			return "", err
		}
		serverList, err := servers.ExtractServers(pages)
		for _, server := range serverList {
			if server.Name == Name {
				return server.ID, nil
			}
		}
	case "keypair":
		pages, err := keypairs.List(client, nil).AllPages()
		if err != nil {
			return "", err
		}
		keypairList, err := keypairs.ExtractKeyPairs(pages)
		for _, keypair := range keypairList {
			if keypair.Name == Name {
				return keypair.PublicKey, nil
			}
		}
	case "network":
		pages, err := networks.List(client, nil).AllPages()
		if err != nil {
			return "", err
		}
		networkList, err := networks.ExtractNetworks(pages)
		for _, network := range networkList {
			if network.Name == Name {
				return network.ID , nil
			}
		}
	}
}

	// return "", errors.New(fmt.Sprintf("could not found Flavor with name %s ", Name))
	return "", nil
}

func main() {
	fmt.Println("Hello")

	_ENDPOINT := "http://192.168.160.200:5000/v3"
	_USERNAME := "taking"
	_PASSWORD := "taking"

	// TODO: 추후 개별 struct 만들어서 넣기
	opts := gophercloud.AuthOptions{
		IdentityEndpoint: _ENDPOINT,
		Username:         _USERNAME,
		Password:         _PASSWORD,
		DomainName:       "default",
	}

	client, err := openstack.AuthenticatedClient(opts)
	if err != nil {
		panic(err)
	}

	fmt.Println("[#1]client Token : ", client.TokenID)

	eo := gophercloud.EndpointOpts{
		Type:   "compute",
		Region: "RegionOne",
	}
	compute, err := openstack.NewComputeV2(client, eo)
	if err != nil {
		panic(err)
	}

	fmt.Println("[#2]compute : ", compute)

	// listOpts := servers.ListOpts{}
	// pager := servers.List(compute, listOpts)
	// pager.EachPage(func(page pagination.Page) (bool, error) {
	// 	serverList, err := servers.ExtractServers(page)
	// 	if err != nil {
	// 		return false, err
	// 	}
	// 	for _, server := range serverList {
	// 		fmt.Printf("%v\n", server)
	// 	}
	// 	return true, nil
	// })

	flavorID, err := GetIDByName(compute, "flavor", "m1.medium")

	if err != nil {
		log.Println(err)
	}

	fmt.Println("flavorID :", flavorID)

	serverID, err := GetIDByName(compute, "server", "public_ip-1")

	if err != nil {
		log.Println(err)
	}

	fmt.Println("serverID :", serverID)

	keypair, err := GetIDByName(compute, "keypair", "taking")

	if err != nil {
		log.Println(err)
	}

	fmt.Println("keypair :", keypair)

	imageID, err := GetIDByName(compute, "image", "Ubuntu-20.04.4")

	if err != nil {
		log.Println(err)
	}

	fmt.Println("imageID :", imageID)

	//networkID, err := GetIDByName(compute, "network", "testing")

	if err != nil {
		log.Println(err)
	}

	fmt.Println("imageID :", imageID)

	copts := servers.CreateOpts{
		Name:      "taking-test",
		ImageRef:  imageID,
		FlavorRef: flavorID,
		// Networks: []servers.Network{
		// 	{UUID: networkID},
		// },
		SecurityGroups: []string{
			"default",
			"ssh",
		},
		Metadata: map[string]string{
			"instance_name_tag": "taking-test",
		},
	}
	r := servers.Create(compute, copts)
	if r.Err != nil {
		panic(r.Err)
	}

}