func main() {

	cnt := containerPrefix + helpers.RandString(32-len(containerPrefix))

	cli := helpers.GetStorageClient(accountName, accountKey).GetBlobService()

	// Create a container.

	ok, err := cli.CreateContainerIfNotExists(cnt, storage.ContainerAccessTypePrivate)
	if !ok {
		fmt.Printf("Failed to create container '%s': %s\n", cnt, err.Error())
		return
	}

	// Make sure not to clobber up the storage account.

	defer func() {
		fmt.Printf("Deleting '%s' and all its contents\n", cnt)
		cli.DeleteContainer(cnt)
	}()

	fmt.Printf("Successfully created '%s'\n", cnt)

	// Create an empty blob

	blob := blobPrefix + helpers.RandString(32-len(blobPrefix))

	if err := cli.CreateBlockBlob(cnt, blob); err != nil {
		fmt.Printf("Failed to create blob '%s' in  '%s': %s\n", blob, cnt, err.Error())
		return
	}

	fmt.Printf("Successfully created '%s'\n", blob)
}
func main() {

	if len(os.Args) < 2 {
		fmt.Printf("usage: blob03 blob-name\n")
		return
	}

	blob := os.Args[1]

	cli := helpers.GetStorageClient(accountName, accountKey).GetBlobService()

	// Create a container.

	_, err := cli.CreateContainerIfNotExists(cnt, storage.ContainerAccessTypeBlob)
	if err != nil {
		fmt.Printf("ERROR: Failed to create container '%s': %s\n", cnt, err.Error())
		return
	}

	fmt.Printf("Successfully created '%s'\n", cnt)

	// First, create an empty page blob
	if err := cli.PutPageBlob(cnt, blob, blobSize); err != nil {
		fmt.Printf("Failed to create '%s' in  '%s': %s\n", blob, cnt, err.Error())
		return
	}

	// Then, write some pages. We will write pages 0, 1, and 2, leaving five pages blank.

	data := helpers.RandBytes(1536)

	if err := writePage(cli, blob, 0, 511, data[0:512]); err != nil {
		return
	}
	if err := writePage(cli, blob, 512, 1023, data[512:1024]); err != nil {
		return
	}
	if err := writePage(cli, blob, 1024, 1535, data[1024:1536]); err != nil {
		return
	}

	// Now that we have written the pages, let's check what's been stored.

	url := cli.GetBlobURL(cnt, blob)

	// The first three pages should correspond to what was written.
	if err := validate(cli, blob, 0, 1535, data[0:1536]); err != nil {
		fmt.Printf("Failed validation of %s: %s\n", url, err.Error())
		return
	}

	// The next five pages should be all zeroes.
	if err := validate(cli, blob, 1536, blobSize-1, make([]byte, blobSize)); err != nil {
		fmt.Printf("Failed validation of %s: %s\n", url, err.Error())
		return
	}

	fmt.Printf("Successfully created, wrote to, and read a page blob at '%s\n", url)

	// Next, let's try clearing a page, that is, setting it to all zeroes.

	if err := clearPage(cli, blob, 512, 1023); err != nil {
		return
	}

	// Now that we have written the pages, let's check what's been stored.

	// The first and third pages should correspond to what was written.
	if err := validate(cli, blob, 0, 511, data[0:512]); err != nil {
		fmt.Printf("Failed validation of %s: %s\n", url, err.Error())
		return
	}
	// The second page should be all zeroes.
	if err := validate(cli, blob, 512, 1023, make([]byte, 1024)); err != nil {
		fmt.Printf("Failed validation of %s: %s\n", url, err.Error())
		return
	}
	if err := validate(cli, blob, 1024, 1535, data[0:1536]); err != nil {
		fmt.Printf("Failed validation of %s: %s\n", url, err.Error())
		return
	}

	// The last five pages should still be all zeroes.
	if err := validate(cli, blob, 1536, blobSize-1, make([]byte, blobSize)); err != nil {
		fmt.Printf("Failed validation of %s: %s\n", url, err.Error())
		return
	}

	// We can check which pages have data by getting the valid page ranges.

	ranges, err := cli.GetPageRanges(cnt, blob)
	if err != nil {
		fmt.Printf("Failed to get page ranges for %s: %s\n", url, err.Error())
		return
	}

	fmt.Printf("Successfully cleared a page at '%s\n", url)

	for _, rng := range ranges.PageList {
		fmt.Printf("[%d,%d]\n", rng.Start, rng.End)
	}

	pl := ranges.PageList

	if len(pl) != 2 || pl[0].Start != 0 || pl[0].End != 511 || pl[1].Start != 1024 || pl[1].End != 1535 {
		fmt.Printf("Incorrect page list returned\n")
		return
	}

	fmt.Printf("Successfully checked page ranges of '%s\n", url)
}
func main() {

	if len(os.Args) < 3 {
		fmt.Printf("usage: blob02 file-name blob-name\n")
		return
	}

	fileName := os.Args[1]
	blob := os.Args[2]

	cli := helpers.GetStorageClient(accountName, accountKey).GetBlobService()

	// Create a container.

	_, err := cli.CreateContainerIfNotExists(cnt, storage.ContainerAccessTypeBlob)
	if err != nil {
		fmt.Printf("ERROR: Failed to create container '%s': %s\n", cnt, err.Error())
		return
	}

	fmt.Printf("Successfully created '%s'\n", cnt)

	// Open the file

	f, err := os.Open(fileName)
	if err != nil {
		fmt.Printf("ERROR: Unable to locate or open file at %s (%s)\n", fileName, err.Error())
		return
	}

	defer f.Close()

	// Get the file info, so we can know its size

	fileInfo, err := f.Stat()

	if err != nil {
		fmt.Printf("ERROR: Unable to retrieve info on file at %s (%s)\n", fileName, err.Error())
		return
	}

	props := storage.BlobProperties{ContentType: imageJPG}

	// Create the blob from the file. Also, pass in a properties block so that the
	// content type may be set.
	if err := cli.CreateBlockBlobFromReader(cnt, blob, uint64(fileInfo.Size()), f, &props); err != nil {
		fmt.Printf("Failed to create '%s' in  '%s': %s\n", blob, cnt, err.Error())
		return
	}

	// We'll want the url of the blob
	url := cli.GetBlobURL(cnt, blob)

	fmt.Printf("Successfully uploaded file to '%s'\n", url)

	if err := cli.SetBlobProperties(cnt, blob, props); err != nil {
		fmt.Printf("Failed to set properties for '%s': %s\n", url, err.Error())
		return
	}

	fmt.Printf("Successfully set properties for '%s'\n", url)

	// Just to make sure, let's see what the properties on the server!
	stored, err := cli.GetBlobProperties(cnt, blob)
	if err != nil {
		fmt.Printf("Failed to retrieve blob properties for '%s': %s\n", url, err.Error())
		return
	}

	fmt.Printf("Stored properties: %s\n", helpers.ToJSON(*stored))
}