// delete cloud files object from container
func Delete(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
containerName := c.String("container")
objectName := c.String("name")
// 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.NewObjectStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err != nil {
fmt.Println(err)
}
_, err2 := objects.Delete(serviceClient, containerName, objectName, nil).Extract()
if err2 != nil {
fmt.Println(err2)
}
fmt.Printf("%v Deleted.", objectName)
}
// print list of cloud block storage volumes to stdout
func Show(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
volumeId := c.Args().First()
if c.String("uuid") != "" { volumeId = c.String("uuid") }
// 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.NewBlockStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err2 != nil { fmt.Println(err2) }
v, err3 := volumes.Get(serviceClient, volumeId).Extract()
if err3 != nil { fmt.Println(err3) }
fmt.Println("Name: ", v.Name)
fmt.Println("ID: ", v.ID)
fmt.Println("Size: ", v.Size)
fmt.Println("Status: ", v.Status)
fmt.Println("Type: ", v.VolumeType)
fmt.Println("Created: ", v.CreatedAt)
}
// delete a cloud block storage snapshots from volume uuid
func Delete(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
volumeId := c.Args().First()
if c.String("uuid") != "" {
volumeId = c.String("uuid")
}
// 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.NewBlockStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err2 != nil {
fmt.Println(err2)
}
// delete snapshot from uuid
err3 := snapshots.Delete(serviceClient, volumeId).ExtractErr()
if err3 != nil {
fmt.Println(err3)
}
}
// create a cloud files container
func Create(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
containerName := c.Args().First()
if c.String("name") != "" {
containerName = c.String("name")
}
// 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.NewObjectStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err != nil {
fmt.Println(err)
}
err2 := containers.Create(serviceClient, containerName, nil)
fmt.Println(err2)
}
func newClient() (*gophercloud.ServiceClient, error) {
// Obtain credentials from the environment.
options, err := rackspace.AuthOptionsFromEnv()
if err != nil {
return nil, err
}
options = tools.OnlyRS(options)
region := os.Getenv("RS_REGION")
if options.Username == "" {
return nil, errors.New("Please provide a Rackspace username as RS_USERNAME.")
}
if options.APIKey == "" {
return nil, errors.New("Please provide a Rackspace API key as RS_API_KEY.")
}
if region == "" {
return nil, errors.New("Please provide a Rackspace region as RS_REGION.")
}
client, err := rackspace.AuthenticatedClient(options)
if err != nil {
return nil, err
}
return rackspace.NewComputeV2(client, gophercloud.EndpointOpts{
Region: region,
})
}
func NewRackspaceSDK(username, apiKey, SSHKeyName string) *RackspaceSDK {
if SSHKeyName == "" {
panic("Empty SSHKeyName of instance don't allow!")
}
sdk := &RackspaceSDK{
Username: username,
APIKey: apiKey,
SSHKeyName: SSHKeyName,
Region: "HKG",
InstanceName: "kmg-RackspaceSDK-auto-build",
ImageName: "Ubuntu 14.04 LTS (Trusty Tahr) (PVHVM)",
FlavorName: "4 GB General Purpose v1",
}
ao := gophercloud.AuthOptions{
Username: sdk.Username,
APIKey: sdk.APIKey,
}
provider, err := rackspace.AuthenticatedClient(ao)
handleErr(err)
serviceClient, err := rackspace.NewComputeV2(provider, gophercloud.EndpointOpts{
Region: sdk.Region,
})
handleErr(err)
sdk.p = serviceClient
return sdk
}
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 newProvider() (*gophercloud.ProviderClient, error) {
opts, err := rackspace.AuthOptionsFromEnv()
if err != nil {
return nil, err
}
opts = tools.OnlyRS(opts)
return rackspace.AuthenticatedClient(opts)
}
func newBlockClient(t *testing.T) (*gophercloud.ServiceClient, error) {
ao, err := rackspace.AuthOptionsFromEnv()
th.AssertNoErr(t, err)
client, err := rackspace.AuthenticatedClient(ao)
th.AssertNoErr(t, err)
return openstack.NewBlockStorageV1(client, gophercloud.EndpointOpts{
Region: os.Getenv("RS_REGION_NAME"),
})
}
func newClient(t *testing.T) *gophercloud.ServiceClient {
ao, err := rackspace.AuthOptionsFromEnv()
th.AssertNoErr(t, err)
client, err := rackspace.AuthenticatedClient(ao)
th.AssertNoErr(t, err)
c, err := rackspace.NewCDNV1(client, gophercloud.EndpointOpts{})
th.AssertNoErr(t, err)
return c
}
func newRackspace(cfg Config) (*Rackspace, error) {
provider, err := rackspace.AuthenticatedClient(cfg.toAuthOptions())
if err != nil {
return nil, err
}
os := Rackspace{
provider: provider,
region: cfg.Global.Region,
lbOpts: cfg.LoadBalancer,
}
return &os, nil
}
func newClient(t *testing.T) *gophercloud.ServiceClient {
ao, err := rackspace.AuthOptionsFromEnv()
th.AssertNoErr(t, err)
client, err := rackspace.AuthenticatedClient(ao)
th.AssertNoErr(t, err)
c, err := rackspace.NewOrchestrationV1(client, gophercloud.EndpointOpts{
Region: os.Getenv("RS_REGION_NAME"),
})
th.AssertNoErr(t, err)
return c
}
func newClusterClient(endpoint string, ao gophercloud.AuthOptions) (*ClusterClient, error) {
provider, err := rackspace.AuthenticatedClient(ao)
if err != nil {
return nil, err
}
return &ClusterClient{
Client: &http.Client{},
Username: ao.Username,
Token: provider.TokenID,
Endpoint: endpoint,
}, nil
}
// create cloud block storage volume in rackspace public cloud
func Create(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
name := c.String("name")
size := c.Int("size")
var volType string
if c.String("type") != "" {
volType = c.String("type")
}
// 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.NewBlockStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err2 != nil {
fmt.Println(err2)
}
// https://github.com/rackspace/gophercloud/blob/master/openstack/blockstorage/v1/volumes/requests.go
opts := osvolumes.CreateOpts{
Name: name,
Size: size,
VolumeType: volType,
}
if volType == "" {
opts = osvolumes.CreateOpts{
Name: name,
Size: size,
}
}
vol, err3 := volumes.Create(serviceClient, opts).Extract()
if err3 != nil {
fmt.Println(err3)
}
fmt.Println(vol)
}
// print list of cloud servers images 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)
}
//opts3 := images.ListOpts{}
cmdErr := images.ListDetail(serviceClient, nil).EachPage(func(page pagination.Page) (bool, error) {
images, err := images.ExtractImages(page)
if err != nil {
fmt.Println(err)
}
// Use the page of []images.Image
// https://github.com/rackspace/gophercloud/blob/master/openstack/compute/v2/images/results.go
for _, i := range images {
fmt.Println("Name: ", i.Name)
fmt.Println("ID: ", i.ID)
fmt.Println("Created: ", i.Created)
fmt.Println("Updated: ", i.Updated)
fmt.Println("MinDisk: ", i.MinDisk)
fmt.Println("MinRAM: ", i.MinRAM)
fmt.Println("Progress: ", i.Progress)
fmt.Println("Status: ", i.Status)
fmt.Println("\n")
}
return true, nil
})
if cmdErr != nil {
fmt.Println(cmdErr)
}
}
// print details of cloud servers instance to stdout
func Details(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
// server create specific options
// check both options and arguments for server uuid
serverid := c.Args().First()
if c.String("uuid") != "" {
serverid = c.String("uuid")
}
// 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)
}
// get cloud server
s, id := servers.Get(serviceClient, serverid).Extract()
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)
if id != nil {
fmt.Println(id)
}
}
func List(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)
provider, err := rackspace.AuthenticatedClient(ao)
if err != nil {
fmt.Println(err)
}
// set rax region
serviceClient, err2 := rackspace.NewNetworkV2(provider, gophercloud.EndpointOpts{
Name: "cloudNetworks",
//Type: "network",
Region: region,
})
if err2 != nil {
fmt.Println(err2)
}
// Retrieve a pager (i.e. a paginated collection)
networks_pager := networks.List(serviceClient)
fmt.Println("networks_pager: ", networks_pager)
// Define an anonymous function to be executed on each page's iteration
err6 := networks_pager.EachPage(func(page pagination.Page) (bool, error) {
networkList, err7 := networks.ExtractNetworks(page)
if err7 != nil {
fmt.Println(err7)
}
for _, n := range networkList {
// "s" will be a servers.Server
// https://github.com/rackspace/gophercloud/blob/master/openstack/compute/v2/servers/results.go
fmt.Println(n)
}
return true, nil
})
if err6 != nil {
fmt.Println(err6)
}
}
// delete all cloud files object from container
func DeleteAll(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
containerName := c.String("container")
useConcurrency := c.String("concurrency")
// 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.NewObjectStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err != nil {
fmt.Println(err)
}
// get objects List and delete each
err3 := objects.List(serviceClient, containerName, nil).EachPage(func(page pagination.Page) (bool, error) {
objectList, err4 := objects.ExtractNames(page)
// https://github.com/rackspace/gophercloud/blob/master/openstack/blockstorage/v1/volumes/results.go
for _, objectName := range objectList {
// now delete each object here
// fmt.Println(objName)
if strings.Compare(useConcurrency, "TRUE") == 0 {
go deleteObj(serviceClient, containerName, objectName)
} else {
deleteObj(serviceClient, containerName, objectName)
}
}
if err4 != nil {
fmt.Println(err4)
}
return true, nil
})
if err3 != nil {
fmt.Println(err3)
}
}
func newClient(t *testing.T) *gophercloud.ServiceClient {
opts, err := rackspace.AuthOptionsFromEnv()
th.AssertNoErr(t, err)
opts = tools.OnlyRS(opts)
client, err := rackspace.AuthenticatedClient(opts)
th.AssertNoErr(t, err)
c, err := rackspace.NewDBV1(client, gophercloud.EndpointOpts{
Region: "IAD",
})
th.AssertNoErr(t, err)
return c
}
func TestAuthenticatedClient(t *testing.T) {
// Obtain credentials from the environment.
ao, err := rackspace.AuthOptionsFromEnv()
th.AssertNoErr(t, err)
client, err := rackspace.AuthenticatedClient(tools.OnlyRS(ao))
if err != nil {
t.Fatalf("Unable to authenticate: %v", err)
}
if client.TokenID == "" {
t.Errorf("No token ID assigned to the client")
}
t.Logf("Client successfully acquired a token: %v", client.TokenID)
}
// 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)
}
}
// upload file to Cloud File container
func Upload(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
containerName := c.String("container")
objectName := c.String("name")
path := c.String("path")
// 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.NewObjectStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err != nil {
fmt.Println(err)
}
f, err2 := os.Open(path)
if err2 != nil {
fmt.Println(err2)
}
defer f.Close()
// reader := bufio.NewReader(f)
_, err3 := objects.Create(
serviceClient,
containerName,
objectName,
f,
nil,
).ExtractHeader()
if err3 != nil {
fmt.Println(err3)
}
fmt.Printf("%v Uploaded.", path)
}
// print list of cloud block storage volumes to stdout
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.NewBlockStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err2 != nil {
fmt.Println(err2)
}
err3 := volumes.List(serviceClient).EachPage(func(page pagination.Page) (bool, error) {
volumeList, err4 := volumes.ExtractVolumes(page)
// https://github.com/rackspace/gophercloud/blob/master/openstack/blockstorage/v1/volumes/results.go
for _, v := range volumeList {
fmt.Println("Name: ", v.Name)
fmt.Println("ID: ", v.ID)
fmt.Println("Size: ", v.Size)
fmt.Println("Status: ", v.Status)
fmt.Println("Type: ", v.VolumeType)
fmt.Println("Created: ", v.CreatedAt)
fmt.Println("\n")
}
if err4 != nil {
fmt.Println(err4)
}
return true, nil
})
if err3 != nil {
fmt.Println(err3)
}
}
func newClient() (*gophercloud.ServiceClient, error) {
opts, err := rackspace.AuthOptionsFromEnv()
if err != nil {
return nil, err
}
opts = tools.OnlyRS(opts)
region := os.Getenv("RS_REGION")
provider, err := rackspace.AuthenticatedClient(opts)
if err != nil {
return nil, err
}
return rackspace.NewBlockStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
}
// print list of cloud files containers to stdout
func List(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
containerName := c.Args().First()
if c.String("container") != "" {
containerName = c.String("container")
}
// 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.NewObjectStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err != nil {
fmt.Println(err)
}
// _, err := containers.Get(serviceClient, "{containerName}").ExtractMetadata()
err3 := objects.List(serviceClient, containerName, nil).EachPage(func(page pagination.Page) (bool, error) {
objectList, err4 := objects.ExtractNames(page)
// https://github.com/rackspace/gophercloud/blob/master/openstack/blockstorage/v1/volumes/results.go
for _, o := range objectList {
fmt.Println(o)
}
if err4 != nil {
fmt.Println(err4)
}
return true, nil
})
if err3 != nil {
fmt.Println(err3)
}
}
// print list of cloud block storage snapshots to stdout
func List(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.NewBlockStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err2 != nil {
fmt.Println(err2)
}
err3 := snapshots.List(serviceClient).EachPage(func(page pagination.Page) (bool, error) {
snapshotList, err4 := snapshots.ExtractSnapshots(page)
for _, s := range snapshotList {
fmt.Println("Name: ", s.Name)
fmt.Println("ID: ", s.ID)
fmt.Println("Size: ", s.Size)
fmt.Println("Status: ", s.Status)
fmt.Println("Parent: ", s.VolumeID)
fmt.Println("Created: ", s.CreatedAt)
fmt.Println("\n")
}
if err4 != nil {
fmt.Println(err4)
}
return true, nil
})
if err3 != nil {
fmt.Println(err3)
}
}
// create cloud servers instance and print out results to stdout (eg. password)
func Create(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
// server create specific options
newservername := c.String("name")
imageid := c.String("image")
flavorid := c.String("flavor")
// 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)
}
// create the cloud server
server, err3 := servers.Create(serviceClient, servers.CreateOpts{
Name: newservername,
ImageRef: imageid,
FlavorRef: flavorid,
}).Extract()
fmt.Println(server)
if err3 != nil {
fmt.Println(err3)
}
}
// Authenticate creates a Rackspace-specific Gophercloud client.
func (c *Client) Authenticate(d *openstack.Driver) error {
if c.Provider != nil {
return nil
}
log.WithFields(log.Fields{
"Username": d.Username,
}).Debug("Authenticating to Rackspace.")
apiKey := c.driver.APIKey
opts := gophercloud.AuthOptions{
Username: d.Username,
APIKey: apiKey,
}
provider, err := rackspace.AuthenticatedClient(opts)
if err != nil {
return err
}
c.Provider = provider
return nil
}
func authFromScratch(ao gophercloud.AuthOptions, region, serviceType string) (*gophercloud.ServiceClient, error) {
pc, err := rackspace.AuthenticatedClient(ao)
if err != nil {
return nil, err
}
var sc *gophercloud.ServiceClient
switch serviceType {
case "compute":
sc, err = rackspace.NewComputeV2(pc, gophercloud.EndpointOpts{
Region: region,
})
break
case "object-store":
sc, err = rackspace.NewObjectStorageV1(pc, gophercloud.EndpointOpts{
Region: region,
})
break
case "blockstorage":
sc, err = rackspace.NewBlockStorageV1(pc, gophercloud.EndpointOpts{
Region: region,
})
break
case "network":
sc, err = rackspace.NewNetworkV2(pc, gophercloud.EndpointOpts{
Region: region,
})
break
}
if err != nil {
return nil, err
}
if sc == nil {
return nil, fmt.Errorf("Unable to create service client: Unknown service type: %s", serviceType)
}
sc.UserAgent.Prepend(util.UserAgent)
return sc, nil
}
// print details of cloud files object to stdout
func Show(c *cli.Context) {
// assign vars from cli args
user := c.String("user")
key := c.String("key")
region := c.String("region")
containerName := c.String("container")
objectName := c.String("name")
// 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.NewObjectStorageV1(provider, gophercloud.EndpointOpts{
Region: region,
})
if err != nil {
fmt.Println(err)
}
myObject, err3 := objects.Get(serviceClient, containerName, objectName, nil).Extract()
if err3 != nil {
fmt.Println(err3)
}
fmt.Println("Name: ", objectName)
fmt.Println("Bytes: ", myObject.ContentLength)
fmt.Println("Type: ", myObject.ContentType)
fmt.Println("Last Modified: ", myObject.LastModified)
}