Exemple #1
0
// 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)
}
Exemple #2
0
// Takes a partial/full disk id or diskname
func (rs *Rackspace) getVolume(diskName string) (volumes.Volume, error) {
	sClient, err := rackspace.NewBlockStorageV1(rs.provider, gophercloud.EndpointOpts{
		Region: rs.region,
	})

	var volume volumes.Volume
	if err != nil || sClient == nil {
		glog.Errorf("Unable to initialize cinder client for region: %s", rs.region)
		return volume, err
	}

	err = volumes.List(sClient).EachPage(func(page pagination.Page) (bool, error) {
		vols, err := volumes.ExtractVolumes(page)
		if err != nil {
			glog.Errorf("Failed to extract volumes: %v", err)
			return false, err
		}

		for _, v := range vols {
			glog.V(4).Infof("%s %s %v", v.ID, v.Name, v.Attachments)
			if v.Name == diskName || strings.Contains(v.ID, diskName) {
				volume = v
				return true, nil
			}
		}

		// if it reached here then no disk with the given name was found.
		errmsg := fmt.Sprintf("Unable to find disk: %s in region %s", diskName, rs.region)
		return false, errors.New(errmsg)
	})
	if err != nil {
		glog.Errorf("Error occured getting volume: %s", diskName)
	}
	return volume, err
}
Exemple #3
0
// 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)
	}
}
Exemple #4
0
// 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)
}
Exemple #5
0
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,
	})
}
Exemple #6
0
// 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)
	}
}
Exemple #7
0
// 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)
	}
}
Exemple #8
0
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
}
Exemple #9
0
// create a cloud block storage snapshots from volume uuid
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")
	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)
	}

	// create snapshot from volume
	opts := snapshots.CreateOpts{VolumeID: volumeId, Name: name}
	s, err3 := snapshots.Create(serviceClient, opts).Extract()

	if err3 != nil {
		fmt.Println(err3)
	}

	fmt.Println(s)
}