func (i *Instances) List(name_filter string) ([]string, error) {
glog.V(2).Infof("rackspace List(%v) called", name_filter)
opts := osservers.ListOpts{
Name: name_filter,
Status: "ACTIVE",
}
pager := servers.List(i.compute, opts)
ret := make([]string, 0)
err := pager.EachPage(func(page pagination.Page) (bool, error) {
sList, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
for _, server := range sList {
ret = append(ret, server.Name)
}
return true, nil
})
if err != nil {
return nil, err
}
glog.V(2).Infof("Found %v entries: %v", len(ret), ret)
return ret, nil
}
func getServerByAddress(client *gophercloud.ServiceClient, name string) (*osservers.Server, error) {
pager := servers.List(client, nil)
serverList := make([]osservers.Server, 0, 1)
err := pager.EachPage(func(page pagination.Page) (bool, error) {
s, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
for _, v := range s {
if serverHasAddress(v, name) {
serverList = append(serverList, v)
}
}
if len(serverList) > 1 {
return false, ErrMultipleResults
}
return true, nil
})
if err != nil {
return nil, err
}
if len(serverList) == 0 {
return nil, ErrNotFound
} else if len(serverList) > 1 {
return nil, ErrMultipleResults
}
return &serverList[0], nil
}
func GetList(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
// step 1, set up auth options
ao := gophercloud.AuthOptions{
Username: user,
APIKey: key,
}
// step 2, rax auth to get back provider instance
provider, err := rackspace.AuthenticatedClient(ao)
if err != nil {
fmt.Println(err)
}
// set rax region
serviceClient, err2 := rackspace.NewComputeV2(provider, gophercloud.EndpointOpts{
Region: region,
})
if err2 != nil {
fmt.Println(err2)
}
// Retrieve a pager (i.e. a paginated collection)
server_pager := servers.List(serviceClient, nil)
// Define an anonymous function to be executed on each page's iteration
err6 := server_pager.EachPage(func(page pagination.Page) (bool, error) {
serverList, err7 := servers.ExtractServers(page)
if err7 != nil {
fmt.Println(err7)
}
for _, s := range serverList {
// "s" will be a servers.Server
// https://github.com/rackspace/gophercloud/blob/master/openstack/compute/v2/servers/results.go
fmt.Println("Name: ", s.Name)
fmt.Println("UUID: ", s.ID)
fmt.Println("Created: ", s.Created)
fmt.Println("Updated: ", s.Updated)
fmt.Println("Progress: ", s.Progress)
fmt.Println("HostID: ", s.HostID)
fmt.Println("Image: ", s.Image["id"])
fmt.Println("Flavor ID: ", s.Flavor["id"])
fmt.Println("Status: ", s.Status)
fmt.Println("Access: ", s.AccessIPv4)
fmt.Println("Public: ", s.Addresses["public"])
fmt.Println("Addresses: ", s.Addresses)
fmt.Println("\n")
}
return true, nil
})
if err6 != nil {
fmt.Println(err6)
}
}
func findServer(t *testing.T) string {
var serverIP string
client, err := newComputeClient()
th.AssertNoErr(t, err)
err = servers.List(client, nil).EachPage(func(page pagination.Page) (bool, error) {
sList, err := servers.ExtractServers(page)
th.AssertNoErr(t, err)
for _, s := range sList {
serverIP = s.AccessIPv4
t.Logf("Found an existing server: ID [%s] Public IP [%s]", s.ID, serverIP)
break
}
return true, nil
})
th.AssertNoErr(t, err)
if serverIP == "" {
t.Log("No server found, creating one")
imageRef := os.Getenv("RS_IMAGE_ID")
if imageRef == "" {
t.Fatalf("OS var RS_IMAGE_ID undefined")
}
flavorRef := os.Getenv("RS_FLAVOR_ID")
if flavorRef == "" {
t.Fatalf("OS var RS_FLAVOR_ID undefined")
}
opts := &servers.CreateOpts{
Name: tools.RandomString("lb_test_", 5),
ImageRef: imageRef,
FlavorRef: flavorRef,
DiskConfig: diskconfig.Manual,
}
s, err := servers.Create(client, opts).Extract()
th.AssertNoErr(t, err)
serverIP = s.AccessIPv4
t.Logf("Created server %s, waiting for it to build", s.ID)
err = servers.WaitForStatus(client, s.ID, "ACTIVE", 300)
th.AssertNoErr(t, err)
t.Logf("Server created successfully.")
}
return serverIP
}
func (command *commandList) Execute(resource *handler.Resource) {
opts := resource.Params.(*paramsList).opts
allPages := resource.Params.(*paramsList).allPages
pager := servers.List(command.Ctx.ServiceClient, opts)
if allPages {
pages, err := pager.AllPages()
if err != nil {
resource.Err = err
return
}
info, err := servers.ExtractServers(pages)
if err != nil {
resource.Err = err
return
}
result := make([]map[string]interface{}, len(info))
for j, server := range info {
result[j] = serverSingle(&server)
}
resource.Result = result
} else {
limit := opts.Limit
err := pager.EachPage(func(page pagination.Page) (bool, error) {
info, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
result := make([]map[string]interface{}, len(info))
for j, server := range info {
result[j] = serverSingle(&server)
}
resource.Result = result
if len(info) >= limit {
return false, nil
}
limit -= len(info)
command.Ctx.WaitGroup.Add(1)
command.Ctx.Results <- resource
return true, nil
})
if err != nil {
resource.Err = err
return
}
}
}
func (sdk *RackspaceSDK) ListAllInstance() (idInstanceMap map[string]Instance) {
idInstanceMap = map[string]Instance{}
err := servers.List(sdk.p, nil).EachPage(func(p pagination.Page) (quit bool, err error) {
serverSlice, err := servers.ExtractServers(p)
for _, server := range serverSlice {
idInstanceMap[server.ID] = Instance{
Ip: server.AccessIPv4,
Id: server.ID,
Name: server.Name,
BelongToSDK: sdk,
}
}
return true, err
})
handleErr(err)
return
}
func listServers(t *testing.T, client *gophercloud.ServiceClient) {
t.Logf("> servers.List")
count := 0
err := servers.List(client, nil).EachPage(func(page pagination.Page) (bool, error) {
count++
t.Logf("--- Page %02d ---", count)
s, err := servers.ExtractServers(page)
th.AssertNoErr(t, err)
for index, server := range s {
logServer(t, &server, index)
}
return true, nil
})
th.AssertNoErr(t, err)
}
func (sdk *RackspaceSDK) ListAllRunningInstance() (ipInstanceMap map[string]Instance) {
ipInstanceMap = map[string]Instance{}
err := servers.List(sdk.p, nil).EachPage(func(p pagination.Page) (quit bool, err error) {
serverSlice, err := servers.ExtractServers(p)
for _, server := range serverSlice {
if server.Status != string(RackspaceInstanceStatusACTIVE) {
fmt.Println(logPrefixRackspace, server.ID, server.AccessIPv4, server.Status)
continue
}
ipInstanceMap[server.AccessIPv4] = Instance{
Ip: server.AccessIPv4,
Id: server.ID,
Name: server.Name,
BelongToSDK: sdk,
}
}
return true, err
})
handleErr(err)
return
}
func getServerByName(client *gophercloud.ServiceClient, name string) (*osservers.Server, error) {
if net.ParseIP(name) != nil {
// we're an IP, so we'll have to walk the full list of servers to
// figure out which one we are.
return getServerByAddress(client, name)
}
opts := osservers.ListOpts{
Name: fmt.Sprintf("^%s$", regexp.QuoteMeta(name)),
Status: "ACTIVE",
}
pager := servers.List(client, opts)
serverList := make([]osservers.Server, 0, 1)
err := pager.EachPage(func(page pagination.Page) (bool, error) {
s, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
serverList = append(serverList, s...)
if len(serverList) > 1 {
return false, ErrMultipleResults
}
return true, nil
})
if err != nil {
return nil, err
}
if len(serverList) == 0 {
return nil, ErrNotFound
} else if len(serverList) > 1 {
return nil, ErrMultipleResults
}
return &serverList[0], nil
}