func (command *commandList) Execute(resource *handler.Resource) { opts := resource.Params.(*paramsList).opts allPages := resource.Params.(*paramsList).allPages pager := flavors.ListDetail(command.Ctx.ServiceClient, opts) if allPages { pages, err := pager.AllPages() if err != nil { resource.Err = err return } info, err := flavors.ExtractFlavors(pages) if err != nil { resource.Err = err return } result := make([]map[string]interface{}, len(info)) for j, flavor := range info { result[j] = structs.Map(flavor) } resource.Result = result } else { limit := opts.Limit err := pager.EachPage(func(page pagination.Page) (bool, error) { info, err := flavors.ExtractFlavors(page) if err != nil { return false, err } result := make([]map[string]interface{}, len(info)) for j, flavor := range info { result[j] = structs.Map(flavor) } resource.Result = result if len(info) >= opts.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) GetAllFlavor() []flavors.Flavor { out := []flavors.Flavor{} err := flavors.ListDetail(sdk.p, nil).EachPage(func(p pagination.Page) (quit bool, err error) { v, err := flavors.ExtractFlavors(p) out = append(out, v...) return true, err }) handleErr(err) return out }
// print list of cloud servers flavors to stdout func Get(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, err := rackspace.NewComputeV2(provider, gophercloud.EndpointOpts{ Region: region, }) if err != nil { fmt.Println(err) } opts := flavors.ListOpts{} cmdErr := flavors.ListDetail(serviceClient, opts).EachPage(func(page pagination.Page) (bool, error) { flavors, err := flavors.ExtractFlavors(page) if err != nil { fmt.Println(err) } // Use the page of []flavors.Flavor // https://github.com/rackspace/gophercloud/blob/master/openstack/compute/v2/flavors/results.go for _, f := range flavors { fmt.Println("ID: ", f.ID) fmt.Println("Name: ", f.Name) fmt.Println("Disk: ", f.Disk) fmt.Println("RAM: ", f.RAM) fmt.Println("VCPUs: ", f.VCPUs) fmt.Println("\n") } return true, nil }) if cmdErr != nil { fmt.Println(cmdErr) } }
// Instances returns an implementation of Instances for Rackspace. func (os *Rackspace) Instances() (cloudprovider.Instances, bool) { glog.V(2).Info("rackspace.Instances() called") compute, err := rackspace.NewComputeV2(os.provider, gophercloud.EndpointOpts{ Region: os.region, }) if err != nil { glog.Warningf("Failed to find compute endpoint: %v", err) return nil, false } pager := flavors.ListDetail(compute, nil) flavor_to_resource := make(map[string]*api.NodeResources) err = pager.EachPage(func(page pagination.Page) (bool, error) { flavorList, err := flavors.ExtractFlavors(page) if err != nil { return false, err } for _, flavor := range flavorList { rsrc := api.NodeResources{ Capacity: api.ResourceList{ api.ResourceCPU: *resource.NewMilliQuantity(int64(flavor.VCPUs*1000), resource.DecimalSI), api.ResourceMemory: resource.MustParse(fmt.Sprintf("%dMi", flavor.RAM)), "openstack.org/disk": resource.MustParse(fmt.Sprintf("%dG", flavor.Disk)), "openstack.org/rxTxFactor": *resource.NewQuantity(int64(flavor.RxTxFactor*1000), resource.DecimalSI), "openstack.org/swap": resource.MustParse(fmt.Sprintf("%dMi", flavor.Swap)), }, } flavor_to_resource[flavor.ID] = &rsrc } return true, nil }) if err != nil { glog.Warningf("Failed to find compute flavors: %v", err) return nil, false } glog.V(2).Infof("Found %v compute flavors", len(flavor_to_resource)) glog.V(1).Info("Claiming to support Instances") return &Instances{compute, flavor_to_resource}, true }