Merge pull request #118 from Azure/dev

zezha-msft · web-flow · commit 678206e7e6e5 · 2019-04-05T13:16:17.000-07:00
Release 0.6.0
diff --git a/azblob/sas_service.go b/azblob/sas_service.go
@@ -61,6 +61,8 @@ func (v BlobSASSignatureValues) NewSASQueryParameters(sharedKeyCredential *Share
 		v.IPRange.String(),
 		string(v.Protocol),
 		v.Version,
+		resource,
+		"",                   // signed timestamp, @TODO add for snapshot sas feature
 		v.CacheControl,       // rscc
 		v.ContentDisposition, // rscd
 		v.ContentEncoding,    // rsce
diff --git a/azblob/url_append_blob.go b/azblob/url_append_blob.go
@@ -69,6 +69,17 @@ func (ab AppendBlobURL) AppendBlock(ctx context.Context, body io.ReadSeeker, ac
 		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
 }
 
+// AppendBlockFromURL copies a new block of data from source URL to the end of the existing append blob.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/append-block-from-url.
+func (ab AppendBlobURL) AppendBlockFromURL(ctx context.Context, sourceURL url.URL, offset int64, count int64, ac AppendBlobAccessConditions, transactionalMD5 []byte) (*AppendBlobAppendBlockFromURLResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.ModifiedAccessConditions.pointers()
+	ifAppendPositionEqual, ifMaxSizeLessThanOrEqual := ac.AppendPositionAccessConditions.pointers()
+	return ab.abClient.AppendBlockFromURL(ctx, sourceURL.String(), 0, httpRange{offset: offset, count: count}.pointers(),
+		transactionalMD5, nil, transactionalMD5, ac.LeaseAccessConditions.pointers(),
+		ifMaxSizeLessThanOrEqual, ifAppendPositionEqual,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
 type AppendBlobAccessConditions struct {
 	ModifiedAccessConditions
 	LeaseAccessConditions
diff --git a/azblob/url_page_blob.go b/azblob/url_page_blob.go
@@ -72,6 +72,20 @@ func (pb PageBlobURL) UploadPages(ctx context.Context, offset int64, body io.Rea
 		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
 }
 
+// UploadPagesFromURL copies 1 or more pages from a source URL to the page blob.
+// The sourceOffset specifies the start offset of source data to copy from.
+// The destOffset specifies the start offset of data in page blob will be written to.
+// The count must be a multiple of 512 bytes.
+// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-page-from-url.
+func (pb PageBlobURL) UploadPagesFromURL(ctx context.Context, sourceURL url.URL, sourceOffset int64, destOffset int64, count int64, ac PageBlobAccessConditions, transactionalMD5 []byte) (*PageBlobUploadPagesFromURLResponse, error) {
+	ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.ModifiedAccessConditions.pointers()
+	ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan, ifSequenceNumberEqual := ac.SequenceNumberAccessConditions.pointers()
+	return pb.pbClient.UploadPagesFromURL(ctx, sourceURL.String(), *PageRange{Start: sourceOffset, End: sourceOffset + count - 1}.pointers(), 0,
+		*PageRange{Start: destOffset, End: destOffset + count - 1}.pointers(), transactionalMD5, nil, ac.LeaseAccessConditions.pointers(),
+		ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan, ifSequenceNumberEqual,
+		ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
+}
+
 // ClearPages frees the specified pages from the page blob.
 // For more information, see https://docs.microsoft.com/rest/api/storageservices/put-page.
 func (pb PageBlobURL) ClearPages(ctx context.Context, offset int64, count int64, ac PageBlobAccessConditions) (*PageBlobClearPagesResponse, error) {
diff --git a/azblob/version.go b/azblob/version.go
@@ -1,3 +1,3 @@
 package azblob
 
-const serviceLibVersion = "0.5"
+const serviceLibVersion = "0.6"
diff --git a/azblob/zc_mmf_unix.go b/azblob/zc_mmf_unix.go
@@ -1,4 +1,4 @@
-// +build linux darwin freebsd openbsd netbsd
+// +build linux darwin freebsd openbsd netbsd dragonfly
 
 package azblob
 
diff --git a/azblob/zc_pipeline.go b/azblob/zc_pipeline.go
@@ -17,6 +17,9 @@ type PipelineOptions struct {
 
 	// Telemetry configures the built-in telemetry policy behavior.
 	Telemetry TelemetryOptions
+
+	// HTTPSender configures the sender of HTTP requests
+	HTTPSender pipeline.Factory
 }
 
 // NewPipeline creates a Pipeline using the specified credentials and options.
@@ -35,8 +38,9 @@ func NewPipeline(c Credential, o PipelineOptions) pipeline.Pipeline {
 		f = append(f, c)
 	}
 	f = append(f,
-		pipeline.MethodFactoryMarker(), // indicates at what stage in the pipeline the method factory is invoked
-		NewRequestLogPolicyFactory(o.RequestLog))
+		NewRequestLogPolicyFactory(o.RequestLog),
+		pipeline.MethodFactoryMarker()) // indicates at what stage in the pipeline the method factory is invoked
+
 
-	return pipeline.NewPipeline(f, pipeline.Options{HTTPSender: nil, Log: o.Log})
+	return pipeline.NewPipeline(f, pipeline.Options{HTTPSender: o.HTTPSender, Log: o.Log})
 }
diff --git a/azblob/zc_policy_retry.go b/azblob/zc_policy_retry.go
@@ -120,7 +120,8 @@ func (o RetryOptions) calcDelay(try int32) time.Duration { // try is >=1; never
 	}
 
 	// Introduce some jitter:  [0.0, 1.0) / 2 = [0.0, 0.5) + 0.8 = [0.8, 1.3)
-	delay = time.Duration(delay.Seconds() * (rand.Float64()/2 + 0.8) * float64(time.Second)) // NOTE: We want math/rand; not crypto/rand
+	// For casts and rounding - be careful, as per https://github.com/golang/go/issues/20757
+	delay = time.Duration(float32(delay) * (rand.Float32()/2 + 0.8)) // NOTE: We want math/rand; not crypto/rand
 	if delay > o.MaxRetryDelay {
 		delay = o.MaxRetryDelay
 	}
@@ -157,7 +158,8 @@ func NewRetryPolicyFactory(o RetryOptions) pipeline.Factory {
 					logf("Primary try=%d, Delay=%v\n", primaryTry, delay)
 					time.Sleep(delay) // The 1st try returns 0 delay
 				} else {
-					delay := time.Second * time.Duration(rand.Float32()/2+0.8)
+					// For casts and rounding - be careful, as per https://github.com/golang/go/issues/20757
+					delay := time.Duration(float32(time.Second) * (rand.Float32()/2 + 0.8))
 					logf("Secondary try=%d, Delay=%v\n", try-primaryTry, delay)
 					time.Sleep(delay) // Delay with some jitter before trying secondary
 				}
diff --git a/azblob/zt_examples_test.go b/azblob/zt_examples_test.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"net"
 	"net/http"
 	"net/url"
 	"os"
@@ -154,6 +155,33 @@ func ExampleNewPipeline() {
 				return level <= pipeline.LogWarning // Log all events from warning to more severe
 			},
 		},
+
+		// Set HTTPSender to override the default HTTP Sender that sends the request over the network
+		HTTPSender: pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
+			return func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
+				// Implement the HTTP client that will override the default sender.
+				// For example, below HTTP client uses a transport that is different from http.DefaultTransport
+				client := http.Client{
+					Transport: &http.Transport{
+						Proxy: nil,
+						DialContext: (&net.Dialer{
+							Timeout:   30 * time.Second,
+							KeepAlive: 30 * time.Second,
+							DualStack: true,
+						}).DialContext,
+						MaxIdleConns:          100,
+						IdleConnTimeout:       180 * time.Second,
+						TLSHandshakeTimeout:   10 * time.Second,
+						ExpectContinueTimeout: 1 * time.Second,
+					},
+				}
+
+				// Send the request over the network
+				resp, err := client.Do(request.WithContext(ctx))
+
+				return &httpResponse{response: resp}, err
+			}
+		}),
 	}
 
 	// Create a request pipeline object configured with credentials and with pipeline options. Once created,
diff --git a/azblob/zt_policy_retry_test.go b/azblob/zt_policy_retry_test.go
@@ -155,6 +155,7 @@ func testRetryTestScenario(c *chk.C, scenario retryTestScenario) {
 		MaxRetryDelay:               4 * time.Second,
 		RetryReadsFromSecondaryHost: "SecondaryDC",
 	}
+	minExpectedTimeToMaxRetries := (retryOptions.MaxRetryDelay * time.Duration(retryOptions.MaxTries-3)) / 2 // a very rough approximation, of a lower bound, given assumption that we hit the cap early in the retry count, and pessimistically assuming that all get halved by random jitter calcs
 	ctx := context.Background()
 	ctx, cancel := context.WithTimeout(ctx, 64 /*2^MaxTries(6)*/ *retryOptions.TryTimeout)
 	retrytestPolicyFactory := newRetryTestPolicyFactory(c, scenario, retryOptions.MaxTries, cancel)
@@ -164,16 +165,18 @@ func testRetryTestScenario(c *chk.C, scenario retryTestScenario) {
 	}
 	p := pipeline.NewPipeline(factories[:], pipeline.Options{})
 	request, err := pipeline.NewRequest(http.MethodGet, *u, strings.NewReader("TestData"))
+	start := time.Now()
 	response, err := p.Do(ctx, nil, request)
 	switch scenario {
 	case retryTestScenarioRetryUntilSuccess:
 		if err != nil || response == nil || response.Response() == nil || response.Response().StatusCode != http.StatusOK {
 			c.Fail() // Operation didn't run to success
 		}
 	case retryTestScenarioRetryUntilMaxRetries:
-		c.Assert(err, chk.NotNil)                                               // Ensure we ended with an error
-		c.Assert(response, chk.IsNil)                                           // Ensure we ended without a valid response
-		c.Assert(retrytestPolicyFactory.try, chk.Equals, retryOptions.MaxTries) // Ensure the operation ends with the exact right number of tries
+		c.Assert(err, chk.NotNil)                                                   // Ensure we ended with an error
+		c.Assert(response, chk.IsNil)                                               // Ensure we ended without a valid response
+		c.Assert(retrytestPolicyFactory.try, chk.Equals, retryOptions.MaxTries)     // Ensure the operation ends with the exact right number of tries
+		c.Assert(time.Since(start) > minExpectedTimeToMaxRetries, chk.Equals, true) // Ensure it took about as long to get here as we expect (bearing in mind randomness in the jitter), as a basic sanity check of our delay duration calculations
 	case retryTestScenarioRetryUntilOperationCancel:
 		c.Assert(err, chk.Equals, context.Canceled)                                     // Ensure we ended due to cancellation
 		c.Assert(response, chk.IsNil)                                                   // Ensure we ended without a valid response
diff --git a/azblob/zt_test.go b/azblob/zt_test.go
@@ -187,11 +187,21 @@ func createNewPageBlob(c *chk.C, container azblob.ContainerURL) (blob azblob.Pag
 	blob, name = getPageBlobURL(c, container)
 
 	resp, err := blob.Create(ctx, azblob.PageBlobPageBytes*10, 0, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
+	c.Assert(err, chk.IsNil)
+	c.Assert(resp.StatusCode(), chk.Equals, 201)
+	return
+}
+
+func createNewPageBlobWithSize(c *chk.C, container azblob.ContainerURL, sizeInBytes int64) (blob azblob.PageBlobURL, name string) {
+	blob, name = getPageBlobURL(c, container)
+
+	resp, err := blob.Create(ctx, sizeInBytes, 0, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
 
 	c.Assert(err, chk.IsNil)
 	c.Assert(resp.StatusCode(), chk.Equals, 201)
 	return
 }
+
 func createBlockBlobWithPrefix(c *chk.C, container azblob.ContainerURL, prefix string) (blob azblob.BlockBlobURL, name string) {
 	name = prefix + generateName(blobPrefix)
 	blob = container.NewBlockBlobURL(name)
diff --git a/azblob/zt_url_append_blob_test.go b/azblob/zt_url_append_blob_test.go
@@ -2,6 +2,8 @@ package azblob_test
 
 import (
 	"context"
+	"io/ioutil"
+	"time"
 
 	"crypto/md5"
 
@@ -74,6 +76,154 @@ func (b *aztestsSuite) TestAppendBlockWithMD5(c *chk.C) {
 	validateStorageError(c, err, azblob.ServiceCodeMd5Mismatch)
 }
 
+func (b *aztestsSuite) TestAppendBlockFromURL(c *chk.C) {
+	bsu := getBSU()
+	credential, err := getGenericCredential("")
+	if err != nil {
+		c.Fatal("Invalid credential")
+	}
+	container, _ := createNewContainer(c, bsu)
+	defer delContainer(c, container)
+
+	testSize := 4 * 1024 * 1024 // 4MB
+	r, sourceData := getRandomDataAndReader(testSize)
+	ctx := context.Background() // Use default Background context
+	srcBlob := container.NewAppendBlobURL(generateName("appendsrc"))
+	destBlob := container.NewAppendBlobURL(generateName("appenddest"))
+
+	// Prepare source blob for copy.
+	cResp1, err := srcBlob.Create(context.Background(), azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
+	c.Assert(err, chk.IsNil)
+	c.Assert(cResp1.StatusCode(), chk.Equals, 201)
+	appendResp, err := srcBlob.AppendBlock(context.Background(), r, azblob.AppendBlobAccessConditions{}, nil)
+	c.Assert(err, chk.IsNil)
+	c.Assert(appendResp.Response().StatusCode, chk.Equals, 201)
+	c.Assert(appendResp.BlobAppendOffset(), chk.Equals, "0")
+	c.Assert(appendResp.BlobCommittedBlockCount(), chk.Equals, int32(1))
+	c.Assert(appendResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
+	c.Assert(appendResp.LastModified().IsZero(), chk.Equals, false)
+	c.Assert(appendResp.ContentMD5(), chk.Not(chk.Equals), "")
+	c.Assert(appendResp.RequestID(), chk.Not(chk.Equals), "")
+	c.Assert(appendResp.Version(), chk.Not(chk.Equals), "")
+	c.Assert(appendResp.Date().IsZero(), chk.Equals, false)
+
+	// Get source blob URL with SAS for AppendBlockFromURL.
+	srcBlobParts := azblob.NewBlobURLParts(srcBlob.URL())
+
+	srcBlobParts.SAS, err = azblob.BlobSASSignatureValues{
+		Protocol:      azblob.SASProtocolHTTPS,              // Users MUST use HTTPS (not HTTP)
+		ExpiryTime:    time.Now().UTC().Add(48 * time.Hour), // 48-hours before expiration
+		ContainerName: srcBlobParts.ContainerName,
+		BlobName:      srcBlobParts.BlobName,
+		Permissions:   azblob.BlobSASPermissions{Read: true}.String(),
+	}.NewSASQueryParameters(credential)
+	if err != nil {
+		c.Fatal(err)
+	}
+
+	srcBlobURLWithSAS := srcBlobParts.URL()
+
+	// Append block from URL.
+	cResp2, err := destBlob.Create(context.Background(), azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
+	c.Assert(err, chk.IsNil)
+	c.Assert(cResp2.StatusCode(), chk.Equals, 201)
+	appendFromURLResp, err := destBlob.AppendBlockFromURL(ctx, srcBlobURLWithSAS, 0, int64(testSize), azblob.AppendBlobAccessConditions{}, nil)
+	c.Assert(err, chk.IsNil)
+	c.Assert(appendFromURLResp.Response().StatusCode, chk.Equals, 201)
+	c.Assert(appendFromURLResp.BlobAppendOffset(), chk.Equals, "0")
+	c.Assert(appendFromURLResp.BlobCommittedBlockCount(), chk.Equals, int32(1))
+	c.Assert(appendFromURLResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
+	c.Assert(appendFromURLResp.LastModified().IsZero(), chk.Equals, false)
+	c.Assert(appendFromURLResp.ContentMD5(), chk.Not(chk.Equals), "")
+	c.Assert(appendFromURLResp.RequestID(), chk.Not(chk.Equals), "")
+	c.Assert(appendFromURLResp.Version(), chk.Not(chk.Equals), "")
+	c.Assert(appendFromURLResp.Date().IsZero(), chk.Equals, false)
+
+	// Check data integrity through downloading.
+	downloadResp, err := destBlob.BlobURL.Download(ctx, 0, azblob.CountToEnd, azblob.BlobAccessConditions{}, false)
+	c.Assert(err, chk.IsNil)
+	destData, err := ioutil.ReadAll(downloadResp.Body(azblob.RetryReaderOptions{}))
+	c.Assert(err, chk.IsNil)
+	c.Assert(destData, chk.DeepEquals, sourceData)
+}
+
+func (b *aztestsSuite) TestAppendBlockFromURLWithMD5(c *chk.C) {
+	bsu := getBSU()
+	credential, err := getGenericCredential("")
+	if err != nil {
+		c.Fatal("Invalid credential")
+	}
+	container, _ := createNewContainer(c, bsu)
+	defer delContainer(c, container)
+
+	testSize := 4 * 1024 * 1024 // 4MB
+	r, sourceData := getRandomDataAndReader(testSize)
+	md5Value := md5.Sum(sourceData)
+	ctx := context.Background() // Use default Background context
+	srcBlob := container.NewAppendBlobURL(generateName("appendsrc"))
+	destBlob := container.NewAppendBlobURL(generateName("appenddest"))
+
+	// Prepare source blob for copy.
+	cResp1, err := srcBlob.Create(context.Background(), azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
+	c.Assert(err, chk.IsNil)
+	c.Assert(cResp1.StatusCode(), chk.Equals, 201)
+	appendResp, err := srcBlob.AppendBlock(context.Background(), r, azblob.AppendBlobAccessConditions{}, nil)
+	c.Assert(err, chk.IsNil)
+	c.Assert(appendResp.Response().StatusCode, chk.Equals, 201)
+	c.Assert(appendResp.BlobAppendOffset(), chk.Equals, "0")
+	c.Assert(appendResp.BlobCommittedBlockCount(), chk.Equals, int32(1))
+	c.Assert(appendResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
+	c.Assert(appendResp.LastModified().IsZero(), chk.Equals, false)
+	c.Assert(appendResp.ContentMD5(), chk.Not(chk.Equals), "")
+	c.Assert(appendResp.RequestID(), chk.Not(chk.Equals), "")
+	c.Assert(appendResp.Version(), chk.Not(chk.Equals), "")
+	c.Assert(appendResp.Date().IsZero(), chk.Equals, false)
+
+	// Get source blob URL with SAS for AppendBlockFromURL.
+	srcBlobParts := azblob.NewBlobURLParts(srcBlob.URL())
+
+	srcBlobParts.SAS, err = azblob.BlobSASSignatureValues{
+		Protocol:      azblob.SASProtocolHTTPS,              // Users MUST use HTTPS (not HTTP)
+		ExpiryTime:    time.Now().UTC().Add(48 * time.Hour), // 48-hours before expiration
+		ContainerName: srcBlobParts.ContainerName,
+		BlobName:      srcBlobParts.BlobName,
+		Permissions:   azblob.BlobSASPermissions{Read: true}.String(),
+	}.NewSASQueryParameters(credential)
+	if err != nil {
+		c.Fatal(err)
+	}
+
+	srcBlobURLWithSAS := srcBlobParts.URL()
+
+	// Append block from URL.
+	cResp2, err := destBlob.Create(context.Background(), azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
+	c.Assert(err, chk.IsNil)
+	c.Assert(cResp2.StatusCode(), chk.Equals, 201)
+	appendFromURLResp, err := destBlob.AppendBlockFromURL(ctx, srcBlobURLWithSAS, 0, int64(testSize), azblob.AppendBlobAccessConditions{}, md5Value[:])
+	c.Assert(err, chk.IsNil)
+	c.Assert(appendFromURLResp.Response().StatusCode, chk.Equals, 201)
+	c.Assert(appendFromURLResp.BlobAppendOffset(), chk.Equals, "0")
+	c.Assert(appendFromURLResp.BlobCommittedBlockCount(), chk.Equals, int32(1))
+	c.Assert(appendFromURLResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
+	c.Assert(appendFromURLResp.LastModified().IsZero(), chk.Equals, false)
+	c.Assert(appendFromURLResp.ContentMD5(), chk.DeepEquals, md5Value[:])
+	c.Assert(appendFromURLResp.RequestID(), chk.Not(chk.Equals), "")
+	c.Assert(appendFromURLResp.Version(), chk.Not(chk.Equals), "")
+	c.Assert(appendFromURLResp.Date().IsZero(), chk.Equals, false)
+
+	// Check data integrity through downloading.
+	downloadResp, err := destBlob.BlobURL.Download(ctx, 0, azblob.CountToEnd, azblob.BlobAccessConditions{}, false)
+	c.Assert(err, chk.IsNil)
+	destData, err := ioutil.ReadAll(downloadResp.Body(azblob.RetryReaderOptions{}))
+	c.Assert(err, chk.IsNil)
+	c.Assert(destData, chk.DeepEquals, sourceData)
+
+	// Test append block from URL with bad MD5 value
+	_, badMD5 := getRandomDataAndReader(16)
+	_, err = destBlob.AppendBlockFromURL(ctx, srcBlobURLWithSAS, 0, int64(testSize), azblob.AppendBlobAccessConditions{}, badMD5[:])
+	validateStorageError(c, err, azblob.ServiceCodeMd5Mismatch)
+}
+
 func (s *aztestsSuite) TestBlobCreateAppendMetadataNonEmpty(c *chk.C) {
 	bsu := getBSU()
 	containerURL, _ := createNewContainer(c, bsu)
diff --git a/azblob/zt_url_blob_test.go b/azblob/zt_url_blob_test.go
@@ -257,7 +257,7 @@ func (s *aztestsSuite) TestBlobStartCopyUsingSASSrc(c *chk.C) {
 	if err != nil {
 		c.Fatal("Invalid credential")
 	}
-	serviceSASValues := azblob.BlobSASSignatureValues{Version: "2015-04-05", StartTime: time.Now().Add(-1 * time.Hour).UTC(),
+	serviceSASValues := azblob.BlobSASSignatureValues{StartTime: time.Now().Add(-1 * time.Hour).UTC(),
 		ExpiryTime: time.Now().Add(time.Hour).UTC(), Permissions: azblob.BlobSASPermissions{Read: true, Write: true}.String(),
 		ContainerName: containerName, BlobName: blobName}
 	queryParams, err := serviceSASValues.NewSASQueryParameters(credential)
diff --git a/azblob/zt_url_container_test.go b/azblob/zt_url_container_test.go
@@ -701,8 +701,7 @@ func (s *aztestsSuite) TestContainerSetPermissionsACLSinglePolicy(c *chk.C) {
 	_, err = containerURL.SetAccessPolicy(ctx, azblob.PublicAccessNone, permissions, azblob.ContainerAccessConditions{})
 	c.Assert(err, chk.IsNil)
 
-	serviceSASValues := azblob.BlobSASSignatureValues{Version: "2015-04-05",
-		Identifier: "0000", ContainerName: containerName}
+	serviceSASValues := azblob.BlobSASSignatureValues{Identifier: "0000", ContainerName: containerName}
 	queryParams, err := serviceSASValues.NewSASQueryParameters(credential)
 	if err != nil {
 		c.Fatal(err)
diff --git a/azblob/zt_url_page_blob_test.go b/azblob/zt_url_page_blob_test.go
diff --git a/azblob/zz_generated_append_blob.go b/azblob/zz_generated_append_blob.go
diff --git a/azblob/zz_generated_client.go b/azblob/zz_generated_client.go
diff --git a/azblob/zz_generated_models.go b/azblob/zz_generated_models.go
diff --git a/azblob/zz_generated_page_blob.go b/azblob/zz_generated_page_blob.go
diff --git a/azblob/zz_generated_version.go b/azblob/zz_generated_version.go

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`package azblob`
`2`	`2`
`3`		`-const serviceLibVersion = "0.5"`
	`3`	`+const serviceLibVersion = "0.6"`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// +build linux darwin freebsd openbsd netbsd`
	`1`	`+// +build linux darwin freebsd openbsd netbsd dragonfly`
`2`	`2`
`3`	`3`	`package azblob`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,9 @@ type PipelineOptions struct {`
`17`	`17`
`18`	`18`	`// Telemetry configures the built-in telemetry policy behavior.`
`19`	`19`	`Telemetry TelemetryOptions`
	`20`	`+`
	`21`	`+ // HTTPSender configures the sender of HTTP requests`
	`22`	`+ HTTPSender pipeline.Factory`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`// NewPipeline creates a Pipeline using the specified credentials and options.`
`@@ -35,8 +38,9 @@ func NewPipeline(c Credential, o PipelineOptions) pipeline.Pipeline {`
`35`	`38`	`f = append(f, c)`
`36`	`39`	`}`
`37`	`40`	`f = append(f,`
`38`		`- pipeline.MethodFactoryMarker(), // indicates at what stage in the pipeline the method factory is invoked`
`39`		`- NewRequestLogPolicyFactory(o.RequestLog))`
	`41`	`+ NewRequestLogPolicyFactory(o.RequestLog),`
	`42`	`+ pipeline.MethodFactoryMarker()) // indicates at what stage in the pipeline the method factory is invoked`
	`43`	`+`
`40`	`44`
`41`		`- return pipeline.NewPipeline(f, pipeline.Options{HTTPSender: nil, Log: o.Log})`
	`45`	`+ return pipeline.NewPipeline(f, pipeline.Options{HTTPSender: o.HTTPSender, Log: o.Log})`
`42`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,8 @@ func (o RetryOptions) calcDelay(try int32) time.Duration { // try is >=1; never`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`// Introduce some jitter: [0.0, 1.0) / 2 = [0.0, 0.5) + 0.8 = [0.8, 1.3)`
`123`		`- delay = time.Duration(delay.Seconds() * (rand.Float64()/2 + 0.8) * float64(time.Second)) // NOTE: We want math/rand; not crypto/rand`
	`123`	`+ // For casts and rounding - be careful, as per https://github.com/golang/go/issues/20757`
	`124`	`+ delay = time.Duration(float32(delay) * (rand.Float32()/2 + 0.8)) // NOTE: We want math/rand; not crypto/rand`
`124`	`125`	`if delay > o.MaxRetryDelay {`
`125`	`126`	`delay = o.MaxRetryDelay`
`126`	`127`	`}`
`@@ -157,7 +158,8 @@ func NewRetryPolicyFactory(o RetryOptions) pipeline.Factory {`
`157`	`158`	`logf("Primary try=%d, Delay=%v\n", primaryTry, delay)`
`158`	`159`	`time.Sleep(delay) // The 1st try returns 0 delay`
`159`	`160`	`} else {`
`160`		`- delay := time.Second * time.Duration(rand.Float32()/2+0.8)`
	`161`	`+ // For casts and rounding - be careful, as per https://github.com/golang/go/issues/20757`
	`162`	`+ delay := time.Duration(float32(time.Second) * (rand.Float32()/2 + 0.8))`
`161`	`163`	`logf("Secondary try=%d, Delay=%v\n", try-primaryTry, delay)`
`162`	`164`	`time.Sleep(delay) // Delay with some jitter before trying secondary`
`163`	`165`	`}`