Golang NewObjectStorageV1 Examples

Example #1

File: delete.go Project: rackeric/erack

// 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)
}

Example #2

File: create.go Project: rackeric/erack

// 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)
}

Example #3

File: deleteall.go Project: rackeric/erack

// 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)
	}
}

Example #4

File: upload.go Project: rackeric/erack

// 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)
}

Example #5

File: list.go Project: rackeric/erack

// 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)
	}
}

Example #6

File: show.go Project: rackeric/erack

// 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)
}

Example #7

File: clients.go Project: flazz/rack

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
}

Example #8

File: download.go Project: rackeric/erack

// download file from Cloud File container
func Download(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)
	}

	result := objects.Download(serviceClient, containerName, objectName, nil)
	content, err := result.ExtractContent()

	err3 := ioutil.WriteFile(path+"/"+objectName, []byte(content), 0644)
	if err3 != nil {
		fmt.Println(err3)
	}
	fmt.Printf("%v Downloaded.", objectName)
}

Example #9

File: common.go Project: Clarifai/kubernetes

func createClient(t *testing.T, cdn bool) (*gophercloud.ServiceClient, error) {
	region := os.Getenv("RS_REGION")
	if region == "" {
		t.Fatal("Please provide a Rackspace region as RS_REGION")
	}

	ao := rackspaceAuthOptions(t)

	provider, err := rackspace.NewClient(ao.IdentityEndpoint)
	th.AssertNoErr(t, err)

	err = rackspace.Authenticate(provider, ao)
	th.AssertNoErr(t, err)

	if cdn {
		return rackspace.NewObjectCDNV1(provider, gophercloud.EndpointOpts{
			Region: region,
		})
	}

	return rackspace.NewObjectStorageV1(provider, gophercloud.EndpointOpts{
		Region: region,
	})
}