Renamed APIs with significant changes
This commit is contained in:
Родитель
70edea0000
Коммит
b67c506542
|
@ -1,67 +1,67 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"time"
|
||||
)
|
||||
|
||||
// HTTPAccessConditions identifies standard HTTP access conditions which you optionally set.
|
||||
type HTTPAccessConditions struct {
|
||||
IfModifiedSince time.Time
|
||||
IfUnmodifiedSince time.Time
|
||||
IfMatch ETag
|
||||
IfNoneMatch ETag
|
||||
}
|
||||
|
||||
// pointers is for internal infrastructure. It returns the fields as pointers.
|
||||
func (ac HTTPAccessConditions) pointers() (ims *time.Time, ius *time.Time, ime *ETag, inme *ETag) {
|
||||
if !ac.IfModifiedSince.IsZero() {
|
||||
ims = &ac.IfModifiedSince
|
||||
}
|
||||
if !ac.IfUnmodifiedSince.IsZero() {
|
||||
ius = &ac.IfUnmodifiedSince
|
||||
}
|
||||
if ac.IfMatch != ETagNone {
|
||||
ime = &ac.IfMatch
|
||||
}
|
||||
if ac.IfNoneMatch != ETagNone {
|
||||
inme = &ac.IfNoneMatch
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ContainerAccessConditions identifies container-specific access conditions which you optionally set.
|
||||
type ContainerAccessConditions struct {
|
||||
HTTPAccessConditions
|
||||
LeaseAccessConditions
|
||||
}
|
||||
|
||||
// BlobAccessConditions identifies blob-specific access conditions which you optionally set.
|
||||
type BlobAccessConditions struct {
|
||||
HTTPAccessConditions
|
||||
LeaseAccessConditions
|
||||
AppendBlobAccessConditions
|
||||
PageBlobAccessConditions
|
||||
}
|
||||
|
||||
// LeaseAccessConditions identifies lease access conditions for a container or blob which you optionally set.
|
||||
type LeaseAccessConditions struct {
|
||||
LeaseID string
|
||||
}
|
||||
|
||||
// pointers is for internal infrastructure. It returns the fields as pointers.
|
||||
func (ac LeaseAccessConditions) pointers() (leaseID *string) {
|
||||
if ac.LeaseID != "" {
|
||||
leaseID = &ac.LeaseID
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
/*
|
||||
// getInt32 is for internal infrastructure. It is used with access condition values where
|
||||
// 0 (the default setting) is meaningful. The library interprets 0 as do not send the header
|
||||
// and the privately-storage field in the access condition object is stored as +1 higher than desired.
|
||||
// THis method returns true, if the value is > 0 (explicitly set) and the stored value - 1 (the set desired value).
|
||||
func getInt32(value int32) (bool, int32) {
|
||||
return value > 0, value - 1
|
||||
}
|
||||
*/
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"time"
|
||||
)
|
||||
|
||||
// HTTPAccessConditions identifies standard HTTP access conditions which you optionally set.
|
||||
type HTTPAccessConditions struct {
|
||||
IfModifiedSince time.Time
|
||||
IfUnmodifiedSince time.Time
|
||||
IfMatch ETag
|
||||
IfNoneMatch ETag
|
||||
}
|
||||
|
||||
// pointers is for internal infrastructure. It returns the fields as pointers.
|
||||
func (ac HTTPAccessConditions) pointers() (ims *time.Time, ius *time.Time, ime *ETag, inme *ETag) {
|
||||
if !ac.IfModifiedSince.IsZero() {
|
||||
ims = &ac.IfModifiedSince
|
||||
}
|
||||
if !ac.IfUnmodifiedSince.IsZero() {
|
||||
ius = &ac.IfUnmodifiedSince
|
||||
}
|
||||
if ac.IfMatch != ETagNone {
|
||||
ime = &ac.IfMatch
|
||||
}
|
||||
if ac.IfNoneMatch != ETagNone {
|
||||
inme = &ac.IfNoneMatch
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ContainerAccessConditions identifies container-specific access conditions which you optionally set.
|
||||
type ContainerAccessConditions struct {
|
||||
HTTPAccessConditions
|
||||
LeaseAccessConditions
|
||||
}
|
||||
|
||||
// BlobAccessConditions identifies blob-specific access conditions which you optionally set.
|
||||
type BlobAccessConditions struct {
|
||||
HTTPAccessConditions
|
||||
LeaseAccessConditions
|
||||
AppendBlobAccessConditions
|
||||
PageBlobAccessConditions
|
||||
}
|
||||
|
||||
// LeaseAccessConditions identifies lease access conditions for a container or blob which you optionally set.
|
||||
type LeaseAccessConditions struct {
|
||||
LeaseID string
|
||||
}
|
||||
|
||||
// pointers is for internal infrastructure. It returns the fields as pointers.
|
||||
func (ac LeaseAccessConditions) pointers() (leaseID *string) {
|
||||
if ac.LeaseID != "" {
|
||||
leaseID = &ac.LeaseID
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
/*
|
||||
// getInt32 is for internal infrastructure. It is used with access condition values where
|
||||
// 0 (the default setting) is meaningful. The library interprets 0 as do not send the header
|
||||
// and the privately-storage field in the access condition object is stored as +1 higher than desired.
|
||||
// THis method returns true, if the value is > 0 (explicitly set) and the stored value - 1 (the set desired value).
|
||||
func getInt32(value int32) (bool, int32) {
|
||||
return value > 0, value - 1
|
||||
}
|
||||
*/
|
||||
|
|
|
@ -0,0 +1,79 @@
|
|||
package azblob
|
||||
|
||||
import "sync/atomic"
|
||||
|
||||
// AtomicMorpherInt32 identifies a method passed to and invoked by the AtomicMorphInt32 function.
|
||||
// The AtomicMorpher callback is passed a startValue and based on this value it returns
|
||||
// what the new value should be and the result that AtomicMorph should return to its caller.
|
||||
type AtomicMorpherInt32 func(startVal int32) (val int32, morphResult interface{})
|
||||
|
||||
// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
|
||||
func AtomicMorphInt32(target *int32, morpher AtomicMorpherInt32) interface{} {
|
||||
if target == nil || morpher == nil {
|
||||
panic("target and morpher mut not be nil")
|
||||
}
|
||||
for {
|
||||
currentVal := atomic.LoadInt32(target)
|
||||
desiredVal, morphResult := morpher(currentVal)
|
||||
if atomic.CompareAndSwapInt32(target, currentVal, desiredVal) {
|
||||
return morphResult
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// AtomicMorpherUint32 identifies a method passed to and invoked by the AtomicMorph function.
|
||||
// The AtomicMorpher callback is passed a startValue and based on this value it returns
|
||||
// what the new value should be and the result that AtomicMorph should return to its caller.
|
||||
type AtomicMorpherUint32 func(startVal uint32) (val uint32, morphResult interface{})
|
||||
|
||||
// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
|
||||
func AtomicMorphUint32(target *uint32, morpher AtomicMorpherUint32) interface{} {
|
||||
if target == nil || morpher == nil {
|
||||
panic("target and morpher mut not be nil")
|
||||
}
|
||||
for {
|
||||
currentVal := atomic.LoadUint32(target)
|
||||
desiredVal, morphResult := morpher(currentVal)
|
||||
if atomic.CompareAndSwapUint32(target, currentVal, desiredVal) {
|
||||
return morphResult
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// AtomicMorpherUint64 identifies a method passed to and invoked by the AtomicMorphUint64 function.
|
||||
// The AtomicMorpher callback is passed a startValue and based on this value it returns
|
||||
// what the new value should be and the result that AtomicMorph should return to its caller.
|
||||
type AtomicMorpherInt64 func(startVal int64) (val int64, morphResult interface{})
|
||||
|
||||
// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
|
||||
func AtomicMorphInt64(target *int64, morpher AtomicMorpherInt64) interface{} {
|
||||
if target == nil || morpher == nil {
|
||||
panic("target and morpher mut not be nil")
|
||||
}
|
||||
for {
|
||||
currentVal := atomic.LoadInt64(target)
|
||||
desiredVal, morphResult := morpher(currentVal)
|
||||
if atomic.CompareAndSwapInt64(target, currentVal, desiredVal) {
|
||||
return morphResult
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// AtomicMorpherUint64 identifies a method passed to and invoked by the AtomicMorphUint64 function.
|
||||
// The AtomicMorpher callback is passed a startValue and based on this value it returns
|
||||
// what the new value should be and the result that AtomicMorph should return to its caller.
|
||||
type AtomicMorpherUint64 func(startVal uint64) (val uint64, morphResult interface{})
|
||||
|
||||
// AtomicMorph atomically morphs target in to new value (and result) as indicated bythe AtomicMorpher callback function.
|
||||
func AtomicMorphUint64(target *uint64, morpher AtomicMorpherUint64) interface{} {
|
||||
if target == nil || morpher == nil {
|
||||
panic("target and morpher mut not be nil")
|
||||
}
|
||||
for {
|
||||
currentVal := atomic.LoadUint64(target)
|
||||
desiredVal, morphResult := morpher(currentVal)
|
||||
if atomic.CompareAndSwapUint64(target, currentVal, desiredVal) {
|
||||
return morphResult
|
||||
}
|
||||
}
|
||||
}
|
|
@ -5,14 +5,14 @@ import (
|
|||
"encoding/base64"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
|
||||
"bytes"
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// CommonResponseHeaders returns the headers common to all blob REST API responses.
|
||||
|
@ -38,13 +38,13 @@ type CommonResponse interface {
|
|||
|
||||
// UploadToBlockBlobOptions identifies options used by the UploadBufferToBlockBlob and UploadFileToBlockBlob functions.
|
||||
type UploadToBlockBlobOptions struct {
|
||||
// BlockSize specifies the block size to use; the default (and maximum size) is BlockBlobMaxPutBlockBytes.
|
||||
BlockSize uint64
|
||||
// BlockSize specifies the block size to use; the default (and maximum size) is BlockBlobMaxStageBlockBytes.
|
||||
BlockSize int64
|
||||
|
||||
// Progress is a function that is invoked periodically as bytes are send in a PutBlock call to the BlockBlobURL.
|
||||
// Progress is a function that is invoked periodically as bytes are sent to the BlockBlobURL.
|
||||
Progress pipeline.ProgressReceiver
|
||||
|
||||
// BlobHTTPHeaders indicates the HTTP headers to be associated with the blob when PutBlockList is called.
|
||||
// BlobHTTPHeaders indicates the HTTP headers to be associated with the blob.
|
||||
BlobHTTPHeaders BlobHTTPHeaders
|
||||
|
||||
// Metadata indicates the metadata to be associated with the blob when PutBlockList is called.
|
||||
|
@ -61,96 +61,69 @@ type UploadToBlockBlobOptions struct {
|
|||
func UploadBufferToBlockBlob(ctx context.Context, b []byte,
|
||||
blockBlobURL BlockBlobURL, o UploadToBlockBlobOptions) (CommonResponse, error) {
|
||||
|
||||
if o.BlockSize < 0 || o.BlockSize > BlockBlobMaxPutBlockBytes {
|
||||
panic(fmt.Sprintf("BlockSize option must be > 0 and <= %d", BlockBlobMaxPutBlockBytes))
|
||||
// Validate parameters and set defaults
|
||||
if o.BlockSize < 0 || o.BlockSize > BlockBlobMaxUploadBlobBytes {
|
||||
panic(fmt.Sprintf("BlockSize option must be > 0 and <= %d", BlockBlobMaxUploadBlobBytes))
|
||||
}
|
||||
if o.BlockSize == 0 {
|
||||
o.BlockSize = BlockBlobMaxPutBlockBytes // Default if unspecified
|
||||
o.BlockSize = BlockBlobMaxUploadBlobBytes // Default if unspecified
|
||||
}
|
||||
size := uint64(len(b))
|
||||
size := int64(len(b))
|
||||
|
||||
if size <= BlockBlobMaxPutBlobBytes {
|
||||
// If the size can fit in 1 Put Blob call, do it this way
|
||||
if size <= BlockBlobMaxUploadBlobBytes {
|
||||
// If the size can fit in 1 Upload call, do it this way
|
||||
var body io.ReadSeeker = bytes.NewReader(b)
|
||||
if o.Progress != nil {
|
||||
body = pipeline.NewRequestBodyProgress(body, o.Progress)
|
||||
}
|
||||
return blockBlobURL.PutBlob(ctx, body, o.BlobHTTPHeaders, o.Metadata, o.AccessConditions)
|
||||
return blockBlobURL.Upload(ctx, body, o.BlobHTTPHeaders, o.Metadata, o.AccessConditions)
|
||||
}
|
||||
|
||||
parallelism := o.Parallelism
|
||||
if parallelism == 0 {
|
||||
parallelism = 5 // default parallelism
|
||||
}
|
||||
|
||||
var numBlocks uint16 = uint16(((size - 1) / o.BlockSize) + 1)
|
||||
var numBlocks = uint16(((size - 1) / o.BlockSize) + 1)
|
||||
if numBlocks > BlockBlobMaxBlocks {
|
||||
panic(fmt.Sprintf("The streamSize is too big or the BlockSize is too small; the number of blocks must be <= %d", BlockBlobMaxBlocks))
|
||||
panic(fmt.Sprintf("The buffer's size is too big or the BlockSize is too small; the number of blocks must be <= %d", BlockBlobMaxBlocks))
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
defer cancel()
|
||||
blockIDList := make([]string, numBlocks) // Base 64 encoded block IDs
|
||||
blockSize := o.BlockSize
|
||||
|
||||
putBlockChannel := make(chan func() (*BlockBlobsPutBlockResponse, error), parallelism) // Create the channel that release 'parallelism' goroutines concurrently
|
||||
putBlockResponseChannel := make(chan error, numBlocks) // Holds each Put Block's response
|
||||
|
||||
// Create the goroutines that process each Put Block (in parallel)
|
||||
for g := uint16(0); g < parallelism; g++ {
|
||||
go func() {
|
||||
for f := range putBlockChannel {
|
||||
_, err := f()
|
||||
putBlockResponseChannel <- err
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
blobProgress := int64(0)
|
||||
blockIDList := make([]string, numBlocks) // Base-64 encoded block IDs
|
||||
progress := int64(0)
|
||||
progressLock := &sync.Mutex{}
|
||||
|
||||
// Add each put block to the channel
|
||||
for blockNum := uint16(0); blockNum < numBlocks; blockNum++ {
|
||||
if blockNum == numBlocks-1 { // Last block
|
||||
blockSize = size - (uint64(blockNum) * o.BlockSize) // Remove size of all uploaded blocks from total
|
||||
}
|
||||
offset := uint64(blockNum) * o.BlockSize
|
||||
err := doBatchTransfer(ctx, batchTransferOptions{
|
||||
operationName: "UploadBufferToBlockBlob",
|
||||
transferSize: size,
|
||||
chunkSize: o.BlockSize,
|
||||
parallelism: o.Parallelism,
|
||||
operation: func(offset int64, count int64) error {
|
||||
// This function is called once per block.
|
||||
// It is passed this block's offset within the buffer and its count of bytes
|
||||
// Prepare to read the proper block/section of the buffer
|
||||
var body io.ReadSeeker = bytes.NewReader(b[offset : offset+count])
|
||||
blockNum := offset / o.BlockSize
|
||||
if o.Progress != nil {
|
||||
blockProgress := int64(0)
|
||||
body = pipeline.NewRequestBodyProgress(body,
|
||||
func(bytesTransferred int64) {
|
||||
diff := bytesTransferred - blockProgress
|
||||
blockProgress = bytesTransferred
|
||||
progressLock.Lock() // 1 goroutine at a time gets a progress report
|
||||
progress += diff
|
||||
o.Progress(progress)
|
||||
progressLock.Unlock()
|
||||
})
|
||||
}
|
||||
|
||||
// Prepare to read the proper block/section of the buffer
|
||||
var body io.ReadSeeker = bytes.NewReader(b[offset : offset+blockSize])
|
||||
capturedBlockNum := blockNum
|
||||
if o.Progress != nil {
|
||||
blockProgress := int64(0)
|
||||
body = pipeline.NewRequestBodyProgress(body,
|
||||
func(bytesTransferred int64) {
|
||||
diff := bytesTransferred - blockProgress
|
||||
blockProgress = bytesTransferred
|
||||
progressLock.Lock()
|
||||
blobProgress += diff
|
||||
o.Progress(blobProgress)
|
||||
progressLock.Unlock()
|
||||
})
|
||||
}
|
||||
|
||||
// Block IDs are unique values to avoid issue if 2+ clients are uploading blocks
|
||||
// at the same time causing PutBlockList to get a mix of blocks from all the clients.
|
||||
blockIDList[blockNum] = base64.StdEncoding.EncodeToString(newUUID().bytes())
|
||||
putBlockChannel <- func() (*BlockBlobsPutBlockResponse, error) {
|
||||
return blockBlobURL.PutBlock(ctx, blockIDList[capturedBlockNum], body, o.AccessConditions.LeaseAccessConditions)
|
||||
}
|
||||
}
|
||||
close(putBlockChannel)
|
||||
|
||||
// Wait for the put blocks to complete
|
||||
for blockNum := uint16(0); blockNum < numBlocks; blockNum++ {
|
||||
responseError := <-putBlockResponseChannel
|
||||
if responseError != nil {
|
||||
cancel() // As soon as any Put Block fails, cancel all remaining Put Block calls
|
||||
return nil, responseError // No need to process anymore responses
|
||||
}
|
||||
// Block IDs are unique values to avoid issue if 2+ clients are uploading blocks
|
||||
// at the same time causing PutBlockList to get a mix of blocks from all the clients.
|
||||
blockIDList[blockNum] = base64.StdEncoding.EncodeToString(newUUID().bytes())
|
||||
_, err := blockBlobURL.StageBlock(ctx, blockIDList[blockNum], body, o.AccessConditions.LeaseAccessConditions)
|
||||
return err
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// All put blocks were successful, call Put Block List to finalize the blob
|
||||
return blockBlobURL.PutBlockList(ctx, blockIDList, o.Metadata, o.BlobHTTPHeaders, o.AccessConditions)
|
||||
return blockBlobURL.CommitBlockList(ctx, blockIDList, o.BlobHTTPHeaders, o.Metadata, o.AccessConditions)
|
||||
}
|
||||
|
||||
// UploadFileToBlockBlob uploads a file in blocks to a block blob.
|
||||
|
@ -172,78 +145,341 @@ func UploadFileToBlockBlob(ctx context.Context, file *os.File,
|
|||
return UploadBufferToBlockBlob(ctx, m, blockBlobURL, o)
|
||||
}
|
||||
|
||||
// DownloadStreamOptions is used to configure a call to NewDownloadBlobToStream to download a large stream with intelligent retries.
|
||||
type DownloadStreamOptions struct {
|
||||
// Range indicates the starting offset and count of bytes within the blob to download.
|
||||
Range BlobRange
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// AccessConditions indicates the BlobAccessConditions to use when accessing the blob.
|
||||
/*
|
||||
const BlobDefaultDownloadBlockSize = int64(4 * 1024 * 1024) // 4MB
|
||||
|
||||
// DownloadFromAzureFileOptions identifies options used by the DownloadAzureFileToBuffer and DownloadAzureFileToFile functions.
|
||||
type DownloadFromBlobOptions struct {
|
||||
// BlockSize specifies the block size to use for each parallel download; the default size is BlobDefaultDownloadBlockSize.
|
||||
BlockSize int64
|
||||
|
||||
// Progress is a function that is invoked periodically as bytes are received.
|
||||
Progress pipeline.ProgressReceiver
|
||||
|
||||
// AccessConditions indicates the access conditions used when making HTTP GET requests against the blob.
|
||||
AccessConditions BlobAccessConditions
|
||||
|
||||
// Parallelism indicates the maximum number of blocks to download in parallel (0=default)
|
||||
Parallelism uint16
|
||||
|
||||
// RetryReaderOptionsPerBlock is used when downloading each block.
|
||||
RetryReaderOptionsPerBlock RetryReaderOptions
|
||||
}
|
||||
|
||||
type retryStream struct {
|
||||
ctx context.Context
|
||||
getBlob func(ctx context.Context, blobRange BlobRange, ac BlobAccessConditions, rangeGetContentMD5 bool) (*GetResponse, error)
|
||||
o DownloadStreamOptions
|
||||
response *http.Response
|
||||
}
|
||||
|
||||
// NewDownloadStream creates a stream over a blob allowing you download the blob's contents.
|
||||
// When network errors occur, the retry stream internally issues new HTTP GET requests for
|
||||
// the remaining range of the blob's contents. The GetBlob argument identifies the function
|
||||
// to invoke when the GetRetryStream needs to make an HTTP GET request as Read methods are called.
|
||||
// The callback can wrap the response body (with progress reporting, for example) before returning.
|
||||
func NewDownloadStream(ctx context.Context,
|
||||
getBlob func(ctx context.Context, blobRange BlobRange, ac BlobAccessConditions, rangeGetContentMD5 bool) (*GetResponse, error),
|
||||
o DownloadStreamOptions) io.ReadCloser {
|
||||
|
||||
// BlobAccessConditions may already have an If-Match:etag header
|
||||
if getBlob == nil {
|
||||
panic("getBlob must not be nil")
|
||||
// downloadAzureFileToBuffer downloads an Azure file to a buffer with parallel.
|
||||
func downloadBlobToBuffer(ctx context.Context, blobURL BlobURL, offset int64, count int64, ac BlobAccessConditions, b []byte, o DownloadFromBlobOptions,
|
||||
initialDownloadResponse *DownloadResponse) error {
|
||||
// Validate parameters, and set defaults.
|
||||
if o.BlockSize < 0 {
|
||||
panic("BlockSize option must be >= 0")
|
||||
}
|
||||
return &retryStream{ctx: ctx, getBlob: getBlob, o: o, response: nil}
|
||||
}
|
||||
|
||||
func (s *retryStream) Read(p []byte) (n int, err error) {
|
||||
for {
|
||||
if s.response != nil { // We working with a successful response
|
||||
n, err := s.response.Body.Read(p) // Read from the stream
|
||||
if err == nil || err == io.EOF { // We successfully read data or end EOF
|
||||
s.o.Range.Offset += int64(n) // Increments the start offset in case we need to make a new HTTP request in the future
|
||||
if s.o.Range.Count != 0 {
|
||||
s.o.Range.Count -= int64(n) // Decrement the count in case we need to make a new HTTP request in the future
|
||||
}
|
||||
return n, err // Return the return to the caller
|
||||
}
|
||||
s.Close()
|
||||
s.response = nil // Something went wrong; our stream is no longer good
|
||||
if nerr, ok := err.(net.Error); ok {
|
||||
if !nerr.Timeout() && !nerr.Temporary() {
|
||||
return n, err // Not retryable
|
||||
}
|
||||
} else {
|
||||
return n, err // Not retryable, just return
|
||||
}
|
||||
}
|
||||
|
||||
// We don't have a response stream to read from, try to get one
|
||||
response, err := s.getBlob(s.ctx, s.o.Range, s.o.AccessConditions, false)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
// Successful GET; this is the network stream we'll read from
|
||||
s.response = response.Response()
|
||||
|
||||
// Ensure that future requests are from the same version of the source
|
||||
s.o.AccessConditions.IfMatch = response.ETag()
|
||||
|
||||
// Loop around and try to read from this stream
|
||||
if o.BlockSize == 0 {
|
||||
o.BlockSize = BlobDefaultDownloadBlockSize
|
||||
}
|
||||
}
|
||||
|
||||
func (s *retryStream) Close() error {
|
||||
if s.response != nil && s.response.Body != nil {
|
||||
return s.response.Body.Close()
|
||||
if count == -1 { // If size not specified, calculate it
|
||||
if initialDownloadResponse != nil {
|
||||
count = initialDownloadResponse.ContentLength() - offset // if we have the length, use it
|
||||
} else {
|
||||
// If we don't have the length at all, get it
|
||||
dr, err := blobURL.Download(ctx, 0, CountToEnd, ac, false)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
count = dr.ContentLength() - offset
|
||||
}
|
||||
}
|
||||
|
||||
if int64(len(b)) < count {
|
||||
panic(fmt.Errorf("The buffer's size should be equal to or larger than the request count of bytes: %d.", count))
|
||||
}
|
||||
|
||||
// Prepare and do parallel download.
|
||||
progress := int64(0)
|
||||
progressLock := &sync.Mutex{}
|
||||
|
||||
err := doBatchTransfer(ctx, batchTransferOptions{
|
||||
operationName: "downloadBlobToBuffer",
|
||||
bufferSize: count,
|
||||
chunkSize: o.BlockSize,
|
||||
parallelism: o.Parallelism,
|
||||
operation: func(offset int64, count int64) error {
|
||||
dr, err := blobURL.Download(ctx, offset, count, ac, false)
|
||||
body := dr.Body(o.RetryReaderOptionsPerBlock)
|
||||
if o.Progress != nil {
|
||||
rangeProgress := int64(0)
|
||||
body = pipeline.NewResponseBodyProgress(
|
||||
body,
|
||||
func(bytesTransferred int64) {
|
||||
diff := bytesTransferred - rangeProgress
|
||||
rangeProgress = bytesTransferred
|
||||
progressLock.Lock()
|
||||
progress += diff
|
||||
o.Progress(progress)
|
||||
progressLock.Unlock()
|
||||
})
|
||||
}
|
||||
_, err = io.ReadFull(body, b[offset:offset+count])
|
||||
body.Close()
|
||||
return err
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// DownloadAzureFileToBuffer downloads an Azure file to a buffer with parallel.
|
||||
func DownloadBlobToBuffer(ctx context.Context, blobURL BlobURL, b []byte, o DownloadFromBlobOptions) error {
|
||||
return downloadBlobToBuffer(ctx, blobURL, nil, b, o)
|
||||
}
|
||||
|
||||
// DownloadBlobToFile downloads an Azure file to a local file.
|
||||
// The file would be created if it doesn't exist, and would be truncated if the size doesn't match.
|
||||
func DownloadBlobToFile(ctx context.Context, blobURL BlobURL, ac BlobAccessConditions, file *os.File, o DownloadFromBlobOptions) error {
|
||||
// 1. Validate parameters.
|
||||
if file == nil {
|
||||
panic("file must not be nil")
|
||||
}
|
||||
|
||||
// 2. Try to get Azure file's size.
|
||||
props, err := blobURL.GetProperties(ctx, ac)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
size := props.ContentLength()
|
||||
|
||||
// 3. Compare and try to resize local file's size if it doesn't match Azure file's size.
|
||||
stat, err := file.Stat()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if stat.Size() != size {
|
||||
if err = file.Truncate(size); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// 4. Set mmap and call DownloadAzureFileToBuffer.
|
||||
m, err := newMMF(file, true, 0, int(size))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer m.unmap()
|
||||
return downloadBlobToBuffer(ctx, blobURL, props, m, o)
|
||||
}
|
||||
*/
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// BatchTransferOptions identifies options used by doBatchTransfer.
|
||||
type batchTransferOptions struct {
|
||||
transferSize int64
|
||||
chunkSize int64
|
||||
parallelism uint16
|
||||
operation func(offset int64, chunkSize int64) error
|
||||
operationName string
|
||||
}
|
||||
|
||||
// doBatchTransfer helps to execute operations in a batch manner.
|
||||
func doBatchTransfer(ctx context.Context, o batchTransferOptions) error {
|
||||
// Prepare and do parallel operations.
|
||||
numChunks := uint16(((o.transferSize - 1) / o.chunkSize) + 1)
|
||||
operationChannel := make(chan func() error, o.parallelism) // Create the channel that release 'parallelism' goroutines concurrently
|
||||
operationResponseChannel := make(chan error, numChunks) // Holds each response
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
defer cancel()
|
||||
|
||||
// Create the goroutines that process each operation (in parallel).
|
||||
if o.parallelism == 0 {
|
||||
o.parallelism = 5 // default parallelism
|
||||
}
|
||||
for g := uint16(0); g < o.parallelism; g++ {
|
||||
//grIndex := g
|
||||
go func() {
|
||||
for f := range operationChannel {
|
||||
//fmt.Printf("[%s] gr-%d start action\n", o.operationName, grIndex)
|
||||
err := f()
|
||||
operationResponseChannel <- err
|
||||
//fmt.Printf("[%s] gr-%d end action\n", o.operationName, grIndex)
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
curChunkSize := o.chunkSize
|
||||
// Add each chunk's operation to the channel.
|
||||
for chunkNum := uint16(0); chunkNum < numChunks; chunkNum++ {
|
||||
if chunkNum == numChunks-1 { // Last chunk
|
||||
curChunkSize = o.transferSize - (int64(chunkNum) * o.chunkSize) // Remove size of all transferred chunks from total
|
||||
}
|
||||
offset := int64(chunkNum) * o.chunkSize
|
||||
|
||||
operationChannel <- func() error {
|
||||
return o.operation(offset, curChunkSize)
|
||||
}
|
||||
}
|
||||
close(operationChannel)
|
||||
|
||||
// Wait for the operations to complete.
|
||||
for chunkNum := uint16(0); chunkNum < numChunks; chunkNum++ {
|
||||
responseError := <-operationResponseChannel
|
||||
if responseError != nil {
|
||||
cancel() // As soon as any operation fails, cancel all remaining operation calls
|
||||
return responseError // No need to process anymore responses
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
type UploadStreamToBlockBlobOptions struct {
|
||||
BufferSize int
|
||||
MaxBuffers int
|
||||
BlobHTTPHeaders BlobHTTPHeaders
|
||||
Metadata Metadata
|
||||
AccessConditions BlobAccessConditions
|
||||
}
|
||||
|
||||
func UploadStreamToBlockBlob(ctx context.Context, reader io.Reader, blockBlobURL BlockBlobURL,
|
||||
o UploadStreamToBlockBlobOptions) (*BlockBlobsCommitBlockListResponse, error) {
|
||||
result, err := uploadStream(ctx, reader,
|
||||
UploadStreamOptions{BufferSize: o.BufferSize, MaxBuffers: o.MaxBuffers},
|
||||
&uploadStreamToBlockBlobOptions{b: blockBlobURL, o: o, blockIDPrefix: newUUID()})
|
||||
return result.(*BlockBlobsCommitBlockListResponse), err
|
||||
}
|
||||
|
||||
type uploadStreamToBlockBlobOptions struct {
|
||||
b BlockBlobURL
|
||||
o UploadStreamToBlockBlobOptions
|
||||
blockIDPrefix uuid // UUID used with all blockIDs
|
||||
maxBlockNum uint32 // defaults to 0
|
||||
firstBlock []byte // Used only if maxBlockNum is 0
|
||||
}
|
||||
|
||||
func (t *uploadStreamToBlockBlobOptions) start(ctx context.Context) (interface{}, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func (t *uploadStreamToBlockBlobOptions) chunk(ctx context.Context, num uint32, buffer []byte) error {
|
||||
if num == 0 && len(buffer) < t.o.BufferSize {
|
||||
// If whole payload fits in 1 block, dont' stage it; End will upload it with 1 I/O operation
|
||||
t.firstBlock = buffer
|
||||
return nil
|
||||
}
|
||||
// Else, upload a staged block...
|
||||
AtomicMorphUint32(&t.maxBlockNum, func(startVal uint32) (val uint32, morphResult interface{}) {
|
||||
// Atomically remember (in t.numBlocks) the maximum block num we've ever seen
|
||||
if startVal < num {
|
||||
return num, nil
|
||||
}
|
||||
return startVal, nil
|
||||
})
|
||||
blockID := newUuidBlockID(t.blockIDPrefix).WithBlockNumber(num).ToBase64()
|
||||
_, err := t.b.StageBlock(ctx, blockID, bytes.NewReader(buffer), LeaseAccessConditions{})
|
||||
return err
|
||||
}
|
||||
|
||||
func (t *uploadStreamToBlockBlobOptions) end(ctx context.Context) (interface{}, error) {
|
||||
if t.maxBlockNum == 0 {
|
||||
// If whole payload fits in 1 block (block #0), upload it with 1 I/O operation
|
||||
return t.b.Upload(ctx, bytes.NewReader(t.firstBlock),
|
||||
t.o.BlobHTTPHeaders, t.o.Metadata, t.o.AccessConditions)
|
||||
}
|
||||
// Multiple blocks staged, commit them all now
|
||||
blockID := newUuidBlockID(t.blockIDPrefix)
|
||||
blockIDs := make([]string, t.maxBlockNum)
|
||||
for bn := uint32(0); bn < t.maxBlockNum; bn++ {
|
||||
blockIDs[bn] = blockID.WithBlockNumber(bn).ToBase64()
|
||||
}
|
||||
return t.b.CommitBlockList(ctx, blockIDs, t.o.BlobHTTPHeaders, t.o.Metadata, t.o.AccessConditions)
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
type iTransfer interface {
|
||||
start(ctx context.Context) (interface{}, error)
|
||||
chunk(ctx context.Context, num uint32, buffer []byte) error
|
||||
end(ctx context.Context) (interface{}, error)
|
||||
}
|
||||
|
||||
type UploadStreamOptions struct {
|
||||
MaxBuffers int
|
||||
BufferSize int
|
||||
}
|
||||
|
||||
func uploadStream(ctx context.Context, reader io.Reader, o UploadStreamOptions, t iTransfer) (interface{}, error) {
|
||||
ctx, cancel := context.WithCancel(ctx) // New context so that any failure cancels everything
|
||||
defer cancel()
|
||||
wg := sync.WaitGroup{} // Used to know when all outgoing messages have finished processing
|
||||
type OutgoingMsg struct {
|
||||
chunkNum uint32
|
||||
buffer []byte
|
||||
}
|
||||
|
||||
// Create a channel to hold the buffers usable for incoming datsa
|
||||
incoming := make(chan []byte, o.MaxBuffers)
|
||||
outgoing := make(chan OutgoingMsg, o.MaxBuffers) // Channel holding outgoing buffers
|
||||
if result, err := t.start(ctx); err != nil {
|
||||
return result, err
|
||||
}
|
||||
|
||||
numBuffers := 0 // The number of buffers & out going goroutines created so far
|
||||
injectBuffer := func() {
|
||||
// For each Buffer, create it and a goroutine to upload it
|
||||
incoming <- make([]byte, o.BufferSize) // Add the new buffer to the incoming channel so this goroutine can from the reader into it
|
||||
numBuffers++
|
||||
go func() {
|
||||
for outgoingMsg := range outgoing {
|
||||
// Upload the outgoing buffer
|
||||
err := t.chunk(ctx, outgoingMsg.chunkNum, outgoingMsg.buffer)
|
||||
wg.Done() // Indicate this buffer was sent
|
||||
if nil != err {
|
||||
cancel()
|
||||
}
|
||||
incoming <- outgoingMsg.buffer // The goroutine reading from the stream can use reuse this buffer now
|
||||
}
|
||||
}()
|
||||
}
|
||||
injectBuffer() // Create our 1st buffer & outgoing goroutine
|
||||
|
||||
// This goroutine grabs a buffer, reads from the stream into the buffer,
|
||||
// and inserts the buffer into the outgoing channel to be uploaded
|
||||
for c := uint32(0); true; c++ { // Iterate once per chunk
|
||||
var buffer []byte
|
||||
if numBuffers < o.MaxBuffers {
|
||||
select {
|
||||
// We're not at max buffers, see if a previously-created buffer is available
|
||||
case buffer = <-incoming:
|
||||
break
|
||||
default:
|
||||
// No buffer available; inject a new buffer & go routine to process it
|
||||
injectBuffer()
|
||||
buffer = <-incoming // Grab the just-injected buffer
|
||||
}
|
||||
} else {
|
||||
// We are at max buffers, block until we get to reuse one
|
||||
buffer = <-incoming
|
||||
}
|
||||
n, err := io.ReadFull(reader, buffer)
|
||||
if err != nil {
|
||||
buffer = buffer[:n] // Make slice match the # of read bytes
|
||||
}
|
||||
if len(buffer) > 0 {
|
||||
// Buffer not empty, upload it
|
||||
wg.Add(1) // We're posting a buffer to be sent
|
||||
outgoing <- OutgoingMsg{chunkNum: c, buffer: buffer}
|
||||
}
|
||||
if err != nil { // The reader is done, no more outgoing buffers
|
||||
break
|
||||
}
|
||||
}
|
||||
// NOTE: Don't close the incoming channel because the outgoing goroutines post buffers into it when they are done
|
||||
close(outgoing) // Make all the outgoing goroutines terminate when this channel is empty
|
||||
wg.Wait() // Wait for all pending outgoing messages to complete
|
||||
// After all blocks uploaded, commit them to the blob & return the result
|
||||
return t.end(ctx)
|
||||
}
|
||||
|
|
|
@ -3,22 +3,22 @@ package azblob
|
|||
import (
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
snapshotTimeFormat = "2006-01-02T15:04:05.0000000Z07:00"
|
||||
snapshot = "snapshot"
|
||||
SnapshotTimeFormat = "2006-01-02T15:04:05.0000000Z07:00"
|
||||
)
|
||||
|
||||
// A BlobURLParts object represents the components that make up an Azure Storage Container/Blob URL. You parse an
|
||||
// existing URL into its parts by calling NewBlobURLParts(). You construct a URL from parts by calling URL().
|
||||
// NOTE: Changing any SAS-related field requires computing a new SAS signature.
|
||||
type BlobURLParts struct {
|
||||
Scheme string // Ex: "https://"
|
||||
Host string // Ex: "account.blob.core.windows.net"
|
||||
ContainerName string // "" if no container
|
||||
BlobName string // "" if no blob
|
||||
Snapshot time.Time // IsZero is true if not a snapshot
|
||||
Scheme string // Ex: "https://"
|
||||
Host string // Ex: "account.blob.core.windows.net"
|
||||
ContainerName string // "" if no container
|
||||
BlobName string // "" if no blob
|
||||
Snapshot string // "" if not a snapshot
|
||||
SAS SASQueryParameters
|
||||
UnparsedParams string
|
||||
}
|
||||
|
@ -51,13 +51,13 @@ func NewBlobURLParts(u url.URL) BlobURLParts {
|
|||
// Convert the query parameters to a case-sensitive map & trim whitespace
|
||||
paramsMap := u.Query()
|
||||
|
||||
up.Snapshot = time.Time{} // Assume no snapshot
|
||||
if snapshotStr, ok := caseInsensitiveValues(paramsMap).Get("snapshot"); ok {
|
||||
up.Snapshot, _ = time.Parse(snapshotTimeFormat, snapshotStr[0])
|
||||
up.Snapshot = "" // Assume no snapshot
|
||||
if snapshotStr, ok := caseInsensitiveValues(paramsMap).Get(snapshot); ok {
|
||||
up.Snapshot = snapshotStr[0]
|
||||
// If we recognized the query parameter, remove it from the map
|
||||
delete(paramsMap, "snapshot")
|
||||
delete(paramsMap, snapshot)
|
||||
}
|
||||
up.SAS = NewSASQueryParameters(paramsMap, true)
|
||||
up.SAS = newSASQueryParameters(paramsMap, true)
|
||||
up.UnparsedParams = paramsMap.Encode()
|
||||
return up
|
||||
}
|
||||
|
@ -88,11 +88,11 @@ func (up BlobURLParts) URL() url.URL {
|
|||
rawQuery := up.UnparsedParams
|
||||
|
||||
// Concatenate blob snapshot query parameter (if it exists)
|
||||
if !up.Snapshot.IsZero() {
|
||||
if up.Snapshot != "" {
|
||||
if len(rawQuery) > 0 {
|
||||
rawQuery += "&"
|
||||
}
|
||||
rawQuery += "snapshot=" + up.Snapshot.Format(snapshotTimeFormat)
|
||||
rawQuery += snapshot + "=" + up.Snapshot
|
||||
}
|
||||
sas := up.SAS.Encode()
|
||||
if sas != "" {
|
||||
|
|
|
@ -1,58 +0,0 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
/**/
|
||||
|
||||
// NewUniqueRequestIDPolicyFactory creates a UniqueRequestIDPolicyFactory object
|
||||
// that sets the request's x-ms-client-request-id header if it doesn't already exist.
|
||||
func NewUniqueRequestIDPolicyFactory() pipeline.Factory {
|
||||
return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
|
||||
// This is Policy's Do method:
|
||||
return func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
id := request.Header.Get(xMsClientRequestID)
|
||||
if id == "" { // Add a unique request ID if the caller didn't specify one already
|
||||
request.Header.Set(xMsClientRequestID, newUUID().String())
|
||||
}
|
||||
return next.Do(ctx, request)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/**/
|
||||
|
||||
const xMsClientRequestID = "x-ms-client-request-id"
|
||||
|
||||
/*
|
||||
// NewUniqueRequestIDPolicyFactory creates a UniqueRequestIDPolicyFactory object
|
||||
// that sets the request's x-ms-client-request-id header if it doesn't already exist.
|
||||
func NewUniqueRequestIDPolicyFactory() pipeline.Factory {
|
||||
return &uniqueRequestIDPolicyFactory{}
|
||||
}
|
||||
|
||||
// uniqueRequestIDPolicyFactory struct
|
||||
type uniqueRequestIDPolicyFactory struct {
|
||||
}
|
||||
|
||||
// New creates a UniqueRequestIDPolicy object.
|
||||
func (f *uniqueRequestIDPolicyFactory) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return &uniqueRequestIDPolicy{next: next}
|
||||
}
|
||||
|
||||
// UniqueRequestIDPolicy ...
|
||||
type uniqueRequestIDPolicy struct {
|
||||
next pipeline.Policy
|
||||
}
|
||||
|
||||
func (p *uniqueRequestIDPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
id := request.Header.Get(xMsClientRequestID)
|
||||
if id == "" { // Add a unique request ID if the caller didn't specify one already
|
||||
request.Header.Set(xMsClientRequestID, newUUID().String())
|
||||
}
|
||||
return p.next.Do(ctx, request)
|
||||
}
|
||||
*/
|
|
@ -1,145 +0,0 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"net"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// SASTimeFormat represents the format of a SAS start or expiry time. Use it when formatting/parsing a time.Time.
|
||||
const SASTimeFormat = "2006-01-02T15:04:05Z" //"2017-07-27T00:00:00Z" // ISO 8601
|
||||
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
|
||||
|
||||
// A SASQueryParameters object represents the components that make up an Azure Storage SAS' query parameters.
|
||||
// You parse a map of query parameters into its fields by calling NewSASQueryParameters(). You add the components
|
||||
// to a query parameter map by calling AddToValues().
|
||||
// NOTE: Changing any field requires computing a new SAS signature using a XxxSASSignatureValues type.
|
||||
//
|
||||
// This type defines the components used by all Azure Storage resources (Containers, Blobs, Files, & Queues).
|
||||
type SASQueryParameters struct {
|
||||
// All members are immutable or values so copies of this struct are goroutine-safe.
|
||||
Version string `param:"sv"`
|
||||
Services string `param:"ss"`
|
||||
ResourceTypes string `param:"srt"`
|
||||
Protocol string `param:"spr"`
|
||||
StartTime time.Time `param:"st"`
|
||||
ExpiryTime time.Time `param:"se"`
|
||||
IPRange IPRange `param:"sip"`
|
||||
Identifier string `param:"si"`
|
||||
Resource string `param:"sr"`
|
||||
Permissions string `param:"sp"`
|
||||
Signature string `param:"sig"`
|
||||
}
|
||||
|
||||
// IPRange represents a SAS IP range's start IP and (optionally) end IP.
|
||||
type IPRange struct {
|
||||
Start net.IP // Not specified if length = 0
|
||||
End net.IP // Not specified if length = 0
|
||||
}
|
||||
|
||||
// String returns a string representation of an IPRange.
|
||||
func (ipr *IPRange) String() string {
|
||||
if len(ipr.Start) == 0 {
|
||||
return ""
|
||||
}
|
||||
start := ipr.Start.String()
|
||||
if len(ipr.End) == 0 {
|
||||
return start
|
||||
}
|
||||
return start + "-" + ipr.End.String()
|
||||
}
|
||||
|
||||
// NewSASQueryParameters creates and initializes a SASQueryParameters object based on the
|
||||
// query parameter map's passed-in values. If deleteSASParametersFromValues is true,
|
||||
// all SAS-related query parameters are removed from the passed-in map. If
|
||||
// deleteSASParametersFromValues is false, the map passed-in map is unaltered.
|
||||
func NewSASQueryParameters(values url.Values, deleteSASParametersFromValues bool) SASQueryParameters {
|
||||
p := SASQueryParameters{}
|
||||
for k, v := range values {
|
||||
val := v[0]
|
||||
isSASKey := true
|
||||
switch strings.ToLower(k) {
|
||||
case "sv":
|
||||
p.Version = val
|
||||
case "ss":
|
||||
p.Services = val
|
||||
case "srt":
|
||||
p.ResourceTypes = val
|
||||
case "spr":
|
||||
p.Protocol = val
|
||||
case "st":
|
||||
p.StartTime, _ = time.Parse(SASTimeFormat, val)
|
||||
case "se":
|
||||
p.ExpiryTime, _ = time.Parse(SASTimeFormat, val)
|
||||
case "sip":
|
||||
dashIndex := strings.Index(val, "-")
|
||||
if dashIndex == -1 {
|
||||
p.IPRange.Start = net.ParseIP(val)
|
||||
} else {
|
||||
p.IPRange.Start = net.ParseIP(val[:dashIndex])
|
||||
p.IPRange.End = net.ParseIP(val[dashIndex+1:])
|
||||
}
|
||||
case "si":
|
||||
p.Identifier = val
|
||||
case "sr":
|
||||
p.Resource = val
|
||||
case "sp":
|
||||
p.Permissions = val
|
||||
case "sig":
|
||||
p.Signature = val
|
||||
default:
|
||||
isSASKey = false // We didn't recognize the query parameter
|
||||
}
|
||||
if isSASKey && deleteSASParametersFromValues {
|
||||
delete(values, k)
|
||||
}
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// AddToValues adds the SAS components to the specified query parameters map.
|
||||
func (p *SASQueryParameters) AddToValues(v url.Values) url.Values {
|
||||
if p.Version != "" {
|
||||
v.Add("sv", p.Version)
|
||||
}
|
||||
if p.Services != "" {
|
||||
v.Add("ss", p.Services)
|
||||
}
|
||||
if p.ResourceTypes != "" {
|
||||
v.Add("srt", p.ResourceTypes)
|
||||
}
|
||||
if p.Protocol != "" {
|
||||
v.Add("spr", p.Protocol)
|
||||
}
|
||||
if !p.StartTime.IsZero() {
|
||||
v.Add("st", p.StartTime.Format(SASTimeFormat))
|
||||
}
|
||||
if !p.ExpiryTime.IsZero() {
|
||||
v.Add("se", p.ExpiryTime.Format(SASTimeFormat))
|
||||
}
|
||||
if len(p.IPRange.Start) > 0 {
|
||||
v.Add("sip", p.IPRange.String())
|
||||
}
|
||||
if p.Identifier != "" {
|
||||
v.Add("si", p.Identifier)
|
||||
}
|
||||
if p.Resource != "" {
|
||||
v.Add("sr", p.Resource)
|
||||
}
|
||||
if p.Permissions != "" {
|
||||
v.Add("sp", p.Permissions)
|
||||
}
|
||||
if p.Signature != "" {
|
||||
v.Add("sig", p.Signature)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// Encode encodes the SAS query parameters into URL encoded form sorted by key.
|
||||
func (p *SASQueryParameters) Encode() string {
|
||||
v := url.Values{}
|
||||
p.AddToValues(v)
|
||||
return v.Encode()
|
||||
}
|
|
@ -1,165 +1,206 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// BlobSASSignatureValues is used to generate a Shared Access Signature (SAS) for an Azure Storage container or blob.
|
||||
type BlobSASSignatureValues struct {
|
||||
Version string `param:"sv"` // If not specified, this defaults to SASVersion
|
||||
Protocol string `param:"spr"` // See the SASProtocol* constants
|
||||
StartTime time.Time `param:"st"` // Not specified if IsZero
|
||||
ExpiryTime time.Time `param:"se"` // Not specified if IsZero
|
||||
Permissions string `param:"sp"`
|
||||
IPRange IPRange `param:"sip"`
|
||||
ContainerName string
|
||||
BlobName string // Use "" to create a Container SAS
|
||||
Identifier string `param:"si"`
|
||||
CacheControl string // rscc
|
||||
ContentDisposition string // rscd
|
||||
ContentEncoding string // rsce
|
||||
ContentLanguage string // rscl
|
||||
ContentType string // rsct
|
||||
}
|
||||
|
||||
// NewSASQueryParameters uses an account's shared key credential to sign this signature values to produce
|
||||
// the proper SAS query parameters.
|
||||
func (v BlobSASSignatureValues) NewSASQueryParameters(sharedKeyCredential *SharedKeyCredential) SASQueryParameters {
|
||||
if sharedKeyCredential == nil {
|
||||
panic("sharedKeyCredential can't be nil")
|
||||
}
|
||||
|
||||
resource := "c"
|
||||
if v.BlobName != "" {
|
||||
resource = "b"
|
||||
}
|
||||
if v.Version == "" {
|
||||
v.Version = SASVersion
|
||||
}
|
||||
startTime, expiryTime := FormatTimesForSASSigning(v.StartTime, v.ExpiryTime)
|
||||
|
||||
// String to sign: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
|
||||
stringToSign := strings.Join([]string{
|
||||
v.Permissions,
|
||||
startTime,
|
||||
expiryTime,
|
||||
getCanonicalName(sharedKeyCredential.AccountName(), v.ContainerName, v.BlobName),
|
||||
v.Identifier,
|
||||
v.IPRange.String(),
|
||||
v.Protocol,
|
||||
v.Version,
|
||||
v.CacheControl, // rscc
|
||||
v.ContentDisposition, // rscd
|
||||
v.ContentEncoding, // rsce
|
||||
v.ContentLanguage, // rscl
|
||||
v.ContentType}, // rsct
|
||||
"\n")
|
||||
signature := sharedKeyCredential.ComputeHMACSHA256(stringToSign)
|
||||
|
||||
p := SASQueryParameters{
|
||||
// Common SAS parameters
|
||||
Version: v.Version,
|
||||
Protocol: v.Protocol,
|
||||
StartTime: v.StartTime,
|
||||
ExpiryTime: v.ExpiryTime,
|
||||
Permissions: v.Permissions,
|
||||
IPRange: v.IPRange,
|
||||
|
||||
// Container/Blob-specific SAS parameters
|
||||
Resource: resource,
|
||||
Identifier: v.Identifier,
|
||||
|
||||
// Calculated SAS signature
|
||||
Signature: signature,
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// getCanonicalName computes the canonical name for a container or blob resource for SAS signing.
|
||||
func getCanonicalName(account string, containerName string, blobName string) string {
|
||||
// Container: "/blob/account/containername"
|
||||
// Blob: "/blob/account/containername/blobname"
|
||||
elements := []string{"/blob/", account, "/", containerName}
|
||||
if blobName != "" {
|
||||
elements = append(elements, "/", strings.Replace(blobName, "\\", "/", -1))
|
||||
}
|
||||
return strings.Join(elements, "")
|
||||
}
|
||||
|
||||
// The ContainerSASPermissions type simplifies creating the permissions string for an Azure Storage container SAS.
|
||||
// Initialize an instance of this type and then call its String method to set BlobSASSignatureValues's Permissions field.
|
||||
type ContainerSASPermissions struct {
|
||||
Read, Add, Create, Write, Delete, List bool
|
||||
}
|
||||
|
||||
// String produces the SAS permissions string for an Azure Storage container.
|
||||
// Call this method to set BlobSASSignatureValues's Permissions field.
|
||||
func (p ContainerSASPermissions) String() string {
|
||||
var b bytes.Buffer
|
||||
if p.Read {
|
||||
b.WriteRune('r')
|
||||
}
|
||||
if p.Add {
|
||||
b.WriteRune('a')
|
||||
}
|
||||
if p.Create {
|
||||
b.WriteRune('c')
|
||||
}
|
||||
if p.Write {
|
||||
b.WriteRune('w')
|
||||
}
|
||||
if p.Delete {
|
||||
b.WriteRune('d')
|
||||
}
|
||||
if p.List {
|
||||
b.WriteRune('l')
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// Parse initializes the ContainerSASPermissions's fields from a string.
|
||||
func (p *ContainerSASPermissions) Parse(s string) {
|
||||
p.Read = strings.ContainsRune(s, 'r')
|
||||
p.Add = strings.ContainsRune(s, 'a')
|
||||
p.Create = strings.ContainsRune(s, 'c')
|
||||
p.Write = strings.ContainsRune(s, 'w')
|
||||
p.Delete = strings.ContainsRune(s, 'd')
|
||||
p.List = strings.ContainsRune(s, 'l')
|
||||
}
|
||||
|
||||
// The BlobSASPermissions type simplifies creating the permissions string for an Azure Storage blob SAS.
|
||||
// Initialize an instance of this type and then call its String method to set BlobSASSignatureValues's Permissions field.
|
||||
type BlobSASPermissions struct{ Read, Add, Create, Write, Delete bool }
|
||||
|
||||
// String produces the SAS permissions string for an Azure Storage blob.
|
||||
// Call this method to set BlobSASSignatureValues's Permissions field.
|
||||
func (p BlobSASPermissions) String() string {
|
||||
var b bytes.Buffer
|
||||
if p.Read {
|
||||
b.WriteRune('r')
|
||||
}
|
||||
if p.Add {
|
||||
b.WriteRune('a')
|
||||
}
|
||||
if p.Create {
|
||||
b.WriteRune('c')
|
||||
}
|
||||
if p.Write {
|
||||
b.WriteRune('w')
|
||||
}
|
||||
if p.Delete {
|
||||
b.WriteRune('d')
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// Parse initializes the BlobSASPermissions's fields from a string.
|
||||
func (p *BlobSASPermissions) Parse(s string) {
|
||||
p.Read = strings.ContainsRune(s, 'r')
|
||||
p.Add = strings.ContainsRune(s, 'a')
|
||||
p.Create = strings.ContainsRune(s, 'c')
|
||||
p.Write = strings.ContainsRune(s, 'w')
|
||||
p.Delete = strings.ContainsRune(s, 'd')
|
||||
}
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// BlobSASSignatureValues is used to generate a Shared Access Signature (SAS) for an Azure Storage container or blob.
|
||||
type BlobSASSignatureValues struct {
|
||||
Version string `param:"sv"` // If not specified, this defaults to SASVersion
|
||||
Protocol SASProtocol `param:"spr"` // See the SASProtocol* constants
|
||||
StartTime time.Time `param:"st"` // Not specified if IsZero
|
||||
ExpiryTime time.Time `param:"se"` // Not specified if IsZero
|
||||
Permissions string `param:"sp"` // Create by initializing a ContainerSASPermissions or BlobSASPermissions and then call String()
|
||||
IPRange IPRange `param:"sip"`
|
||||
Identifier string `param:"si"`
|
||||
ContainerName string
|
||||
BlobName string // Use "" to create a Container SAS
|
||||
CacheControl string // rscc
|
||||
ContentDisposition string // rscd
|
||||
ContentEncoding string // rsce
|
||||
ContentLanguage string // rscl
|
||||
ContentType string // rsct
|
||||
}
|
||||
|
||||
// NewSASQueryParameters uses an account's shared key credential to sign this signature values to produce
|
||||
// the proper SAS query parameters.
|
||||
func (v BlobSASSignatureValues) NewSASQueryParameters(sharedKeyCredential *SharedKeyCredential) SASQueryParameters {
|
||||
if sharedKeyCredential == nil {
|
||||
panic("sharedKeyCredential can't be nil")
|
||||
}
|
||||
|
||||
resource := "c"
|
||||
if v.BlobName == "" {
|
||||
// Make sure the permission characters are in the correct order
|
||||
perms := &ContainerSASPermissions{}
|
||||
if err := perms.Parse(v.Permissions); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
v.Permissions = perms.String()
|
||||
} else {
|
||||
resource = "b"
|
||||
// Make sure the permission characters are in the correct order
|
||||
perms := &BlobSASPermissions{}
|
||||
if err := perms.Parse(v.Permissions); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
v.Permissions = perms.String()
|
||||
}
|
||||
if v.Version == "" {
|
||||
v.Version = SASVersion
|
||||
}
|
||||
startTime, expiryTime := FormatTimesForSASSigning(v.StartTime, v.ExpiryTime)
|
||||
|
||||
// String to sign: http://msdn.microsoft.com/en-us/library/azure/dn140255.aspx
|
||||
stringToSign := strings.Join([]string{
|
||||
v.Permissions,
|
||||
startTime,
|
||||
expiryTime,
|
||||
getCanonicalName(sharedKeyCredential.AccountName(), v.ContainerName, v.BlobName),
|
||||
v.Identifier,
|
||||
v.IPRange.String(),
|
||||
string(v.Protocol),
|
||||
v.Version,
|
||||
v.CacheControl, // rscc
|
||||
v.ContentDisposition, // rscd
|
||||
v.ContentEncoding, // rsce
|
||||
v.ContentLanguage, // rscl
|
||||
v.ContentType}, // rsct
|
||||
"\n")
|
||||
signature := sharedKeyCredential.ComputeHMACSHA256(stringToSign)
|
||||
|
||||
p := SASQueryParameters{
|
||||
// Common SAS parameters
|
||||
version: v.Version,
|
||||
protocol: v.Protocol,
|
||||
startTime: v.StartTime,
|
||||
expiryTime: v.ExpiryTime,
|
||||
permissions: v.Permissions,
|
||||
ipRange: v.IPRange,
|
||||
|
||||
// Container/Blob-specific SAS parameters
|
||||
resource: resource,
|
||||
identifier: v.Identifier,
|
||||
|
||||
// Calculated SAS signature
|
||||
signature: signature,
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// getCanonicalName computes the canonical name for a container or blob resource for SAS signing.
|
||||
func getCanonicalName(account string, containerName string, blobName string) string {
|
||||
// Container: "/blob/account/containername"
|
||||
// Blob: "/blob/account/containername/blobname"
|
||||
elements := []string{"/blob/", account, "/", containerName}
|
||||
if blobName != "" {
|
||||
elements = append(elements, "/", strings.Replace(blobName, "\\", "/", -1))
|
||||
}
|
||||
return strings.Join(elements, "")
|
||||
}
|
||||
|
||||
// The ContainerSASPermissions type simplifies creating the permissions string for an Azure Storage container SAS.
|
||||
// Initialize an instance of this type and then call its String method to set BlobSASSignatureValues's Permissions field.
|
||||
type ContainerSASPermissions struct {
|
||||
Read, Add, Create, Write, Delete, List bool
|
||||
}
|
||||
|
||||
// String produces the SAS permissions string for an Azure Storage container.
|
||||
// Call this method to set BlobSASSignatureValues's Permissions field.
|
||||
func (p ContainerSASPermissions) String() string {
|
||||
var b bytes.Buffer
|
||||
if p.Read {
|
||||
b.WriteRune('r')
|
||||
}
|
||||
if p.Add {
|
||||
b.WriteRune('a')
|
||||
}
|
||||
if p.Create {
|
||||
b.WriteRune('c')
|
||||
}
|
||||
if p.Write {
|
||||
b.WriteRune('w')
|
||||
}
|
||||
if p.Delete {
|
||||
b.WriteRune('d')
|
||||
}
|
||||
if p.List {
|
||||
b.WriteRune('l')
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// Parse initializes the ContainerSASPermissions's fields from a string.
|
||||
func (p *ContainerSASPermissions) Parse(s string) error {
|
||||
*p = ContainerSASPermissions{} // Clear the flags
|
||||
for _, r := range s {
|
||||
switch r {
|
||||
case 'r':
|
||||
p.Read = true
|
||||
case 'a':
|
||||
p.Add = true
|
||||
case 'c':
|
||||
p.Create = true
|
||||
case 'w':
|
||||
p.Write = true
|
||||
case 'd':
|
||||
p.Delete = true
|
||||
case 'l':
|
||||
p.List = true
|
||||
default:
|
||||
return fmt.Errorf("Invalid permission: '%v'", r)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// The BlobSASPermissions type simplifies creating the permissions string for an Azure Storage blob SAS.
|
||||
// Initialize an instance of this type and then call its String method to set BlobSASSignatureValues's Permissions field.
|
||||
type BlobSASPermissions struct{ Read, Add, Create, Write, Delete bool }
|
||||
|
||||
// String produces the SAS permissions string for an Azure Storage blob.
|
||||
// Call this method to set BlobSASSignatureValues's Permissions field.
|
||||
func (p BlobSASPermissions) String() string {
|
||||
var b bytes.Buffer
|
||||
if p.Read {
|
||||
b.WriteRune('r')
|
||||
}
|
||||
if p.Add {
|
||||
b.WriteRune('a')
|
||||
}
|
||||
if p.Create {
|
||||
b.WriteRune('c')
|
||||
}
|
||||
if p.Write {
|
||||
b.WriteRune('w')
|
||||
}
|
||||
if p.Delete {
|
||||
b.WriteRune('d')
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// Parse initializes the BlobSASPermissions's fields from a string.
|
||||
func (p *BlobSASPermissions) Parse(s string) error {
|
||||
*p = BlobSASPermissions{} // Clear the flags
|
||||
for _, r := range s {
|
||||
switch r {
|
||||
case 'r':
|
||||
p.Read = true
|
||||
case 'a':
|
||||
p.Add = true
|
||||
case 'c':
|
||||
p.Create = true
|
||||
case 'w':
|
||||
p.Write = true
|
||||
case 'd':
|
||||
p.Delete = true
|
||||
default:
|
||||
return fmt.Errorf("Invalid permission: '%v'", r)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
|
@ -1,195 +1,195 @@
|
|||
package azblob
|
||||
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/blob-service-error-codes
|
||||
|
||||
// ServiceCode values indicate a service failure.
|
||||
const (
|
||||
// ServiceCodeAppendPositionConditionNotMet means the append position condition specified was not met.
|
||||
ServiceCodeAppendPositionConditionNotMet ServiceCodeType = "AppendPositionConditionNotMet"
|
||||
|
||||
// ServiceCodeBlobAlreadyExists means the specified blob already exists.
|
||||
ServiceCodeBlobAlreadyExists ServiceCodeType = "BlobAlreadyExists"
|
||||
|
||||
// ServiceCodeBlobNotFound means the specified blob does not exist.
|
||||
ServiceCodeBlobNotFound ServiceCodeType = "BlobNotFound"
|
||||
|
||||
// ServiceCodeBlobOverwritten means the blob has been recreated since the previous snapshot was taken.
|
||||
ServiceCodeBlobOverwritten ServiceCodeType = "BlobOverwritten"
|
||||
|
||||
// ServiceCodeBlobTierInadequateForContentLength means the specified blob tier size limit cannot be less than content length.
|
||||
ServiceCodeBlobTierInadequateForContentLength ServiceCodeType = "BlobTierInadequateForContentLength"
|
||||
|
||||
// ServiceCodeBlockCountExceedsLimit means the committed block count cannot exceed the maximum limit of 50,000 blocks
|
||||
// or that the uncommitted block count cannot exceed the maximum limit of 100,000 blocks.
|
||||
ServiceCodeBlockCountExceedsLimit ServiceCodeType = "BlockCountExceedsLimit"
|
||||
|
||||
// ServiceCodeBlockListTooLong means the block list may not contain more than 50,000 blocks.
|
||||
ServiceCodeBlockListTooLong ServiceCodeType = "BlockListTooLong"
|
||||
|
||||
// ServiceCodeCannotChangeToLowerTier means that a higher blob tier has already been explicitly set.
|
||||
ServiceCodeCannotChangeToLowerTier ServiceCodeType = "CannotChangeToLowerTier"
|
||||
|
||||
// ServiceCodeCannotVerifyCopySource means that the service could not verify the copy source within the specified time.
|
||||
// Examine the HTTP status code and message for more information about the failure.
|
||||
ServiceCodeCannotVerifyCopySource ServiceCodeType = "CannotVerifyCopySource"
|
||||
|
||||
// ServiceCodeContainerAlreadyExists means the specified container already exists.
|
||||
ServiceCodeContainerAlreadyExists ServiceCodeType = "ContainerAlreadyExists"
|
||||
|
||||
// ServiceCodeContainerBeingDeleted means the specified container is being deleted.
|
||||
ServiceCodeContainerBeingDeleted ServiceCodeType = "ContainerBeingDeleted"
|
||||
|
||||
// ServiceCodeContainerDisabled means the specified container has been disabled by the administrator.
|
||||
ServiceCodeContainerDisabled ServiceCodeType = "ContainerDisabled"
|
||||
|
||||
// ServiceCodeContainerNotFound means the specified container does not exist.
|
||||
ServiceCodeContainerNotFound ServiceCodeType = "ContainerNotFound"
|
||||
|
||||
// ServiceCodeContentLengthLargerThanTierLimit means the blob's content length cannot exceed its tier limit.
|
||||
ServiceCodeContentLengthLargerThanTierLimit ServiceCodeType = "ContentLengthLargerThanTierLimit"
|
||||
|
||||
// ServiceCodeCopyAcrossAccountsNotSupported means the copy source account and destination account must be the same.
|
||||
ServiceCodeCopyAcrossAccountsNotSupported ServiceCodeType = "CopyAcrossAccountsNotSupported"
|
||||
|
||||
// ServiceCodeCopyIDMismatch means the specified copy ID did not match the copy ID for the pending copy operation.
|
||||
ServiceCodeCopyIDMismatch ServiceCodeType = "CopyIdMismatch"
|
||||
|
||||
// ServiceCodeFeatureVersionMismatch means the type of blob in the container is unrecognized by this version or
|
||||
// that the operation for AppendBlob requires at least version 2015-02-21.
|
||||
ServiceCodeFeatureVersionMismatch ServiceCodeType = "FeatureVersionMismatch"
|
||||
|
||||
// ServiceCodeIncrementalCopyBlobMismatch means the specified source blob is different than the copy source of the existing incremental copy blob.
|
||||
ServiceCodeIncrementalCopyBlobMismatch ServiceCodeType = "IncrementalCopyBlobMismatch"
|
||||
|
||||
// ServiceCodeIncrementalCopyOfEralierVersionSnapshotNotAllowed means the specified snapshot is earlier than the last snapshot copied into the incremental copy blob.
|
||||
ServiceCodeIncrementalCopyOfEralierVersionSnapshotNotAllowed ServiceCodeType = "IncrementalCopyOfEralierVersionSnapshotNotAllowed"
|
||||
|
||||
// ServiceCodeIncrementalCopySourceMustBeSnapshot means the source for incremental copy request must be a snapshot.
|
||||
ServiceCodeIncrementalCopySourceMustBeSnapshot ServiceCodeType = "IncrementalCopySourceMustBeSnapshot"
|
||||
|
||||
// ServiceCodeInfiniteLeaseDurationRequired means the lease ID matched, but the specified lease must be an infinite-duration lease.
|
||||
ServiceCodeInfiniteLeaseDurationRequired ServiceCodeType = "InfiniteLeaseDurationRequired"
|
||||
|
||||
// ServiceCodeInvalidBlobOrBlock means the specified blob or block content is invalid.
|
||||
ServiceCodeInvalidBlobOrBlock ServiceCodeType = "InvalidBlobOrBlock"
|
||||
|
||||
// ServiceCodeInvalidBlobType means the blob type is invalid for this operation.
|
||||
ServiceCodeInvalidBlobType ServiceCodeType = "InvalidBlobType"
|
||||
|
||||
// ServiceCodeInvalidBlockID means the specified block ID is invalid. The block ID must be Base64-encoded.
|
||||
ServiceCodeInvalidBlockID ServiceCodeType = "InvalidBlockId"
|
||||
|
||||
// ServiceCodeInvalidBlockList means the specified block list is invalid.
|
||||
ServiceCodeInvalidBlockList ServiceCodeType = "InvalidBlockList"
|
||||
|
||||
// ServiceCodeInvalidOperation means an invalid operation against a blob snapshot.
|
||||
ServiceCodeInvalidOperation ServiceCodeType = "InvalidOperation"
|
||||
|
||||
// ServiceCodeInvalidPageRange means the page range specified is invalid.
|
||||
ServiceCodeInvalidPageRange ServiceCodeType = "InvalidPageRange"
|
||||
|
||||
// ServiceCodeInvalidSourceBlobType means the copy source blob type is invalid for this operation.
|
||||
ServiceCodeInvalidSourceBlobType ServiceCodeType = "InvalidSourceBlobType"
|
||||
|
||||
// ServiceCodeInvalidSourceBlobURL means the source URL for incremental copy request must be valid Azure Storage blob URL.
|
||||
ServiceCodeInvalidSourceBlobURL ServiceCodeType = "InvalidSourceBlobUrl"
|
||||
|
||||
// ServiceCodeInvalidVersionForPageBlobOperation means that all operations on page blobs require at least version 2009-09-19.
|
||||
ServiceCodeInvalidVersionForPageBlobOperation ServiceCodeType = "InvalidVersionForPageBlobOperation"
|
||||
|
||||
// ServiceCodeLeaseAlreadyPresent means there is already a lease present.
|
||||
ServiceCodeLeaseAlreadyPresent ServiceCodeType = "LeaseAlreadyPresent"
|
||||
|
||||
// ServiceCodeLeaseAlreadyBroken means the lease has already been broken and cannot be broken again.
|
||||
ServiceCodeLeaseAlreadyBroken ServiceCodeType = "LeaseAlreadyBroken"
|
||||
|
||||
// ServiceCodeLeaseIDMismatchWithBlobOperation means the lease ID specified did not match the lease ID for the blob.
|
||||
ServiceCodeLeaseIDMismatchWithBlobOperation ServiceCodeType = "LeaseIdMismatchWithBlobOperation"
|
||||
|
||||
// ServiceCodeLeaseIDMismatchWithContainerOperation means the lease ID specified did not match the lease ID for the container.
|
||||
ServiceCodeLeaseIDMismatchWithContainerOperation ServiceCodeType = "LeaseIdMismatchWithContainerOperation"
|
||||
|
||||
// ServiceCodeLeaseIDMismatchWithLeaseOperation means the lease ID specified did not match the lease ID for the blob/container.
|
||||
ServiceCodeLeaseIDMismatchWithLeaseOperation ServiceCodeType = "LeaseIdMismatchWithLeaseOperation"
|
||||
|
||||
// ServiceCodeLeaseIDMissing means there is currently a lease on the blob/container and no lease ID was specified in the request.
|
||||
ServiceCodeLeaseIDMissing ServiceCodeType = "LeaseIdMissing"
|
||||
|
||||
// ServiceCodeLeaseIsBreakingAndCannotBeAcquired means the lease ID matched, but the lease is currently in breaking state and cannot be acquired until it is broken.
|
||||
ServiceCodeLeaseIsBreakingAndCannotBeAcquired ServiceCodeType = "LeaseIsBreakingAndCannotBeAcquired"
|
||||
|
||||
// ServiceCodeLeaseIsBreakingAndCannotBeChanged means the lease ID matched, but the lease is currently in breaking state and cannot be changed.
|
||||
ServiceCodeLeaseIsBreakingAndCannotBeChanged ServiceCodeType = "LeaseIsBreakingAndCannotBeChanged"
|
||||
|
||||
// ServiceCodeLeaseIsBrokenAndCannotBeRenewed means the lease ID matched, but the lease has been broken explicitly and cannot be renewed.
|
||||
ServiceCodeLeaseIsBrokenAndCannotBeRenewed ServiceCodeType = "LeaseIsBrokenAndCannotBeRenewed"
|
||||
|
||||
// ServiceCodeLeaseLost means a lease ID was specified, but the lease for the blob/container has expired.
|
||||
ServiceCodeLeaseLost ServiceCodeType = "LeaseLost"
|
||||
|
||||
// ServiceCodeLeaseNotPresentWithBlobOperation means there is currently no lease on the blob.
|
||||
ServiceCodeLeaseNotPresentWithBlobOperation ServiceCodeType = "LeaseNotPresentWithBlobOperation"
|
||||
|
||||
// ServiceCodeLeaseNotPresentWithContainerOperation means there is currently no lease on the container.
|
||||
ServiceCodeLeaseNotPresentWithContainerOperation ServiceCodeType = "LeaseNotPresentWithContainerOperation"
|
||||
|
||||
// ServiceCodeLeaseNotPresentWithLeaseOperation means there is currently no lease on the blob/container.
|
||||
ServiceCodeLeaseNotPresentWithLeaseOperation ServiceCodeType = "LeaseNotPresentWithLeaseOperation"
|
||||
|
||||
// ServiceCodeMaxBlobSizeConditionNotMet means the max blob size condition specified was not met.
|
||||
ServiceCodeMaxBlobSizeConditionNotMet ServiceCodeType = "MaxBlobSizeConditionNotMet"
|
||||
|
||||
// ServiceCodeNoPendingCopyOperation means there is currently no pending copy operation.
|
||||
ServiceCodeNoPendingCopyOperation ServiceCodeType = "NoPendingCopyOperation"
|
||||
|
||||
// ServiceCodeOperationNotAllowedOnIncrementalCopyBlob means the specified operation is not allowed on an incremental copy blob.
|
||||
ServiceCodeOperationNotAllowedOnIncrementalCopyBlob ServiceCodeType = "OperationNotAllowedOnIncrementalCopyBlob"
|
||||
|
||||
// ServiceCodePendingCopyOperation means there is currently a pending copy operation.
|
||||
ServiceCodePendingCopyOperation ServiceCodeType = "PendingCopyOperation"
|
||||
|
||||
// ServiceCodePreviousSnapshotCannotBeNewer means the prevsnapshot query parameter value cannot be newer than snapshot query parameter value.
|
||||
ServiceCodePreviousSnapshotCannotBeNewer ServiceCodeType = "PreviousSnapshotCannotBeNewer"
|
||||
|
||||
// ServiceCodePreviousSnapshotNotFound means the previous snapshot is not found.
|
||||
ServiceCodePreviousSnapshotNotFound ServiceCodeType = "PreviousSnapshotNotFound"
|
||||
|
||||
// ServiceCodePreviousSnapshotOperationNotSupported means that differential Get Page Ranges is not supported on the previous snapshot.
|
||||
ServiceCodePreviousSnapshotOperationNotSupported ServiceCodeType = "PreviousSnapshotOperationNotSupported"
|
||||
|
||||
// ServiceCodeSequenceNumberConditionNotMet means the sequence number condition specified was not met.
|
||||
ServiceCodeSequenceNumberConditionNotMet ServiceCodeType = "SequenceNumberConditionNotMet"
|
||||
|
||||
// ServiceCodeSequenceNumberIncrementTooLarge means the sequence number increment cannot be performed because it would result in overflow of the sequence number.
|
||||
ServiceCodeSequenceNumberIncrementTooLarge ServiceCodeType = "SequenceNumberIncrementTooLarge"
|
||||
|
||||
// ServiceCodeSnapshotCountExceeded means the snapshot count against this blob has been exceeded.
|
||||
ServiceCodeSnapshotCountExceeded ServiceCodeType = "SnapshotCountExceeded"
|
||||
|
||||
// ServiceCodeSnaphotOperationRateExceeded means the rate of snapshot operations against this blob has been exceeded.
|
||||
ServiceCodeSnaphotOperationRateExceeded ServiceCodeType = "SnaphotOperationRateExceeded"
|
||||
|
||||
// ServiceCodeSnapshotsPresent means this operation is not permitted while the blob has snapshots.
|
||||
ServiceCodeSnapshotsPresent ServiceCodeType = "SnapshotsPresent"
|
||||
|
||||
// ServiceCodeSourceConditionNotMet means the source condition specified using HTTP conditional header(s) is not met.
|
||||
ServiceCodeSourceConditionNotMet ServiceCodeType = "SourceConditionNotMet"
|
||||
|
||||
// ServiceCodeSystemInUse means this blob is in use by the system.
|
||||
ServiceCodeSystemInUse ServiceCodeType = "SystemInUse"
|
||||
|
||||
// ServiceCodeTargetConditionNotMet means the target condition specified using HTTP conditional header(s) is not met.
|
||||
ServiceCodeTargetConditionNotMet ServiceCodeType = "TargetConditionNotMet"
|
||||
|
||||
// ServiceCodeUnauthorizedBlobOverwrite means this request is not authorized to perform blob overwrites.
|
||||
ServiceCodeUnauthorizedBlobOverwrite ServiceCodeType = "UnauthorizedBlobOverwrite"
|
||||
|
||||
// ServiceCodeBlobBeingRehydrated means this operation is not permitted because the blob is being rehydrated.
|
||||
ServiceCodeBlobBeingRehydrated ServiceCodeType = "BlobBeingRehydrated"
|
||||
|
||||
// ServiceCodeBlobArchived means this operation is not permitted on an archived blob.
|
||||
ServiceCodeBlobArchived ServiceCodeType = "BlobArchived"
|
||||
|
||||
// ServiceCodeBlobNotArchived means this blob is currently not in the archived state.
|
||||
ServiceCodeBlobNotArchived ServiceCodeType = "BlobNotArchived"
|
||||
)
|
||||
package azblob
|
||||
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/blob-service-error-codes
|
||||
|
||||
// ServiceCode values indicate a service failure.
|
||||
const (
|
||||
// ServiceCodeAppendPositionConditionNotMet means the append position condition specified was not met.
|
||||
ServiceCodeAppendPositionConditionNotMet ServiceCodeType = "AppendPositionConditionNotMet"
|
||||
|
||||
// ServiceCodeBlobAlreadyExists means the specified blob already exists.
|
||||
ServiceCodeBlobAlreadyExists ServiceCodeType = "BlobAlreadyExists"
|
||||
|
||||
// ServiceCodeBlobNotFound means the specified blob does not exist.
|
||||
ServiceCodeBlobNotFound ServiceCodeType = "BlobNotFound"
|
||||
|
||||
// ServiceCodeBlobOverwritten means the blob has been recreated since the previous snapshot was taken.
|
||||
ServiceCodeBlobOverwritten ServiceCodeType = "BlobOverwritten"
|
||||
|
||||
// ServiceCodeBlobTierInadequateForContentLength means the specified blob tier size limit cannot be less than content length.
|
||||
ServiceCodeBlobTierInadequateForContentLength ServiceCodeType = "BlobTierInadequateForContentLength"
|
||||
|
||||
// ServiceCodeBlockCountExceedsLimit means the committed block count cannot exceed the maximum limit of 50,000 blocks
|
||||
// or that the uncommitted block count cannot exceed the maximum limit of 100,000 blocks.
|
||||
ServiceCodeBlockCountExceedsLimit ServiceCodeType = "BlockCountExceedsLimit"
|
||||
|
||||
// ServiceCodeBlockListTooLong means the block list may not contain more than 50,000 blocks.
|
||||
ServiceCodeBlockListTooLong ServiceCodeType = "BlockListTooLong"
|
||||
|
||||
// ServiceCodeCannotChangeToLowerTier means that a higher blob tier has already been explicitly set.
|
||||
ServiceCodeCannotChangeToLowerTier ServiceCodeType = "CannotChangeToLowerTier"
|
||||
|
||||
// ServiceCodeCannotVerifyCopySource means that the service could not verify the copy source within the specified time.
|
||||
// Examine the HTTP status code and message for more information about the failure.
|
||||
ServiceCodeCannotVerifyCopySource ServiceCodeType = "CannotVerifyCopySource"
|
||||
|
||||
// ServiceCodeContainerAlreadyExists means the specified container already exists.
|
||||
ServiceCodeContainerAlreadyExists ServiceCodeType = "ContainerAlreadyExists"
|
||||
|
||||
// ServiceCodeContainerBeingDeleted means the specified container is being deleted.
|
||||
ServiceCodeContainerBeingDeleted ServiceCodeType = "ContainerBeingDeleted"
|
||||
|
||||
// ServiceCodeContainerDisabled means the specified container has been disabled by the administrator.
|
||||
ServiceCodeContainerDisabled ServiceCodeType = "ContainerDisabled"
|
||||
|
||||
// ServiceCodeContainerNotFound means the specified container does not exist.
|
||||
ServiceCodeContainerNotFound ServiceCodeType = "ContainerNotFound"
|
||||
|
||||
// ServiceCodeContentLengthLargerThanTierLimit means the blob's content length cannot exceed its tier limit.
|
||||
ServiceCodeContentLengthLargerThanTierLimit ServiceCodeType = "ContentLengthLargerThanTierLimit"
|
||||
|
||||
// ServiceCodeCopyAcrossAccountsNotSupported means the copy source account and destination account must be the same.
|
||||
ServiceCodeCopyAcrossAccountsNotSupported ServiceCodeType = "CopyAcrossAccountsNotSupported"
|
||||
|
||||
// ServiceCodeCopyIDMismatch means the specified copy ID did not match the copy ID for the pending copy operation.
|
||||
ServiceCodeCopyIDMismatch ServiceCodeType = "CopyIdMismatch"
|
||||
|
||||
// ServiceCodeFeatureVersionMismatch means the type of blob in the container is unrecognized by this version or
|
||||
// that the operation for AppendBlob requires at least version 2015-02-21.
|
||||
ServiceCodeFeatureVersionMismatch ServiceCodeType = "FeatureVersionMismatch"
|
||||
|
||||
// ServiceCodeIncrementalCopyBlobMismatch means the specified source blob is different than the copy source of the existing incremental copy blob.
|
||||
ServiceCodeIncrementalCopyBlobMismatch ServiceCodeType = "IncrementalCopyBlobMismatch"
|
||||
|
||||
// ServiceCodeIncrementalCopyOfEralierVersionSnapshotNotAllowed means the specified snapshot is earlier than the last snapshot copied into the incremental copy blob.
|
||||
ServiceCodeIncrementalCopyOfEralierVersionSnapshotNotAllowed ServiceCodeType = "IncrementalCopyOfEralierVersionSnapshotNotAllowed"
|
||||
|
||||
// ServiceCodeIncrementalCopySourceMustBeSnapshot means the source for incremental copy request must be a snapshot.
|
||||
ServiceCodeIncrementalCopySourceMustBeSnapshot ServiceCodeType = "IncrementalCopySourceMustBeSnapshot"
|
||||
|
||||
// ServiceCodeInfiniteLeaseDurationRequired means the lease ID matched, but the specified lease must be an infinite-duration lease.
|
||||
ServiceCodeInfiniteLeaseDurationRequired ServiceCodeType = "InfiniteLeaseDurationRequired"
|
||||
|
||||
// ServiceCodeInvalidBlobOrBlock means the specified blob or block content is invalid.
|
||||
ServiceCodeInvalidBlobOrBlock ServiceCodeType = "InvalidBlobOrBlock"
|
||||
|
||||
// ServiceCodeInvalidBlobType means the blob type is invalid for this operation.
|
||||
ServiceCodeInvalidBlobType ServiceCodeType = "InvalidBlobType"
|
||||
|
||||
// ServiceCodeInvalidBlockID means the specified block ID is invalid. The block ID must be Base64-encoded.
|
||||
ServiceCodeInvalidBlockID ServiceCodeType = "InvalidBlockId"
|
||||
|
||||
// ServiceCodeInvalidBlockList means the specified block list is invalid.
|
||||
ServiceCodeInvalidBlockList ServiceCodeType = "InvalidBlockList"
|
||||
|
||||
// ServiceCodeInvalidOperation means an invalid operation against a blob snapshot.
|
||||
ServiceCodeInvalidOperation ServiceCodeType = "InvalidOperation"
|
||||
|
||||
// ServiceCodeInvalidPageRange means the page range specified is invalid.
|
||||
ServiceCodeInvalidPageRange ServiceCodeType = "InvalidPageRange"
|
||||
|
||||
// ServiceCodeInvalidSourceBlobType means the copy source blob type is invalid for this operation.
|
||||
ServiceCodeInvalidSourceBlobType ServiceCodeType = "InvalidSourceBlobType"
|
||||
|
||||
// ServiceCodeInvalidSourceBlobURL means the source URL for incremental copy request must be valid Azure Storage blob URL.
|
||||
ServiceCodeInvalidSourceBlobURL ServiceCodeType = "InvalidSourceBlobUrl"
|
||||
|
||||
// ServiceCodeInvalidVersionForPageBlobOperation means that all operations on page blobs require at least version 2009-09-19.
|
||||
ServiceCodeInvalidVersionForPageBlobOperation ServiceCodeType = "InvalidVersionForPageBlobOperation"
|
||||
|
||||
// ServiceCodeLeaseAlreadyPresent means there is already a lease present.
|
||||
ServiceCodeLeaseAlreadyPresent ServiceCodeType = "LeaseAlreadyPresent"
|
||||
|
||||
// ServiceCodeLeaseAlreadyBroken means the lease has already been broken and cannot be broken again.
|
||||
ServiceCodeLeaseAlreadyBroken ServiceCodeType = "LeaseAlreadyBroken"
|
||||
|
||||
// ServiceCodeLeaseIDMismatchWithBlobOperation means the lease ID specified did not match the lease ID for the blob.
|
||||
ServiceCodeLeaseIDMismatchWithBlobOperation ServiceCodeType = "LeaseIdMismatchWithBlobOperation"
|
||||
|
||||
// ServiceCodeLeaseIDMismatchWithContainerOperation means the lease ID specified did not match the lease ID for the container.
|
||||
ServiceCodeLeaseIDMismatchWithContainerOperation ServiceCodeType = "LeaseIdMismatchWithContainerOperation"
|
||||
|
||||
// ServiceCodeLeaseIDMismatchWithLeaseOperation means the lease ID specified did not match the lease ID for the blob/container.
|
||||
ServiceCodeLeaseIDMismatchWithLeaseOperation ServiceCodeType = "LeaseIdMismatchWithLeaseOperation"
|
||||
|
||||
// ServiceCodeLeaseIDMissing means there is currently a lease on the blob/container and no lease ID was specified in the request.
|
||||
ServiceCodeLeaseIDMissing ServiceCodeType = "LeaseIdMissing"
|
||||
|
||||
// ServiceCodeLeaseIsBreakingAndCannotBeAcquired means the lease ID matched, but the lease is currently in breaking state and cannot be acquired until it is broken.
|
||||
ServiceCodeLeaseIsBreakingAndCannotBeAcquired ServiceCodeType = "LeaseIsBreakingAndCannotBeAcquired"
|
||||
|
||||
// ServiceCodeLeaseIsBreakingAndCannotBeChanged means the lease ID matched, but the lease is currently in breaking state and cannot be changed.
|
||||
ServiceCodeLeaseIsBreakingAndCannotBeChanged ServiceCodeType = "LeaseIsBreakingAndCannotBeChanged"
|
||||
|
||||
// ServiceCodeLeaseIsBrokenAndCannotBeRenewed means the lease ID matched, but the lease has been broken explicitly and cannot be renewed.
|
||||
ServiceCodeLeaseIsBrokenAndCannotBeRenewed ServiceCodeType = "LeaseIsBrokenAndCannotBeRenewed"
|
||||
|
||||
// ServiceCodeLeaseLost means a lease ID was specified, but the lease for the blob/container has expired.
|
||||
ServiceCodeLeaseLost ServiceCodeType = "LeaseLost"
|
||||
|
||||
// ServiceCodeLeaseNotPresentWithBlobOperation means there is currently no lease on the blob.
|
||||
ServiceCodeLeaseNotPresentWithBlobOperation ServiceCodeType = "LeaseNotPresentWithBlobOperation"
|
||||
|
||||
// ServiceCodeLeaseNotPresentWithContainerOperation means there is currently no lease on the container.
|
||||
ServiceCodeLeaseNotPresentWithContainerOperation ServiceCodeType = "LeaseNotPresentWithContainerOperation"
|
||||
|
||||
// ServiceCodeLeaseNotPresentWithLeaseOperation means there is currently no lease on the blob/container.
|
||||
ServiceCodeLeaseNotPresentWithLeaseOperation ServiceCodeType = "LeaseNotPresentWithLeaseOperation"
|
||||
|
||||
// ServiceCodeMaxBlobSizeConditionNotMet means the max blob size condition specified was not met.
|
||||
ServiceCodeMaxBlobSizeConditionNotMet ServiceCodeType = "MaxBlobSizeConditionNotMet"
|
||||
|
||||
// ServiceCodeNoPendingCopyOperation means there is currently no pending copy operation.
|
||||
ServiceCodeNoPendingCopyOperation ServiceCodeType = "NoPendingCopyOperation"
|
||||
|
||||
// ServiceCodeOperationNotAllowedOnIncrementalCopyBlob means the specified operation is not allowed on an incremental copy blob.
|
||||
ServiceCodeOperationNotAllowedOnIncrementalCopyBlob ServiceCodeType = "OperationNotAllowedOnIncrementalCopyBlob"
|
||||
|
||||
// ServiceCodePendingCopyOperation means there is currently a pending copy operation.
|
||||
ServiceCodePendingCopyOperation ServiceCodeType = "PendingCopyOperation"
|
||||
|
||||
// ServiceCodePreviousSnapshotCannotBeNewer means the prevsnapshot query parameter value cannot be newer than snapshot query parameter value.
|
||||
ServiceCodePreviousSnapshotCannotBeNewer ServiceCodeType = "PreviousSnapshotCannotBeNewer"
|
||||
|
||||
// ServiceCodePreviousSnapshotNotFound means the previous snapshot is not found.
|
||||
ServiceCodePreviousSnapshotNotFound ServiceCodeType = "PreviousSnapshotNotFound"
|
||||
|
||||
// ServiceCodePreviousSnapshotOperationNotSupported means that differential Get Page Ranges is not supported on the previous snapshot.
|
||||
ServiceCodePreviousSnapshotOperationNotSupported ServiceCodeType = "PreviousSnapshotOperationNotSupported"
|
||||
|
||||
// ServiceCodeSequenceNumberConditionNotMet means the sequence number condition specified was not met.
|
||||
ServiceCodeSequenceNumberConditionNotMet ServiceCodeType = "SequenceNumberConditionNotMet"
|
||||
|
||||
// ServiceCodeSequenceNumberIncrementTooLarge means the sequence number increment cannot be performed because it would result in overflow of the sequence number.
|
||||
ServiceCodeSequenceNumberIncrementTooLarge ServiceCodeType = "SequenceNumberIncrementTooLarge"
|
||||
|
||||
// ServiceCodeSnapshotCountExceeded means the snapshot count against this blob has been exceeded.
|
||||
ServiceCodeSnapshotCountExceeded ServiceCodeType = "SnapshotCountExceeded"
|
||||
|
||||
// ServiceCodeSnaphotOperationRateExceeded means the rate of snapshot operations against this blob has been exceeded.
|
||||
ServiceCodeSnaphotOperationRateExceeded ServiceCodeType = "SnaphotOperationRateExceeded"
|
||||
|
||||
// ServiceCodeSnapshotsPresent means this operation is not permitted while the blob has snapshots.
|
||||
ServiceCodeSnapshotsPresent ServiceCodeType = "SnapshotsPresent"
|
||||
|
||||
// ServiceCodeSourceConditionNotMet means the source condition specified using HTTP conditional header(s) is not met.
|
||||
ServiceCodeSourceConditionNotMet ServiceCodeType = "SourceConditionNotMet"
|
||||
|
||||
// ServiceCodeSystemInUse means this blob is in use by the system.
|
||||
ServiceCodeSystemInUse ServiceCodeType = "SystemInUse"
|
||||
|
||||
// ServiceCodeTargetConditionNotMet means the target condition specified using HTTP conditional header(s) is not met.
|
||||
ServiceCodeTargetConditionNotMet ServiceCodeType = "TargetConditionNotMet"
|
||||
|
||||
// ServiceCodeUnauthorizedBlobOverwrite means this request is not authorized to perform blob overwrites.
|
||||
ServiceCodeUnauthorizedBlobOverwrite ServiceCodeType = "UnauthorizedBlobOverwrite"
|
||||
|
||||
// ServiceCodeBlobBeingRehydrated means this operation is not permitted because the blob is being rehydrated.
|
||||
ServiceCodeBlobBeingRehydrated ServiceCodeType = "BlobBeingRehydrated"
|
||||
|
||||
// ServiceCodeBlobArchived means this operation is not permitted on an archived blob.
|
||||
ServiceCodeBlobArchived ServiceCodeType = "BlobArchived"
|
||||
|
||||
// ServiceCodeBlobNotArchived means this blob is currently not in the archived state.
|
||||
ServiceCodeBlobNotArchived ServiceCodeType = "BlobNotArchived"
|
||||
)
|
||||
|
|
|
@ -4,11 +4,18 @@ import (
|
|||
"context"
|
||||
"io"
|
||||
"net/url"
|
||||
"time"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
const (
|
||||
// AppendBlobMaxAppendBlockBytes indicates the maximum number of bytes that can be sent in a call to AppendBlock.
|
||||
AppendBlobMaxAppendBlockBytes = 4 * 1024 * 1024 // 4MB
|
||||
|
||||
// AppendBlobMaxBlocks indicates the maximum number of blocks allowed in an append blob.
|
||||
AppendBlobMaxBlocks = 50000
|
||||
)
|
||||
|
||||
// AppendBlobURL defines a set of operations applicable to append blobs.
|
||||
type AppendBlobURL struct {
|
||||
BlobURL
|
||||
|
@ -28,8 +35,8 @@ func (ab AppendBlobURL) WithPipeline(p pipeline.Pipeline) AppendBlobURL {
|
|||
}
|
||||
|
||||
// WithSnapshot creates a new AppendBlobURL object identical to the source but with the specified snapshot timestamp.
|
||||
// Pass time.Time{} to remove the snapshot returning a URL to the base blob.
|
||||
func (ab AppendBlobURL) WithSnapshot(snapshot time.Time) AppendBlobURL {
|
||||
// Pass "" to remove the snapshot returning a URL to the base blob.
|
||||
func (ab AppendBlobURL) WithSnapshot(snapshot string) AppendBlobURL {
|
||||
p := NewBlobURLParts(ab.URL())
|
||||
p.Snapshot = snapshot
|
||||
return NewAppendBlobURL(p.URL(), ab.blobClient.Pipeline())
|
||||
|
@ -37,22 +44,23 @@ func (ab AppendBlobURL) WithSnapshot(snapshot time.Time) AppendBlobURL {
|
|||
|
||||
// Create creates a 0-length append blob. Call AppendBlock to append data to an append blob.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-blob.
|
||||
func (ab AppendBlobURL) Create(ctx context.Context, metadata Metadata, h BlobHTTPHeaders, ac BlobAccessConditions) (*BlobsPutResponse, error) {
|
||||
func (ab AppendBlobURL) Create(ctx context.Context, h BlobHTTPHeaders, metadata Metadata, ac BlobAccessConditions) (*AppendBlobsCreateResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch := ac.HTTPAccessConditions.pointers()
|
||||
return ab.blobClient.Put(ctx, BlobAppendBlob, nil, nil, nil,
|
||||
&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.contentMD5Pointer(), &h.CacheControl,
|
||||
metadata, ac.LeaseAccessConditions.pointers(),
|
||||
&h.ContentDisposition,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch, nil, nil, nil)
|
||||
|
||||
return ab.abClient.Create(ctx, 0, nil,
|
||||
&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5,
|
||||
&h.CacheControl, metadata, ac.LeaseAccessConditions.pointers(), &h.ContentDisposition,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch, nil)
|
||||
}
|
||||
|
||||
// AppendBlock commits a new block of data to the end of the existing append blob.
|
||||
// AppendBlock writes a stream to a new block of data to the end of the existing append blob.
|
||||
// This method panics if the stream is not at position 0.
|
||||
// Note that the http client closes the body stream after the request is sent to the service.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/append-block.
|
||||
func (ab AppendBlobURL) AppendBlock(ctx context.Context, body io.ReadSeeker, ac BlobAccessConditions) (*AppendBlobsAppendBlockResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
ifAppendPositionEqual, ifMaxSizeLessThanOrEqual := ac.AppendBlobAccessConditions.pointers()
|
||||
return ab.abClient.AppendBlock(ctx, body, nil, ac.LeaseAccessConditions.pointers(),
|
||||
return ab.abClient.AppendBlock(ctx, validateSeekableStreamAt0AndGetCount(body), body, nil,
|
||||
ac.LeaseAccessConditions.pointers(),
|
||||
ifMaxSizeLessThanOrEqual, ifAppendPositionEqual,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
|
|
@ -2,12 +2,8 @@ package azblob
|
|||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"net/url"
|
||||
)
|
||||
|
||||
// A BlobURL represents a URL to an Azure Storage blob; the blob may be a block blob, append blob, or page blob.
|
||||
|
@ -44,8 +40,8 @@ func (b BlobURL) WithPipeline(p pipeline.Pipeline) BlobURL {
|
|||
}
|
||||
|
||||
// WithSnapshot creates a new BlobURL object identical to the source but with the specified snapshot timestamp.
|
||||
// Pass time.Time{} to remove the snapshot returning a URL to the base blob.
|
||||
func (b BlobURL) WithSnapshot(snapshot time.Time) BlobURL {
|
||||
// Pass "" to remove the snapshot returning a URL to the base blob.
|
||||
func (b BlobURL) WithSnapshot(snapshot string) BlobURL {
|
||||
p := NewBlobURLParts(b.URL())
|
||||
p.Snapshot = snapshot
|
||||
return NewBlobURL(p.URL(), b.blobClient.Pipeline())
|
||||
|
@ -66,66 +62,30 @@ func (b BlobURL) ToPageBlobURL() PageBlobURL {
|
|||
return NewPageBlobURL(b.URL(), b.blobClient.Pipeline())
|
||||
}
|
||||
|
||||
// StartCopy copies the data at the source URL to a blob.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/copy-blob.
|
||||
func (b BlobURL) StartCopy(ctx context.Context, source url.URL, metadata Metadata, srcac BlobAccessConditions, dstac BlobAccessConditions) (*BlobsCopyResponse, error) {
|
||||
srcIfModifiedSince, srcIfUnmodifiedSince, srcIfMatchETag, srcIfNoneMatchETag := srcac.HTTPAccessConditions.pointers()
|
||||
dstIfModifiedSince, dstIfUnmodifiedSince, dstIfMatchETag, dstIfNoneMatchETag := dstac.HTTPAccessConditions.pointers()
|
||||
srcLeaseID := srcac.LeaseAccessConditions.pointers()
|
||||
dstLeaseID := dstac.LeaseAccessConditions.pointers()
|
||||
|
||||
return b.blobClient.Copy(ctx, source.String(), nil, metadata,
|
||||
srcIfModifiedSince, srcIfUnmodifiedSince,
|
||||
srcIfMatchETag, srcIfNoneMatchETag,
|
||||
dstIfModifiedSince, dstIfUnmodifiedSince,
|
||||
dstIfMatchETag, dstIfNoneMatchETag,
|
||||
dstLeaseID, srcLeaseID, nil)
|
||||
}
|
||||
|
||||
// AbortCopy stops a pending copy that was previously started and leaves a destination blob with 0 length and metadata.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/abort-copy-blob.
|
||||
func (b BlobURL) AbortCopy(ctx context.Context, copyID string, ac LeaseAccessConditions) (*BlobsAbortCopyResponse, error) {
|
||||
return b.blobClient.AbortCopy(ctx, copyID, "abort", nil, ac.pointers(), nil)
|
||||
}
|
||||
|
||||
// BlobRange defines a range of bytes within a blob, starting at Offset and ending
|
||||
// at Offset+Count. Use a zero-value BlobRange to indicate the entire blob.
|
||||
type BlobRange struct {
|
||||
Offset int64
|
||||
Count int64
|
||||
}
|
||||
|
||||
func (dr *BlobRange) pointers() *string {
|
||||
if dr.Offset < 0 {
|
||||
panic("The blob's range Offset must be >= 0")
|
||||
}
|
||||
if dr.Count < 0 {
|
||||
panic("The blob's range Count must be >= 0")
|
||||
}
|
||||
if dr.Offset == 0 && dr.Count == 0 {
|
||||
return nil
|
||||
}
|
||||
endRange := ""
|
||||
if dr.Count > 0 {
|
||||
endRange = strconv.FormatInt((dr.Offset+dr.Count)-1, 10)
|
||||
}
|
||||
dataRange := fmt.Sprintf("bytes=%v-%s", dr.Offset, endRange)
|
||||
return &dataRange
|
||||
}
|
||||
|
||||
// GetBlob reads a range of bytes from a blob. The response also includes the blob's properties and metadata.
|
||||
// DownloadBlob reads a range of bytes from a blob. The response also includes the blob's properties and metadata.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-blob.
|
||||
func (b BlobURL) GetBlob(ctx context.Context, blobRange BlobRange, ac BlobAccessConditions, rangeGetContentMD5 bool) (*GetResponse, error) {
|
||||
func (b BlobURL) Download(ctx context.Context, offset int64, count int64, ac BlobAccessConditions, rangeGetContentMD5 bool) (*DownloadResponse, error) {
|
||||
var xRangeGetContentMD5 *bool
|
||||
if rangeGetContentMD5 {
|
||||
xRangeGetContentMD5 = &rangeGetContentMD5
|
||||
}
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return b.blobClient.Get(ctx, nil, nil, blobRange.pointers(), ac.LeaseAccessConditions.pointers(), xRangeGetContentMD5,
|
||||
dr, err := b.blobClient.Download(ctx, nil, nil,
|
||||
httpRange{offset: offset, count: count}.pointers(),
|
||||
ac.LeaseAccessConditions.pointers(), xRangeGetContentMD5,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &DownloadResponse{
|
||||
b: b,
|
||||
r: dr,
|
||||
ctx: ctx,
|
||||
getInfo: HTTPGetterInfo{Offset: offset, Count: count, ETag: dr.ETag()},
|
||||
}, err
|
||||
}
|
||||
|
||||
// Delete marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection.
|
||||
// DeleteBlob marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection.
|
||||
// Note that deleting a blob also deletes all its snapshots.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/delete-blob.
|
||||
func (b BlobURL) Delete(ctx context.Context, deleteOptions DeleteSnapshotsOptionType, ac BlobAccessConditions) (*BlobsDeleteResponse, error) {
|
||||
|
@ -134,26 +94,41 @@ func (b BlobURL) Delete(ctx context.Context, deleteOptions DeleteSnapshotsOption
|
|||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// GetPropertiesAndMetadata returns the blob's metadata and properties.
|
||||
// Undelete restores the contents and metadata of a soft-deleted blob and any associated soft-deleted snapshots.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/undelete-blob.
|
||||
func (b BlobURL) Undelete(ctx context.Context) (*BlobsUndeleteResponse, error) {
|
||||
return b.blobClient.Undelete(ctx, nil, nil)
|
||||
}
|
||||
|
||||
// SetTier operation sets the tier on a blob. The operation is allowed on a page
|
||||
// blob in a premium storage account and on a block blob in a blob storage account (locally
|
||||
// redundant storage only). A premium page blob's tier determines the allowed size, IOPS, and
|
||||
// bandwidth of the blob. A block blob's tier determines Hot/Cool/Archive storage type. This operation
|
||||
// does not update the blob's ETag.
|
||||
// For detailed information about block blob level tiering see https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blob-storage-tiers.
|
||||
func (b BlobURL) SetTier(ctx context.Context, tier AccessTierType) (*BlobsSetTierResponse, error) {
|
||||
return b.blobClient.SetTier(ctx, tier, nil, nil)
|
||||
}
|
||||
|
||||
// GetBlobProperties returns the blob's properties.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-blob-properties.
|
||||
func (b BlobURL) GetPropertiesAndMetadata(ctx context.Context, ac BlobAccessConditions) (*BlobsGetPropertiesResponse, error) {
|
||||
func (b BlobURL) GetProperties(ctx context.Context, ac BlobAccessConditions) (*BlobsGetPropertiesResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return b.blobClient.GetProperties(ctx, nil, nil, ac.LeaseAccessConditions.pointers(),
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
// NOTE: GetMetadata actually calls GetProperties since this returns a the properties AND the metadata
|
||||
}
|
||||
|
||||
// SetProperties changes a blob's HTTP header properties.
|
||||
// SetBlobHTTPHeaders changes a blob's HTTP headers.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-blob-properties.
|
||||
func (b BlobURL) SetProperties(ctx context.Context, h BlobHTTPHeaders, ac BlobAccessConditions) (*BlobsSetPropertiesResponse, error) {
|
||||
func (b BlobURL) SetHTTPHeaders(ctx context.Context, h BlobHTTPHeaders, ac BlobAccessConditions) (*BlobsSetHTTPHeadersResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return b.blobClient.SetProperties(ctx, nil,
|
||||
&h.CacheControl, &h.ContentType, h.contentMD5Pointer(), &h.ContentEncoding, &h.ContentLanguage,
|
||||
return b.blobClient.SetHTTPHeaders(ctx, nil,
|
||||
&h.CacheControl, &h.ContentType, h.ContentMD5, &h.ContentEncoding, &h.ContentLanguage,
|
||||
ac.LeaseAccessConditions.pointers(), ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag,
|
||||
&h.ContentDisposition, nil, SequenceNumberActionNone, nil, nil)
|
||||
&h.ContentDisposition, nil)
|
||||
}
|
||||
|
||||
// SetMetadata changes a blob's metadata.
|
||||
// SetBlobMetadata changes a blob's metadata.
|
||||
// https://docs.microsoft.com/rest/api/storageservices/set-blob-metadata.
|
||||
func (b BlobURL) SetMetadata(ctx context.Context, metadata Metadata, ac BlobAccessConditions) (*BlobsSetMetadataResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
|
@ -163,54 +138,54 @@ func (b BlobURL) SetMetadata(ctx context.Context, metadata Metadata, ac BlobAcce
|
|||
|
||||
// CreateSnapshot creates a read-only snapshot of a blob.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/snapshot-blob.
|
||||
func (b BlobURL) CreateSnapshot(ctx context.Context, metadata Metadata, ac BlobAccessConditions) (*BlobsTakeSnapshotResponse, error) {
|
||||
func (b BlobURL) CreateSnapshot(ctx context.Context, metadata Metadata, ac BlobAccessConditions) (*BlobsCreateSnapshotResponse, error) {
|
||||
// CreateSnapshot does NOT panic if the user tries to create a snapshot using a URL that already has a snapshot query parameter
|
||||
// because checking this would be a performance hit for a VERY unusual path and I don't think the common case should suffer this
|
||||
// performance hit.
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return b.blobClient.TakeSnapshot(ctx, nil, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, ac.LeaseAccessConditions.pointers(), nil)
|
||||
return b.blobClient.CreateSnapshot(ctx, nil, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, ac.LeaseAccessConditions.pointers(), nil)
|
||||
}
|
||||
|
||||
// AcquireLease acquires a lease on the blob for write and delete operations. The lease duration must be between
|
||||
// 15 to 60 seconds, or infinite (-1).
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
|
||||
func (b BlobURL) AcquireLease(ctx context.Context, proposedID string, duration int32, ac HTTPAccessConditions) (*BlobsLeaseResponse, error) {
|
||||
func (b BlobURL) AcquireLease(ctx context.Context, proposedID string, duration int32, ac HTTPAccessConditions) (*BlobsAcquireLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
|
||||
return b.blobClient.Lease(ctx, LeaseActionAcquire, nil, nil, nil, &duration, &proposedID,
|
||||
return b.blobClient.AcquireLease(ctx, nil, &duration, &proposedID,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// RenewLease renews the blob's previously-acquired lease.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
|
||||
func (b BlobURL) RenewLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*BlobsLeaseResponse, error) {
|
||||
func (b BlobURL) RenewLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*BlobsRenewLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
|
||||
return b.blobClient.Lease(ctx, LeaseActionRenew, nil, &leaseID, nil, nil, nil,
|
||||
return b.blobClient.RenewLease(ctx, leaseID, nil,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// ReleaseLease releases the blob's previously-acquired lease.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
|
||||
func (b BlobURL) ReleaseLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*BlobsLeaseResponse, error) {
|
||||
func (b BlobURL) ReleaseLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*BlobsReleaseLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
|
||||
return b.blobClient.Lease(ctx, LeaseActionRelease, nil, &leaseID, nil, nil, nil,
|
||||
return b.blobClient.ReleaseLease(ctx, leaseID, nil,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// BreakLease breaks the blob's previously-acquired lease (if it exists). Pass the LeaseBreakDefault (-1) constant to break
|
||||
// a fixed-duration lease when it expires or an infinite lease immediately.
|
||||
// BreakLease breaks the blob's previously-acquired lease (if it exists). Pass the LeaseBreakDefault (-1)
|
||||
// constant to break a fixed-duration lease when it expires or an infinite lease immediately.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
|
||||
func (b BlobURL) BreakLease(ctx context.Context, leaseID string, breakPeriodInSeconds int32, ac HTTPAccessConditions) (*BlobsLeaseResponse, error) {
|
||||
func (b BlobURL) BreakLease(ctx context.Context, breakPeriodInSeconds int32, ac HTTPAccessConditions) (*BlobsBreakLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
|
||||
return b.blobClient.Lease(ctx, LeaseActionBreak, nil, &leaseID, leasePeriodPointer(breakPeriodInSeconds), nil, nil,
|
||||
return b.blobClient.BreakLease(ctx, nil, leasePeriodPointer(breakPeriodInSeconds),
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// ChangeLease changes the blob's lease ID.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-blob.
|
||||
func (b BlobURL) ChangeLease(ctx context.Context, leaseID string, proposedID string, ac HTTPAccessConditions) (*BlobsLeaseResponse, error) {
|
||||
func (b BlobURL) ChangeLease(ctx context.Context, leaseID string, proposedID string, ac HTTPAccessConditions) (*BlobsChangeLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.pointers()
|
||||
return b.blobClient.Lease(ctx, LeaseActionChange, nil, &leaseID, nil, nil, &proposedID,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
return b.blobClient.ChangeLease(ctx, leaseID, proposedID,
|
||||
nil, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// LeaseBreakNaturally tells ContainerURL's or BlobURL's BreakLease method to break the lease using service semantics.
|
||||
|
@ -223,18 +198,24 @@ func leasePeriodPointer(period int32) (p *int32) {
|
|||
return nil
|
||||
}
|
||||
|
||||
// Undelete restores the contents and metadata of a soft-deleted blob and any associated soft-deleted snapshots.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/undelete-blob.
|
||||
func (b BlobURL) Undelete(ctx context.Context) (*BlobsUndeleteResponse, error) {
|
||||
return b.blobClient.Undelete(ctx, nil, nil)
|
||||
// StartCopyFromURL copies the data at the source URL to a blob.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/copy-blob.
|
||||
func (b BlobURL) StartCopyFromURL(ctx context.Context, source url.URL, metadata Metadata, srcac BlobAccessConditions, dstac BlobAccessConditions) (*BlobsStartCopyFromURLResponse, error) {
|
||||
srcIfModifiedSince, srcIfUnmodifiedSince, srcIfMatchETag, srcIfNoneMatchETag := srcac.HTTPAccessConditions.pointers()
|
||||
dstIfModifiedSince, dstIfUnmodifiedSince, dstIfMatchETag, dstIfNoneMatchETag := dstac.HTTPAccessConditions.pointers()
|
||||
srcLeaseID := srcac.LeaseAccessConditions.pointers()
|
||||
dstLeaseID := dstac.LeaseAccessConditions.pointers()
|
||||
|
||||
return b.blobClient.StartCopyFromURL(ctx, source.String(), nil, metadata,
|
||||
srcIfModifiedSince, srcIfUnmodifiedSince,
|
||||
srcIfMatchETag, srcIfNoneMatchETag,
|
||||
dstIfModifiedSince, dstIfUnmodifiedSince,
|
||||
dstIfMatchETag, dstIfNoneMatchETag,
|
||||
dstLeaseID, srcLeaseID, nil)
|
||||
}
|
||||
|
||||
// SetBlobTier operation sets the tier on a blob. The operation is allowed on a page
|
||||
// blob in a premium storage account and on a block blob in a blob storage account (locally
|
||||
// redundant storage only). A premium page blob's tier determines the allowed size, IOPS, and
|
||||
// bandwidth of the blob. A block blob's tier determines Hot/Cool/Archive storage type. This operation
|
||||
// does not update the blob's ETag.
|
||||
// For detailed information about block blob level tiering see https://docs.microsoft.com/en-us/azure/storage/blobs/storage-blob-storage-tiers.
|
||||
func (b BlobURL) SetBlobTier(ctx context.Context, tier AccessTierType) (*BlobsSetBlobTierResponse, error) {
|
||||
return b.blobClient.SetBlobTier(ctx, tier, nil, nil)
|
||||
// AbortCopyFromURL stops a pending copy that was previously started and leaves a destination blob with 0 length and metadata.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/abort-copy-blob.
|
||||
func (b BlobURL) AbortCopyFromURL(ctx context.Context, copyID string, ac LeaseAccessConditions) (*BlobsAbortCopyFromURLResponse, error) {
|
||||
return b.blobClient.AbortCopyFromURL(ctx, copyID, nil, ac.pointers(), nil)
|
||||
}
|
||||
|
|
|
@ -4,17 +4,18 @@ import (
|
|||
"context"
|
||||
"io"
|
||||
"net/url"
|
||||
"time"
|
||||
|
||||
"encoding/base64"
|
||||
"encoding/binary"
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
const (
|
||||
// BlockBlobMaxPutBlobBytes indicates the maximum number of bytes that can be sent in a call to PutBlob.
|
||||
BlockBlobMaxPutBlobBytes = 256 * 1024 * 1024 // 256MB
|
||||
// BlockBlobMaxPutBlobBytes indicates the maximum number of bytes that can be sent in a call to Upload.
|
||||
BlockBlobMaxUploadBlobBytes = 256 * 1024 * 1024 // 256MB
|
||||
|
||||
// BlockBlobMaxPutBlockBytes indicates the maximum number of bytes that can be sent in a call to PutBlock.
|
||||
BlockBlobMaxPutBlockBytes = 100 * 1024 * 1024 // 100MB
|
||||
// BlockBlobMaxStageBlockBytes indicates the maximum number of bytes that can be sent in a call to StageBlock.
|
||||
BlockBlobMaxStageBlockBytes = 100 * 1024 * 1024 // 100MB
|
||||
|
||||
// BlockBlobMaxBlocks indicates the maximum number of blocks allowed in a block blob.
|
||||
BlockBlobMaxBlocks = 50000
|
||||
|
@ -42,24 +43,49 @@ func (bb BlockBlobURL) WithPipeline(p pipeline.Pipeline) BlockBlobURL {
|
|||
}
|
||||
|
||||
// WithSnapshot creates a new BlockBlobURL object identical to the source but with the specified snapshot timestamp.
|
||||
// Pass time.Time{} to remove the snapshot returning a URL to the base blob.
|
||||
func (bb BlockBlobURL) WithSnapshot(snapshot time.Time) BlockBlobURL {
|
||||
// Pass "" to remove the snapshot returning a URL to the base blob.
|
||||
func (bb BlockBlobURL) WithSnapshot(snapshot string) BlockBlobURL {
|
||||
p := NewBlobURLParts(bb.URL())
|
||||
p.Snapshot = snapshot
|
||||
return NewBlockBlobURL(p.URL(), bb.blobClient.Pipeline())
|
||||
}
|
||||
|
||||
// PutBlob creates a new block blob, or updates the content of an existing block blob.
|
||||
// Upload creates a new block blob or overwrites an existing block blob.
|
||||
// Updating an existing block blob overwrites any existing metadata on the blob. Partial updates are not
|
||||
// supported with PutBlob; the content of the existing blob is overwritten with the new content. To
|
||||
// perform a partial update of a block blob's, use PutBlock and PutBlockList.
|
||||
// supported with Upload; the content of the existing blob is overwritten with the new content. To
|
||||
// perform a partial update of a block blob, use StageBlock and CommitBlockList.
|
||||
// This method panics if the stream is not at position 0.
|
||||
// Note that the http client closes the body stream after the request is sent to the service.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-blob.
|
||||
func (bb BlockBlobURL) PutBlob(ctx context.Context, body io.ReadSeeker, h BlobHTTPHeaders, metadata Metadata, ac BlobAccessConditions) (*BlobsPutResponse, error) {
|
||||
func (bb BlockBlobURL) Upload(ctx context.Context, body io.ReadSeeker, h BlobHTTPHeaders, metadata Metadata, ac BlobAccessConditions) (*BlockBlobsUploadResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return bb.blobClient.Put(ctx, BlobBlockBlob, body, nil, nil,
|
||||
&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.contentMD5Pointer(), &h.CacheControl,
|
||||
metadata, ac.LeaseAccessConditions.pointers(),
|
||||
&h.ContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil, nil, nil)
|
||||
return bb.bbClient.Upload(ctx, validateSeekableStreamAt0AndGetCount(body), body,nil,
|
||||
&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5,
|
||||
&h.CacheControl, metadata, ac.LeaseAccessConditions.pointers(),
|
||||
&h.ContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag,
|
||||
nil)
|
||||
}
|
||||
|
||||
// StageBlock uploads the specified block to the block blob's "staging area" to be later committed by a call to CommitBlockList.
|
||||
// Note that the http client closes the body stream after the request is sent to the service.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-block.
|
||||
func (bb BlockBlobURL) StageBlock(ctx context.Context, base64BlockID string, body io.ReadSeeker, ac LeaseAccessConditions) (*BlockBlobsStageBlockResponse, error) {
|
||||
return bb.bbClient.StageBlock(ctx, base64BlockID, validateSeekableStreamAt0AndGetCount(body), body, nil, ac.pointers(), nil)
|
||||
}
|
||||
|
||||
// CommitBlockList writes a blob by specifying the list of block IDs that make up the blob.
|
||||
// In order to be written as part of a blob, a block must have been successfully written
|
||||
// to the server in a prior PutBlock operation. You can call PutBlockList to update a blob
|
||||
// by uploading only those blocks that have changed, then committing the new and existing
|
||||
// blocks together. Any blocks not specified in the block list and permanently deleted.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-block-list.
|
||||
func (bb BlockBlobURL) CommitBlockList(ctx context.Context, base64BlockIDs []string, h BlobHTTPHeaders,
|
||||
metadata Metadata, ac BlobAccessConditions) (*BlockBlobsCommitBlockListResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return bb.bbClient.CommitBlockList(ctx, BlockLookupList{Latest: base64BlockIDs}, nil,
|
||||
&h.CacheControl, &h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5,
|
||||
metadata, ac.LeaseAccessConditions.pointers(), &h.ContentDisposition,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// GetBlockList returns the list of blocks that have been uploaded as part of a block blob using the specified block list filter.
|
||||
|
@ -68,23 +94,55 @@ func (bb BlockBlobURL) GetBlockList(ctx context.Context, listType BlockListType,
|
|||
return bb.bbClient.GetBlockList(ctx, listType, nil, nil, ac.pointers(), nil)
|
||||
}
|
||||
|
||||
// PutBlock uploads the specified block to the block blob's "staging area" to be later committed by a call to PutBlockList.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-block.
|
||||
func (bb BlockBlobURL) PutBlock(ctx context.Context, base64BlockID string, body io.ReadSeeker, ac LeaseAccessConditions) (*BlockBlobsPutBlockResponse, error) {
|
||||
return bb.bbClient.PutBlock(ctx, base64BlockID, body, nil, ac.pointers(), nil)
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
type BlockID [64]byte
|
||||
|
||||
func (blockID BlockID) ToBase64() string {
|
||||
return base64.StdEncoding.EncodeToString(blockID[:])
|
||||
}
|
||||
|
||||
// PutBlockList writes a blob by specifying the list of block IDs that make up the blob.
|
||||
// In order to be written as part of a blob, a block must have been successfully written
|
||||
// to the server in a prior PutBlock operation. You can call PutBlockList to update a blob
|
||||
// by uploading only those blocks that have changed, then committing the new and existing
|
||||
// blocks together. Any blocks not specified in the block list and permanently deleted.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-block-list.
|
||||
func (bb BlockBlobURL) PutBlockList(ctx context.Context, base64BlockIDs []string, metadata Metadata,
|
||||
h BlobHTTPHeaders, ac BlobAccessConditions) (*BlockBlobsPutBlockListResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return bb.bbClient.PutBlockList(ctx, BlockLookupList{Latest: base64BlockIDs}, nil,
|
||||
&h.CacheControl, &h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.contentMD5Pointer(),
|
||||
metadata, ac.LeaseAccessConditions.pointers(), &h.ContentDisposition,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
func (blockID *BlockID) FromBase64(s string) error {
|
||||
*blockID = BlockID{} // Zero out the block ID
|
||||
_, err := base64.StdEncoding.Decode(blockID[:], ([]byte)(s))
|
||||
return err
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
type uuidBlockID BlockID
|
||||
|
||||
func (ubi uuidBlockID) UUID() uuid {
|
||||
u := uuid{}
|
||||
copy(u[:], ubi[:len(u)])
|
||||
return u
|
||||
}
|
||||
|
||||
func (ubi uuidBlockID) Number() uint32 {
|
||||
return binary.BigEndian.Uint32(ubi[len(uuid{}):])
|
||||
}
|
||||
|
||||
func newUuidBlockID(u uuid) uuidBlockID {
|
||||
ubi := uuidBlockID{} // Create a new uuidBlockID
|
||||
copy(ubi[:len(u)], u[:]) // Copy the specified UUID into it
|
||||
// Block number defaults to 0
|
||||
return ubi
|
||||
}
|
||||
|
||||
func (ubi *uuidBlockID) SetUUID(u uuid) *uuidBlockID {
|
||||
copy(ubi[:len(u)], u[:])
|
||||
return ubi
|
||||
}
|
||||
|
||||
func (ubi uuidBlockID) WithBlockNumber(blockNumber uint32) uuidBlockID {
|
||||
binary.BigEndian.PutUint32(ubi[len(uuid{}):], blockNumber) // Put block number after UUID
|
||||
return ubi // Return the passed-in copy
|
||||
}
|
||||
|
||||
func (ubi uuidBlockID) ToBase64() string {
|
||||
return BlockID(ubi).ToBase64()
|
||||
}
|
||||
|
||||
func (ubi *uuidBlockID) FromBase64(s string) error {
|
||||
return (*BlockID)(ubi).FromBase64(s)
|
||||
}
|
||||
|
|
|
@ -3,15 +3,15 @@ package azblob
|
|||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"strings"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// A ContainerURL represents a URL to the Azure Storage container allowing you to manipulate its blobs.
|
||||
type ContainerURL struct {
|
||||
client containerClient
|
||||
client containersClient
|
||||
}
|
||||
|
||||
// NewContainerURL creates a ContainerURL object using the specified URL and request policy pipeline.
|
||||
|
@ -19,7 +19,7 @@ func NewContainerURL(url url.URL, p pipeline.Pipeline) ContainerURL {
|
|||
if p == nil {
|
||||
panic("p can't be nil")
|
||||
}
|
||||
client := newContainerClient(url, p)
|
||||
client := newContainersClient(url, p)
|
||||
return ContainerURL{client: client}
|
||||
}
|
||||
|
||||
|
@ -81,32 +81,33 @@ func (c ContainerURL) NewPageBlobURL(blobName string) PageBlobURL {
|
|||
|
||||
// Create creates a new container within a storage account. If a container with the same name already exists, the operation fails.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/create-container.
|
||||
func (c ContainerURL) Create(ctx context.Context, metadata Metadata, publicAccessType PublicAccessType) (*ContainerCreateResponse, error) {
|
||||
func (c ContainerURL) Create(ctx context.Context, metadata Metadata, publicAccessType PublicAccessType) (*ContainersCreateResponse, error) {
|
||||
return c.client.Create(ctx, nil, metadata, publicAccessType, nil)
|
||||
}
|
||||
|
||||
// Delete marks the specified container for deletion. The container and any blobs contained within it are later deleted during garbage collection.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/delete-container.
|
||||
func (c ContainerURL) Delete(ctx context.Context, ac ContainerAccessConditions) (*ContainerDeleteResponse, error) {
|
||||
func (c ContainerURL) Delete(ctx context.Context, ac ContainerAccessConditions) (*ContainersDeleteResponse, error) {
|
||||
if ac.IfMatch != ETagNone || ac.IfNoneMatch != ETagNone {
|
||||
panic("the IfMatch and IfNoneMatch access conditions must have their default values because they are ignored by the service")
|
||||
}
|
||||
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return c.client.Delete(ctx, nil, nil, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
ifModifiedSince, ifUnmodifiedSince, _, _:= ac.HTTPAccessConditions.pointers()
|
||||
return c.client.Delete(ctx, nil, ac.LeaseAccessConditions.pointers(),
|
||||
ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
}
|
||||
|
||||
// GetPropertiesAndMetadata returns the container's metadata and system properties.
|
||||
// GetContainerProperties returns the container's properties.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-container-metadata.
|
||||
func (c ContainerURL) GetPropertiesAndMetadata(ctx context.Context, ac LeaseAccessConditions) (*ContainerGetPropertiesResponse, error) {
|
||||
func (c ContainerURL) GetProperties(ctx context.Context, ac LeaseAccessConditions) (*ContainersGetPropertiesResponse, error) {
|
||||
// NOTE: GetMetadata actually calls GetProperties internally because GetProperties returns the metadata AND the properties.
|
||||
// This allows us to not expose a GetProperties method at all simplifying the API.
|
||||
return c.client.GetProperties(ctx, nil, ac.pointers(), nil)
|
||||
}
|
||||
|
||||
// SetMetadata sets the container's metadata.
|
||||
// SetContainerMetadata sets the container's metadata.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-container-metadata.
|
||||
func (c ContainerURL) SetMetadata(ctx context.Context, metadata Metadata, ac ContainerAccessConditions) (*ContainerSetMetadataResponse, error) {
|
||||
func (c ContainerURL) SetMetadata(ctx context.Context, metadata Metadata, ac ContainerAccessConditions) (*ContainersSetMetadataResponse, error) {
|
||||
if !ac.IfUnmodifiedSince.IsZero() || ac.IfMatch != ETagNone || ac.IfNoneMatch != ETagNone {
|
||||
panic("the IfUnmodifiedSince, IfMatch, and IfNoneMatch must have their default values because they are ignored by the blob service")
|
||||
}
|
||||
|
@ -114,10 +115,10 @@ func (c ContainerURL) SetMetadata(ctx context.Context, metadata Metadata, ac Con
|
|||
return c.client.SetMetadata(ctx, nil, ac.LeaseAccessConditions.pointers(), metadata, ifModifiedSince, nil)
|
||||
}
|
||||
|
||||
// GetPermissions returns the container's permissions. The permissions indicate whether container's blobs may be accessed publicly.
|
||||
// GetContainerAccessPolicy returns the container's access policy. The access policy indicates whether container's blobs may be accessed publicly.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-container-acl.
|
||||
func (c ContainerURL) GetPermissions(ctx context.Context, ac LeaseAccessConditions) (*SignedIdentifiers, error) {
|
||||
return c.client.GetACL(ctx, nil, ac.pointers(), nil)
|
||||
func (c ContainerURL) GetAccessPolicy(ctx context.Context, ac LeaseAccessConditions) (*SignedIdentifiers, error) {
|
||||
return c.client.GetAccessPolicy(ctx, nil, ac.pointers(), nil)
|
||||
}
|
||||
|
||||
// The AccessPolicyPermission type simplifies creating the permissions string for a container's access policy.
|
||||
|
@ -152,77 +153,102 @@ func (p AccessPolicyPermission) String() string {
|
|||
}
|
||||
|
||||
// Parse initializes the AccessPolicyPermission's fields from a string.
|
||||
func (p *AccessPolicyPermission) Parse(s string) {
|
||||
p.Read = strings.ContainsRune(s, 'r')
|
||||
p.Add = strings.ContainsRune(s, 'a')
|
||||
p.Create = strings.ContainsRune(s, 'c')
|
||||
p.Write = strings.ContainsRune(s, 'w')
|
||||
p.Delete = strings.ContainsRune(s, 'd')
|
||||
p.List = strings.ContainsRune(s, 'l')
|
||||
func (p *AccessPolicyPermission) Parse(s string) error {
|
||||
*p = AccessPolicyPermission{} // Clear the flags
|
||||
for _, r := range s {
|
||||
switch r {
|
||||
case 'r':
|
||||
p.Read = true
|
||||
case 'a':
|
||||
p.Add = true
|
||||
case 'c':
|
||||
p.Create = true
|
||||
case 'w':
|
||||
p.Write = true
|
||||
case 'd':
|
||||
p.Delete = true
|
||||
case 'l':
|
||||
p.List = true
|
||||
default:
|
||||
return fmt.Errorf("invalid permission: '%v'", r)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetPermissions sets the container's permissions. The permissions indicate whether blobs in a container may be accessed publicly.
|
||||
// SetContainerAccessPolicy sets the container's permissions. The access policy indicates whether blobs in a container may be accessed publicly.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-container-acl.
|
||||
func (c ContainerURL) SetPermissions(ctx context.Context, accessType PublicAccessType, permissions []SignedIdentifier,
|
||||
ac ContainerAccessConditions) (*ContainerSetACLResponse, error) {
|
||||
func (c ContainerURL) SetAccessPolicy(ctx context.Context, accessType PublicAccessType, si []SignedIdentifier,
|
||||
ac ContainerAccessConditions) (*ContainersSetAccessPolicyResponse, error) {
|
||||
if ac.IfMatch != ETagNone || ac.IfNoneMatch != ETagNone {
|
||||
panic("the IfMatch and IfNoneMatch access conditions must have their default values because they are ignored by the service")
|
||||
}
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return c.client.SetACL(ctx, permissions, nil, nil, accessType, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
ifModifiedSince, ifUnmodifiedSince, _, _:= ac.HTTPAccessConditions.pointers()
|
||||
return c.client.SetAccessPolicy(ctx, si, nil, ac.LeaseAccessConditions.pointers(),
|
||||
accessType, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
}
|
||||
|
||||
// AcquireLease acquires a lease on the container for delete operations. The lease duration must be between 15 to 60 seconds, or infinite (-1).
|
||||
// AcquireContainerLease acquires a lease on the container for delete operations. The lease duration must be between 15 to 60 seconds, or infinite (-1).
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
|
||||
func (c ContainerURL) AcquireLease(ctx context.Context, proposedID string, duration int32, ac HTTPAccessConditions) (*ContainerLeaseResponse, error) {
|
||||
func (c ContainerURL) AcquireLease(ctx context.Context, proposedID string, duration int32, ac HTTPAccessConditions) (*ContainersAcquireLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
|
||||
return c.client.Lease(ctx, LeaseActionAcquire, nil, nil, nil, &duration, &proposedID,
|
||||
return c.client.AcquireLease(ctx, nil, &duration, &proposedID,
|
||||
ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
}
|
||||
|
||||
// RenewLease renews the container's previously-acquired lease.
|
||||
// RenewContainerLease renews the container's previously-acquired lease.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
|
||||
func (c ContainerURL) RenewLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*ContainerLeaseResponse, error) {
|
||||
func (c ContainerURL) RenewLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*ContainersRenewLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
|
||||
return c.client.Lease(ctx, LeaseActionRenew, nil, &leaseID, nil, nil, nil, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
return c.client.RenewLease(ctx, leaseID, nil, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
}
|
||||
|
||||
// ReleaseLease releases the container's previously-acquired lease.
|
||||
// ReleaseContainerLease releases the container's previously-acquired lease.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
|
||||
func (c ContainerURL) ReleaseLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*ContainerLeaseResponse, error) {
|
||||
func (c ContainerURL) ReleaseLease(ctx context.Context, leaseID string, ac HTTPAccessConditions) (*ContainersReleaseLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
|
||||
return c.client.Lease(ctx, LeaseActionRelease, nil, &leaseID, nil, nil, nil, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
return c.client.ReleaseLease(ctx,leaseID, nil, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
}
|
||||
|
||||
// BreakLease breaks the container's previously-acquired lease (if it exists).
|
||||
// BreakContainerLease breaks the container's previously-acquired lease (if it exists).
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
|
||||
func (c ContainerURL) BreakLease(ctx context.Context, leaseID string, period int32, ac HTTPAccessConditions) (*ContainerLeaseResponse, error) {
|
||||
func (c ContainerURL) BreakLease(ctx context.Context, period int32, ac HTTPAccessConditions) (*ContainersBreakLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
|
||||
return c.client.Lease(ctx, LeaseActionBreak, nil, &leaseID, leasePeriodPointer(period), nil, nil, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
return c.client.BreakLease(ctx, nil, leasePeriodPointer(period), ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
}
|
||||
|
||||
// ChangeLease changes the container's lease ID.
|
||||
// ChangeContainerLease changes the container's lease ID.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/lease-container.
|
||||
func (c ContainerURL) ChangeLease(ctx context.Context, leaseID string, proposedID string, ac HTTPAccessConditions) (*ContainerLeaseResponse, error) {
|
||||
func (c ContainerURL) ChangeLease(ctx context.Context, leaseID string, proposedID string, ac HTTPAccessConditions) (*ContainersChangeLeaseResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, _, _ := ac.pointers()
|
||||
return c.client.Lease(ctx, LeaseActionChange, nil, &leaseID, nil, nil, &proposedID, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
return c.client.ChangeLease(ctx, leaseID, proposedID, nil, ifModifiedSince, ifUnmodifiedSince, nil)
|
||||
}
|
||||
|
||||
// ListBlobs returns a single segment of blobs starting from the specified Marker. Use an empty
|
||||
// ListBlobsFlatSegment returns a single segment of blobs starting from the specified Marker. Use an empty
|
||||
// Marker to start enumeration from the beginning. Blob names are returned in lexicographic order.
|
||||
// After getting a segment, process it, and then call ListBlobs again (passing the the previously-returned
|
||||
// Marker) to get the next segment.
|
||||
// After getting a segment, process it, and then call ListBlobsFlatSegment again (passing the the
|
||||
// previously-returned Marker) to get the next segment.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/list-blobs.
|
||||
func (c ContainerURL) ListBlobs(ctx context.Context, marker Marker, o ListBlobsOptions) (*ListBlobsResponse, error) {
|
||||
prefix, delimiter, include, maxResults := o.pointers()
|
||||
return c.client.ListBlobs(ctx, prefix, delimiter, marker.val, maxResults, include, nil, nil)
|
||||
func (c ContainerURL) ListBlobsFlatSegment(ctx context.Context, marker Marker, o ListBlobsSegmentOptions) (*ListBlobsFlatResponse, error) {
|
||||
prefix, include, maxResults := o.pointers()
|
||||
return c.client.ListBlobFlatSegment(ctx, prefix, marker.val, maxResults, include, nil, nil)
|
||||
}
|
||||
|
||||
// ListBlobsHierarchicalSegment returns a single segment of blobs starting from the specified Marker. Use an empty
|
||||
// Marker to start enumeration from the beginning. Blob names are returned in lexicographic order.
|
||||
// After getting a segment, process it, and then call ListBlobsHierarchicalSegment again (passing the the
|
||||
// previously-returned Marker) to get the next segment.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/list-blobs.
|
||||
func (c ContainerURL) ListBlobsHierarchySegment(ctx context.Context, marker Marker, delimiter string, o ListBlobsSegmentOptions) (*ListBlobsHierarchyResponse, error) {
|
||||
prefix, include, maxResults := o.pointers()
|
||||
return c.client.ListBlobHierarchySegment(ctx, delimiter, prefix, marker.val, maxResults, include, nil, nil)
|
||||
}
|
||||
|
||||
|
||||
// ListBlobsOptions defines options available when calling ListBlobs.
|
||||
type ListBlobsOptions struct {
|
||||
type ListBlobsSegmentOptions struct {
|
||||
Details BlobListingDetails // No IncludeType header is produced if ""
|
||||
Prefix string // No Prefix header is produced if ""
|
||||
Delimiter string
|
||||
|
||||
// SetMaxResults sets the maximum desired results you want the service to return. Note, the
|
||||
// service may return fewer results than requested.
|
||||
|
@ -230,14 +256,11 @@ type ListBlobsOptions struct {
|
|||
MaxResults int32
|
||||
}
|
||||
|
||||
func (o *ListBlobsOptions) pointers() (prefix *string, delimiter *string, include ListBlobsIncludeType, maxResults *int32) {
|
||||
func (o *ListBlobsSegmentOptions) pointers() (prefix *string, include []ListBlobsIncludeItemType, maxResults *int32) {
|
||||
if o.Prefix != "" {
|
||||
prefix = &o.Prefix
|
||||
}
|
||||
if o.Delimiter != "" {
|
||||
delimiter = &o.Delimiter
|
||||
}
|
||||
include = ListBlobsIncludeType(o.Details.string())
|
||||
include = o.Details.slice()
|
||||
if o.MaxResults != 0 {
|
||||
if o.MaxResults < 0 {
|
||||
panic("MaxResults must be >= 0")
|
||||
|
@ -253,26 +276,23 @@ type BlobListingDetails struct {
|
|||
}
|
||||
|
||||
// string produces the Include query parameter's value.
|
||||
func (d *BlobListingDetails) string() string {
|
||||
items := make([]string, 0, 4)
|
||||
func (d *BlobListingDetails) slice() []ListBlobsIncludeItemType {
|
||||
items := []ListBlobsIncludeItemType{}
|
||||
// NOTE: Multiple strings MUST be appended in alphabetic order or signing the string for authentication fails!
|
||||
if d.Copy {
|
||||
items = append(items, string(ListBlobsIncludeCopy))
|
||||
items = append(items, ListBlobsIncludeItemCopy)
|
||||
}
|
||||
if d.Deleted {
|
||||
items = append(items, string(ListBlobsIncludeDeleted))
|
||||
items = append(items, ListBlobsIncludeItemDeleted)
|
||||
}
|
||||
if d.Metadata {
|
||||
items = append(items, string(ListBlobsIncludeMetadata))
|
||||
items = append(items, ListBlobsIncludeItemMetadata)
|
||||
}
|
||||
if d.Snapshots {
|
||||
items = append(items, string(ListBlobsIncludeSnapshots))
|
||||
items = append(items, ListBlobsIncludeItemSnapshots)
|
||||
}
|
||||
if d.UncommittedBlobs {
|
||||
items = append(items, string(ListBlobsIncludeUncommittedblobs))
|
||||
items = append(items, ListBlobsIncludeItemUncommittedblobs)
|
||||
}
|
||||
if len(items) > 0 {
|
||||
return strings.Join(items, ",")
|
||||
}
|
||||
return string(ListBlobsIncludeNone)
|
||||
return items
|
||||
}
|
||||
|
|
|
@ -6,7 +6,6 @@ import (
|
|||
"io"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
@ -16,7 +15,7 @@ const (
|
|||
PageBlobPageBytes = 512
|
||||
|
||||
// PageBlobMaxPutPagesBytes indicates the maximum number of bytes that can be sent in a call to PutPage.
|
||||
PageBlobMaxPutPagesBytes = 4 * 1024 * 1024 // 4MB
|
||||
PageBlobMaxUploadPagesBytes = 4 * 1024 * 1024 // 4MB
|
||||
)
|
||||
|
||||
// PageBlobURL defines a set of operations applicable to page blobs.
|
||||
|
@ -41,76 +40,88 @@ func (pb PageBlobURL) WithPipeline(p pipeline.Pipeline) PageBlobURL {
|
|||
}
|
||||
|
||||
// WithSnapshot creates a new PageBlobURL object identical to the source but with the specified snapshot timestamp.
|
||||
// Pass time.Time{} to remove the snapshot returning a URL to the base blob.
|
||||
func (pb PageBlobURL) WithSnapshot(snapshot time.Time) PageBlobURL {
|
||||
// Pass "" to remove the snapshot returning a URL to the base blob.
|
||||
func (pb PageBlobURL) WithSnapshot(snapshot string) PageBlobURL {
|
||||
p := NewBlobURLParts(pb.URL())
|
||||
p.Snapshot = snapshot
|
||||
return NewPageBlobURL(p.URL(), pb.blobClient.Pipeline())
|
||||
}
|
||||
|
||||
// Create creates a page blob of the specified length. Call PutPage to upload data data to a page blob.
|
||||
// CreatePageBlob creates a page blob of the specified length. Call PutPage to upload data data to a page blob.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-blob.
|
||||
func (pb PageBlobURL) Create(ctx context.Context, size int64, sequenceNumber int64, metadata Metadata, h BlobHTTPHeaders, ac BlobAccessConditions) (*BlobsPutResponse, error) {
|
||||
func (pb PageBlobURL) Create(ctx context.Context, size int64, sequenceNumber int64, h BlobHTTPHeaders, metadata Metadata, ac BlobAccessConditions) (*PageBlobsCreateResponse, error) {
|
||||
if sequenceNumber < 0 {
|
||||
panic("sequenceNumber must be greater than or equal to 0")
|
||||
}
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return pb.blobClient.Put(ctx, BlobPageBlob, nil, nil, nil,
|
||||
&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.contentMD5Pointer(), &h.CacheControl,
|
||||
return pb.pbClient.Create(ctx, 0, nil,
|
||||
&h.ContentType, &h.ContentEncoding, &h.ContentLanguage, h.ContentMD5, &h.CacheControl,
|
||||
metadata, ac.LeaseAccessConditions.pointers(),
|
||||
&h.ContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, &size, &sequenceNumber, nil)
|
||||
}
|
||||
|
||||
// PutPages writes 1 or more pages to the page blob. The start and end offsets must be a multiple of 512.
|
||||
// UploadPages writes 1 or more pages to the page blob. The start offset and the stream size must be a multiple of 512 bytes.
|
||||
// This method panics if the stream is not at position 0.
|
||||
// Note that the http client closes the body stream after the request is sent to the service.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/put-page.
|
||||
func (pb PageBlobURL) PutPages(ctx context.Context, pr PageRange, body io.ReadSeeker, ac BlobAccessConditions) (*PageBlobsPutPageResponse, error) {
|
||||
func (pb PageBlobURL) UploadPages(ctx context.Context, offset int64, body io.ReadSeeker, ac BlobAccessConditions) (*PageBlobsUploadPagesResponse, error) {
|
||||
count := validateSeekableStreamAt0AndGetCount(body)
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan, ifSequenceNumberEqual := ac.PageBlobAccessConditions.pointers()
|
||||
return pb.pbClient.PutPage(ctx, PageWriteUpdate, body, nil, pr.pointers(), ac.LeaseAccessConditions.pointers(),
|
||||
return pb.pbClient.UploadPages(ctx, count, body, nil,
|
||||
PageRange{Start: offset, End: offset + count - 1}.pointers(),
|
||||
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, pr PageRange, ac BlobAccessConditions) (*PageBlobsPutPageResponse, error) {
|
||||
func (pb PageBlobURL) ClearPages(ctx context.Context, offset int64, count int64, ac BlobAccessConditions) (*PageBlobsClearPagesResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan, ifSequenceNumberEqual := ac.PageBlobAccessConditions.pointers()
|
||||
return pb.pbClient.PutPage(ctx, PageWriteClear, nil, nil, pr.pointers(), ac.LeaseAccessConditions.pointers(),
|
||||
return pb.pbClient.ClearPages(ctx, 0, nil,
|
||||
PageRange{Start: offset, End: offset + count - 1}.pointers(),
|
||||
ac.LeaseAccessConditions.pointers(),
|
||||
ifSequenceNumberLessThanOrEqual, ifSequenceNumberLessThan,
|
||||
ifSequenceNumberEqual, ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// GetPageRanges returns the list of valid page ranges for a page blob or snapshot of a page blob.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-page-ranges.
|
||||
func (pb PageBlobURL) GetPageRanges(ctx context.Context, br BlobRange, ac BlobAccessConditions) (*PageList, error) {
|
||||
func (pb PageBlobURL) GetPageRanges(ctx context.Context, offset int64, count int64, ac BlobAccessConditions) (*PageList, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return pb.pbClient.GetPageRanges(ctx, nil, nil, nil, br.pointers(), ac.LeaseAccessConditions.pointers(),
|
||||
return pb.pbClient.GetPageRanges(ctx, nil, nil,
|
||||
httpRange{offset: offset, count: count}.pointers(),
|
||||
ac.LeaseAccessConditions.pointers(),
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// GetPageRangesDiff gets the collection of page ranges that differ between a specified snapshot and this page blob.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/get-page-ranges.
|
||||
func (pb PageBlobURL) GetPageRangesDiff(ctx context.Context, br BlobRange, prevSnapshot time.Time, ac BlobAccessConditions) (*PageList, error) {
|
||||
func (pb PageBlobURL) GetPageRangesDiff(ctx context.Context, offset int64, count int64, prevSnapshot string, ac BlobAccessConditions) (*PageList, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return pb.pbClient.GetPageRanges(ctx, nil, nil, &prevSnapshot, br.pointers(),
|
||||
ac.LeaseAccessConditions.pointers(), ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
return pb.pbClient.GetPageRangesDiff(ctx, nil, nil, &prevSnapshot,
|
||||
httpRange{offset: offset, count: count}.pointers(),
|
||||
ac.LeaseAccessConditions.pointers(),
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag,
|
||||
nil)
|
||||
}
|
||||
|
||||
// Resize resizes the page blob to the specified size (which must be a multiple of 512).
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/set-blob-properties.
|
||||
func (pb PageBlobURL) Resize(ctx context.Context, length int64, ac BlobAccessConditions) (*BlobsSetPropertiesResponse, error) {
|
||||
if length%PageBlobPageBytes != 0 {
|
||||
panic("Length must be a multiple of PageBlobPageBytes (512)")
|
||||
func (pb PageBlobURL) Resize(ctx context.Context, size int64, ac BlobAccessConditions) (*PageBlobsResizeResponse, error) {
|
||||
if size%PageBlobPageBytes != 0 {
|
||||
panic("Size must be a multiple of PageBlobPageBytes (512)")
|
||||
}
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
return pb.blobClient.SetProperties(ctx, nil, nil, nil, nil, nil, nil, ac.LeaseAccessConditions.pointers(),
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil, &length, SequenceNumberActionNone, nil, nil)
|
||||
return pb.pbClient.Resize(ctx, size, nil, ac.LeaseAccessConditions.pointers(),
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
// SetSequenceNumber sets the page blob's sequence number.
|
||||
func (pb PageBlobURL) SetSequenceNumber(ctx context.Context, action SequenceNumberActionType, sequenceNumber int64,
|
||||
h BlobHTTPHeaders, ac BlobAccessConditions) (*BlobsSetPropertiesResponse, error) {
|
||||
func (pb PageBlobURL) UpdateSequenceNumber(ctx context.Context, action SequenceNumberActionType, sequenceNumber int64,
|
||||
ac BlobAccessConditions) (*PageBlobsUpdateSequenceNumberResponse, error) {
|
||||
if sequenceNumber < 0 {
|
||||
panic("sequenceNumber must be greater than or equal to 0")
|
||||
}
|
||||
|
@ -119,9 +130,9 @@ func (pb PageBlobURL) SetSequenceNumber(ctx context.Context, action SequenceNumb
|
|||
sn = nil
|
||||
}
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch := ac.HTTPAccessConditions.pointers()
|
||||
return pb.blobClient.SetProperties(ctx, nil, &h.CacheControl, &h.ContentType, h.contentMD5Pointer(), &h.ContentEncoding, &h.ContentLanguage,
|
||||
ac.LeaseAccessConditions.pointers(),
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch, &h.ContentDisposition, nil, action, sn, nil)
|
||||
return pb.pbClient.UpdateSequenceNumber(ctx, action, nil,
|
||||
ac.LeaseAccessConditions.pointers(), ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch,
|
||||
sn, nil)
|
||||
}
|
||||
|
||||
// StartIncrementalCopy begins an operation to start an incremental copy from one page blob's snapshot to this page blob.
|
||||
|
@ -129,12 +140,12 @@ func (pb PageBlobURL) SetSequenceNumber(ctx context.Context, action SequenceNumb
|
|||
// The copied snapshots are complete copies of the original snapshot and can be read or copied from as usual.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/incremental-copy-blob and
|
||||
// https://docs.microsoft.com/en-us/azure/virtual-machines/windows/incremental-snapshots.
|
||||
func (pb PageBlobURL) StartIncrementalCopy(ctx context.Context, source url.URL, snapshot time.Time, ac BlobAccessConditions) (*PageBlobsIncrementalCopyResponse, error) {
|
||||
func (pb PageBlobURL) StartCopyIncremental(ctx context.Context, source url.URL, snapshot string, ac BlobAccessConditions) (*PageBlobsCopyIncrementalResponse, error) {
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag := ac.HTTPAccessConditions.pointers()
|
||||
qp := source.Query()
|
||||
qp.Set("snapshot", snapshot.Format(snapshotTimeFormat))
|
||||
qp.Set("snapshot", snapshot)
|
||||
source.RawQuery = qp.Encode()
|
||||
return pb.pbClient.IncrementalCopy(ctx, source.String(), nil, nil,
|
||||
return pb.pbClient.CopyIncremental(ctx, source.String(), nil, nil,
|
||||
ifModifiedSince, ifUnmodifiedSince, ifMatchETag, ifNoneMatchETag, nil)
|
||||
}
|
||||
|
||||
|
@ -145,10 +156,10 @@ func (pr PageRange) pointers() *string {
|
|||
if pr.End <= 0 {
|
||||
panic("PageRange's End value must be greater than 0")
|
||||
}
|
||||
if pr.Start%512 != 0 {
|
||||
if pr.Start%PageBlobPageBytes != 0 {
|
||||
panic("PageRange's Start value must be a multiple of 512")
|
||||
}
|
||||
if pr.End%512 != 511 {
|
||||
if pr.End%PageBlobPageBytes != (PageBlobPageBytes - 1) {
|
||||
panic("PageRange's End value must be 1 less than a multiple of 512")
|
||||
}
|
||||
if pr.End <= pr.Start {
|
||||
|
@ -166,25 +177,25 @@ type PageBlobAccessConditions struct {
|
|||
// IfSequenceNumberLessThan=0 means no 'IfSequenceNumberLessThan' header specified.
|
||||
// IfSequenceNumberLessThan>0 means 'IfSequenceNumberLessThan' header specified with its value
|
||||
// IfSequenceNumberLessThan==-1 means 'IfSequenceNumberLessThan' header specified with a value of 0
|
||||
IfSequenceNumberLessThan int32
|
||||
IfSequenceNumberLessThan int64
|
||||
|
||||
// IfSequenceNumberLessThanOrEqual ensures that the page blob operation succeeds
|
||||
// only if the blob's sequence number is less than or equal to a value.
|
||||
// IfSequenceNumberLessThanOrEqual=0 means no 'IfSequenceNumberLessThanOrEqual' header specified.
|
||||
// IfSequenceNumberLessThanOrEqual>0 means 'IfSequenceNumberLessThanOrEqual' header specified with its value
|
||||
// IfSequenceNumberLessThanOrEqual=-1 means 'IfSequenceNumberLessThanOrEqual' header specified with a value of 0
|
||||
IfSequenceNumberLessThanOrEqual int32
|
||||
IfSequenceNumberLessThanOrEqual int64
|
||||
|
||||
// IfSequenceNumberEqual ensures that the page blob operation succeeds
|
||||
// only if the blob's sequence number is equal to a value.
|
||||
// IfSequenceNumberEqual=0 means no 'IfSequenceNumberEqual' header specified.
|
||||
// IfSequenceNumberEqual>0 means 'IfSequenceNumberEqual' header specified with its value
|
||||
// IfSequenceNumberEqual=-1 means 'IfSequenceNumberEqual' header specified with a value of 0
|
||||
IfSequenceNumberEqual int32
|
||||
IfSequenceNumberEqual int64
|
||||
}
|
||||
|
||||
// pointers is for internal infrastructure. It returns the fields as pointers.
|
||||
func (ac PageBlobAccessConditions) pointers() (snltoe *int32, snlt *int32, sne *int32) {
|
||||
func (ac PageBlobAccessConditions) pointers() (snltoe *int64, snlt *int64, sne *int64) {
|
||||
if ac.IfSequenceNumberLessThan < -1 {
|
||||
panic("Ifsequencenumberlessthan can't be less than -1")
|
||||
}
|
||||
|
@ -195,7 +206,7 @@ func (ac PageBlobAccessConditions) pointers() (snltoe *int32, snlt *int32, sne *
|
|||
panic("IfSequenceNumberEqual can't be less than -1")
|
||||
}
|
||||
|
||||
var zero int32 // Defaults to 0
|
||||
var zero int64 // Defaults to 0
|
||||
switch ac.IfSequenceNumberLessThan {
|
||||
case -1:
|
||||
snlt = &zero
|
||||
|
|
|
@ -9,51 +9,13 @@ import (
|
|||
)
|
||||
|
||||
const (
|
||||
// RootContainerName is the special Azure Storage name used to identify a storage account's root container.
|
||||
RootContainerName = "$root"
|
||||
// ContainerNameRoot is the special Azure Storage name used to identify a storage account's root container.
|
||||
ContainerNameRoot = "$root"
|
||||
|
||||
// ContainerNameLogs is the special Azure Storage name used to identify a storage account's logs container.
|
||||
ContainerNameLogs = "$logs"
|
||||
)
|
||||
|
||||
// PipelineOptions is used to configure a request policy pipeline's retry policy and logging.
|
||||
type PipelineOptions struct {
|
||||
// Log configures the pipeline's logging infrastructure indicating what information is logged and where.
|
||||
Log pipeline.LogOptions
|
||||
|
||||
// Retry configures the built-in retry policy behavior.
|
||||
Retry RetryOptions
|
||||
|
||||
// RequestLog configures the built-in request logging policy.
|
||||
RequestLog RequestLogOptions
|
||||
|
||||
// Telemetry configures the built-in telemetry policy behavior.
|
||||
Telemetry TelemetryOptions
|
||||
}
|
||||
|
||||
// NewPipeline creates a Pipeline using the specified credentials and options.
|
||||
func NewPipeline(c Credential, o PipelineOptions) pipeline.Pipeline {
|
||||
if c == nil {
|
||||
panic("c can't be nil")
|
||||
}
|
||||
|
||||
// Closest to API goes first; closest to the wire goes last
|
||||
f := []pipeline.Factory{
|
||||
NewTelemetryPolicyFactory(o.Telemetry),
|
||||
NewUniqueRequestIDPolicyFactory(),
|
||||
NewRetryPolicyFactory(o.Retry),
|
||||
}
|
||||
|
||||
if _, ok := c.(*anonymousCredentialPolicyFactory); !ok {
|
||||
// For AnonymousCredential, we optimize out the policy factory since it doesn't do anything
|
||||
// NOTE: The credential's policy factory must appear close to the wire so it can sign any
|
||||
// changes made by other factories (like UniqueRequestIDPolicyFactory)
|
||||
f = append(f, c)
|
||||
}
|
||||
f = append(f,
|
||||
pipeline.MethodFactoryMarker(), // indicates at what stage in the pipeline the method factory is invoked
|
||||
NewRequestLogPolicyFactory(o.RequestLog))
|
||||
|
||||
return pipeline.NewPipeline(f, pipeline.Options{HTTPSender: nil, Log: o.Log})
|
||||
}
|
||||
|
||||
// A ServiceURL represents a URL to the Azure Storage Blob service allowing you to manipulate blob containers.
|
||||
type ServiceURL struct {
|
||||
client serviceClient
|
||||
|
@ -94,15 +56,6 @@ func (s ServiceURL) NewContainerURL(containerName string) ContainerURL {
|
|||
return NewContainerURL(containerURL, s.client.Pipeline())
|
||||
}
|
||||
|
||||
// NewRootContainerURL creates a new ContainerURL object by concatenating $root (RootContainerName)
|
||||
// to the end of ServiceURL's URL. The new ContainerURL uses the same request policy pipeline as the
|
||||
// ServiceURL. To change the pipeline, create the ContainerURL and then call its WithPipeline method
|
||||
// passing in the desired pipeline object. Or, call NewContainerURL instead of calling the NewContainerURL method.
|
||||
func (s ServiceURL) NewRootContainerURL() ContainerURL {
|
||||
containerURL := appendToURLPath(s.URL(), RootContainerName)
|
||||
return NewContainerURL(containerURL, s.client.Pipeline())
|
||||
}
|
||||
|
||||
// appendToURLPath appends a string to the end of a URL's path (prefixing the string with a '/' if required)
|
||||
func appendToURLPath(u url.URL, name string) url.URL {
|
||||
// e.g. "https://ms.com/a/b/?k1=v1&k2=v2#f"
|
||||
|
@ -123,25 +76,25 @@ func appendToURLPath(u url.URL, name string) url.URL {
|
|||
return u
|
||||
}
|
||||
|
||||
// ListContainers returns a single segment of containers starting from the specified Marker. Use an empty
|
||||
// ListContainersFlatSegment returns a single segment of containers starting from the specified Marker. Use an empty
|
||||
// Marker to start enumeration from the beginning. Container names are returned in lexicographic order.
|
||||
// After getting a segment, process it, and then call ListContainers again (passing the the previously-returned
|
||||
// Marker) to get the next segment. For more information, see
|
||||
// After getting a segment, process it, and then call ListContainersFlatSegment again (passing the the
|
||||
// previously-returned Marker) to get the next segment. For more information, see
|
||||
// https://docs.microsoft.com/rest/api/storageservices/list-containers2.
|
||||
func (s ServiceURL) ListContainers(ctx context.Context, marker Marker, o ListContainersOptions) (*ListContainersResponse, error) {
|
||||
func (s ServiceURL) ListContainersSegment(ctx context.Context, marker Marker, o ListContainersSegmentOptions) (*ListContainersResponse, error) {
|
||||
prefix, include, maxResults := o.pointers()
|
||||
return s.client.ListContainers(ctx, prefix, marker.val, maxResults, include, nil, nil)
|
||||
return s.client.ListContainersSegment(ctx, prefix, marker.val, maxResults, include, nil, nil)
|
||||
}
|
||||
|
||||
// ListContainersOptions defines options available when calling ListContainers.
|
||||
type ListContainersOptions struct {
|
||||
type ListContainersSegmentOptions struct {
|
||||
Detail ListContainersDetail // No IncludeType header is produced if ""
|
||||
Prefix string // No Prefix header is produced if ""
|
||||
MaxResults int32 // 0 means unspecified
|
||||
Prefix string // No Prefix header is produced if ""
|
||||
MaxResults int32 // 0 means unspecified
|
||||
// TODO: update swagger to generate this type?
|
||||
}
|
||||
|
||||
func (o *ListContainersOptions) pointers() (prefix *string, include ListContainersIncludeType, maxResults *int32) {
|
||||
func (o *ListContainersSegmentOptions) pointers() (prefix *string, include ListContainersIncludeType, maxResults *int32) {
|
||||
if o.Prefix != "" {
|
||||
prefix = &o.Prefix
|
||||
}
|
||||
|
@ -155,7 +108,7 @@ func (o *ListContainersOptions) pointers() (prefix *string, include ListContaine
|
|||
return
|
||||
}
|
||||
|
||||
// ListContainersDetail indicates what additional information the service should return with each container.
|
||||
// ListContainersFlatDetail indicates what additional information the service should return with each container.
|
||||
type ListContainersDetail struct {
|
||||
// Tells the service whether to return metadata for each container.
|
||||
Metadata bool
|
||||
|
@ -174,23 +127,18 @@ func (d *ListContainersDetail) string() string {
|
|||
return string(ListContainersIncludeNone)
|
||||
}
|
||||
|
||||
// GetProperties operation gets the properties of a storage account’s Blob service, including properties
|
||||
// for Storage Analytics and CORS (Cross-Origin Resource Sharing) rules. For more information see
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/get-blob-service-properties.
|
||||
func (s ServiceURL) GetProperties(ctx context.Context) (*StorageServiceProperties, error) {
|
||||
return s.client.GetProperties(ctx, nil, nil)
|
||||
func (bsu ServiceURL) GetProperties(ctx context.Context) (*StorageServiceProperties, error) {
|
||||
return bsu.client.GetProperties(ctx, nil, nil)
|
||||
}
|
||||
|
||||
// SetProperties operation sets properties for a storage account’s Blob service endpoint,
|
||||
// including properties for Storage Analytics and CORS (Cross-Origin Resource Sharing) rules. For more
|
||||
// information see https://docs.microsoft.com/en-us/rest/api/storageservices/set-blob-service-properties.
|
||||
func (s ServiceURL) SetProperties(ctx context.Context, properties StorageServiceProperties) (*ServiceSetPropertiesResponse, error) {
|
||||
return s.client.SetProperties(ctx, properties, nil, nil)
|
||||
func (bsu ServiceURL) SetProperties(ctx context.Context, properties StorageServiceProperties) (*ServiceSetPropertiesResponse, error) {
|
||||
return bsu.client.SetProperties(ctx, properties, nil, nil)
|
||||
}
|
||||
|
||||
// GetStats operation retrieves statistics related to replication for the Blob service. It is only available on the secondary location
|
||||
// endpoint when read-access geo-redundant replication is enabled for the storage account.
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/get-blob-service-stats
|
||||
func (s ServiceURL) GetStats(ctx context.Context) (*StorageServiceStats, error) {
|
||||
return s.client.GetStats(ctx, nil, nil)
|
||||
func (bsu ServiceURL) GetStatistics(ctx context.Context) (*StorageServiceStats, error) {
|
||||
return bsu.client.GetStatistics(ctx, nil, nil)
|
||||
}
|
||||
|
||||
func (bsu ServiceURL) PreflightRequest(ctx context.Context) (*StorageServiceStats, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
|
98
2017-07-29/azblob/credential_anonymous.go → 2017-07-29/azblob/zc_credential_anonymous.go
Normal file → Executable file
98
2017-07-29/azblob/credential_anonymous.go → 2017-07-29/azblob/zc_credential_anonymous.go
Normal file → Executable file
|
@ -1,43 +1,55 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// Credential represent any credential type; it is used to create a credential policy Factory.
|
||||
type Credential interface {
|
||||
pipeline.Factory
|
||||
credentialMarker()
|
||||
}
|
||||
|
||||
// NewAnonymousCredential creates an anonymous credential for use with HTTP(S)
|
||||
// requests that read blobs from public containers or for use with Shared Access
|
||||
// Signatures (SAS).
|
||||
func NewAnonymousCredential() Credential {
|
||||
return &anonymousCredentialPolicyFactory{}
|
||||
}
|
||||
|
||||
// anonymousCredentialPolicyFactory is the credential's policy factory.
|
||||
type anonymousCredentialPolicyFactory struct {
|
||||
}
|
||||
|
||||
// New creates a credential policy object.
|
||||
func (f *anonymousCredentialPolicyFactory) New(next pipeline.Policy, config *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return &anonymousCredentialPolicy{next: next}
|
||||
}
|
||||
|
||||
// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
|
||||
func (*anonymousCredentialPolicyFactory) credentialMarker() {}
|
||||
|
||||
// anonymousCredentialPolicy is the credential's policy object.
|
||||
type anonymousCredentialPolicy struct {
|
||||
next pipeline.Policy
|
||||
}
|
||||
|
||||
// Do implements the credential's policy interface.
|
||||
func (p anonymousCredentialPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
// For anonymous credentials, this is effectively a no-op
|
||||
return p.next.Do(ctx, request)
|
||||
}
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// Credential represent any credential type; it is used to create a credential policy Factory.
|
||||
type Credential interface {
|
||||
pipeline.Factory
|
||||
credentialMarker()
|
||||
}
|
||||
|
||||
type credentialFunc pipeline.FactoryFunc
|
||||
|
||||
func (f credentialFunc) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return f(next, po)
|
||||
}
|
||||
|
||||
// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
|
||||
func (credentialFunc) credentialMarker() {}
|
||||
|
||||
//////////////////////////////
|
||||
|
||||
// NewAnonymousCredential creates an anonymous credential for use with HTTP(S) requests that read public resource
|
||||
// or for use with Shared Access Signatures (SAS).
|
||||
func NewAnonymousCredential() Credential {
|
||||
return anonymousCredentialFactory
|
||||
}
|
||||
|
||||
var anonymousCredentialFactory Credential = &anonymousCredentialPolicyFactory{} // Singleton
|
||||
|
||||
// anonymousCredentialPolicyFactory is the credential's policy factory.
|
||||
type anonymousCredentialPolicyFactory struct {
|
||||
}
|
||||
|
||||
// New creates a credential policy object.
|
||||
func (f *anonymousCredentialPolicyFactory) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return &anonymousCredentialPolicy{next: next}
|
||||
}
|
||||
|
||||
// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
|
||||
func (*anonymousCredentialPolicyFactory) credentialMarker() {}
|
||||
|
||||
// anonymousCredentialPolicy is the credential's policy object.
|
||||
type anonymousCredentialPolicy struct {
|
||||
next pipeline.Policy
|
||||
}
|
||||
|
||||
// Do implements the credential's policy interface.
|
||||
func (p anonymousCredentialPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
// For anonymous credentials, this is effectively a no-op
|
||||
return p.next.Do(ctx, request)
|
||||
}
|
49
2017-07-29/azblob/credential_shared_key.go → 2017-07-29/azblob/zc_credential_shared_key.go
Normal file → Executable file
49
2017-07-29/azblob/credential_shared_key.go → 2017-07-29/azblob/zc_credential_shared_key.go
Normal file → Executable file
|
@ -6,6 +6,7 @@ import (
|
|||
"crypto/hmac"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"sort"
|
||||
|
@ -39,39 +40,31 @@ func (f SharedKeyCredential) AccountName() string {
|
|||
}
|
||||
|
||||
// New creates a credential policy object.
|
||||
func (f *SharedKeyCredential) New(next pipeline.Policy, config *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return sharedKeyCredentialPolicy{factory: f, next: next, config: config}
|
||||
func (f *SharedKeyCredential) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return pipeline.PolicyFunc(func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
// Add a x-ms-date header if it doesn't already exist
|
||||
if d := request.Header.Get(headerXmsDate); d == "" {
|
||||
request.Header[headerXmsDate] = []string{time.Now().UTC().Format(http.TimeFormat)}
|
||||
}
|
||||
stringToSign := f.buildStringToSign(request)
|
||||
signature := f.ComputeHMACSHA256(stringToSign)
|
||||
authHeader := strings.Join([]string{"SharedKey ", f.accountName, ":", signature}, "")
|
||||
request.Header[headerAuthorization] = []string{authHeader}
|
||||
|
||||
response, err := next.Do(ctx, request)
|
||||
if err != nil && response != nil && response.Response() != nil && response.Response().StatusCode == http.StatusForbidden {
|
||||
fmt.Println("HASH:", signature)
|
||||
fmt.Println("S2S\n", stringToSign)
|
||||
// Service failed to authenticate request, log it
|
||||
po.Log(pipeline.LogError, "===== HTTP Forbidden status, String-to-Sign:\n"+stringToSign+"\n===============================\n")
|
||||
}
|
||||
return response, err
|
||||
})
|
||||
}
|
||||
|
||||
// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
|
||||
func (*SharedKeyCredential) credentialMarker() {}
|
||||
|
||||
// sharedKeyCredentialPolicy is the credential's policy object.
|
||||
type sharedKeyCredentialPolicy struct {
|
||||
factory *SharedKeyCredential
|
||||
next pipeline.Policy
|
||||
config *pipeline.PolicyOptions
|
||||
}
|
||||
|
||||
// Do implements the credential's policy interface.
|
||||
func (p sharedKeyCredentialPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
// Add a x-ms-date header if it doesn't already exist
|
||||
if d := request.Header.Get(headerXmsDate); d == "" {
|
||||
request.Header[headerXmsDate] = []string{time.Now().UTC().Format(http.TimeFormat)}
|
||||
}
|
||||
stringToSign := p.factory.buildStringToSign(request)
|
||||
signature := p.factory.ComputeHMACSHA256(stringToSign)
|
||||
authHeader := strings.Join([]string{"SharedKey ", p.factory.accountName, ":", signature}, "")
|
||||
request.Header[headerAuthorization] = []string{authHeader}
|
||||
|
||||
response, err := p.next.Do(ctx, request)
|
||||
if err != nil && response != nil && response.Response() != nil && response.Response().StatusCode == http.StatusForbidden {
|
||||
// Service failed to authenticate request, log it
|
||||
p.config.Log(pipeline.LogError, "===== HTTP Forbidden status, String-to-Sign:\n"+stringToSign+"\n===============================\n")
|
||||
}
|
||||
return response, err
|
||||
}
|
||||
|
||||
// Constants ensuring that header names are correctly spelled and consistently cased.
|
||||
const (
|
||||
headerAuthorization = "Authorization"
|
87
2017-07-29/azblob/credential_token.go → 2017-07-29/azblob/zc_credential_token.go
Normal file → Executable file
87
2017-07-29/azblob/credential_token.go → 2017-07-29/azblob/zc_credential_token.go
Normal file → Executable file
|
@ -1,48 +1,39 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// NewTokenCredential creates a token credential for use with role-based
|
||||
// access control (RBAC) access to Azure Storage resources.
|
||||
func NewTokenCredential(token string) *TokenCredential {
|
||||
f := &TokenCredential{}
|
||||
f.SetToken(token)
|
||||
return f
|
||||
}
|
||||
|
||||
// TokenCredential is a pipeline.Factory is the credential's policy factory.
|
||||
type TokenCredential struct{ token atomic.Value }
|
||||
|
||||
// Token returns the current token value
|
||||
func (f *TokenCredential) Token() string { return f.token.Load().(string) }
|
||||
|
||||
// SetToken changes the current token value
|
||||
func (f *TokenCredential) SetToken(token string) { f.token.Store(token) }
|
||||
|
||||
// New creates a credential policy object.
|
||||
func (f *TokenCredential) New(next pipeline.Policy, config *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return &tokenCredentialPolicy{factory: f, next: next}
|
||||
}
|
||||
|
||||
// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
|
||||
func (*TokenCredential) credentialMarker() {}
|
||||
|
||||
// tokenCredentialPolicy is the credential's policy object.
|
||||
type tokenCredentialPolicy struct {
|
||||
factory *TokenCredential
|
||||
next pipeline.Policy
|
||||
}
|
||||
|
||||
// Do implements the credential's policy interface.
|
||||
func (p tokenCredentialPolicy) Do(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
if request.URL.Scheme != "https" {
|
||||
panic("Token credentials require a URL using the https protocol scheme.")
|
||||
}
|
||||
request.Header[headerAuthorization] = []string{"Bearer " + p.factory.Token()}
|
||||
return p.next.Do(ctx, request)
|
||||
}
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"context"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// NewTokenCredential creates a token credential for use with role-based
|
||||
// access control (RBAC) access to Azure Storage resources.
|
||||
func NewTokenCredential(token string) *TokenCredential {
|
||||
f := &TokenCredential{}
|
||||
f.SetToken(token)
|
||||
return f
|
||||
}
|
||||
|
||||
// TokenCredential is a pipeline.Factory is the credential's policy factory.
|
||||
type TokenCredential struct{ token atomic.Value }
|
||||
|
||||
// Token returns the current token value
|
||||
func (f *TokenCredential) Token() string { return f.token.Load().(string) }
|
||||
|
||||
// SetToken changes the current token value
|
||||
func (f *TokenCredential) SetToken(token string) { f.token.Store(token) }
|
||||
|
||||
// credentialMarker is a package-internal method that exists just to satisfy the Credential interface.
|
||||
func (*TokenCredential) credentialMarker() {}
|
||||
|
||||
// New creates a credential policy object.
|
||||
func (f *TokenCredential) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
|
||||
return pipeline.PolicyFunc(func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
if request.URL.Scheme != "https" {
|
||||
panic("Token credentials require a URL using the https protocol scheme.")
|
||||
}
|
||||
request.Header[headerAuthorization] = []string{"Bearer " + f.Token()}
|
||||
return next.Do(ctx, request)
|
||||
})
|
||||
}
|
|
@ -1,25 +1,27 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"os"
|
||||
"syscall"
|
||||
)
|
||||
|
||||
type mmf []byte
|
||||
|
||||
func newMMF(file *os.File, writable bool, offset int64, length int) (mmf, error) {
|
||||
prot, flags := syscall.PROT_READ, syscall.MAP_SHARED // Assume read-only
|
||||
if writable {
|
||||
prot, flags = syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED
|
||||
}
|
||||
addr, err := syscall.Mmap(int(file.Fd()), offset, length, prot, flags)
|
||||
return mmf(addr), err
|
||||
}
|
||||
|
||||
func (m *mmf) unmap() {
|
||||
err := syscall.Munmap(*m)
|
||||
*m = nil
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
// +build linux darwin
|
||||
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"os"
|
||||
"syscall"
|
||||
)
|
||||
|
||||
type mmf []byte
|
||||
|
||||
func newMMF(file *os.File, writable bool, offset int64, length int) (mmf, error) {
|
||||
prot, flags := syscall.PROT_READ, syscall.MAP_SHARED // Assume read-only
|
||||
if writable {
|
||||
prot, flags = syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED
|
||||
}
|
||||
addr, err := syscall.Mmap(int(file.Fd()), offset, length, prot, flags)
|
||||
return mmf(addr), err
|
||||
}
|
||||
|
||||
func (m *mmf) unmap() {
|
||||
err := syscall.Munmap(*m)
|
||||
*m = nil
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
76
2017-07-29/azblob/mmap_windows.go → 2017-07-29/azblob/zc_mmf_windows.go
Normal file → Executable file
76
2017-07-29/azblob/mmap_windows.go → 2017-07-29/azblob/zc_mmf_windows.go
Normal file → Executable file
|
@ -1,38 +1,38 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"os"
|
||||
"reflect"
|
||||
"syscall"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
type mmf []byte
|
||||
|
||||
func newMMF(file *os.File, writable bool, offset int64, length int) (mmf, error) {
|
||||
prot, access := uint32(syscall.PAGE_READONLY), uint32(syscall.FILE_MAP_READ) // Assume read-only
|
||||
if writable {
|
||||
prot, access = uint32(syscall.PAGE_READWRITE), uint32(syscall.FILE_MAP_WRITE)
|
||||
}
|
||||
hMMF, errno := syscall.CreateFileMapping(syscall.Handle(file.Fd()), nil, prot, uint32(int64(length)>>32), uint32(int64(length)&0xffffffff), nil)
|
||||
if hMMF == 0 {
|
||||
return nil, os.NewSyscallError("CreateFileMapping", errno)
|
||||
}
|
||||
defer syscall.CloseHandle(hMMF)
|
||||
addr, errno := syscall.MapViewOfFile(hMMF, access, uint32(offset>>32), uint32(offset&0xffffffff), uintptr(length))
|
||||
m := mmf{}
|
||||
h := (*reflect.SliceHeader)(unsafe.Pointer(&m))
|
||||
h.Data = addr
|
||||
h.Len = length
|
||||
h.Cap = h.Len
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (m *mmf) unmap() {
|
||||
addr := uintptr(unsafe.Pointer(&(([]byte)(*m)[0])))
|
||||
*m = mmf{}
|
||||
err := syscall.UnmapViewOfFile(addr)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"os"
|
||||
"reflect"
|
||||
"syscall"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
type mmf []byte
|
||||
|
||||
func newMMF(file *os.File, writable bool, offset int64, length int) (mmf, error) {
|
||||
prot, access := uint32(syscall.PAGE_READONLY), uint32(syscall.FILE_MAP_READ) // Assume read-only
|
||||
if writable {
|
||||
prot, access = uint32(syscall.PAGE_READWRITE), uint32(syscall.FILE_MAP_WRITE)
|
||||
}
|
||||
hMMF, errno := syscall.CreateFileMapping(syscall.Handle(file.Fd()), nil, prot, uint32(int64(length)>>32), uint32(int64(length)&0xffffffff), nil)
|
||||
if hMMF == 0 {
|
||||
return nil, os.NewSyscallError("CreateFileMapping", errno)
|
||||
}
|
||||
defer syscall.CloseHandle(hMMF)
|
||||
addr, errno := syscall.MapViewOfFile(hMMF, access, uint32(offset>>32), uint32(offset&0xffffffff), uintptr(length))
|
||||
m := mmf{}
|
||||
h := (*reflect.SliceHeader)(unsafe.Pointer(&m))
|
||||
h.Data = addr
|
||||
h.Len = length
|
||||
h.Cap = h.Len
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (m *mmf) unmap() {
|
||||
addr := uintptr(unsafe.Pointer(&(([]byte)(*m)[0])))
|
||||
*m = mmf{}
|
||||
err := syscall.UnmapViewOfFile(addr)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
|
@ -0,0 +1,46 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// PipelineOptions is used to configure a request policy pipeline's retry policy and logging.
|
||||
type PipelineOptions struct {
|
||||
// Log configures the pipeline's logging infrastructure indicating what information is logged and where.
|
||||
Log pipeline.LogOptions
|
||||
|
||||
// Retry configures the built-in retry policy behavior.
|
||||
Retry RetryOptions
|
||||
|
||||
// RequestLog configures the built-in request logging policy.
|
||||
RequestLog RequestLogOptions
|
||||
|
||||
// Telemetry configures the built-in telemetry policy behavior.
|
||||
Telemetry TelemetryOptions
|
||||
}
|
||||
|
||||
// NewPipeline creates a Pipeline using the specified credentials and options.
|
||||
func NewPipeline(c Credential, o PipelineOptions) pipeline.Pipeline {
|
||||
if c == nil {
|
||||
panic("c can't be nil")
|
||||
}
|
||||
|
||||
// Closest to API goes first; closest to the wire goes last
|
||||
f := []pipeline.Factory{
|
||||
NewTelemetryPolicyFactory(o.Telemetry),
|
||||
NewUniqueRequestIDPolicyFactory(),
|
||||
NewRetryPolicyFactory(o.Retry),
|
||||
}
|
||||
|
||||
if _, ok := c.(*anonymousCredentialPolicyFactory); !ok {
|
||||
// For AnonymousCredential, we optimize out the policy factory since it doesn't do anything
|
||||
// NOTE: The credential's policy factory must appear close to the wire so it can sign any
|
||||
// changes made by other factories (like UniqueRequestIDPolicyFactory)
|
||||
f = append(f, c)
|
||||
}
|
||||
f = append(f,
|
||||
pipeline.MethodFactoryMarker(), // indicates at what stage in the pipeline the method factory is invoked
|
||||
NewRequestLogPolicyFactory(o.RequestLog))
|
||||
|
||||
return pipeline.NewPipeline(f, pipeline.Options{HTTPSender: nil, Log: o.Log})
|
||||
}
|
11
2017-07-29/azblob/policy_request_log.go → 2017-07-29/azblob/zc_policy_request_log.go
Normal file → Executable file
11
2017-07-29/azblob/policy_request_log.go → 2017-07-29/azblob/zc_policy_request_log.go
Normal file → Executable file
|
@ -18,6 +18,9 @@ type RequestLogOptions struct {
|
|||
// LogWarningIfTryOverThreshold logs a warning if a tried operation takes longer than the specified
|
||||
// duration (-1=no logging; 0=default threshold).
|
||||
LogWarningIfTryOverThreshold time.Duration
|
||||
|
||||
// TurnOffDefaultLogging turns off the default logging written to Windows Event Log or syslog.
|
||||
//TurnOffDefaultLogging bool
|
||||
}
|
||||
|
||||
func (o RequestLogOptions) defaults() RequestLogOptions {
|
||||
|
@ -82,12 +85,12 @@ func NewRequestLogPolicyFactory(o RequestLogOptions) pipeline.Factory {
|
|||
}
|
||||
fmt.Fprintf(b, "==> REQUEST/RESPONSE (Try=%d/%v%s, OpTime=%v) -- ", try, tryDuration, slow, opDuration)
|
||||
if err != nil { // This HTTP request did not get a response from the service
|
||||
fmt.Fprintf(b, "REQUEST ERROR\n")
|
||||
fmt.Fprint(b, "REQUEST ERROR\n")
|
||||
} else {
|
||||
if logLevel == pipeline.LogError {
|
||||
fmt.Fprintf(b, "RESPONSE STATUS CODE ERROR\n")
|
||||
fmt.Fprint(b, "RESPONSE STATUS CODE ERROR\n")
|
||||
} else {
|
||||
fmt.Fprintf(b, "RESPONSE SUCCESSFULLY RECEIVED\n")
|
||||
fmt.Fprint(b, "RESPONSE SUCCESSFULLY RECEIVED\n")
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -97,7 +100,7 @@ func NewRequestLogPolicyFactory(o RequestLogOptions) pipeline.Factory {
|
|||
}
|
||||
msg := b.String()
|
||||
|
||||
if forceLog {
|
||||
if forceLog /*&& !o.TurnOffDefaultLogging */{
|
||||
pipeline.ForceLog(logLevel, msg)
|
||||
}
|
||||
if shouldLog {
|
45
2017-07-29/azblob/policy_retry.go → 2017-07-29/azblob/zc_policy_retry.go
Normal file → Executable file
45
2017-07-29/azblob/policy_retry.go → 2017-07-29/azblob/zc_policy_retry.go
Normal file → Executable file
|
@ -9,6 +9,8 @@ import (
|
|||
"time"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"io/ioutil"
|
||||
"io"
|
||||
)
|
||||
|
||||
// RetryPolicy tells the pipeline what kind of retry policy to use. See the RetryPolicy* constants.
|
||||
|
@ -40,8 +42,11 @@ type RetryOptions struct {
|
|||
TryTimeout time.Duration
|
||||
|
||||
// RetryDelay specifies the amount of delay to use before retrying an operation (0=default).
|
||||
// The delay increases (exponentially or linearly) with each retry up to a maximum specified by
|
||||
// MaxRetryDelay. If you specify 0, then you must also specify 0 for MaxRetryDelay.
|
||||
// When RetryPolicy is specified as RetryPolicyExponential, the delay increases exponentially
|
||||
// with each retry up to a maximum specified by MaxRetryDelay.
|
||||
// If you specify 0, then you must also specify 0 for MaxRetryDelay.
|
||||
// If you specify RetryDelay, then you must also specify MaxRetryDelay, and MaxRetryDelay should be
|
||||
// equal to or greater than RetryDelay.
|
||||
RetryDelay time.Duration
|
||||
|
||||
// MaxRetryDelay specifies the maximum delay allowed before retrying an operation (0=default).
|
||||
|
@ -52,7 +57,12 @@ type RetryOptions struct {
|
|||
// If RetryReadsFromSecondaryHost is "" (the default) then operations are not retried against another host.
|
||||
// NOTE: Before setting this field, make sure you understand the issues around reading stale & potentially-inconsistent
|
||||
// data at this webpage: https://docs.microsoft.com/en-us/azure/storage/common/storage-designing-ha-apps-with-ragrs
|
||||
RetryReadsFromSecondaryHost string
|
||||
RetryReadsFromSecondaryHost string // Comment this our for non-Blob SDKs
|
||||
}
|
||||
|
||||
func (o RetryOptions) retryReadsFromSecondaryHost() string {
|
||||
return o.RetryReadsFromSecondaryHost // This is for the Blob SDK only
|
||||
//return "" // This is for non-blob SDKs
|
||||
}
|
||||
|
||||
func (o RetryOptions) defaults() RetryOptions {
|
||||
|
@ -117,7 +127,7 @@ 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(rand.Float32()/2 + 0.8) // NOTE: We want math/rand; not crypto/rand
|
||||
delay = time.Duration(delay.Seconds() * (rand.Float64()/2 + 0.8) * float64(time.Second)) // NOTE: We want math/rand; not crypto/rand
|
||||
if delay > o.MaxRetryDelay {
|
||||
delay = o.MaxRetryDelay
|
||||
}
|
||||
|
@ -133,10 +143,10 @@ func NewRetryPolicyFactory(o RetryOptions) pipeline.Factory {
|
|||
primaryTry := int32(0) // This indicates how many tries we've attempted against the primary DC
|
||||
|
||||
// We only consider retrying against a secondary if we have a read request (GET/HEAD) AND this policy has a Secondary URL it can use
|
||||
considerSecondary := (request.Method == http.MethodGet || request.Method == http.MethodHead) && o.RetryReadsFromSecondaryHost != ""
|
||||
considerSecondary := (request.Method == http.MethodGet || request.Method == http.MethodHead) && o.retryReadsFromSecondaryHost() != ""
|
||||
|
||||
// Exponential retry algorithm: ((2 ^ attempt) - 1) * delay * random(0.8, 1.2)
|
||||
// When to retry: connection failure or an HTTP status code of 500 or greater, except 501 and 505
|
||||
// When to retry: connection failure or temporary/timeout. NOTE: StorageError considers HTTP 500/503 as temporary & is therefore retryable
|
||||
// If using a secondary:
|
||||
// Even tries go against primary; odd tries go against the secondary
|
||||
// For a primary wait ((2 ^ primaryTries - 1) * delay * random(0.8, 1.2)
|
||||
|
@ -161,14 +171,15 @@ func NewRetryPolicyFactory(o RetryOptions) pipeline.Factory {
|
|||
|
||||
// Clone the original request to ensure that each try starts with the original (unmutated) request.
|
||||
requestCopy := request.Copy()
|
||||
if try > 1 {
|
||||
// For a retry, seek to the beginning of the Body stream.
|
||||
if err = requestCopy.RewindBody(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
// For each try, seek to the beginning of the Body stream. We do this even for the 1st try because
|
||||
// the stream may not be at offset 0 when we first get it and we want the same behavior for the
|
||||
// 1st try as for additional tries.
|
||||
if err = requestCopy.RewindBody(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
if !tryingPrimary {
|
||||
requestCopy.Request.URL.Host = o.RetryReadsFromSecondaryHost
|
||||
requestCopy.Request.URL.Host = o.retryReadsFromSecondaryHost()
|
||||
}
|
||||
|
||||
// Set the server-side timeout query parameter "timeout=[seconds]"
|
||||
|
@ -211,7 +222,7 @@ func NewRetryPolicyFactory(o RetryOptions) pipeline.Factory {
|
|||
action = "Retry: Secondary URL returned 404"
|
||||
case err != nil:
|
||||
// NOTE: Protocol Responder returns non-nil if REST API returns invalid status code for the invoked operation
|
||||
if nerr, ok := err.(net.Error); ok && (nerr.Temporary() || nerr.Timeout()) {
|
||||
if netErr, ok := err.(net.Error); ok && (netErr.Temporary() || netErr.Timeout()) {
|
||||
action = "Retry: net.Error and Temporary() or Timeout()"
|
||||
} else {
|
||||
action = "NoRetry: unrecognized error"
|
||||
|
@ -234,6 +245,12 @@ func NewRetryPolicyFactory(o RetryOptions) pipeline.Factory {
|
|||
}
|
||||
break // Don't retry
|
||||
}
|
||||
if response != nil && response.Response() != nil {
|
||||
// If we're going to retry and we got a previous response, then flush its body to avoid leaking its TCP connection
|
||||
body := response.Response().Body
|
||||
io.Copy(ioutil.Discard, body)
|
||||
body.Close()
|
||||
}
|
||||
// If retrying, cancel the current per-try timeout context
|
||||
tryCancel()
|
||||
}
|
||||
|
@ -262,7 +279,7 @@ func (r *deadlineExceededReadCloser) Read(p []byte) (int, error) {
|
|||
}
|
||||
func (r *deadlineExceededReadCloser) Seek(offset int64, whence int) (int64, error) {
|
||||
// For an HTTP request, the ReadCloser MUST also implement seek
|
||||
// For an HTTP Repsonse, Seek MUST not be called (or this will panic)
|
||||
// For an HTTP response, Seek MUST not be called (or this will panic)
|
||||
o, err := r.r.(io.Seeker).Seek(offset, whence)
|
||||
return o, improveDeadlineExceeded(err)
|
||||
}
|
102
2017-07-29/azblob/policy_telemetry.go → 2017-07-29/azblob/zc_policy_telemetry.go
Normal file → Executable file
102
2017-07-29/azblob/policy_telemetry.go → 2017-07-29/azblob/zc_policy_telemetry.go
Normal file → Executable file
|
@ -1,51 +1,51 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"runtime"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// TelemetryOptions configures the telemetry policy's behavior.
|
||||
type TelemetryOptions struct {
|
||||
// Value is a string prepended to each request's User-Agent and sent to the service.
|
||||
// The service records the user-agent in logs for diagnostics and tracking of client requests.
|
||||
Value string
|
||||
}
|
||||
|
||||
// NewTelemetryPolicyFactory creates a factory that can create telemetry policy objects
|
||||
// which add telemetry information to outgoing HTTP requests.
|
||||
func NewTelemetryPolicyFactory(o TelemetryOptions) pipeline.Factory {
|
||||
b := &bytes.Buffer{}
|
||||
b.WriteString(o.Value)
|
||||
if b.Len() > 0 {
|
||||
b.WriteRune(' ')
|
||||
}
|
||||
fmt.Fprintf(b, "Azure-Storage/%s %s", serviceLibVersion, platformInfo)
|
||||
telemetryValue := b.String()
|
||||
|
||||
return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
|
||||
return func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
request.Header.Set("User-Agent", telemetryValue)
|
||||
return next.Do(ctx, request)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// NOTE: the ONLY function that should write to this variable is this func
|
||||
var platformInfo = func() string {
|
||||
// Azure-Storage/version (runtime; os type and version)”
|
||||
// Azure-Storage/1.4.0 (NODE-VERSION v4.5.0; Windows_NT 10.0.14393)'
|
||||
operatingSystem := runtime.GOOS // Default OS string
|
||||
switch operatingSystem {
|
||||
case "windows":
|
||||
operatingSystem = os.Getenv("OS") // Get more specific OS information
|
||||
case "linux": // accept default OS info
|
||||
case "freebsd": // accept default OS info
|
||||
}
|
||||
return fmt.Sprintf("(%s; %s)", runtime.Version(), operatingSystem)
|
||||
}()
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"runtime"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// TelemetryOptions configures the telemetry policy's behavior.
|
||||
type TelemetryOptions struct {
|
||||
// Value is a string prepended to each request's User-Agent and sent to the service.
|
||||
// The service records the user-agent in logs for diagnostics and tracking of client requests.
|
||||
Value string
|
||||
}
|
||||
|
||||
// NewTelemetryPolicyFactory creates a factory that can create telemetry policy objects
|
||||
// which add telemetry information to outgoing HTTP requests.
|
||||
func NewTelemetryPolicyFactory(o TelemetryOptions) pipeline.Factory {
|
||||
b := &bytes.Buffer{}
|
||||
b.WriteString(o.Value)
|
||||
if b.Len() > 0 {
|
||||
b.WriteRune(' ')
|
||||
}
|
||||
fmt.Fprintf(b, "Azure-Storage/%s %s", serviceLibVersion, platformInfo)
|
||||
telemetryValue := b.String()
|
||||
|
||||
return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
|
||||
return func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
request.Header.Set("User-Agent", telemetryValue)
|
||||
return next.Do(ctx, request)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// NOTE: the ONLY function that should write to this variable is this func
|
||||
var platformInfo = func() string {
|
||||
// Azure-Storage/version (runtime; os type and version)”
|
||||
// Azure-Storage/1.4.0 (NODE-VERSION v4.5.0; Windows_NT 10.0.14393)'
|
||||
operatingSystem := runtime.GOOS // Default OS string
|
||||
switch operatingSystem {
|
||||
case "windows":
|
||||
operatingSystem = os.Getenv("OS") // Get more specific OS information
|
||||
case "linux": // accept default OS info
|
||||
case "freebsd": // accept default OS info
|
||||
}
|
||||
return fmt.Sprintf("(%s; %s)", runtime.Version(), operatingSystem)
|
||||
}()
|
|
@ -0,0 +1,24 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// NewUniqueRequestIDPolicyFactory creates a UniqueRequestIDPolicyFactory object
|
||||
// that sets the request's x-ms-client-request-id header if it doesn't already exist.
|
||||
func NewUniqueRequestIDPolicyFactory() pipeline.Factory {
|
||||
return pipeline.FactoryFunc(func(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.PolicyFunc {
|
||||
// This is Policy's Do method:
|
||||
return func(ctx context.Context, request pipeline.Request) (pipeline.Response, error) {
|
||||
id := request.Header.Get(xMsClientRequestID)
|
||||
if id == "" { // Add a unique request ID if the caller didn't specify one already
|
||||
request.Header.Set(xMsClientRequestID, newUUID().String())
|
||||
}
|
||||
return next.Do(ctx, request)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
const xMsClientRequestID = "x-ms-client-request-id"
|
|
@ -0,0 +1,125 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
const CountToEnd = 0
|
||||
|
||||
// HTTPGetter is a function type that refers to a method that performs an HTTP GET operation.
|
||||
type HTTPGetter func(ctx context.Context, i HTTPGetterInfo) (*http.Response, error)
|
||||
|
||||
// HTTPGetterInfo is passed to an HTTPGetter function passing it parameters
|
||||
// that should be used to make an HTTP GET request.
|
||||
type HTTPGetterInfo struct {
|
||||
// Offset specifies the start offset that should be used when
|
||||
// creating the HTTP GET request's Range header
|
||||
Offset int64
|
||||
|
||||
// Count specifies the count of bytes that should be used to calculate
|
||||
// the end offset when creating the HTTP GET request's Range header
|
||||
Count int64
|
||||
|
||||
// ETag specifies the resource's etag that should be used when creating
|
||||
// the HTTP GET request's If-Match header
|
||||
ETag ETag
|
||||
}
|
||||
|
||||
// RetryingReaderOptions contains properties which can help to decide when to do retry.
|
||||
type RetryReaderOptions struct {
|
||||
// MaxRetryRequests specifies the maximum number of HTTP GET requests that will be made
|
||||
// while reading from a RetryReader. A value of zero means that no additional HTTP
|
||||
// GET requests will be made.
|
||||
MaxRetryRequests int
|
||||
doInjectError bool
|
||||
doInjectErrorRound int
|
||||
}
|
||||
|
||||
// retryReader implements io.ReaderCloser methods.
|
||||
// retryReader tries to read from response, and if the response is nil or there is retriable network error
|
||||
// returned during reading, it will retry according to resilient reader option through executing
|
||||
// user defined action with provided data to get a new response, and continue the overall reading process
|
||||
// through reading from the new response.
|
||||
type retryReader struct {
|
||||
ctx context.Context
|
||||
response *http.Response
|
||||
info HTTPGetterInfo
|
||||
o RetryReaderOptions
|
||||
getter HTTPGetter
|
||||
}
|
||||
|
||||
// NewResilientReader creates a resilient reader.
|
||||
func NewRetryReader(ctx context.Context, initialResponse *http.Response,
|
||||
info HTTPGetterInfo, o RetryReaderOptions, getter HTTPGetter) io.ReadCloser {
|
||||
if getter == nil {
|
||||
panic("getter must not be nil")
|
||||
}
|
||||
return &retryReader{ctx: ctx, getter: getter, info: info, response: initialResponse, o: o}
|
||||
}
|
||||
|
||||
func (s *retryReader) Read(p []byte) (n int, err error) {
|
||||
try := 0
|
||||
for ; try <= s.o.MaxRetryRequests; try++ {
|
||||
//fmt.Println(try) // Comment out for debugging.
|
||||
if s.response != nil { // We're working with a successful response
|
||||
n, err := s.response.Body.Read(p) // Read from the stream
|
||||
|
||||
// Injection mechanism for testing.
|
||||
if s.o.doInjectError && try == s.o.doInjectErrorRound {
|
||||
err = &net.DNSError{IsTemporary: true}
|
||||
}
|
||||
|
||||
// We successfully read data or end EOF.
|
||||
if err == nil || err == io.EOF {
|
||||
s.info.Offset += int64(n) // Increments the start offset in case we need to make a new HTTP request in the future
|
||||
if s.info.Count != CountToEnd {
|
||||
s.info.Count -= int64(n) // Decrement the count in case we need to make a new HTTP request in the future
|
||||
}
|
||||
return n, err // Return the return to the caller
|
||||
}
|
||||
|
||||
s.Close()
|
||||
s.response = nil // Something went wrong; our stream is no longer good
|
||||
|
||||
// Check the retry count and error code, and decide whether to retry.
|
||||
if try == s.o.MaxRetryRequests {
|
||||
return n, err // No retry, or retry exhausted
|
||||
} else if netErr, ok := err.(net.Error); ok {
|
||||
if !netErr.Timeout() && !netErr.Temporary() {
|
||||
return n, err // Not retryable
|
||||
}
|
||||
} else {
|
||||
return n, err // Not retryable, just return
|
||||
}
|
||||
}
|
||||
|
||||
// We don't have a response stream to read from, try to get one.
|
||||
response, err := s.getter(s.ctx, s.info)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
// Successful GET; this is the network stream we'll read from.
|
||||
s.response = response
|
||||
|
||||
// Loop around and try to read from this stream.
|
||||
}
|
||||
|
||||
if s.o.doInjectError &&
|
||||
s.o.doInjectErrorRound <= s.o.MaxRetryRequests &&
|
||||
s.o.doInjectErrorRound > 0 &&
|
||||
try < s.o.doInjectErrorRound {
|
||||
panic("invalid status, internal error, stream read retry is not working properly.")
|
||||
}
|
||||
|
||||
return 0, nil // The compiler is wrong; we never actually get here
|
||||
}
|
||||
|
||||
func (s *retryReader) Close() error {
|
||||
if s.response != nil && s.response.Body != nil {
|
||||
return s.response.Body.Close()
|
||||
}
|
||||
return nil
|
||||
}
|
387
2017-07-29/azblob/sas_account.go → 2017-07-29/azblob/zc_sas_account.go
Normal file → Executable file
387
2017-07-29/azblob/sas_account.go → 2017-07-29/azblob/zc_sas_account.go
Normal file → Executable file
|
@ -1,170 +1,217 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// SASVersion indicates the SAS version.
|
||||
const SASVersion = "2015-04-05"
|
||||
|
||||
const (
|
||||
// SASProtocolHTTPS can be specified for a SAS protocol
|
||||
SASProtocolHTTPS = "https"
|
||||
|
||||
// SASProtocolHTTPSandHTTP can be specified for a SAS protocol
|
||||
SASProtocolHTTPSandHTTP = "https,http"
|
||||
)
|
||||
|
||||
// FormatTimesForSASSigning converts a time.Time to a snapshotTimeFormat string suitable for a
|
||||
// SASField's StartTime or ExpiryTime fields. Returns "" if value.IsZero().
|
||||
func FormatTimesForSASSigning(startTime, expiryTime time.Time) (string, string) {
|
||||
ss := ""
|
||||
if !startTime.IsZero() {
|
||||
ss = startTime.Format(SASTimeFormat) // "yyyy-MM-ddTHH:mm:ssZ"
|
||||
}
|
||||
se := ""
|
||||
if !expiryTime.IsZero() {
|
||||
se = expiryTime.Format(SASTimeFormat) // "yyyy-MM-ddTHH:mm:ssZ"
|
||||
}
|
||||
return ss, se
|
||||
}
|
||||
|
||||
// AccountSASSignatureValues is used to generate a Shared Access Signature (SAS) for an Azure Storage account.
|
||||
type AccountSASSignatureValues struct {
|
||||
Version string `param:"sv"` // If not specified, this defaults to azstorage.SASVersion
|
||||
Protocol string `param:"spr"` // See the SASProtocol* constants
|
||||
StartTime time.Time `param:"st"` // Not specified if IsZero
|
||||
ExpiryTime time.Time `param:"se"` // Not specified if IsZero
|
||||
Permissions string `param:"sp"`
|
||||
IPRange IPRange `param:"sip"`
|
||||
Services string `param:"ss"`
|
||||
ResourceTypes string `param:"srt"`
|
||||
}
|
||||
|
||||
// NewSASQueryParameters uses an account's shared key credential to sign this signature values to produce
|
||||
// the proper SAS query parameters.
|
||||
func (v AccountSASSignatureValues) NewSASQueryParameters(sharedKeyCredential *SharedKeyCredential) SASQueryParameters {
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/Constructing-an-Account-SAS
|
||||
if v.ExpiryTime.IsZero() || v.Permissions == "" || v.ResourceTypes == "" || v.Services == "" {
|
||||
panic("Account SAS is missing at least one of these: ExpiryTime, Permissions, Service, or ResourceType")
|
||||
}
|
||||
if v.Version == "" {
|
||||
v.Version = SASVersion
|
||||
}
|
||||
startTime, expiryTime := FormatTimesForSASSigning(v.StartTime, v.ExpiryTime)
|
||||
|
||||
stringToSign := strings.Join([]string{
|
||||
sharedKeyCredential.AccountName(),
|
||||
v.Permissions,
|
||||
v.Services,
|
||||
v.ResourceTypes,
|
||||
startTime,
|
||||
expiryTime,
|
||||
v.IPRange.String(),
|
||||
v.Protocol,
|
||||
v.Version,
|
||||
""}, // That right, the account SAS requires a terminating extra newline
|
||||
"\n")
|
||||
|
||||
signature := sharedKeyCredential.ComputeHMACSHA256(stringToSign)
|
||||
p := SASQueryParameters{
|
||||
// Common SAS parameters
|
||||
Version: v.Version,
|
||||
Protocol: v.Protocol,
|
||||
StartTime: v.StartTime,
|
||||
ExpiryTime: v.ExpiryTime,
|
||||
Permissions: v.Permissions,
|
||||
IPRange: v.IPRange,
|
||||
|
||||
// Account-specific SAS parameters
|
||||
Services: v.Services,
|
||||
ResourceTypes: v.ResourceTypes,
|
||||
|
||||
// Calculated SAS signature
|
||||
Signature: signature,
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// The AccountSASPermissions type simplifies creating the permissions string for an Azure Storage Account SAS.
|
||||
// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's Permissions field.
|
||||
type AccountSASPermissions struct {
|
||||
Read, Write, Delete, List, Add, Create, Update, Process bool
|
||||
}
|
||||
|
||||
// String produces the SAS permissions string for an Azure Storage account.
|
||||
// Call this method to set AccountSASSignatureValues's Permissions field.
|
||||
func (p AccountSASPermissions) String() string {
|
||||
var buffer bytes.Buffer
|
||||
if p.Read {
|
||||
buffer.WriteRune('r')
|
||||
}
|
||||
if p.Write {
|
||||
buffer.WriteRune('w')
|
||||
}
|
||||
if p.Delete {
|
||||
buffer.WriteRune('d')
|
||||
}
|
||||
if p.List {
|
||||
buffer.WriteRune('l')
|
||||
}
|
||||
if p.Add {
|
||||
buffer.WriteRune('a')
|
||||
}
|
||||
if p.Create {
|
||||
buffer.WriteRune('c')
|
||||
}
|
||||
if p.Update {
|
||||
buffer.WriteRune('u')
|
||||
}
|
||||
if p.Process {
|
||||
buffer.WriteRune('p')
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// The AccountSASServices type simplifies creating the services string for an Azure Storage Account SAS.
|
||||
// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's Services field.
|
||||
type AccountSASServices struct {
|
||||
Blob, Queue, File bool
|
||||
}
|
||||
|
||||
// String produces the SAS services string for an Azure Storage account.
|
||||
// Call this method to set AccountSASSignatureValues's Services field.
|
||||
func (s AccountSASServices) String() string {
|
||||
var buffer bytes.Buffer
|
||||
if s.Blob {
|
||||
buffer.WriteRune('b')
|
||||
}
|
||||
if s.Queue {
|
||||
buffer.WriteRune('q')
|
||||
}
|
||||
if s.File {
|
||||
buffer.WriteRune('f')
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// The AccountSASResourceTypes type simplifies creating the resource types string for an Azure Storage Account SAS.
|
||||
// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's ResourceTypes field.
|
||||
type AccountSASResourceTypes struct {
|
||||
Service, Container, Object bool
|
||||
}
|
||||
|
||||
// String produces the SAS resource types string for an Azure Storage account.
|
||||
// Call this method to set AccountSASSignatureValues's ResourceTypes field.
|
||||
func (rt AccountSASResourceTypes) String() string {
|
||||
var buffer bytes.Buffer
|
||||
if rt.Service {
|
||||
buffer.WriteRune('s')
|
||||
}
|
||||
if rt.Container {
|
||||
buffer.WriteRune('c')
|
||||
}
|
||||
if rt.Object {
|
||||
buffer.WriteRune('o')
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// AccountSASSignatureValues is used to generate a Shared Access Signature (SAS) for an Azure Storage account.
|
||||
// For more information, see https://docs.microsoft.com/rest/api/storageservices/constructing-an-account-sas
|
||||
type AccountSASSignatureValues struct {
|
||||
Version string `param:"sv"` // If not specified, this defaults to SASVersion
|
||||
Protocol SASProtocol `param:"spr"` // See the SASProtocol* constants
|
||||
StartTime time.Time `param:"st"` // Not specified if IsZero
|
||||
ExpiryTime time.Time `param:"se"` // Not specified if IsZero
|
||||
Permissions string `param:"sp"` // Create by initializing a AccountSASPermissions and then call String()
|
||||
IPRange IPRange `param:"sip"`
|
||||
Services string `param:"ss"` // Create by initializing AccountSASServices and then call String()
|
||||
ResourceTypes string `param:"srt"` // Create by initializing AccountSASResourceTypes and then call String()
|
||||
}
|
||||
|
||||
// NewSASQueryParameters uses an account's shared key credential to sign this signature values to produce
|
||||
// the proper SAS query parameters.
|
||||
func (v AccountSASSignatureValues) NewSASQueryParameters(sharedKeyCredential *SharedKeyCredential) SASQueryParameters {
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/Constructing-an-Account-SAS
|
||||
if v.ExpiryTime.IsZero() || v.Permissions == "" || v.ResourceTypes == "" || v.Services == "" {
|
||||
panic("Account SAS is missing at least one of these: ExpiryTime, Permissions, Service, or ResourceType")
|
||||
}
|
||||
if v.Version == "" {
|
||||
v.Version = SASVersion
|
||||
}
|
||||
perms := &AccountSASPermissions{}
|
||||
if err := perms.Parse(v.Permissions); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
v.Permissions = perms.String()
|
||||
|
||||
startTime, expiryTime := FormatTimesForSASSigning(v.StartTime, v.ExpiryTime)
|
||||
|
||||
stringToSign := strings.Join([]string{
|
||||
sharedKeyCredential.AccountName(),
|
||||
v.Permissions,
|
||||
v.Services,
|
||||
v.ResourceTypes,
|
||||
startTime,
|
||||
expiryTime,
|
||||
v.IPRange.String(),
|
||||
string(v.Protocol),
|
||||
v.Version,
|
||||
""}, // That right, the account SAS requires a terminating extra newline
|
||||
"\n")
|
||||
|
||||
signature := sharedKeyCredential.ComputeHMACSHA256(stringToSign)
|
||||
p := SASQueryParameters{
|
||||
// Common SAS parameters
|
||||
version: v.Version,
|
||||
protocol: v.Protocol,
|
||||
startTime: v.StartTime,
|
||||
expiryTime: v.ExpiryTime,
|
||||
permissions: v.Permissions,
|
||||
ipRange: v.IPRange,
|
||||
|
||||
// Account-specific SAS parameters
|
||||
services: v.Services,
|
||||
resourceTypes: v.ResourceTypes,
|
||||
|
||||
// Calculated SAS signature
|
||||
signature: signature,
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// The AccountSASPermissions type simplifies creating the permissions string for an Azure Storage Account SAS.
|
||||
// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's Permissions field.
|
||||
type AccountSASPermissions struct {
|
||||
Read, Write, Delete, List, Add, Create, Update, Process bool
|
||||
}
|
||||
|
||||
// String produces the SAS permissions string for an Azure Storage account.
|
||||
// Call this method to set AccountSASSignatureValues's Permissions field.
|
||||
func (p AccountSASPermissions) String() string {
|
||||
var buffer bytes.Buffer
|
||||
if p.Read {
|
||||
buffer.WriteRune('r')
|
||||
}
|
||||
if p.Write {
|
||||
buffer.WriteRune('w')
|
||||
}
|
||||
if p.Delete {
|
||||
buffer.WriteRune('d')
|
||||
}
|
||||
if p.List {
|
||||
buffer.WriteRune('l')
|
||||
}
|
||||
if p.Add {
|
||||
buffer.WriteRune('a')
|
||||
}
|
||||
if p.Create {
|
||||
buffer.WriteRune('c')
|
||||
}
|
||||
if p.Update {
|
||||
buffer.WriteRune('u')
|
||||
}
|
||||
if p.Process {
|
||||
buffer.WriteRune('p')
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// Parse initializes the AccountSASPermissions's fields from a string.
|
||||
func (p *AccountSASPermissions) Parse(s string) error {
|
||||
*p = AccountSASPermissions{} // Clear out the flags
|
||||
for _, r := range s {
|
||||
switch r {
|
||||
case 'r':
|
||||
p.Read = true
|
||||
case 'w':
|
||||
p.Write = true
|
||||
case 'd':
|
||||
p.Delete = true
|
||||
case 'l':
|
||||
p.List = true
|
||||
case 'a':
|
||||
p.Add = true
|
||||
case 'c':
|
||||
p.Create = true
|
||||
case 'u':
|
||||
p.Update = true
|
||||
case 'p':
|
||||
p.Process = true
|
||||
default:
|
||||
return fmt.Errorf("Invalid permission character: '%v'", r)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// The AccountSASServices type simplifies creating the services string for an Azure Storage Account SAS.
|
||||
// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's Services field.
|
||||
type AccountSASServices struct {
|
||||
Blob, Queue, File bool
|
||||
}
|
||||
|
||||
// String produces the SAS services string for an Azure Storage account.
|
||||
// Call this method to set AccountSASSignatureValues's Services field.
|
||||
func (s AccountSASServices) String() string {
|
||||
var buffer bytes.Buffer
|
||||
if s.Blob {
|
||||
buffer.WriteRune('b')
|
||||
}
|
||||
if s.Queue {
|
||||
buffer.WriteRune('q')
|
||||
}
|
||||
if s.File {
|
||||
buffer.WriteRune('f')
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// Parse initializes the AccountSASServices' fields from a string.
|
||||
func (a *AccountSASServices) Parse(s string) error {
|
||||
*a = AccountSASServices{} // Clear out the flags
|
||||
for _, r := range s {
|
||||
switch r {
|
||||
case 'b':
|
||||
a.Blob = true
|
||||
case 'q':
|
||||
a.Queue = true
|
||||
case 'f':
|
||||
a.File = true
|
||||
default:
|
||||
return fmt.Errorf("Invalid service character: '%v'", r)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// The AccountSASResourceTypes type simplifies creating the resource types string for an Azure Storage Account SAS.
|
||||
// Initialize an instance of this type and then call its String method to set AccountSASSignatureValues's ResourceTypes field.
|
||||
type AccountSASResourceTypes struct {
|
||||
Service, Container, Object bool
|
||||
}
|
||||
|
||||
// String produces the SAS resource types string for an Azure Storage account.
|
||||
// Call this method to set AccountSASSignatureValues's ResourceTypes field.
|
||||
func (rt AccountSASResourceTypes) String() string {
|
||||
var buffer bytes.Buffer
|
||||
if rt.Service {
|
||||
buffer.WriteRune('s')
|
||||
}
|
||||
if rt.Container {
|
||||
buffer.WriteRune('c')
|
||||
}
|
||||
if rt.Object {
|
||||
buffer.WriteRune('o')
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// Parse initializes the AccountSASResourceType's fields from a string.
|
||||
func (rt *AccountSASResourceTypes) Parse(s string) error {
|
||||
*rt = AccountSASResourceTypes{} // Clear out the flags
|
||||
for _, r := range s {
|
||||
switch r {
|
||||
case 's':
|
||||
rt.Service = true
|
||||
case 'q':
|
||||
rt.Container = true
|
||||
case 'o':
|
||||
rt.Object = true
|
||||
default:
|
||||
return fmt.Errorf("Invalid resource type: '%v'", r)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
|
@ -0,0 +1,211 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"net"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// SASVersion indicates the SAS version.
|
||||
const SASVersion = ServiceVersion
|
||||
|
||||
type SASProtocol string
|
||||
|
||||
const (
|
||||
// SASProtocolHTTPS can be specified for a SAS protocol
|
||||
SASProtocolHTTPS SASProtocol = "https"
|
||||
|
||||
// SASProtocolHTTPSandHTTP can be specified for a SAS protocol
|
||||
SASProtocolHTTPSandHTTP SASProtocol = "https,http"
|
||||
)
|
||||
|
||||
// FormatTimesForSASSigning converts a time.Time to a snapshotTimeFormat string suitable for a
|
||||
// SASField's StartTime or ExpiryTime fields. Returns "" if value.IsZero().
|
||||
func FormatTimesForSASSigning(startTime, expiryTime time.Time) (string, string) {
|
||||
ss := ""
|
||||
if !startTime.IsZero() {
|
||||
ss = startTime.Format(SASTimeFormat) // "yyyy-MM-ddTHH:mm:ssZ"
|
||||
}
|
||||
se := ""
|
||||
if !expiryTime.IsZero() {
|
||||
se = expiryTime.Format(SASTimeFormat) // "yyyy-MM-ddTHH:mm:ssZ"
|
||||
}
|
||||
return ss, se
|
||||
}
|
||||
|
||||
// SASTimeFormat represents the format of a SAS start or expiry time. Use it when formatting/parsing a time.Time.
|
||||
const SASTimeFormat = "2006-01-02T15:04:05Z" //"2017-07-27T00:00:00Z" // ISO 8601
|
||||
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/constructing-a-service-sas
|
||||
|
||||
// A SASQueryParameters object represents the components that make up an Azure Storage SAS' query parameters.
|
||||
// You parse a map of query parameters into its fields by calling NewSASQueryParameters(). You add the components
|
||||
// to a query parameter map by calling AddToValues().
|
||||
// NOTE: Changing any field requires computing a new SAS signature using a XxxSASSignatureValues type.
|
||||
//
|
||||
// This type defines the components used by all Azure Storage resources (Containers, Blobs, Files, & Queues).
|
||||
type SASQueryParameters struct {
|
||||
// All members are immutable or values so copies of this struct are goroutine-safe.
|
||||
version string `param:"sv"`
|
||||
services string `param:"ss"`
|
||||
resourceTypes string `param:"srt"`
|
||||
protocol SASProtocol `param:"spr"`
|
||||
startTime time.Time `param:"st"`
|
||||
expiryTime time.Time `param:"se"`
|
||||
ipRange IPRange `param:"sip"`
|
||||
identifier string `param:"si"`
|
||||
resource string `param:"sr"`
|
||||
permissions string `param:"sp"`
|
||||
signature string `param:"sig"`
|
||||
}
|
||||
|
||||
func (p *SASQueryParameters) Version() string {
|
||||
return p.version
|
||||
}
|
||||
|
||||
func (p *SASQueryParameters) Services() string {
|
||||
return p.services
|
||||
}
|
||||
func (p *SASQueryParameters) ResourceTypes() string {
|
||||
return p.resourceTypes
|
||||
}
|
||||
func (p *SASQueryParameters) Protocol() SASProtocol {
|
||||
return p.protocol
|
||||
}
|
||||
func (p *SASQueryParameters) StartTime() time.Time {
|
||||
return p.startTime
|
||||
}
|
||||
func (p *SASQueryParameters) ExpiryTime() time.Time {
|
||||
return p.expiryTime
|
||||
}
|
||||
|
||||
func (p *SASQueryParameters) IPRange() IPRange {
|
||||
return p.ipRange
|
||||
}
|
||||
|
||||
func (p *SASQueryParameters) Identifier() string {
|
||||
return p.identifier
|
||||
}
|
||||
|
||||
func (p *SASQueryParameters) Resource() string {
|
||||
return p.resource
|
||||
}
|
||||
func (p *SASQueryParameters) Permissions() string {
|
||||
return p.permissions
|
||||
}
|
||||
|
||||
func (p *SASQueryParameters) Signature() string {
|
||||
return p.signature
|
||||
}
|
||||
|
||||
// IPRange represents a SAS IP range's start IP and (optionally) end IP.
|
||||
type IPRange struct {
|
||||
Start net.IP // Not specified if length = 0
|
||||
End net.IP // Not specified if length = 0
|
||||
}
|
||||
|
||||
// String returns a string representation of an IPRange.
|
||||
func (ipr *IPRange) String() string {
|
||||
if len(ipr.Start) == 0 {
|
||||
return ""
|
||||
}
|
||||
start := ipr.Start.String()
|
||||
if len(ipr.End) == 0 {
|
||||
return start
|
||||
}
|
||||
return start + "-" + ipr.End.String()
|
||||
}
|
||||
|
||||
// NewSASQueryParameters creates and initializes a SASQueryParameters object based on the
|
||||
// query parameter map's passed-in values. If deleteSASParametersFromValues is true,
|
||||
// all SAS-related query parameters are removed from the passed-in map. If
|
||||
// deleteSASParametersFromValues is false, the map passed-in map is unaltered.
|
||||
func newSASQueryParameters(values url.Values, deleteSASParametersFromValues bool) SASQueryParameters {
|
||||
p := SASQueryParameters{}
|
||||
for k, v := range values {
|
||||
val := v[0]
|
||||
isSASKey := true
|
||||
switch strings.ToLower(k) {
|
||||
case "sv":
|
||||
p.version = val
|
||||
case "ss":
|
||||
p.services = val
|
||||
case "srt":
|
||||
p.resourceTypes = val
|
||||
case "spr":
|
||||
p.protocol = SASProtocol(val)
|
||||
case "st":
|
||||
p.startTime, _ = time.Parse(SASTimeFormat, val)
|
||||
case "se":
|
||||
p.expiryTime, _ = time.Parse(SASTimeFormat, val)
|
||||
case "sip":
|
||||
dashIndex := strings.Index(val, "-")
|
||||
if dashIndex == -1 {
|
||||
p.ipRange.Start = net.ParseIP(val)
|
||||
} else {
|
||||
p.ipRange.Start = net.ParseIP(val[:dashIndex])
|
||||
p.ipRange.End = net.ParseIP(val[dashIndex+1:])
|
||||
}
|
||||
case "si":
|
||||
p.identifier = val
|
||||
case "sr":
|
||||
p.resource = val
|
||||
case "sp":
|
||||
p.permissions = val
|
||||
case "sig":
|
||||
p.signature = val
|
||||
default:
|
||||
isSASKey = false // We didn't recognize the query parameter
|
||||
}
|
||||
if isSASKey && deleteSASParametersFromValues {
|
||||
delete(values, k)
|
||||
}
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// AddToValues adds the SAS components to the specified query parameters map.
|
||||
func (p *SASQueryParameters) addToValues(v url.Values) url.Values {
|
||||
if p.version != "" {
|
||||
v.Add("sv", p.version)
|
||||
}
|
||||
if p.services != "" {
|
||||
v.Add("ss", p.services)
|
||||
}
|
||||
if p.resourceTypes != "" {
|
||||
v.Add("srt", p.resourceTypes)
|
||||
}
|
||||
if p.protocol != "" {
|
||||
v.Add("spr", string(p.protocol))
|
||||
}
|
||||
if !p.startTime.IsZero() {
|
||||
v.Add("st", p.startTime.Format(SASTimeFormat))
|
||||
}
|
||||
if !p.expiryTime.IsZero() {
|
||||
v.Add("se", p.expiryTime.Format(SASTimeFormat))
|
||||
}
|
||||
if len(p.ipRange.Start) > 0 {
|
||||
v.Add("sip", p.ipRange.String())
|
||||
}
|
||||
if p.identifier != "" {
|
||||
v.Add("si", p.identifier)
|
||||
}
|
||||
if p.resource != "" {
|
||||
v.Add("sr", p.resource)
|
||||
}
|
||||
if p.permissions != "" {
|
||||
v.Add("sp", p.permissions)
|
||||
}
|
||||
if p.signature != "" {
|
||||
v.Add("sig", p.signature)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// Encode encodes the SAS query parameters into URL encoded form sorted by key.
|
||||
func (p *SASQueryParameters) Encode() string {
|
||||
v := url.Values{}
|
||||
p.addToValues(v)
|
||||
return v.Encode()
|
||||
}
|
262
2017-07-29/azblob/service_codes_common.go → 2017-07-29/azblob/zc_service_codes_common.go
Normal file → Executable file
262
2017-07-29/azblob/service_codes_common.go → 2017-07-29/azblob/zc_service_codes_common.go
Normal file → Executable file
|
@ -1,131 +1,131 @@
|
|||
package azblob
|
||||
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/common-rest-api-error-codes
|
||||
|
||||
const (
|
||||
// ServiceCodeNone is the default value. It indicates that the error was related to the service or that the service didn't return a code.
|
||||
ServiceCodeNone ServiceCodeType = ""
|
||||
|
||||
// ServiceCodeAccountAlreadyExists means the specified account already exists.
|
||||
ServiceCodeAccountAlreadyExists ServiceCodeType = "AccountAlreadyExists"
|
||||
|
||||
// ServiceCodeAccountBeingCreated means the specified account is in the process of being created (403).
|
||||
ServiceCodeAccountBeingCreated ServiceCodeType = "AccountBeingCreated"
|
||||
|
||||
// ServiceCodeAccountIsDisabled means the specified account is disabled (403).
|
||||
ServiceCodeAccountIsDisabled ServiceCodeType = "AccountIsDisabled"
|
||||
|
||||
// ServiceCodeAuthenticationFailed means the server failed to authenticate the request. Make sure the value of the Authorization header is formed correctly including the signature (403).
|
||||
ServiceCodeAuthenticationFailed ServiceCodeType = "AuthenticationFailed"
|
||||
|
||||
// ServiceCodeConditionHeadersNotSupported means the condition headers are not supported (400).
|
||||
ServiceCodeConditionHeadersNotSupported ServiceCodeType = "ConditionHeadersNotSupported"
|
||||
|
||||
// ServiceCodeConditionNotMet means the condition specified in the conditional header(s) was not met for a read/write operation (304/412).
|
||||
ServiceCodeConditionNotMet ServiceCodeType = "ConditionNotMet"
|
||||
|
||||
// ServiceCodeEmptyMetadataKey means the key for one of the metadata key-value pairs is empty (400).
|
||||
ServiceCodeEmptyMetadataKey ServiceCodeType = "EmptyMetadataKey"
|
||||
|
||||
// ServiceCodeInsufficientAccountPermissions means read operations are currently disabled or Write operations are not allowed or The account being accessed does not have sufficient permissions to execute this operation (403).
|
||||
ServiceCodeInsufficientAccountPermissions ServiceCodeType = "InsufficientAccountPermissions"
|
||||
|
||||
// ServiceCodeInternalError means the server encountered an internal error. Please retry the request (500).
|
||||
ServiceCodeInternalError ServiceCodeType = "InternalError"
|
||||
|
||||
// ServiceCodeInvalidAuthenticationInfo means the authentication information was not provided in the correct format. Verify the value of Authorization header (400).
|
||||
ServiceCodeInvalidAuthenticationInfo ServiceCodeType = "InvalidAuthenticationInfo"
|
||||
|
||||
// ServiceCodeInvalidHeaderValue means the value provided for one of the HTTP headers was not in the correct format (400).
|
||||
ServiceCodeInvalidHeaderValue ServiceCodeType = "InvalidHeaderValue"
|
||||
|
||||
// ServiceCodeInvalidHTTPVerb means the HTTP verb specified was not recognized by the server (400).
|
||||
ServiceCodeInvalidHTTPVerb ServiceCodeType = "InvalidHttpVerb"
|
||||
|
||||
// ServiceCodeInvalidInput means one of the request inputs is not valid (400).
|
||||
ServiceCodeInvalidInput ServiceCodeType = "InvalidInput"
|
||||
|
||||
// ServiceCodeInvalidMd5 means the MD5 value specified in the request is invalid. The MD5 value must be 128 bits and Base64-encoded (400).
|
||||
ServiceCodeInvalidMd5 ServiceCodeType = "InvalidMd5"
|
||||
|
||||
// ServiceCodeInvalidMetadata means the specified metadata is invalid. It includes characters that are not permitted (400).
|
||||
ServiceCodeInvalidMetadata ServiceCodeType = "InvalidMetadata"
|
||||
|
||||
// ServiceCodeInvalidQueryParameterValue means an invalid value was specified for one of the query parameters in the request URI (400).
|
||||
ServiceCodeInvalidQueryParameterValue ServiceCodeType = "InvalidQueryParameterValue"
|
||||
|
||||
// ServiceCodeInvalidRange means the range specified is invalid for the current size of the resource (416).
|
||||
ServiceCodeInvalidRange ServiceCodeType = "InvalidRange"
|
||||
|
||||
// ServiceCodeInvalidResourceName means the specified resource name contains invalid characters (400).
|
||||
ServiceCodeInvalidResourceName ServiceCodeType = "InvalidResourceName"
|
||||
|
||||
// ServiceCodeInvalidURI means the requested URI does not represent any resource on the server (400).
|
||||
ServiceCodeInvalidURI ServiceCodeType = "InvalidUri"
|
||||
|
||||
// ServiceCodeInvalidXMLDocument means the specified XML is not syntactically valid (400).
|
||||
ServiceCodeInvalidXMLDocument ServiceCodeType = "InvalidXmlDocument"
|
||||
|
||||
// ServiceCodeInvalidXMLNodeValue means the value provided for one of the XML nodes in the request body was not in the correct format (400).
|
||||
ServiceCodeInvalidXMLNodeValue ServiceCodeType = "InvalidXmlNodeValue"
|
||||
|
||||
// ServiceCodeMd5Mismatch means the MD5 value specified in the request did not match the MD5 value calculated by the server (400).
|
||||
ServiceCodeMd5Mismatch ServiceCodeType = "Md5Mismatch"
|
||||
|
||||
// ServiceCodeMetadataTooLarge means the size of the specified metadata exceeds the maximum size permitted (400).
|
||||
ServiceCodeMetadataTooLarge ServiceCodeType = "MetadataTooLarge"
|
||||
|
||||
// ServiceCodeMissingContentLengthHeader means the Content-Length header was not specified (411).
|
||||
ServiceCodeMissingContentLengthHeader ServiceCodeType = "MissingContentLengthHeader"
|
||||
|
||||
// ServiceCodeMissingRequiredQueryParameter means a required query parameter was not specified for this request (400).
|
||||
ServiceCodeMissingRequiredQueryParameter ServiceCodeType = "MissingRequiredQueryParameter"
|
||||
|
||||
// ServiceCodeMissingRequiredHeader means a required HTTP header was not specified (400).
|
||||
ServiceCodeMissingRequiredHeader ServiceCodeType = "MissingRequiredHeader"
|
||||
|
||||
// ServiceCodeMissingRequiredXMLNode means a required XML node was not specified in the request body (400).
|
||||
ServiceCodeMissingRequiredXMLNode ServiceCodeType = "MissingRequiredXmlNode"
|
||||
|
||||
// ServiceCodeMultipleConditionHeadersNotSupported means multiple condition headers are not supported (400).
|
||||
ServiceCodeMultipleConditionHeadersNotSupported ServiceCodeType = "MultipleConditionHeadersNotSupported"
|
||||
|
||||
// ServiceCodeOperationTimedOut means the operation could not be completed within the permitted time (500).
|
||||
ServiceCodeOperationTimedOut ServiceCodeType = "OperationTimedOut"
|
||||
|
||||
// ServiceCodeOutOfRangeInput means one of the request inputs is out of range (400).
|
||||
ServiceCodeOutOfRangeInput ServiceCodeType = "OutOfRangeInput"
|
||||
|
||||
// ServiceCodeOutOfRangeQueryParameterValue means a query parameter specified in the request URI is outside the permissible range (400).
|
||||
ServiceCodeOutOfRangeQueryParameterValue ServiceCodeType = "OutOfRangeQueryParameterValue"
|
||||
|
||||
// ServiceCodeRequestBodyTooLarge means the size of the request body exceeds the maximum size permitted (413).
|
||||
ServiceCodeRequestBodyTooLarge ServiceCodeType = "RequestBodyTooLarge"
|
||||
|
||||
// ServiceCodeResourceTypeMismatch means the specified resource type does not match the type of the existing resource (409).
|
||||
ServiceCodeResourceTypeMismatch ServiceCodeType = "ResourceTypeMismatch"
|
||||
|
||||
// ServiceCodeRequestURLFailedToParse means the url in the request could not be parsed (400).
|
||||
ServiceCodeRequestURLFailedToParse ServiceCodeType = "RequestUrlFailedToParse"
|
||||
|
||||
// ServiceCodeResourceAlreadyExists means the specified resource already exists (409).
|
||||
ServiceCodeResourceAlreadyExists ServiceCodeType = "ResourceAlreadyExists"
|
||||
|
||||
// ServiceCodeResourceNotFound means the specified resource does not exist (404).
|
||||
ServiceCodeResourceNotFound ServiceCodeType = "ResourceNotFound"
|
||||
|
||||
// ServiceCodeServerBusy means the server is currently unable to receive requests. Please retry your request or Ingress/egress is over the account limit or operations per second is over the account limit (503).
|
||||
ServiceCodeServerBusy ServiceCodeType = "ServerBusy"
|
||||
|
||||
// ServiceCodeUnsupportedHeader means one of the HTTP headers specified in the request is not supported (400).
|
||||
ServiceCodeUnsupportedHeader ServiceCodeType = "UnsupportedHeader"
|
||||
|
||||
// ServiceCodeUnsupportedXMLNode means one of the XML nodes specified in the request body is not supported (400).
|
||||
ServiceCodeUnsupportedXMLNode ServiceCodeType = "UnsupportedXmlNode"
|
||||
|
||||
// ServiceCodeUnsupportedQueryParameter means one of the query parameters specified in the request URI is not supported (400).
|
||||
ServiceCodeUnsupportedQueryParameter ServiceCodeType = "UnsupportedQueryParameter"
|
||||
|
||||
// ServiceCodeUnsupportedHTTPVerb means the resource doesn't support the specified HTTP verb (405).
|
||||
ServiceCodeUnsupportedHTTPVerb ServiceCodeType = "UnsupportedHttpVerb"
|
||||
)
|
||||
package azblob
|
||||
|
||||
// https://docs.microsoft.com/en-us/rest/api/storageservices/common-rest-api-error-codes
|
||||
|
||||
const (
|
||||
// ServiceCodeNone is the default value. It indicates that the error was related to the service or that the service didn't return a code.
|
||||
ServiceCodeNone ServiceCodeType = ""
|
||||
|
||||
// ServiceCodeAccountAlreadyExists means the specified account already exists.
|
||||
ServiceCodeAccountAlreadyExists ServiceCodeType = "AccountAlreadyExists"
|
||||
|
||||
// ServiceCodeAccountBeingCreated means the specified account is in the process of being created (403).
|
||||
ServiceCodeAccountBeingCreated ServiceCodeType = "AccountBeingCreated"
|
||||
|
||||
// ServiceCodeAccountIsDisabled means the specified account is disabled (403).
|
||||
ServiceCodeAccountIsDisabled ServiceCodeType = "AccountIsDisabled"
|
||||
|
||||
// ServiceCodeAuthenticationFailed means the server failed to authenticate the request. Make sure the value of the Authorization header is formed correctly including the signature (403).
|
||||
ServiceCodeAuthenticationFailed ServiceCodeType = "AuthenticationFailed"
|
||||
|
||||
// ServiceCodeConditionHeadersNotSupported means the condition headers are not supported (400).
|
||||
ServiceCodeConditionHeadersNotSupported ServiceCodeType = "ConditionHeadersNotSupported"
|
||||
|
||||
// ServiceCodeConditionNotMet means the condition specified in the conditional header(s) was not met for a read/write operation (304/412).
|
||||
ServiceCodeConditionNotMet ServiceCodeType = "ConditionNotMet"
|
||||
|
||||
// ServiceCodeEmptyMetadataKey means the key for one of the metadata key-value pairs is empty (400).
|
||||
ServiceCodeEmptyMetadataKey ServiceCodeType = "EmptyMetadataKey"
|
||||
|
||||
// ServiceCodeInsufficientAccountPermissions means read operations are currently disabled or Write operations are not allowed or The account being accessed does not have sufficient permissions to execute this operation (403).
|
||||
ServiceCodeInsufficientAccountPermissions ServiceCodeType = "InsufficientAccountPermissions"
|
||||
|
||||
// ServiceCodeInternalError means the server encountered an internal error. Please retry the request (500).
|
||||
ServiceCodeInternalError ServiceCodeType = "InternalError"
|
||||
|
||||
// ServiceCodeInvalidAuthenticationInfo means the authentication information was not provided in the correct format. Verify the value of Authorization header (400).
|
||||
ServiceCodeInvalidAuthenticationInfo ServiceCodeType = "InvalidAuthenticationInfo"
|
||||
|
||||
// ServiceCodeInvalidHeaderValue means the value provided for one of the HTTP headers was not in the correct format (400).
|
||||
ServiceCodeInvalidHeaderValue ServiceCodeType = "InvalidHeaderValue"
|
||||
|
||||
// ServiceCodeInvalidHTTPVerb means the HTTP verb specified was not recognized by the server (400).
|
||||
ServiceCodeInvalidHTTPVerb ServiceCodeType = "InvalidHttpVerb"
|
||||
|
||||
// ServiceCodeInvalidInput means one of the request inputs is not valid (400).
|
||||
ServiceCodeInvalidInput ServiceCodeType = "InvalidInput"
|
||||
|
||||
// ServiceCodeInvalidMd5 means the MD5 value specified in the request is invalid. The MD5 value must be 128 bits and Base64-encoded (400).
|
||||
ServiceCodeInvalidMd5 ServiceCodeType = "InvalidMd5"
|
||||
|
||||
// ServiceCodeInvalidMetadata means the specified metadata is invalid. It includes characters that are not permitted (400).
|
||||
ServiceCodeInvalidMetadata ServiceCodeType = "InvalidMetadata"
|
||||
|
||||
// ServiceCodeInvalidQueryParameterValue means an invalid value was specified for one of the query parameters in the request URI (400).
|
||||
ServiceCodeInvalidQueryParameterValue ServiceCodeType = "InvalidQueryParameterValue"
|
||||
|
||||
// ServiceCodeInvalidRange means the range specified is invalid for the current size of the resource (416).
|
||||
ServiceCodeInvalidRange ServiceCodeType = "InvalidRange"
|
||||
|
||||
// ServiceCodeInvalidResourceName means the specified resource name contains invalid characters (400).
|
||||
ServiceCodeInvalidResourceName ServiceCodeType = "InvalidResourceName"
|
||||
|
||||
// ServiceCodeInvalidURI means the requested URI does not represent any resource on the server (400).
|
||||
ServiceCodeInvalidURI ServiceCodeType = "InvalidUri"
|
||||
|
||||
// ServiceCodeInvalidXMLDocument means the specified XML is not syntactically valid (400).
|
||||
ServiceCodeInvalidXMLDocument ServiceCodeType = "InvalidXmlDocument"
|
||||
|
||||
// ServiceCodeInvalidXMLNodeValue means the value provided for one of the XML nodes in the request body was not in the correct format (400).
|
||||
ServiceCodeInvalidXMLNodeValue ServiceCodeType = "InvalidXmlNodeValue"
|
||||
|
||||
// ServiceCodeMd5Mismatch means the MD5 value specified in the request did not match the MD5 value calculated by the server (400).
|
||||
ServiceCodeMd5Mismatch ServiceCodeType = "Md5Mismatch"
|
||||
|
||||
// ServiceCodeMetadataTooLarge means the size of the specified metadata exceeds the maximum size permitted (400).
|
||||
ServiceCodeMetadataTooLarge ServiceCodeType = "MetadataTooLarge"
|
||||
|
||||
// ServiceCodeMissingContentLengthHeader means the Content-Length header was not specified (411).
|
||||
ServiceCodeMissingContentLengthHeader ServiceCodeType = "MissingContentLengthHeader"
|
||||
|
||||
// ServiceCodeMissingRequiredQueryParameter means a required query parameter was not specified for this request (400).
|
||||
ServiceCodeMissingRequiredQueryParameter ServiceCodeType = "MissingRequiredQueryParameter"
|
||||
|
||||
// ServiceCodeMissingRequiredHeader means a required HTTP header was not specified (400).
|
||||
ServiceCodeMissingRequiredHeader ServiceCodeType = "MissingRequiredHeader"
|
||||
|
||||
// ServiceCodeMissingRequiredXMLNode means a required XML node was not specified in the request body (400).
|
||||
ServiceCodeMissingRequiredXMLNode ServiceCodeType = "MissingRequiredXmlNode"
|
||||
|
||||
// ServiceCodeMultipleConditionHeadersNotSupported means multiple condition headers are not supported (400).
|
||||
ServiceCodeMultipleConditionHeadersNotSupported ServiceCodeType = "MultipleConditionHeadersNotSupported"
|
||||
|
||||
// ServiceCodeOperationTimedOut means the operation could not be completed within the permitted time (500).
|
||||
ServiceCodeOperationTimedOut ServiceCodeType = "OperationTimedOut"
|
||||
|
||||
// ServiceCodeOutOfRangeInput means one of the request inputs is out of range (400).
|
||||
ServiceCodeOutOfRangeInput ServiceCodeType = "OutOfRangeInput"
|
||||
|
||||
// ServiceCodeOutOfRangeQueryParameterValue means a query parameter specified in the request URI is outside the permissible range (400).
|
||||
ServiceCodeOutOfRangeQueryParameterValue ServiceCodeType = "OutOfRangeQueryParameterValue"
|
||||
|
||||
// ServiceCodeRequestBodyTooLarge means the size of the request body exceeds the maximum size permitted (413).
|
||||
ServiceCodeRequestBodyTooLarge ServiceCodeType = "RequestBodyTooLarge"
|
||||
|
||||
// ServiceCodeResourceTypeMismatch means the specified resource type does not match the type of the existing resource (409).
|
||||
ServiceCodeResourceTypeMismatch ServiceCodeType = "ResourceTypeMismatch"
|
||||
|
||||
// ServiceCodeRequestURLFailedToParse means the url in the request could not be parsed (400).
|
||||
ServiceCodeRequestURLFailedToParse ServiceCodeType = "RequestUrlFailedToParse"
|
||||
|
||||
// ServiceCodeResourceAlreadyExists means the specified resource already exists (409).
|
||||
ServiceCodeResourceAlreadyExists ServiceCodeType = "ResourceAlreadyExists"
|
||||
|
||||
// ServiceCodeResourceNotFound means the specified resource does not exist (404).
|
||||
ServiceCodeResourceNotFound ServiceCodeType = "ResourceNotFound"
|
||||
|
||||
// ServiceCodeServerBusy means the server is currently unable to receive requests. Please retry your request or Ingress/egress is over the account limit or operations per second is over the account limit (503).
|
||||
ServiceCodeServerBusy ServiceCodeType = "ServerBusy"
|
||||
|
||||
// ServiceCodeUnsupportedHeader means one of the HTTP headers specified in the request is not supported (400).
|
||||
ServiceCodeUnsupportedHeader ServiceCodeType = "UnsupportedHeader"
|
||||
|
||||
// ServiceCodeUnsupportedXMLNode means one of the XML nodes specified in the request body is not supported (400).
|
||||
ServiceCodeUnsupportedXMLNode ServiceCodeType = "UnsupportedXmlNode"
|
||||
|
||||
// ServiceCodeUnsupportedQueryParameter means one of the query parameters specified in the request URI is not supported (400).
|
||||
ServiceCodeUnsupportedQueryParameter ServiceCodeType = "UnsupportedQueryParameter"
|
||||
|
||||
// ServiceCodeUnsupportedHTTPVerb means the resource doesn't support the specified HTTP verb (405).
|
||||
ServiceCodeUnsupportedHTTPVerb ServiceCodeType = "UnsupportedHttpVerb"
|
||||
)
|
220
2017-07-29/azblob/storage_error.go → 2017-07-29/azblob/zc_storage_error.go
Normal file → Executable file
220
2017-07-29/azblob/storage_error.go → 2017-07-29/azblob/zc_storage_error.go
Normal file → Executable file
|
@ -1,110 +1,110 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"sort"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
func init() {
|
||||
// wire up our custom error handling constructor
|
||||
responseErrorFactory = newStorageError
|
||||
}
|
||||
|
||||
// ServiceCodeType is a string identifying a specific container or blob error.
|
||||
// For more information, see https://docs.microsoft.com/en-us/rest/api/storageservices/blob-service-error-codes
|
||||
type ServiceCodeType string
|
||||
|
||||
// StorageError identifies a responder-generated network or response parsing error.
|
||||
type StorageError interface {
|
||||
// ResponseError implements error's Error(), net.Error's Temporary() and Timeout() methods & Response().
|
||||
ResponseError
|
||||
|
||||
// ServiceCode returns a service error code. Your code can use this to make error recovery decisions.
|
||||
ServiceCode() ServiceCodeType
|
||||
}
|
||||
|
||||
// storageError is the internat struct that implements the public StorageError interface.
|
||||
type storageError struct {
|
||||
responseError
|
||||
serviceCode ServiceCodeType
|
||||
details map[string]string
|
||||
}
|
||||
|
||||
// newStorageError creates an error object that implements the error interface.
|
||||
func newStorageError(cause error, response *http.Response, description string) error {
|
||||
return &storageError{
|
||||
responseError: responseError{
|
||||
ErrorNode: pipeline.ErrorNode{}.Initialize(cause, 3),
|
||||
response: response,
|
||||
description: description,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// ServiceCode returns service-error information. The caller may examine these values but should not modify any of them.
|
||||
func (e *storageError) ServiceCode() ServiceCodeType { return e.serviceCode }
|
||||
|
||||
// Error implements the error interface's Error method to return a string representation of the error.
|
||||
func (e *storageError) Error() string {
|
||||
b := &bytes.Buffer{}
|
||||
fmt.Fprintf(b, "===== RESPONSE ERROR (ServiceCode=%s) =====\n", e.serviceCode)
|
||||
fmt.Fprintf(b, "Description=%s, Details: ", e.description)
|
||||
if len(e.details) == 0 {
|
||||
b.WriteString("(none)\n")
|
||||
} else {
|
||||
b.WriteRune('\n')
|
||||
keys := make([]string, 0, len(e.details))
|
||||
// Alphabetize the details
|
||||
for k := range e.details {
|
||||
keys = append(keys, k)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
for _, k := range keys {
|
||||
fmt.Fprintf(b, " %s: %+v\n", k, e.details[k])
|
||||
}
|
||||
}
|
||||
req := pipeline.Request{Request: e.response.Request}.Copy() // Make a copy of the response's request
|
||||
pipeline.WriteRequestWithResponse(b, prepareRequestForLogging(req), e.response, nil)
|
||||
return e.ErrorNode.Error(b.String())
|
||||
}
|
||||
|
||||
// Temporary returns true if the error occurred due to a temporary condition (including an HTTP status of 500 or 503).
|
||||
func (e *storageError) Temporary() bool {
|
||||
if e.response != nil {
|
||||
if (e.response.StatusCode == http.StatusInternalServerError) || (e.response.StatusCode == http.StatusServiceUnavailable) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return e.ErrorNode.Temporary()
|
||||
}
|
||||
|
||||
// UnmarshalXML performs custom unmarshalling of XML-formatted Azure storage request errors.
|
||||
func (e *storageError) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
|
||||
tokName := ""
|
||||
var t xml.Token
|
||||
for t, err = d.Token(); err == nil; t, err = d.Token() {
|
||||
switch tt := t.(type) {
|
||||
case xml.StartElement:
|
||||
tokName = tt.Name.Local
|
||||
break
|
||||
case xml.CharData:
|
||||
switch tokName {
|
||||
case "Code":
|
||||
e.serviceCode = ServiceCodeType(tt)
|
||||
case "Message":
|
||||
e.description = string(tt)
|
||||
default:
|
||||
if e.details == nil {
|
||||
e.details = map[string]string{}
|
||||
}
|
||||
e.details[tokName] = string(tt)
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"sort"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
func init() {
|
||||
// wire up our custom error handling constructor
|
||||
responseErrorFactory = newStorageError
|
||||
}
|
||||
|
||||
// ServiceCodeType is a string identifying a storage service error.
|
||||
// For more information, see https://docs.microsoft.com/en-us/rest/api/storageservices/status-and-error-codes2
|
||||
type ServiceCodeType string
|
||||
|
||||
// StorageError identifies a responder-generated network or response parsing error.
|
||||
type StorageError interface {
|
||||
// ResponseError implements error's Error(), net.Error's Temporary() and Timeout() methods & Response().
|
||||
ResponseError
|
||||
|
||||
// ServiceCode returns a service error code. Your code can use this to make error recovery decisions.
|
||||
ServiceCode() ServiceCodeType
|
||||
}
|
||||
|
||||
// storageError is the internal struct that implements the public StorageError interface.
|
||||
type storageError struct {
|
||||
responseError
|
||||
serviceCode ServiceCodeType
|
||||
details map[string]string
|
||||
}
|
||||
|
||||
// newStorageError creates an error object that implements the error interface.
|
||||
func newStorageError(cause error, response *http.Response, description string) error {
|
||||
return &storageError{
|
||||
responseError: responseError{
|
||||
ErrorNode: pipeline.ErrorNode{}.Initialize(cause, 3),
|
||||
response: response,
|
||||
description: description,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// ServiceCode returns service-error information. The caller may examine these values but should not modify any of them.
|
||||
func (e *storageError) ServiceCode() ServiceCodeType { return e.serviceCode }
|
||||
|
||||
// Error implements the error interface's Error method to return a string representation of the error.
|
||||
func (e *storageError) Error() string {
|
||||
b := &bytes.Buffer{}
|
||||
fmt.Fprintf(b, "===== RESPONSE ERROR (ServiceCode=%s) =====\n", e.serviceCode)
|
||||
fmt.Fprintf(b, "Description=%s, Details: ", e.description)
|
||||
if len(e.details) == 0 {
|
||||
b.WriteString("(none)\n")
|
||||
} else {
|
||||
b.WriteRune('\n')
|
||||
keys := make([]string, 0, len(e.details))
|
||||
// Alphabetize the details
|
||||
for k := range e.details {
|
||||
keys = append(keys, k)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
for _, k := range keys {
|
||||
fmt.Fprintf(b, " %s: %+v\n", k, e.details[k])
|
||||
}
|
||||
}
|
||||
req := pipeline.Request{Request: e.response.Request}.Copy() // Make a copy of the response's request
|
||||
pipeline.WriteRequestWithResponse(b, prepareRequestForLogging(req), e.response, nil)
|
||||
return e.ErrorNode.Error(b.String())
|
||||
}
|
||||
|
||||
// Temporary returns true if the error occurred due to a temporary condition (including an HTTP status of 500 or 503).
|
||||
func (e *storageError) Temporary() bool {
|
||||
if e.response != nil {
|
||||
if (e.response.StatusCode == http.StatusInternalServerError) || (e.response.StatusCode == http.StatusServiceUnavailable) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return e.ErrorNode.Temporary()
|
||||
}
|
||||
|
||||
// UnmarshalXML performs custom unmarshalling of XML-formatted Azure storage request errors.
|
||||
func (e *storageError) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
|
||||
tokName := ""
|
||||
var t xml.Token
|
||||
for t, err = d.Token(); err == nil; t, err = d.Token() {
|
||||
switch tt := t.(type) {
|
||||
case xml.StartElement:
|
||||
tokName = tt.Name.Local
|
||||
break
|
||||
case xml.CharData:
|
||||
switch tokName {
|
||||
case "Code":
|
||||
e.serviceCode = ServiceCodeType(tt)
|
||||
case "Message":
|
||||
e.description = string(tt)
|
||||
default:
|
||||
if e.details == nil {
|
||||
e.details = map[string]string{}
|
||||
}
|
||||
e.details[tokName] = string(tt)
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
|
@ -0,0 +1,61 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// httpRange defines a range of bytes within an HTTP resource, starting at offset and
|
||||
// ending at offset+count. A zero-value httpRange indicates the entire resource. An httpRange
|
||||
// which has an offset but na zero value count indicates from the offset to the resource's end.
|
||||
type httpRange struct {
|
||||
offset int64
|
||||
count int64
|
||||
}
|
||||
|
||||
func (r httpRange) pointers() *string {
|
||||
if r.offset == 0 && r.count == 0 { // Do common case first for performance
|
||||
return nil // No specified range
|
||||
}
|
||||
if r.offset < 0 {
|
||||
panic("The range offset must be >= 0")
|
||||
}
|
||||
if r.count < 0 {
|
||||
panic("The range count must be >= 0")
|
||||
}
|
||||
endOffset := "" // if count == 0
|
||||
if r.count > 0 {
|
||||
endOffset = strconv.FormatInt((r.offset+r.count)-1, 10)
|
||||
}
|
||||
dataRange := fmt.Sprintf("bytes=%v-%s", r.offset, endOffset)
|
||||
return &dataRange
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func validateSeekableStreamAt0AndGetCount(body io.ReadSeeker) int64 {
|
||||
if body == nil { // nil body's are "logically" seekable to 0 and are 0 bytes long
|
||||
return 0
|
||||
}
|
||||
validateSeekableStreamAt0(body)
|
||||
count, err := body.Seek(0, io.SeekEnd)
|
||||
if err != nil {
|
||||
panic("failed to seek stream")
|
||||
}
|
||||
body.Seek(0, io.SeekStart)
|
||||
return count
|
||||
}
|
||||
|
||||
func validateSeekableStreamAt0(body io.ReadSeeker) {
|
||||
if body == nil { // nil body's are "logically" seekable to 0
|
||||
return
|
||||
}
|
||||
if pos, err := body.Seek(0, io.SeekCurrent); pos != 0 || err != nil {
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
panic(errors.New("stream must be set to position 0"))
|
||||
}
|
||||
}
|
|
@ -1,80 +1,80 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"fmt"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// The UUID reserved variants.
|
||||
const (
|
||||
reservedNCS byte = 0x80
|
||||
reservedRFC4122 byte = 0x40
|
||||
reservedMicrosoft byte = 0x20
|
||||
reservedFuture byte = 0x00
|
||||
)
|
||||
|
||||
// A UUID representation compliant with specification in RFC 4122 document.
|
||||
type uuid [16]byte
|
||||
|
||||
// NewUUID returns a new uuid using RFC 4122 algorithm.
|
||||
func newUUID() (u uuid) {
|
||||
u = uuid{}
|
||||
// Set all bits to randomly (or pseudo-randomly) chosen values.
|
||||
_, err := rand.Read(u[:])
|
||||
if err != nil {
|
||||
panic("ran.Read failed")
|
||||
}
|
||||
u[8] = (u[8] | reservedRFC4122) & 0x7F // u.setVariant(ReservedRFC4122)
|
||||
|
||||
var version byte = 4
|
||||
u[6] = (u[6] & 0xF) | (version << 4) // u.setVersion(4)
|
||||
return
|
||||
}
|
||||
|
||||
// String returns an unparsed version of the generated UUID sequence.
|
||||
func (u uuid) String() string {
|
||||
return fmt.Sprintf("%x-%x-%x-%x-%x", u[0:4], u[4:6], u[6:8], u[8:10], u[10:])
|
||||
}
|
||||
|
||||
// ParseUUID parses a string formatted as "003020100-0504-0706-0809-0a0b0c0d0e0f"
|
||||
// or "{03020100-0504-0706-0809-0a0b0c0d0e0f}" into a UUID.
|
||||
func parseUUID(uuidStr string) uuid {
|
||||
char := func(hexString string) byte {
|
||||
i, _ := strconv.ParseUint(hexString, 16, 8)
|
||||
return byte(i)
|
||||
}
|
||||
if uuidStr[0] == '{' {
|
||||
uuidStr = uuidStr[1:] // Skip over the '{'
|
||||
}
|
||||
// 03020100 - 05 04 - 07 06 - 08 09 - 0a 0b 0c 0d 0e 0f
|
||||
// 1 11 1 11 11 1 12 22 2 22 22 22 33 33 33
|
||||
// 01234567 8 90 12 3 45 67 8 90 12 3 45 67 89 01 23 45
|
||||
uuidVal := uuid{
|
||||
char(uuidStr[0:2]),
|
||||
char(uuidStr[2:4]),
|
||||
char(uuidStr[4:6]),
|
||||
char(uuidStr[6:8]),
|
||||
|
||||
char(uuidStr[9:11]),
|
||||
char(uuidStr[11:13]),
|
||||
|
||||
char(uuidStr[14:16]),
|
||||
char(uuidStr[16:18]),
|
||||
|
||||
char(uuidStr[19:21]),
|
||||
char(uuidStr[21:23]),
|
||||
|
||||
char(uuidStr[24:26]),
|
||||
char(uuidStr[26:28]),
|
||||
char(uuidStr[28:30]),
|
||||
char(uuidStr[30:32]),
|
||||
char(uuidStr[32:34]),
|
||||
char(uuidStr[34:36]),
|
||||
}
|
||||
return uuidVal
|
||||
}
|
||||
|
||||
func (u uuid) bytes() []byte {
|
||||
return u[:]
|
||||
}
|
||||
package azblob
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"fmt"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// The UUID reserved variants.
|
||||
const (
|
||||
reservedNCS byte = 0x80
|
||||
reservedRFC4122 byte = 0x40
|
||||
reservedMicrosoft byte = 0x20
|
||||
reservedFuture byte = 0x00
|
||||
)
|
||||
|
||||
// A UUID representation compliant with specification in RFC 4122 document.
|
||||
type uuid [16]byte
|
||||
|
||||
// NewUUID returns a new uuid using RFC 4122 algorithm.
|
||||
func newUUID() (u uuid) {
|
||||
u = uuid{}
|
||||
// Set all bits to randomly (or pseudo-randomly) chosen values.
|
||||
_, err := rand.Read(u[:])
|
||||
if err != nil {
|
||||
panic("ran.Read failed")
|
||||
}
|
||||
u[8] = (u[8] | reservedRFC4122) & 0x7F // u.setVariant(ReservedRFC4122)
|
||||
|
||||
var version byte = 4
|
||||
u[6] = (u[6] & 0xF) | (version << 4) // u.setVersion(4)
|
||||
return
|
||||
}
|
||||
|
||||
// String returns an unparsed version of the generated UUID sequence.
|
||||
func (u uuid) String() string {
|
||||
return fmt.Sprintf("%x-%x-%x-%x-%x", u[0:4], u[4:6], u[6:8], u[8:10], u[10:])
|
||||
}
|
||||
|
||||
// ParseUUID parses a string formatted as "003020100-0504-0706-0809-0a0b0c0d0e0f"
|
||||
// or "{03020100-0504-0706-0809-0a0b0c0d0e0f}" into a UUID.
|
||||
func parseUUID(uuidStr string) uuid {
|
||||
char := func(hexString string) byte {
|
||||
i, _ := strconv.ParseUint(hexString, 16, 8)
|
||||
return byte(i)
|
||||
}
|
||||
if uuidStr[0] == '{' {
|
||||
uuidStr = uuidStr[1:] // Skip over the '{'
|
||||
}
|
||||
// 03020100 - 05 04 - 07 06 - 08 09 - 0a 0b 0c 0d 0e 0f
|
||||
// 1 11 1 11 11 1 12 22 2 22 22 22 33 33 33
|
||||
// 01234567 8 90 12 3 45 67 8 90 12 3 45 67 89 01 23 45
|
||||
uuidVal := uuid{
|
||||
char(uuidStr[0:2]),
|
||||
char(uuidStr[2:4]),
|
||||
char(uuidStr[4:6]),
|
||||
char(uuidStr[6:8]),
|
||||
|
||||
char(uuidStr[9:11]),
|
||||
char(uuidStr[11:13]),
|
||||
|
||||
char(uuidStr[14:16]),
|
||||
char(uuidStr[16:18]),
|
||||
|
||||
char(uuidStr[19:21]),
|
||||
char(uuidStr[21:23]),
|
||||
|
||||
char(uuidStr[24:26]),
|
||||
char(uuidStr[26:28]),
|
||||
char(uuidStr[28:30]),
|
||||
char(uuidStr[30:32]),
|
||||
char(uuidStr[32:34]),
|
||||
char(uuidStr[34:36]),
|
||||
}
|
||||
return uuidVal
|
||||
}
|
||||
|
||||
func (u uuid) bytes() []byte {
|
||||
return u[:]
|
||||
}
|
|
@ -1,89 +1,89 @@
|
|||
// Copyright 2017 Microsoft Corporation. All rights reserved.
|
||||
// Use of this source code is governed by an MIT
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/*
|
||||
Package azblob allows you to manipulate Azure Storage containers and blobs objects.
|
||||
|
||||
URL Types
|
||||
|
||||
The most common types you'll work with are the XxxURL types. The methods of these types make requests
|
||||
against the Azure Storage Service.
|
||||
|
||||
- ServiceURL's methods perform operations on a storage account.
|
||||
- ContainerURL's methods perform operations on an account's container.
|
||||
- BlockBlobURL's methods perform operations on a container's block blob.
|
||||
- AppendBlobURL's methods perform operations on a container's append blob.
|
||||
- PageBlobURL's methods perform operations on a container's page blob.
|
||||
- BlobURL's methods perform operations on a container's blob regardless of the blob's type.
|
||||
|
||||
Internally, each XxxURL object contains a URL and a request pipeline. The URL indicates the endpoint where each HTTP
|
||||
request is sent and the pipeline indicates how the outgoing HTTP request and incoming HTTP response is processed.
|
||||
The pipeline specifies things like retry policies, logging, deserializaiton of HTTP response payloads, and more.
|
||||
|
||||
Pipelines are threadsafe and may be shared by multiple XxxURL objects. When you create a ServiceURL, you pass
|
||||
an initial pipeline. When you call ServiceURL's NewContainerURL method, the new ContainerURL object has its own
|
||||
URL but it shares the same pipeline as the parent ServiceURL object.
|
||||
|
||||
To work with a blob, call one of ContainerURL's 4 NewXxxBlobURL methods depending on how you want to treat the blob.
|
||||
To treat the blob as a block blob, append blob, or page blob, call NewBlockBlobURL, NewAppendBlobURL, or NewPageBlobURL
|
||||
respectively. These three types are all identical except for the methods they expose; each type exposes the methods
|
||||
relevant to the type of blob represented. If you're not sure how you want to treat a blob, you can call NewBlobURL;
|
||||
this returns an object whose methods are relevant to any kind of blob. When you call ContainerURL's NewXxxBlobURL,
|
||||
the new XxxBlobURL object has its own URL but it shares the same pipeline as the parent ContainerURL object. You
|
||||
can easily switch between blob types (method sets) by calling a ToXxxBlobURL method.
|
||||
|
||||
If you'd like to use a different pipeline with a ServiceURL, ContainerURL, or XxxBlobURL object, then call the XxxURL
|
||||
object's WithPipeline method passing in the desired pipeline. The WithPipeline methods create a new XxxURL object
|
||||
with the same URL as the original but with the specified pipeline.
|
||||
|
||||
Note that XxxURL objects use little memory, are goroutine-safe, and many objects share the same pipeline. This means that
|
||||
XxxURL objects share a lot of system resources making them very efficient.
|
||||
|
||||
All of XxxURL's methods that make HTTP requests return rich error handling information so you can discern network failures,
|
||||
transient failures, timeout failures, service failures, etc. See the StorageError interface for more information and an
|
||||
example of how to do deal with errors.
|
||||
|
||||
URL and Shared Access Signature Manipulation
|
||||
|
||||
The library includes a BlobURLParts type for deconstructing and reconstructing URLs. And you can use the there are types
|
||||
for generating and parsing Shared Access Signature (SAS)
|
||||
- Use the AccountSASSignatureValues type to create a SAS for a storage account
|
||||
- Use the BlobSASSignatureValues type to create a SAS for a container or blob.
|
||||
- Use the SASQueryParameters type to turn signature values in to query parameres or to parse query parameters.
|
||||
|
||||
To generate a SAS, you must use the SharedKeyCredential type.
|
||||
|
||||
Credentials
|
||||
|
||||
When creating a request pipeline, you must specify one of this package's credential types.
|
||||
- Call the NewAnonymousCredential function for requests that contain a Shared Access Signature (SAS) or for requests to public resources.
|
||||
- Call the NewSharedKeyCredential function (with an account name & key) to access any and all account resources. You must also use this
|
||||
to generate Shared Access Signatures.
|
||||
|
||||
HTTP Request Policy Factories
|
||||
|
||||
This package defines several request policy factories for use with the pipeline package.
|
||||
Most applications will not use these factories directly; instead, the NewPipeline
|
||||
function creates the these factories, initializes them (via the PipelineOptions type)
|
||||
and returns a pipeline object for use by the XxxURL objects.
|
||||
|
||||
However, for advanced scenarios, developers can access these policy factory directly
|
||||
and even create their own and then construct their own pipeline in order to affect HTTP
|
||||
requests and responses performed by the XxxURL objects. For example, developers can
|
||||
introduce their own logging, random failures, request recording & playback for fast
|
||||
testing, HTTP request pacing, alternate retry mechanisms, metering, metrics, etc. The
|
||||
possibilities are endless!
|
||||
|
||||
Below are the request pipeline policy factory functions that are provided with this
|
||||
package:
|
||||
- NewRetryPolicyFactory Enables rich retry semantics for failed HTTP requests
|
||||
- NewRequestLogPolicyFactory Enables rich logging support for HTTP requests/responses & failures
|
||||
- NewTelemetryPolicyFactory Enables simple modification of the HTTP request's User-Agent header so each request reports the SDK version & language/runtime making the requests
|
||||
- NewUniqueRequestIDPolicyFactory Adds a x-ms-client-request-id header with a unique UUID value to an HTTP request to help with diagnosing failures
|
||||
|
||||
Also, note that all the NewXxxCredential functions return request policy factory objects which get injected into the pipeline.
|
||||
*/
|
||||
package azblob
|
||||
|
||||
// TokenCredential Use this to access resources using Role-Based Access Control (RBAC).
|
||||
// Copyright 2017 Microsoft Corporation. All rights reserved.
|
||||
// Use of this source code is governed by an MIT
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/*
|
||||
Package azblob allows you to manipulate Azure Storage containers and blobs objects.
|
||||
|
||||
URL Types
|
||||
|
||||
The most common types you'll work with are the XxxURL types. The methods of these types make requests
|
||||
against the Azure Storage Service.
|
||||
|
||||
- ServiceURL's methods perform operations on a storage account.
|
||||
- ContainerURL's methods perform operations on an account's container.
|
||||
- BlockBlobURL's methods perform operations on a container's block blob.
|
||||
- AppendBlobURL's methods perform operations on a container's append blob.
|
||||
- PageBlobURL's methods perform operations on a container's page blob.
|
||||
- BlobURL's methods perform operations on a container's blob regardless of the blob's type.
|
||||
|
||||
Internally, each XxxURL object contains a URL and a request pipeline. The URL indicates the endpoint where each HTTP
|
||||
request is sent and the pipeline indicates how the outgoing HTTP request and incoming HTTP response is processed.
|
||||
The pipeline specifies things like retry policies, logging, deserialization of HTTP response payloads, and more.
|
||||
|
||||
Pipelines are threadsafe and may be shared by multiple XxxURL objects. When you create a ServiceURL, you pass
|
||||
an initial pipeline. When you call ServiceURL's NewContainerURL method, the new ContainerURL object has its own
|
||||
URL but it shares the same pipeline as the parent ServiceURL object.
|
||||
|
||||
To work with a blob, call one of ContainerURL's 4 NewXxxBlobURL methods depending on how you want to treat the blob.
|
||||
To treat the blob as a block blob, append blob, or page blob, call NewBlockBlobURL, NewAppendBlobURL, or NewPageBlobURL
|
||||
respectively. These three types are all identical except for the methods they expose; each type exposes the methods
|
||||
relevant to the type of blob represented. If you're not sure how you want to treat a blob, you can call NewBlobURL;
|
||||
this returns an object whose methods are relevant to any kind of blob. When you call ContainerURL's NewXxxBlobURL,
|
||||
the new XxxBlobURL object has its own URL but it shares the same pipeline as the parent ContainerURL object. You
|
||||
can easily switch between blob types (method sets) by calling a ToXxxBlobURL method.
|
||||
|
||||
If you'd like to use a different pipeline with a ServiceURL, ContainerURL, or XxxBlobURL object, then call the XxxURL
|
||||
object's WithPipeline method passing in the desired pipeline. The WithPipeline methods create a new XxxURL object
|
||||
with the same URL as the original but with the specified pipeline.
|
||||
|
||||
Note that XxxURL objects use little memory, are goroutine-safe, and many objects share the same pipeline. This means that
|
||||
XxxURL objects share a lot of system resources making them very efficient.
|
||||
|
||||
All of XxxURL's methods that make HTTP requests return rich error handling information so you can discern network failures,
|
||||
transient failures, timeout failures, service failures, etc. See the StorageError interface for more information and an
|
||||
example of how to do deal with errors.
|
||||
|
||||
URL and Shared Access Signature Manipulation
|
||||
|
||||
The library includes a BlobURLParts type for deconstructing and reconstructing URLs. And you can use the following types
|
||||
for generating and parsing Shared Access Signature (SAS)
|
||||
- Use the AccountSASSignatureValues type to create a SAS for a storage account.
|
||||
- Use the BlobSASSignatureValues type to create a SAS for a container or blob.
|
||||
- Use the SASQueryParameters type to turn signature values in to query parameres or to parse query parameters.
|
||||
|
||||
To generate a SAS, you must use the SharedKeyCredential type.
|
||||
|
||||
Credentials
|
||||
|
||||
When creating a request pipeline, you must specify one of this package's credential types.
|
||||
- Call the NewAnonymousCredential function for requests that contain a Shared Access Signature (SAS).
|
||||
- Call the NewSharedKeyCredential function (with an account name & key) to access any account resources. You must also use this
|
||||
to generate Shared Access Signatures.
|
||||
|
||||
HTTP Request Policy Factories
|
||||
|
||||
This package defines several request policy factories for use with the pipeline package.
|
||||
Most applications will not use these factories directly; instead, the NewPipeline
|
||||
function creates these factories, initializes them (via the PipelineOptions type)
|
||||
and returns a pipeline object for use by the XxxURL objects.
|
||||
|
||||
However, for advanced scenarios, developers can access these policy factories directly
|
||||
and even create their own and then construct their own pipeline in order to affect HTTP
|
||||
requests and responses performed by the XxxURL objects. For example, developers can
|
||||
introduce their own logging, random failures, request recording & playback for fast
|
||||
testing, HTTP request pacing, alternate retry mechanisms, metering, metrics, etc. The
|
||||
possibilities are endless!
|
||||
|
||||
Below are the request pipeline policy factory functions that are provided with this
|
||||
package:
|
||||
- NewRetryPolicyFactory Enables rich retry semantics for failed HTTP requests.
|
||||
- NewRequestLogPolicyFactory Enables rich logging support for HTTP requests/responses & failures.
|
||||
- NewTelemetryPolicyFactory Enables simple modification of the HTTP request's User-Agent header so each request reports the SDK version & language/runtime making the requests.
|
||||
- NewUniqueRequestIDPolicyFactory Adds a x-ms-client-request-id header with a unique UUID value to an HTTP request to help with diagnosing failures.
|
||||
|
||||
Also, note that all the NewXxxCredential functions return request policy factory objects which get injected into the pipeline.
|
||||
*/
|
||||
package azblob
|
||||
|
||||
// TokenCredential Use this to access resources using Role-Based Access Control (RBAC).
|
||||
|
|
|
@ -20,15 +20,7 @@ import (
|
|||
// https://godoc.org/github.com/fluhus/godoc-tricks
|
||||
|
||||
func accountInfo() (string, string) {
|
||||
return mustGetEnv("ACCOUNT_NAME"), mustGetEnv("ACCOUNT_KEY")
|
||||
}
|
||||
|
||||
func mustGetEnv(key string) string {
|
||||
v := os.Getenv(key)
|
||||
if v == "" {
|
||||
panic("Env variable '" + key + "' required for integration tests.")
|
||||
}
|
||||
return v
|
||||
return os.Getenv("ACCOUNT_NAME"), os.Getenv("ACCOUNT_KEY")
|
||||
}
|
||||
|
||||
// This example shows how to get started using the Azure Storage Blob SDK for Go.
|
||||
|
@ -74,20 +66,21 @@ func Example() {
|
|||
|
||||
// Create the blob with string (plain text) content.
|
||||
data := "Hello World!"
|
||||
_, err = blobURL.PutBlob(ctx, strings.NewReader(data), BlobHTTPHeaders{ContentType: "text/plain"}, Metadata{}, BlobAccessConditions{})
|
||||
_, err = blobURL.Upload(ctx, strings.NewReader(data), BlobHTTPHeaders{ContentType: "text/plain"}, Metadata{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Download the blob's contents and verify that it worked correctly
|
||||
get, err := blobURL.GetBlob(ctx, BlobRange{}, BlobAccessConditions{}, false)
|
||||
get, err := blobURL.Download(ctx, 0, 0, BlobAccessConditions{}, false)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
downloadedData := &bytes.Buffer{}
|
||||
downloadedData.ReadFrom(get.Body())
|
||||
get.Body().Close() // The client must close the response body when finished with it
|
||||
reader := get.Body(RetryReaderOptions{})
|
||||
downloadedData.ReadFrom(reader)
|
||||
reader.Close() // The client must close the response body when finished with it
|
||||
if data != downloadedData.String() {
|
||||
log.Fatal("downloaded data doesn't match uploaded data")
|
||||
}
|
||||
|
@ -95,7 +88,7 @@ func Example() {
|
|||
// List the blob(s) in our container; since a container may hold millions of blobs, this is done 1 segment at a time.
|
||||
for marker := (Marker{}); marker.NotDone(); { // The parens around Marker{} are required to avoid compiler error.
|
||||
// Get a result segment starting with the blob indicated by the current Marker.
|
||||
listBlob, err := containerURL.ListBlobs(ctx, marker, ListBlobsOptions{})
|
||||
listBlob, err := containerURL.ListBlobsFlatSegment(ctx, marker, ListBlobsSegmentOptions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -151,7 +144,9 @@ func ExampleNewPipeline() {
|
|||
// This method is not called for filtered-out severities.
|
||||
logger.Output(2, m) // This example uses Go's standard logger
|
||||
},
|
||||
MinimumLevelToLog: func() pipeline.LogLevel { return pipeline.LogInfo }, // Log all events from informational to more severe
|
||||
ShouldLog: func(level pipeline.LogLevel) bool {
|
||||
return level <= pipeline.LogWarning // Log all events from warning to more severe
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
|
@ -176,7 +171,7 @@ func ExampleNewPipeline() {
|
|||
// In this example, I reconfigure the retry policies, create a new pipeline, and then create a new
|
||||
// ContainerURL object that has the same URL as its parent.
|
||||
po.Retry = RetryOptions{
|
||||
Policy: RetryPolicyFixed, // Use exponential backoff as opposed to linear
|
||||
Policy: RetryPolicyFixed, // Use fixed time backoff
|
||||
MaxTries: 4, // Try at most 3 times to perform the operation (set to 1 to disable retries)
|
||||
TryTimeout: time.Minute * 1, // Maximum time allowed for any single try
|
||||
RetryDelay: time.Second * 5, // Backoff amount for each retry (exponential or linear)
|
||||
|
@ -219,12 +214,12 @@ func ExampleStorageError() {
|
|||
create, err := containerURL.Create(context.Background(), Metadata{}, PublicAccessNone)
|
||||
|
||||
if err != nil { // An error occurred
|
||||
if serr, ok := err.(StorageError); ok { // This error is a Service-specific error
|
||||
if stgErr, ok := err.(StorageError); ok { // This error is a Service-specific error
|
||||
// StorageError also implements net.Error so you could call its Timeout/Temporary methods if you want.
|
||||
switch serr.ServiceCode() { // Compare serviceCode to various ServiceCodeXxx constants
|
||||
switch stgErr.ServiceCode() { // Compare serviceCode to various ServiceCodeXxx constants
|
||||
case ServiceCodeContainerAlreadyExists:
|
||||
// You can also look at the http.Response object that failed.
|
||||
if failedResponse := serr.Response(); failedResponse != nil {
|
||||
if failedResponse := stgErr.Response(); failedResponse != nil {
|
||||
// From the response object, you can get the initiating http.Request object
|
||||
failedRequest := failedResponse.Request
|
||||
_ = failedRequest // Avoid compiler's "declared and not used" error
|
||||
|
@ -249,7 +244,7 @@ func ExampleBlobURLParts() {
|
|||
// Let's start with a URL that identifies a snapshot of a blob in a container.
|
||||
// The URL also contains a Shared Access Signature (SAS):
|
||||
u, _ := url.Parse("https://myaccount.blob.core.windows.net/mycontainter/ReadMe.txt?" +
|
||||
"snapshot=2011-03-09T01:42:34.9360000Z" +
|
||||
"snapshot=2011-03-09T01:42:34Z&" +
|
||||
"sv=2015-02-21&sr=b&st=2111-01-09T01:42:34.936Z&se=2222-03-09T01:42:34.936Z&sp=rw&sip=168.1.5.60-168.1.5.70&" +
|
||||
"spr=https,http&si=myIdentifier&ss=bf&srt=s&sig=92836758923659283652983562==")
|
||||
|
||||
|
@ -259,12 +254,12 @@ func ExampleBlobURLParts() {
|
|||
// Now, we access the parts (this example prints them).
|
||||
fmt.Println(parts.Host, parts.ContainerName, parts.BlobName, parts.Snapshot)
|
||||
sas := parts.SAS
|
||||
fmt.Println(sas.Version, sas.Resource, sas.StartTime, sas.ExpiryTime, sas.Permissions,
|
||||
sas.IPRange, sas.Protocol, sas.Identifier, sas.Services, sas.Signature)
|
||||
fmt.Println(sas.Version(), sas.Resource(), sas.StartTime(), sas.ExpiryTime(), sas.Permissions(),
|
||||
sas.IPRange(), sas.Protocol(), sas.Identifier(), sas.Services(), sas.Signature())
|
||||
|
||||
// You can then change some of the fields and construct a new URL:
|
||||
parts.SAS = SASQueryParameters{} // Remove the SAS query parameters
|
||||
parts.Snapshot = time.Time{} // Remove the snapshot timestamp
|
||||
parts.Snapshot = "" // Remove the snapshot timestamp
|
||||
parts.ContainerName = "othercontainer" // Change the container name
|
||||
// In this example, we'll keep the blob name as is.
|
||||
|
||||
|
@ -284,8 +279,8 @@ func ExampleAccountSASSignatureValues() {
|
|||
|
||||
// Set the desired SAS signature values and sign them with the shared key credentials to get the SAS query parameters.
|
||||
sasQueryParams := AccountSASSignatureValues{
|
||||
Protocol: SASProtocolHTTPS, // Users MUST use HTTPS (not HTTP)
|
||||
ExpiryTime: time.Now().Add(48 * time.Hour), // 48-hours before expiration
|
||||
Protocol: SASProtocolHTTPS, // Users MUST use HTTPS (not HTTP)
|
||||
ExpiryTime: time.Now().UTC().Add(48 * time.Hour), // 48-hours before expiration
|
||||
Permissions: AccountSASPermissions{Read: true, List: true}.String(),
|
||||
Services: AccountSASServices{Blob: true}.String(),
|
||||
ResourceTypes: AccountSASResourceTypes{Container: true, Object: true}.String(),
|
||||
|
@ -305,10 +300,9 @@ func ExampleAccountSASSignatureValues() {
|
|||
serviceURL := NewServiceURL(*u, NewPipeline(NewAnonymousCredential(), PipelineOptions{}))
|
||||
// Now, you can use this serviceURL just like any other to make requests of the resource.
|
||||
|
||||
// If you have a SAS query parameter string, you can parse it into its parts:
|
||||
values, _ := url.ParseQuery(qp)
|
||||
sasQueryParams = NewSASQueryParameters(values, true)
|
||||
fmt.Printf("SAS expiry time=%v", sasQueryParams.ExpiryTime)
|
||||
// You can parse a URL into its constituent parts:
|
||||
blobURLParts := NewBlobURLParts(serviceURL.URL())
|
||||
fmt.Printf("SAS expiry time=%v", blobURLParts.SAS.ExpiryTime())
|
||||
|
||||
_ = serviceURL // Avoid compiler's "declared and not used" error
|
||||
}
|
||||
|
@ -327,8 +321,8 @@ func ExampleBlobSASSignatureValues() {
|
|||
|
||||
// Set the desired SAS signature values and sign them with the shared key credentials to get the SAS query parameters.
|
||||
sasQueryParams := BlobSASSignatureValues{
|
||||
Protocol: SASProtocolHTTPS, // Users MUST use HTTPS (not HTTP)
|
||||
ExpiryTime: time.Now().Add(48 * time.Hour), // 48-hours before expiration
|
||||
Protocol: SASProtocolHTTPS, // Users MUST use HTTPS (not HTTP)
|
||||
ExpiryTime: time.Now().UTC().Add(48 * time.Hour), // 48-hours before expiration
|
||||
ContainerName: containerName,
|
||||
BlobName: blobName,
|
||||
|
||||
|
@ -355,15 +349,14 @@ func ExampleBlobSASSignatureValues() {
|
|||
// Now, you can use this blobURL just like any other to make requests of the resource.
|
||||
|
||||
// If you have a SAS query parameter string, you can parse it into its parts:
|
||||
values, _ := url.ParseQuery(qp)
|
||||
sasQueryParams = NewSASQueryParameters(values, true)
|
||||
fmt.Printf("SAS expiry time=%v", sasQueryParams.ExpiryTime)
|
||||
blobURLParts := NewBlobURLParts(blobURL.URL())
|
||||
fmt.Printf("SAS expiry time=%v", blobURLParts.SAS.ExpiryTime())
|
||||
|
||||
_ = blobURL // Avoid compiler's "declared and not used" error
|
||||
}
|
||||
|
||||
// This example shows how to manipulate a container's permissions.
|
||||
func ExampleContainerURL_SetPermissions() {
|
||||
func ExampleContainerURL_SetContainerAccessPolicy() {
|
||||
// From the Azure portal, get your Storage account's name and account key.
|
||||
accountName, accountKey := accountInfo()
|
||||
|
||||
|
@ -388,7 +381,7 @@ func ExampleContainerURL_SetPermissions() {
|
|||
blobURL := containerURL.NewBlockBlobURL("HelloWorld.txt") // Blob names can be mixed case
|
||||
|
||||
// Create the blob and put some text in it
|
||||
_, err = blobURL.PutBlob(ctx, strings.NewReader("Hello World!"), BlobHTTPHeaders{ContentType: "text/plain"}, Metadata{}, BlobAccessConditions{})
|
||||
_, err = blobURL.Upload(ctx, strings.NewReader("Hello World!"), BlobHTTPHeaders{ContentType: "text/plain"}, Metadata{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -403,7 +396,7 @@ func ExampleContainerURL_SetPermissions() {
|
|||
// We expected this error because the service returns an HTTP 404 status code when a blob
|
||||
// exists but the requester does not have permission to access it.
|
||||
// This is how we change the container's permission to allow public/anonymous aceess:
|
||||
_, err := containerURL.SetPermissions(ctx, PublicAccessBlob, []SignedIdentifier{}, ContainerAccessConditions{})
|
||||
_, err := containerURL.SetAccessPolicy(ctx, PublicAccessBlob, []SignedIdentifier{}, ContainerAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -426,7 +419,7 @@ func ExampleBlobAccessConditions() {
|
|||
accountName, accountKey := accountInfo()
|
||||
|
||||
// Create a BlockBlobURL object that wraps a blob's URL and a default pipeline.
|
||||
u, _ := url.Parse(fmt.Sprintf("https://%s.blob.core.windows.net/mycontainer/Data,txt", accountName))
|
||||
u, _ := url.Parse(fmt.Sprintf("https://%s.blob.core.windows.net/mycontainer/Data.txt", accountName))
|
||||
blobURL := NewBlockBlobURL(*u, NewPipeline(NewSharedKeyCredential(accountName, accountKey), PipelineOptions{}))
|
||||
|
||||
ctx := context.Background() // This example uses a never-expiring context
|
||||
|
@ -434,42 +427,42 @@ func ExampleBlobAccessConditions() {
|
|||
// This helper function displays the results of an operation; it is called frequently below.
|
||||
showResult := func(response pipeline.Response, err error) {
|
||||
if err != nil {
|
||||
if serr, ok := err.(StorageError); !ok {
|
||||
if stgErr, ok := err.(StorageError); !ok {
|
||||
log.Fatal(err) // Network failure
|
||||
} else {
|
||||
fmt.Print("Failure: " + serr.Response().Status + "\n")
|
||||
fmt.Print("Failure: " + stgErr.Response().Status + "\n")
|
||||
}
|
||||
} else {
|
||||
if get, ok := response.(*GetResponse); ok {
|
||||
get.Body().Close() // The client must close the response body when finished with it
|
||||
if get, ok := response.(*DownloadResponse); ok {
|
||||
get.Body(RetryReaderOptions{}).Close() // The client must close the response body when finished with it
|
||||
}
|
||||
fmt.Print("Success: " + response.Response().Status + "\n")
|
||||
}
|
||||
}
|
||||
|
||||
// Create the blob (unconditionally; succeeds)
|
||||
put, err := blobURL.PutBlob(ctx, strings.NewReader("Text-1"), BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
showResult(put, err)
|
||||
upload, err := blobURL.Upload(ctx, strings.NewReader("Text-1"), BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
showResult(upload, err)
|
||||
|
||||
// Download blob content if the blob has been modified since we uploaded it (fails):
|
||||
showResult(blobURL.GetBlob(ctx, BlobRange{},
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfModifiedSince: put.LastModified()}}, false))
|
||||
showResult(blobURL.Download(ctx, 0, 0,
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfModifiedSince: upload.LastModified()}}, false))
|
||||
|
||||
// Download blob content if the blob hasn't been modified in the last 24 hours (fails):
|
||||
showResult(blobURL.GetBlob(ctx, BlobRange{},
|
||||
showResult(blobURL.Download(ctx, 0, 0,
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfUnmodifiedSince: time.Now().UTC().Add(time.Hour * -24)}}, false))
|
||||
|
||||
// Upload new content if the blob hasn't changed since the version identified by ETag (succeeds):
|
||||
put, err = blobURL.PutBlob(ctx, strings.NewReader("Text-2"), BlobHTTPHeaders{}, Metadata{},
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfMatch: put.ETag()}})
|
||||
showResult(put, err)
|
||||
upload, err = blobURL.Upload(ctx, strings.NewReader("Text-2"), BlobHTTPHeaders{}, Metadata{},
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfMatch: upload.ETag()}})
|
||||
showResult(upload, err)
|
||||
|
||||
// Download content if it has changed since the version identified by ETag (fails):
|
||||
showResult(blobURL.GetBlob(ctx, BlobRange{},
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfNoneMatch: put.ETag()}}, false))
|
||||
showResult(blobURL.Download(ctx, 0, 0,
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfNoneMatch: upload.ETag()}}, false))
|
||||
|
||||
// Upload content if the blob doesn't already exist (fails):
|
||||
showResult(blobURL.PutBlob(ctx, strings.NewReader("Text-3"), BlobHTTPHeaders{}, Metadata{},
|
||||
showResult(blobURL.Upload(ctx, strings.NewReader("Text-3"), BlobHTTPHeaders{}, Metadata{},
|
||||
BlobAccessConditions{HTTPAccessConditions: HTTPAccessConditions{IfNoneMatch: ETagAny}}))
|
||||
}
|
||||
|
||||
|
@ -489,13 +482,13 @@ func ExampleMetadata_containers() {
|
|||
// NOTE: Metadata key names are always converted to lowercase before being sent to the Storage Service.
|
||||
// Therefore, you should always use lowercase letters; especially when querying a map for a metadata key.
|
||||
creatingApp, _ := os.Executable()
|
||||
_, err := containerURL.Create(ctx, Metadata{"createdby": "Jeffrey", "app": creatingApp}, PublicAccessNone)
|
||||
_, err := containerURL.Create(ctx, Metadata{"author": "Jeffrey", "app": creatingApp}, PublicAccessNone)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Query the container's metadata
|
||||
get, err := containerURL.GetPropertiesAndMetadata(ctx, LeaseAccessConditions{})
|
||||
get, err := containerURL.GetProperties(ctx, LeaseAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -507,7 +500,7 @@ func ExampleMetadata_containers() {
|
|||
}
|
||||
|
||||
// Update the metadata and write it back to the container
|
||||
metadata["createdby"] = "Aidan" // NOTE: The keyname is in all lowercase letters
|
||||
metadata["author"] = "Aidan" // NOTE: The keyname is in all lowercase letters
|
||||
_, err = containerURL.SetMetadata(ctx, metadata, ContainerAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
|
@ -533,14 +526,14 @@ func ExampleMetadata_blobs() {
|
|||
// NOTE: Metadata key names are always converted to lowercase before being sent to the Storage Service.
|
||||
// Therefore, you should always use lowercase letters; especially when querying a map for a metadata key.
|
||||
creatingApp, _ := os.Executable()
|
||||
_, err := blobURL.PutBlob(ctx, strings.NewReader("Some text"), BlobHTTPHeaders{},
|
||||
Metadata{"createdby": "Jeffrey", "app": creatingApp}, BlobAccessConditions{})
|
||||
_, err := blobURL.Upload(ctx, strings.NewReader("Some text"), BlobHTTPHeaders{},
|
||||
Metadata{"author": "Jeffrey", "app": creatingApp}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Query the blob's properties and metadata
|
||||
get, err := blobURL.GetPropertiesAndMetadata(ctx, BlobAccessConditions{})
|
||||
get, err := blobURL.GetProperties(ctx, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -555,7 +548,7 @@ func ExampleMetadata_blobs() {
|
|||
}
|
||||
|
||||
// Update the blob's metadata and write it back to the blob
|
||||
metadata["updatedby"] = "Grant" // Add a new key/value; NOTE: The keyname is in all lowercase letters
|
||||
metadata["editor"] = "Grant" // Add a new key/value; NOTE: The keyname is in all lowercase letters
|
||||
_, err = blobURL.SetMetadata(ctx, metadata, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
|
@ -578,7 +571,7 @@ func ExampleBlobHTTPHeaders() {
|
|||
ctx := context.Background() // This example uses a never-expiring context
|
||||
|
||||
// Create a blob with HTTP headers
|
||||
_, err := blobURL.PutBlob(ctx, strings.NewReader("Some text"),
|
||||
_, err := blobURL.Upload(ctx, strings.NewReader("Some text"),
|
||||
BlobHTTPHeaders{
|
||||
ContentType: "text/html; charset=utf-8",
|
||||
ContentDisposition: "attachment",
|
||||
|
@ -588,7 +581,7 @@ func ExampleBlobHTTPHeaders() {
|
|||
}
|
||||
|
||||
// GetMetadata returns the blob's properties, HTTP headers, and metadata
|
||||
get, err := blobURL.GetPropertiesAndMetadata(ctx, BlobAccessConditions{})
|
||||
get, err := blobURL.GetProperties(ctx, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -602,7 +595,7 @@ func ExampleBlobHTTPHeaders() {
|
|||
|
||||
// Update the blob's HTTP Headers and write them back to the blob
|
||||
httpHeaders.ContentType = "text/plain"
|
||||
_, err = blobURL.SetProperties(ctx, httpHeaders, BlobAccessConditions{})
|
||||
_, err = blobURL.SetHTTPHeaders(ctx, httpHeaders, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -651,14 +644,14 @@ func ExampleBlockBlobURL() {
|
|||
base64BlockIDs[index] = blockIDIntToBase64(index) // Some people use UUIDs for block IDs
|
||||
|
||||
// Upload a block to this blob specifying the Block ID and its content (up to 100MB); this block is uncommitted.
|
||||
_, err := blobURL.PutBlock(ctx, base64BlockIDs[index], strings.NewReader(word), LeaseAccessConditions{})
|
||||
_, err := blobURL.StageBlock(ctx, base64BlockIDs[index], strings.NewReader(word), LeaseAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// After all the blocks are uploaded, atomically commit them to the blob.
|
||||
_, err := blobURL.PutBlockList(ctx, base64BlockIDs, Metadata{}, BlobHTTPHeaders{}, BlobAccessConditions{})
|
||||
_, err := blobURL.CommitBlockList(ctx, base64BlockIDs, BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -674,13 +667,14 @@ func ExampleBlockBlobURL() {
|
|||
|
||||
// Download the blob in its entirety; download operations do not take blocks into account.
|
||||
// NOTE: For really large blobs, downloading them like allocates a lot of memory.
|
||||
get, err := blobURL.GetBlob(ctx, BlobRange{}, BlobAccessConditions{}, false)
|
||||
get, err := blobURL.Download(ctx, 0, 0, BlobAccessConditions{}, false)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
blobData := &bytes.Buffer{}
|
||||
blobData.ReadFrom(get.Body())
|
||||
get.Body().Close() // The client must close the response body when finished with it
|
||||
reader := get.Body(RetryReaderOptions{})
|
||||
blobData.ReadFrom(reader)
|
||||
reader.Close() // The client must close the response body when finished with it
|
||||
fmt.Println(blobData)
|
||||
}
|
||||
|
||||
|
@ -696,7 +690,7 @@ func ExampleAppendBlobURL() {
|
|||
appendBlobURL := NewAppendBlobURL(*u, NewPipeline(NewSharedKeyCredential(accountName, accountKey), PipelineOptions{}))
|
||||
|
||||
ctx := context.Background() // This example uses a never-expiring context
|
||||
_, err := appendBlobURL.Create(ctx, Metadata{}, BlobHTTPHeaders{}, BlobAccessConditions{})
|
||||
_, err := appendBlobURL.Create(ctx, BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -709,13 +703,14 @@ func ExampleAppendBlobURL() {
|
|||
}
|
||||
|
||||
// Download the entire append blob's contents and show it.
|
||||
get, err := appendBlobURL.GetBlob(ctx, BlobRange{}, BlobAccessConditions{}, false)
|
||||
get, err := appendBlobURL.Download(ctx, 0, 0, BlobAccessConditions{}, false)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
b := bytes.Buffer{}
|
||||
b.ReadFrom(get.Body())
|
||||
get.Body().Close() // The client must close the response body when finished with it
|
||||
reader := get.Body(RetryReaderOptions{})
|
||||
b.ReadFrom(reader)
|
||||
reader.Close() // The client must close the response body when finished with it
|
||||
fmt.Println(b.String())
|
||||
}
|
||||
|
||||
|
@ -730,27 +725,25 @@ func ExamplePageBlobURL() {
|
|||
NewPipeline(NewSharedKeyCredential(accountName, accountKey), PipelineOptions{}))
|
||||
|
||||
ctx := context.Background() // This example uses a never-expiring context
|
||||
_, err := blobURL.Create(ctx, PageBlobPageBytes*4, 0, Metadata{}, BlobHTTPHeaders{}, BlobAccessConditions{})
|
||||
_, err := blobURL.Create(ctx, PageBlobPageBytes*4, 0, BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
page := [PageBlobPageBytes]byte{}
|
||||
copy(page[:], "Page 0")
|
||||
_, err = blobURL.PutPages(ctx, PageRange{Start: 0 * PageBlobPageBytes, End: 1*PageBlobPageBytes - 1},
|
||||
bytes.NewReader(page[:]), BlobAccessConditions{})
|
||||
_, err = blobURL.UploadPages(ctx, 0*PageBlobPageBytes, bytes.NewReader(page[:]), BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
copy(page[:], "Page 1")
|
||||
_, err = blobURL.PutPages(ctx, PageRange{Start: 2 * PageBlobPageBytes, End: 3*PageBlobPageBytes - 1},
|
||||
bytes.NewReader(page[:]), BlobAccessConditions{})
|
||||
_, err = blobURL.UploadPages(ctx, 2*PageBlobPageBytes, bytes.NewReader(page[:]), BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
getPages, err := blobURL.GetPageRanges(ctx, BlobRange{Offset: 0 * PageBlobPageBytes, Count: 10*PageBlobPageBytes - 1}, BlobAccessConditions{})
|
||||
getPages, err := blobURL.GetPageRanges(ctx, 0*PageBlobPageBytes, 10*PageBlobPageBytes, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -758,12 +751,12 @@ func ExamplePageBlobURL() {
|
|||
fmt.Printf("Start=%d, End=%d\n", pr.Start, pr.End)
|
||||
}
|
||||
|
||||
_, err = blobURL.ClearPages(ctx, PageRange{Start: 0 * PageBlobPageBytes, End: 1*PageBlobPageBytes - 1}, BlobAccessConditions{})
|
||||
_, err = blobURL.ClearPages(ctx, 0*PageBlobPageBytes, 1*PageBlobPageBytes, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
getPages, err = blobURL.GetPageRanges(ctx, BlobRange{Offset: 0 * PageBlobPageBytes, Count: 10*PageBlobPageBytes - 1}, BlobAccessConditions{})
|
||||
getPages, err = blobURL.GetPageRanges(ctx, 0*PageBlobPageBytes, 10*PageBlobPageBytes, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -771,13 +764,14 @@ func ExamplePageBlobURL() {
|
|||
fmt.Printf("Start=%d, End=%d\n", pr.Start, pr.End)
|
||||
}
|
||||
|
||||
get, err := blobURL.GetBlob(ctx, BlobRange{}, BlobAccessConditions{}, false)
|
||||
get, err := blobURL.Download(ctx, 0, 0, BlobAccessConditions{}, false)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
blobData := &bytes.Buffer{}
|
||||
blobData.ReadFrom(get.Body())
|
||||
get.Body().Close() // The client must close the response body when finished with it
|
||||
reader := get.Body(RetryReaderOptions{})
|
||||
blobData.ReadFrom(reader)
|
||||
reader.Close() // The client must close the response body when finished with it
|
||||
fmt.Printf("%#v", blobData.Bytes())
|
||||
}
|
||||
|
||||
|
@ -798,7 +792,7 @@ func Example_blobSnapshots() {
|
|||
ctx := context.Background() // This example uses a never-expiring context
|
||||
|
||||
// Create the original blob:
|
||||
_, err := baseBlobURL.PutBlob(ctx, strings.NewReader("Some text"), BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
_, err := baseBlobURL.Upload(ctx, strings.NewReader("Some text"), BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -808,33 +802,35 @@ func Example_blobSnapshots() {
|
|||
snapshot := createSnapshot.Snapshot()
|
||||
|
||||
// Modify the original blob & show it:
|
||||
_, err = baseBlobURL.PutBlob(ctx, strings.NewReader("New text"), BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
_, err = baseBlobURL.Upload(ctx, strings.NewReader("New text"), BlobHTTPHeaders{}, Metadata{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
get, err := baseBlobURL.GetBlob(ctx, BlobRange{}, BlobAccessConditions{}, false)
|
||||
get, err := baseBlobURL.Download(ctx, 0, 0, BlobAccessConditions{}, false)
|
||||
b := bytes.Buffer{}
|
||||
b.ReadFrom(get.Body())
|
||||
get.Body().Close() // The client must close the response body when finished with it
|
||||
reader := get.Body(RetryReaderOptions{})
|
||||
b.ReadFrom(reader)
|
||||
reader.Close() // The client must close the response body when finished with it
|
||||
fmt.Println(b.String())
|
||||
|
||||
// Show snapshot blob via original blob URI & snapshot time:
|
||||
snapshotBlobURL := baseBlobURL.WithSnapshot(snapshot)
|
||||
get, err = snapshotBlobURL.GetBlob(ctx, BlobRange{}, BlobAccessConditions{}, false)
|
||||
get, err = snapshotBlobURL.Download(ctx, 0, 0, BlobAccessConditions{}, false)
|
||||
b.Reset()
|
||||
b.ReadFrom(get.Body())
|
||||
get.Body().Close() // The client must close the response body when finished with it
|
||||
reader = get.Body(RetryReaderOptions{})
|
||||
b.ReadFrom(reader)
|
||||
reader.Close() // The client must close the response body when finished with it
|
||||
fmt.Println(b.String())
|
||||
|
||||
// FYI: You can get the base blob URL from one of its snapshot by passing time.Time{} to WithSnapshot:
|
||||
baseBlobURL = snapshotBlobURL.WithSnapshot(time.Time{})
|
||||
// FYI: You can get the base blob URL from one of its snapshot by passing "" to WithSnapshot:
|
||||
baseBlobURL = snapshotBlobURL.WithSnapshot("")
|
||||
|
||||
// Show all blobs in the container with their snapshots:
|
||||
// List the blob(s) in our container; since a container may hold millions of blobs, this is done 1 segment at a time.
|
||||
for marker := (Marker{}); marker.NotDone(); { // The parens around Marker{} are required to avoid compiler error.
|
||||
// Get a result segment starting with the blob indicated by the current Marker.
|
||||
listBlobs, err := containerURL.ListBlobs(ctx, marker, ListBlobsOptions{
|
||||
listBlobs, err := containerURL.ListBlobsFlatSegment(ctx, marker, ListBlobsSegmentOptions{
|
||||
Details: BlobListingDetails{Snapshots: true}})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
|
@ -846,15 +842,15 @@ func Example_blobSnapshots() {
|
|||
// Process the blobs returned in this result segment (if the segment is empty, the loop body won't execute)
|
||||
for _, blobInfo := range listBlobs.Blobs.Blob {
|
||||
snaptime := "N/A"
|
||||
if !blobInfo.Snapshot.IsZero() {
|
||||
snaptime = blobInfo.Snapshot.String()
|
||||
if blobInfo.Snapshot != "" {
|
||||
snaptime = blobInfo.Snapshot
|
||||
}
|
||||
fmt.Printf("Blob name: %s, Snapshot: %s\n", blobInfo.Name, snaptime)
|
||||
}
|
||||
}
|
||||
|
||||
// Promote read-only snapshot to writable base blob:
|
||||
_, err = baseBlobURL.StartCopy(ctx, snapshotBlobURL.URL(), Metadata{}, BlobAccessConditions{}, BlobAccessConditions{})
|
||||
_, err = baseBlobURL.StartCopyFromURL(ctx, snapshotBlobURL.URL(), Metadata{}, BlobAccessConditions{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -889,7 +885,7 @@ func Example_progressUploadDownload() {
|
|||
requestBody := strings.NewReader("Some text to write")
|
||||
|
||||
// Wrap the request body in a RequestBodyProgress and pass a callback function for progress reporting.
|
||||
_, err := blobURL.PutBlob(ctx,
|
||||
_, err := blobURL.Upload(ctx,
|
||||
pipeline.NewRequestBodyProgress(requestBody, func(bytesTransferred int64) {
|
||||
fmt.Printf("Wrote %d of %d bytes.", bytesTransferred, requestBody.Len())
|
||||
}),
|
||||
|
@ -902,14 +898,16 @@ func Example_progressUploadDownload() {
|
|||
}
|
||||
|
||||
// Here's how to read the blob's data with progress reporting:
|
||||
get, err := blobURL.GetBlob(ctx, BlobRange{}, BlobAccessConditions{}, false)
|
||||
get, err := blobURL.Download(ctx, 0, 0, BlobAccessConditions{}, false)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Wrap the response body in a ResponseBodyProgress and pass a callback function for progress reporting.
|
||||
responseBody := pipeline.NewResponseBodyProgress(get.Body(), func(bytesTransferred int64) {
|
||||
fmt.Printf("Read %d of %d bytes.", bytesTransferred, get.ContentLength())
|
||||
})
|
||||
responseBody := pipeline.NewResponseBodyProgress(get.Body(RetryReaderOptions{}),
|
||||
func(bytesTransferred int64) {
|
||||
fmt.Printf("Read %d of %d bytes.", bytesTransferred, get.ContentLength())
|
||||
})
|
||||
|
||||
downloadedData := &bytes.Buffer{}
|
||||
downloadedData.ReadFrom(responseBody)
|
||||
|
@ -931,18 +929,16 @@ func ExampleBlobURL_startCopy() {
|
|||
ctx := context.Background() // This example uses a never-expiring context
|
||||
|
||||
src, _ := url.Parse("https://cdn2.auth0.com/docs/media/addons/azure_blob.svg")
|
||||
startCopy, err := blobURL.StartCopy(ctx, *src, nil, BlobAccessConditions{}, BlobAccessConditions{})
|
||||
startCopy, err := blobURL.StartCopyFromURL(ctx, *src, nil, BlobAccessConditions{}, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
//abortCopy, err := blobURL.AbortCopy(ct, copyID, LeaseAccessConditions{})
|
||||
|
||||
copyID := startCopy.CopyID()
|
||||
copyStatus := startCopy.CopyStatus()
|
||||
for copyStatus == CopyStatusPending {
|
||||
time.Sleep(time.Second * 2)
|
||||
getMetadata, err := blobURL.GetPropertiesAndMetadata(ctx, BlobAccessConditions{})
|
||||
getMetadata, err := blobURL.GetProperties(ctx, BlobAccessConditions{})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
@ -1000,18 +996,11 @@ func ExampleNewDownloadStream() {
|
|||
contentLength := int64(0) // Used for progress reporting to report the total number of bytes being downloaded.
|
||||
|
||||
// NewGetRetryStream creates an intelligent retryable stream around a blob; it returns an io.ReadCloser.
|
||||
rs := NewDownloadStream(context.Background(),
|
||||
// We pass more tha "blobUrl.GetBlob" here so we can capture the blob's full
|
||||
// content length on the very first internal call to Read.
|
||||
func(ctx context.Context, blobRange BlobRange, ac BlobAccessConditions, rangeGetContentMD5 bool) (*GetResponse, error) {
|
||||
get, err := blobURL.GetBlob(ctx, blobRange, ac, rangeGetContentMD5)
|
||||
if err == nil && contentLength == 0 {
|
||||
// If 1st successful Get, record blob's full size for progress reporting
|
||||
contentLength = get.ContentLength()
|
||||
}
|
||||
return get, err
|
||||
},
|
||||
DownloadStreamOptions{})
|
||||
dr, err := blobURL.Download(context.TODO(), 0, -1, BlobAccessConditions{}, false)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
rs := dr.Body(RetryReaderOptions{})
|
||||
|
||||
// NewResponseBodyStream wraps the GetRetryStream with progress reporting; it returns an io.ReadCloser.
|
||||
stream := pipeline.NewResponseBodyProgress(rs,
|
||||
|
|
|
@ -1,204 +1,204 @@
|
|||
package azblob_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
chk "gopkg.in/check.v1"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"github.com/Azure/azure-storage-blob-go/2016-05-31/azblob"
|
||||
)
|
||||
|
||||
// For testing docs, see: https://labix.org/gocheck
|
||||
// To test a specific test: go test -check.f MyTestSuite
|
||||
|
||||
type retryTestScenario int32
|
||||
|
||||
const (
|
||||
// Retry until success. Max reties hit. Operation time out prevents additional retries
|
||||
retryTestScenarioRetryUntilSuccess retryTestScenario = 1
|
||||
retryTestScenarioRetryUntilOperationCancel retryTestScenario = 2
|
||||
retryTestScenarioRetryUntilMaxRetries retryTestScenario = 3
|
||||
)
|
||||
|
||||
func (s *aztestsSuite) TestRetryTestScenarioUntilSuccess(c *chk.C) {
|
||||
testRetryTestScenario(c, retryTestScenarioRetryUntilSuccess)
|
||||
}
|
||||
|
||||
func (s *aztestsSuite) TestRetryTestScenarioUntilOperationCancel(c *chk.C) {
|
||||
testRetryTestScenario(c, retryTestScenarioRetryUntilOperationCancel)
|
||||
}
|
||||
func (s *aztestsSuite) TestRetryTestScenarioUntilMaxRetries(c *chk.C) {
|
||||
testRetryTestScenario(c, retryTestScenarioRetryUntilMaxRetries)
|
||||
}
|
||||
func newRetryTestPolicyFactory(c *chk.C, scenario retryTestScenario, maxRetries int32, cancel context.CancelFunc) *retryTestPolicyFactory {
|
||||
return &retryTestPolicyFactory{c: c, scenario: scenario, maxRetries: maxRetries, cancel: cancel}
|
||||
}
|
||||
|
||||
type retryTestPolicyFactory struct {
|
||||
c *chk.C
|
||||
scenario retryTestScenario
|
||||
maxRetries int32
|
||||
cancel context.CancelFunc
|
||||
try int32
|
||||
}
|
||||
|
||||
func (f *retryTestPolicyFactory) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
|
||||
f.try = 0 // Reset this for each test
|
||||
return &retryTestPolicy{factory: f, next: next}
|
||||
}
|
||||
|
||||
type retryTestPolicy struct {
|
||||
next pipeline.Policy
|
||||
factory *retryTestPolicyFactory
|
||||
}
|
||||
|
||||
type retryError struct {
|
||||
temporary, timeout bool
|
||||
}
|
||||
|
||||
func (e *retryError) Temporary() bool { return e.temporary }
|
||||
func (e *retryError) Timeout() bool { return e.timeout }
|
||||
func (e *retryError) Error() string {
|
||||
return fmt.Sprintf("Temporary=%t, Timeout=%t", e.Temporary(), e.Timeout())
|
||||
}
|
||||
|
||||
type httpResponse struct {
|
||||
response *http.Response
|
||||
}
|
||||
|
||||
func (r *httpResponse) Response() *http.Response { return r.response }
|
||||
|
||||
func (p *retryTestPolicy) Do(ctx context.Context, request pipeline.Request) (response pipeline.Response, err error) {
|
||||
c := p.factory.c
|
||||
p.factory.try++ // Increment the try
|
||||
c.Assert(p.factory.try <= p.factory.maxRetries, chk.Equals, true) // Ensure # of tries < MaxRetries
|
||||
req := request.Request
|
||||
|
||||
// Validate the expected pre-conditions for each try
|
||||
expectedHost := "PrimaryDC"
|
||||
if p.factory.try%2 == 0 {
|
||||
if p.factory.scenario != retryTestScenarioRetryUntilSuccess || p.factory.try <= 4 {
|
||||
expectedHost = "SecondaryDC"
|
||||
}
|
||||
}
|
||||
c.Assert(req.URL.Host, chk.Equals, expectedHost) // Ensure we got the expected primary/secondary DC
|
||||
|
||||
// Ensure that any headers & query parameters this method adds (later) are removed/reset for each try
|
||||
c.Assert(req.Header.Get("TestHeader"), chk.Equals, "") // Ensure our "TestHeader" is not in the HTTP request
|
||||
values := req.URL.Query()
|
||||
c.Assert(len(values["TestQueryParam"]), chk.Equals, 0) // TestQueryParam shouldn't be in the HTTP request
|
||||
|
||||
if seeker, ok := req.Body.(io.ReadSeeker); !ok {
|
||||
c.Fail() // Body must be an io.ReadSeeker
|
||||
} else {
|
||||
pos, err := seeker.Seek(0, io.SeekCurrent)
|
||||
c.Assert(err, chk.IsNil) // Ensure that body was seekable
|
||||
c.Assert(pos, chk.Equals, int64(0)) // Ensure body seeked back to position 0
|
||||
}
|
||||
|
||||
// Add a query param & header; these not be here on the next try
|
||||
values["TestQueryParam"] = []string{"TestQueryParamValue"}
|
||||
req.Header.Set("TestHeader", "TestValue") // Add a header this not exist with each try
|
||||
b := []byte{0}
|
||||
n, err := req.Body.Read(b)
|
||||
c.Assert(n, chk.Equals, 1) // Read failed
|
||||
|
||||
switch p.factory.scenario {
|
||||
case retryTestScenarioRetryUntilSuccess:
|
||||
switch p.factory.try {
|
||||
case 1:
|
||||
if deadline, ok := ctx.Deadline(); ok {
|
||||
time.Sleep(time.Until(deadline) + time.Second) // Let the context timeout expire
|
||||
}
|
||||
err = ctx.Err()
|
||||
case 2:
|
||||
err = &retryError{temporary: true}
|
||||
case 3:
|
||||
err = &retryError{timeout: true}
|
||||
case 4:
|
||||
response = &httpResponse{response: &http.Response{StatusCode: http.StatusNotFound}}
|
||||
case 5:
|
||||
err = &retryError{temporary: true} // These attempts all fail but we're making sure we never see the secondary DC again
|
||||
case 6:
|
||||
response = &httpResponse{response: &http.Response{StatusCode: http.StatusOK}} // Stop retries with valid response
|
||||
default:
|
||||
c.Fail() // Retries should have stopped so we shouldn't get here
|
||||
}
|
||||
case retryTestScenarioRetryUntilOperationCancel:
|
||||
switch p.factory.try {
|
||||
case 1:
|
||||
p.factory.cancel()
|
||||
err = context.Canceled
|
||||
default:
|
||||
c.Fail() // Retries should have stopped so we shouldn't get here
|
||||
}
|
||||
case retryTestScenarioRetryUntilMaxRetries:
|
||||
err = &retryError{temporary: true} // Keep retrying until maxRetries is hit
|
||||
}
|
||||
return response, err // Return the response & err
|
||||
}
|
||||
|
||||
func testRetryTestScenario(c *chk.C, scenario retryTestScenario) {
|
||||
u, _ := url.Parse("http://PrimaryDC")
|
||||
retryOptions := azblob.RetryOptions{
|
||||
Policy: azblob.RetryPolicyExponential,
|
||||
MaxTries: 6,
|
||||
TryTimeout: 2 * time.Second,
|
||||
RetryDelay: 1 * time.Second,
|
||||
MaxRetryDelay: 4 * time.Second,
|
||||
RetryReadsFromSecondaryHost: "SecondaryDC",
|
||||
}
|
||||
ctx := context.Background()
|
||||
ctx, cancel := context.WithTimeout(ctx, 64 /*2^MaxTries(6)*/ *retryOptions.TryTimeout)
|
||||
retrytestPolicyFactory := newRetryTestPolicyFactory(c, scenario, retryOptions.MaxTries, cancel)
|
||||
factories := [...]pipeline.Factory{
|
||||
azblob.NewRetryPolicyFactory(retryOptions),
|
||||
retrytestPolicyFactory,
|
||||
}
|
||||
p := pipeline.NewPipeline(factories[:], pipeline.Options{})
|
||||
request, err := pipeline.NewRequest(http.MethodGet, *u, strings.NewReader("TestData"))
|
||||
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
|
||||
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
|
||||
c.Assert(retrytestPolicyFactory.try <= retryOptions.MaxTries, chk.Equals, true) // Ensure we didn't end due to reaching max tries
|
||||
}
|
||||
cancel()
|
||||
}
|
||||
|
||||
/*
|
||||
Fail primary; retry should be on secondary URL - maybe do this twice
|
||||
Fail secondary; and never see primary again
|
||||
|
||||
Make sure any mutations are lost on each retry
|
||||
Make sure body is reset on each retry
|
||||
|
||||
Timeout a try; should retry (unless no more)
|
||||
timeout an operation; should not retry
|
||||
check timeout query param; should be try timeout
|
||||
|
||||
Return Temporary() = true; should retry (unless max)
|
||||
Return Timeout() true; should retry (unless max)
|
||||
|
||||
Secondary try returns 404; no more tries against secondary
|
||||
|
||||
error where Temporary() and Timeout() return false; no retry
|
||||
error where Temporary() & Timeout don't exist; no retry
|
||||
no error; no retry; return success, nil
|
||||
*/
|
||||
package azblob_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
chk "gopkg.in/check.v1"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"github.com/Azure/azure-storage-blob-go/2016-05-31/azblob"
|
||||
)
|
||||
|
||||
// For testing docs, see: https://labix.org/gocheck
|
||||
// To test a specific test: go test -check.f MyTestSuite
|
||||
|
||||
type retryTestScenario int32
|
||||
|
||||
const (
|
||||
// Retry until success. Max reties hit. Operation time out prevents additional retries
|
||||
retryTestScenarioRetryUntilSuccess retryTestScenario = 1
|
||||
retryTestScenarioRetryUntilOperationCancel retryTestScenario = 2
|
||||
retryTestScenarioRetryUntilMaxRetries retryTestScenario = 3
|
||||
)
|
||||
|
||||
func (s *aztestsSuite) TestRetryTestScenarioUntilSuccess(c *chk.C) {
|
||||
testRetryTestScenario(c, retryTestScenarioRetryUntilSuccess)
|
||||
}
|
||||
|
||||
func (s *aztestsSuite) TestRetryTestScenarioUntilOperationCancel(c *chk.C) {
|
||||
testRetryTestScenario(c, retryTestScenarioRetryUntilOperationCancel)
|
||||
}
|
||||
func (s *aztestsSuite) TestRetryTestScenarioUntilMaxRetries(c *chk.C) {
|
||||
testRetryTestScenario(c, retryTestScenarioRetryUntilMaxRetries)
|
||||
}
|
||||
func newRetryTestPolicyFactory(c *chk.C, scenario retryTestScenario, maxRetries int32, cancel context.CancelFunc) *retryTestPolicyFactory {
|
||||
return &retryTestPolicyFactory{c: c, scenario: scenario, maxRetries: maxRetries, cancel: cancel}
|
||||
}
|
||||
|
||||
type retryTestPolicyFactory struct {
|
||||
c *chk.C
|
||||
scenario retryTestScenario
|
||||
maxRetries int32
|
||||
cancel context.CancelFunc
|
||||
try int32
|
||||
}
|
||||
|
||||
func (f *retryTestPolicyFactory) New(next pipeline.Policy, po *pipeline.PolicyOptions) pipeline.Policy {
|
||||
f.try = 0 // Reset this for each test
|
||||
return &retryTestPolicy{factory: f, next: next}
|
||||
}
|
||||
|
||||
type retryTestPolicy struct {
|
||||
next pipeline.Policy
|
||||
factory *retryTestPolicyFactory
|
||||
}
|
||||
|
||||
type retryError struct {
|
||||
temporary, timeout bool
|
||||
}
|
||||
|
||||
func (e *retryError) Temporary() bool { return e.temporary }
|
||||
func (e *retryError) Timeout() bool { return e.timeout }
|
||||
func (e *retryError) Error() string {
|
||||
return fmt.Sprintf("Temporary=%t, Timeout=%t", e.Temporary(), e.Timeout())
|
||||
}
|
||||
|
||||
type httpResponse struct {
|
||||
response *http.Response
|
||||
}
|
||||
|
||||
func (r *httpResponse) Response() *http.Response { return r.response }
|
||||
|
||||
func (p *retryTestPolicy) Do(ctx context.Context, request pipeline.Request) (response pipeline.Response, err error) {
|
||||
c := p.factory.c
|
||||
p.factory.try++ // Increment the try
|
||||
c.Assert(p.factory.try <= p.factory.maxRetries, chk.Equals, true) // Ensure # of tries < MaxRetries
|
||||
req := request.Request
|
||||
|
||||
// Validate the expected pre-conditions for each try
|
||||
expectedHost := "PrimaryDC"
|
||||
if p.factory.try%2 == 0 {
|
||||
if p.factory.scenario != retryTestScenarioRetryUntilSuccess || p.factory.try <= 4 {
|
||||
expectedHost = "SecondaryDC"
|
||||
}
|
||||
}
|
||||
c.Assert(req.URL.Host, chk.Equals, expectedHost) // Ensure we got the expected primary/secondary DC
|
||||
|
||||
// Ensure that any headers & query parameters this method adds (later) are removed/reset for each try
|
||||
c.Assert(req.Header.Get("TestHeader"), chk.Equals, "") // Ensure our "TestHeader" is not in the HTTP request
|
||||
values := req.URL.Query()
|
||||
c.Assert(len(values["TestQueryParam"]), chk.Equals, 0) // TestQueryParam shouldn't be in the HTTP request
|
||||
|
||||
if seeker, ok := req.Body.(io.ReadSeeker); !ok {
|
||||
c.Fail() // Body must be an io.ReadSeeker
|
||||
} else {
|
||||
pos, err := seeker.Seek(0, io.SeekCurrent)
|
||||
c.Assert(err, chk.IsNil) // Ensure that body was seekable
|
||||
c.Assert(pos, chk.Equals, int64(0)) // Ensure body seeked back to position 0
|
||||
}
|
||||
|
||||
// Add a query param & header; these not be here on the next try
|
||||
values["TestQueryParam"] = []string{"TestQueryParamValue"}
|
||||
req.Header.Set("TestHeader", "TestValue") // Add a header this not exist with each try
|
||||
b := []byte{0}
|
||||
n, err := req.Body.Read(b)
|
||||
c.Assert(n, chk.Equals, 1) // Read failed
|
||||
|
||||
switch p.factory.scenario {
|
||||
case retryTestScenarioRetryUntilSuccess:
|
||||
switch p.factory.try {
|
||||
case 1:
|
||||
if deadline, ok := ctx.Deadline(); ok {
|
||||
time.Sleep(time.Until(deadline) + time.Second) // Let the context timeout expire
|
||||
}
|
||||
err = ctx.Err()
|
||||
case 2:
|
||||
err = &retryError{temporary: true}
|
||||
case 3:
|
||||
err = &retryError{timeout: true}
|
||||
case 4:
|
||||
response = &httpResponse{response: &http.Response{StatusCode: http.StatusNotFound}}
|
||||
case 5:
|
||||
err = &retryError{temporary: true} // These attempts all fail but we're making sure we never see the secondary DC again
|
||||
case 6:
|
||||
response = &httpResponse{response: &http.Response{StatusCode: http.StatusOK}} // Stop retries with valid response
|
||||
default:
|
||||
c.Fail() // Retries should have stopped so we shouldn't get here
|
||||
}
|
||||
case retryTestScenarioRetryUntilOperationCancel:
|
||||
switch p.factory.try {
|
||||
case 1:
|
||||
p.factory.cancel()
|
||||
err = context.Canceled
|
||||
default:
|
||||
c.Fail() // Retries should have stopped so we shouldn't get here
|
||||
}
|
||||
case retryTestScenarioRetryUntilMaxRetries:
|
||||
err = &retryError{temporary: true} // Keep retrying until maxRetries is hit
|
||||
}
|
||||
return response, err // Return the response & err
|
||||
}
|
||||
|
||||
func testRetryTestScenario(c *chk.C, scenario retryTestScenario) {
|
||||
u, _ := url.Parse("http://PrimaryDC")
|
||||
retryOptions := azblob.RetryOptions{
|
||||
Policy: azblob.RetryPolicyExponential,
|
||||
MaxTries: 6,
|
||||
TryTimeout: 2 * time.Second,
|
||||
RetryDelay: 1 * time.Second,
|
||||
MaxRetryDelay: 4 * time.Second,
|
||||
RetryReadsFromSecondaryHost: "SecondaryDC",
|
||||
}
|
||||
ctx := context.Background()
|
||||
ctx, cancel := context.WithTimeout(ctx, 64 /*2^MaxTries(6)*/ *retryOptions.TryTimeout)
|
||||
retrytestPolicyFactory := newRetryTestPolicyFactory(c, scenario, retryOptions.MaxTries, cancel)
|
||||
factories := [...]pipeline.Factory{
|
||||
azblob.NewRetryPolicyFactory(retryOptions),
|
||||
retrytestPolicyFactory,
|
||||
}
|
||||
p := pipeline.NewPipeline(factories[:], pipeline.Options{})
|
||||
request, err := pipeline.NewRequest(http.MethodGet, *u, strings.NewReader("TestData"))
|
||||
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
|
||||
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
|
||||
c.Assert(retrytestPolicyFactory.try <= retryOptions.MaxTries, chk.Equals, true) // Ensure we didn't end due to reaching max tries
|
||||
}
|
||||
cancel()
|
||||
}
|
||||
|
||||
/*
|
||||
Fail primary; retry should be on secondary URL - maybe do this twice
|
||||
Fail secondary; and never see primary again
|
||||
|
||||
Make sure any mutations are lost on each retry
|
||||
Make sure body is reset on each retry
|
||||
|
||||
Timeout a try; should retry (unless no more)
|
||||
timeout an operation; should not retry
|
||||
check timeout query param; should be try timeout
|
||||
|
||||
Return Temporary() = true; should retry (unless max)
|
||||
Return Timeout() true; should retry (unless max)
|
||||
|
||||
Secondary try returns 404; no more tries against secondary
|
||||
|
||||
error where Temporary() and Timeout() return false; no retry
|
||||
error where Temporary() & Timeout don't exist; no retry
|
||||
no error; no retry; return success, nil
|
||||
*/
|
||||
|
|
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
@ -18,7 +18,7 @@ func (b *AppendBlobURLSuite) TestAppendBlock(c *chk.C) {
|
|||
|
||||
blob := container.NewAppendBlobURL(generateBlobName())
|
||||
|
||||
resp, err := blob.Create(context.Background(), nil, azblob.BlobHTTPHeaders{}, azblob.BlobAccessConditions{})
|
||||
resp, err := blob.Create(context.Background(), azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.StatusCode(), chk.Equals, 201)
|
||||
|
||||
|
@ -26,7 +26,7 @@ func (b *AppendBlobURLSuite) TestAppendBlock(c *chk.C) {
|
|||
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, "1")
|
||||
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), "")
|
||||
|
@ -37,5 +37,5 @@ func (b *AppendBlobURLSuite) TestAppendBlock(c *chk.C) {
|
|||
appendResp, err = blob.AppendBlock(context.Background(), getReaderToRandomBytes(1024), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(appendResp.BlobAppendOffset(), chk.Equals, "1024")
|
||||
c.Assert(appendResp.BlobCommittedBlockCount(), chk.Equals, "2")
|
||||
c.Assert(appendResp.BlobCommittedBlockCount(), chk.Equals, int32(2))
|
||||
}
|
||||
|
|
|
@ -38,7 +38,7 @@ func (b *BlobURLSuite) TestCreateDelete(c *chk.C) {
|
|||
|
||||
blob := container.NewBlockBlobURL(generateBlobName())
|
||||
|
||||
putResp, err := blob.PutBlob(context.Background(), nil, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
putResp, err := blob.Upload(context.Background(), nil, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(putResp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(putResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
|
@ -67,12 +67,12 @@ func (b *BlobURLSuite) TestGetSetProperties(c *chk.C) {
|
|||
ContentType: "mytype",
|
||||
ContentLanguage: "martian",
|
||||
}
|
||||
setResp, err := blob.SetProperties(context.Background(), properties, azblob.BlobAccessConditions{})
|
||||
setResp, err := blob.SetHTTPHeaders(context.Background(), properties, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(setResp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(setResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(setResp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(setResp.BlobSequenceNumber(), chk.Equals, "")
|
||||
c.Assert(setResp.BlobSequenceNumber(), chk.Equals, int64(-1))
|
||||
c.Assert(setResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(setResp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(setResp.Date().IsZero(), chk.Equals, false)
|
||||
|
@ -128,7 +128,7 @@ func (b *BlobURLSuite) TestGetSetMetadata(c *chk.C) {
|
|||
c.Assert(setResp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(setResp.Date().IsZero(), chk.Equals, false)
|
||||
|
||||
getResp, err := blob.GetPropertiesAndMetadata(context.Background(), azblob.BlobAccessConditions{})
|
||||
getResp, err := blob.GetProperties(context.Background(), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(getResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(getResp.LastModified().IsZero(), chk.Equals, false)
|
||||
|
@ -145,11 +145,11 @@ func (b *BlobURLSuite) TestCopy(c *chk.C) {
|
|||
defer delContainer(c, container)
|
||||
|
||||
sourceBlob, _ := createNewBlockBlob(c, container)
|
||||
_, err := sourceBlob.PutBlob(context.Background(), getReaderToRandomBytes(2048), azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
_, err := sourceBlob.Upload(context.Background(), getReaderToRandomBytes(2048), azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
destBlob, _ := createNewBlockBlob(c, container)
|
||||
copyResp, err := destBlob.StartCopy(context.Background(), sourceBlob.URL(), nil, azblob.BlobAccessConditions{}, azblob.BlobAccessConditions{})
|
||||
copyResp, err := destBlob.StartCopyFromURL(context.Background(), sourceBlob.URL(), nil, azblob.BlobAccessConditions{}, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(copyResp.Response().StatusCode, chk.Equals, 202)
|
||||
c.Assert(copyResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
|
@ -160,7 +160,7 @@ func (b *BlobURLSuite) TestCopy(c *chk.C) {
|
|||
c.Assert(copyResp.CopyID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(copyResp.CopyStatus(), chk.Not(chk.Equals), "")
|
||||
|
||||
abortResp, err := destBlob.AbortCopy(context.Background(), copyResp.CopyID(), azblob.LeaseAccessConditions{})
|
||||
abortResp, err := destBlob.AbortCopyFromURL(context.Background(), copyResp.CopyID(), azblob.LeaseAccessConditions{})
|
||||
// small copy completes before we have time to abort so check for failure case
|
||||
c.Assert(err, chk.NotNil)
|
||||
c.Assert(abortResp, chk.IsNil)
|
||||
|
@ -179,21 +179,21 @@ func (b *BlobURLSuite) TestSnapshot(c *chk.C) {
|
|||
resp, err := blob.CreateSnapshot(context.Background(), nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(resp.Snapshot().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.Snapshot()=="", chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
|
||||
blobs, err := container.ListBlobs(context.Background(), azblob.Marker{}, azblob.ListBlobsOptions{Details: azblob.BlobListingDetails{Snapshots: true}})
|
||||
blobs, err := container.ListBlobsFlatSegment(context.Background(), azblob.Marker{}, azblob.ListBlobsSegmentOptions{Details: azblob.BlobListingDetails{Snapshots: true}})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blobs.Blobs.Blob, chk.HasLen, 2)
|
||||
|
||||
_, err = blob.Delete(context.Background(), azblob.DeleteSnapshotsOptionOnly, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
blobs, err = container.ListBlobs(context.Background(), azblob.Marker{}, azblob.ListBlobsOptions{Details: azblob.BlobListingDetails{Snapshots: true}})
|
||||
blobs, err = container.ListBlobsFlatSegment(context.Background(), azblob.Marker{}, azblob.ListBlobsSegmentOptions{Details: azblob.BlobListingDetails{Snapshots: true}})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blobs.Blobs.Blob, chk.HasLen, 1)
|
||||
}
|
||||
|
@ -234,28 +234,25 @@ func (b *BlobURLSuite) TestLeaseAcquireRelease(c *chk.C) {
|
|||
|
||||
blob, _ := createNewBlockBlob(c, container)
|
||||
|
||||
resp, err := blob.AcquireLease(context.Background(), "", 15, azblob.HTTPAccessConditions{})
|
||||
leaseID := resp.LeaseID()
|
||||
acq, err := blob.AcquireLease(context.Background(), "", 15, azblob.HTTPAccessConditions{})
|
||||
leaseID := acq.LeaseID() // FIX
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, leaseID)
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(acq.StatusCode(), chk.Equals, 201)
|
||||
c.Assert(acq.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(acq.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(acq.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(acq.LeaseID(), chk.Equals, leaseID)
|
||||
c.Assert(acq.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(acq.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = blob.ReleaseLease(context.Background(), leaseID, azblob.HTTPAccessConditions{})
|
||||
rel, err := blob.ReleaseLease(context.Background(), leaseID, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, "")
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(rel.StatusCode(), chk.Equals, 200)
|
||||
c.Assert(rel.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(rel.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(rel.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(rel.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(rel.Version(), chk.Not(chk.Equals), "")
|
||||
}
|
||||
|
||||
func (b *BlobURLSuite) TestLeaseRenewChangeBreak(c *chk.C) {
|
||||
|
@ -265,45 +262,41 @@ func (b *BlobURLSuite) TestLeaseRenewChangeBreak(c *chk.C) {
|
|||
|
||||
blob, _ := createNewBlockBlob(c, container)
|
||||
|
||||
resp, err := blob.AcquireLease(context.Background(), newUUID().String(), 15, azblob.HTTPAccessConditions{})
|
||||
acq, err := blob.AcquireLease(context.Background(), newUUID().String(), 15, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
leaseID := resp.LeaseID()
|
||||
leaseID := acq.LeaseID()
|
||||
|
||||
resp, err = blob.ChangeLease(context.Background(), leaseID, newUUID().String(), azblob.HTTPAccessConditions{})
|
||||
chg, err := blob.ChangeLease(context.Background(), leaseID, newUUID().String(), azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
newID := resp.LeaseID()
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
newID := chg.LeaseID()
|
||||
c.Assert(chg.StatusCode(), chk.Equals, 200)
|
||||
c.Assert(chg.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(chg.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(chg.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(chg.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(chg.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = blob.RenewLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
renew, err := blob.RenewLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(renew.StatusCode(), chk.Equals, 200)
|
||||
c.Assert(renew.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(renew.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(renew.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(renew.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(renew.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(renew.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = blob.BreakLease(context.Background(), newID, 5, azblob.HTTPAccessConditions{})
|
||||
brk, err := blob.BreakLease(context.Background(), 5, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 202)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, "")
|
||||
c.Assert(resp.LeaseTime(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(brk.StatusCode(), chk.Equals, 202)
|
||||
c.Assert(brk.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(brk.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(brk.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(brk.LeaseTime(), chk.Not(chk.Equals), "")
|
||||
c.Assert(brk.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(brk.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = blob.ReleaseLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
_, err = blob.ReleaseLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
}
|
||||
|
||||
|
@ -314,10 +307,10 @@ func (b *BlobURLSuite) TestGetBlobRange(c *chk.C) {
|
|||
|
||||
blob, _ := createNewBlockBlob(c, container)
|
||||
contentR, contentD := getRandomDataAndReader(2048)
|
||||
_, err := blob.PutBlob(context.Background(), contentR, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
_, err := blob.Upload(context.Background(), contentR, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
resp, err := blob.GetBlob(context.Background(), azblob.BlobRange{Offset: 0, Count: 1024}, azblob.BlobAccessConditions{}, false)
|
||||
resp, err := blob.Download(context.Background(), 0, 1024, azblob.BlobAccessConditions{}, false)
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.ContentLength(), chk.Equals, int64(1024))
|
||||
|
||||
|
@ -325,7 +318,7 @@ func (b *BlobURLSuite) TestGetBlobRange(c *chk.C) {
|
|||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(download, chk.DeepEquals, contentD[:1024])
|
||||
|
||||
resp, err = blob.GetBlob(context.Background(), azblob.BlobRange{Offset: 1024}, azblob.BlobAccessConditions{}, false)
|
||||
resp, err = blob.Download(context.Background(), 1024, 0, azblob.BlobAccessConditions{}, false)
|
||||
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.ContentLength(), chk.Equals, int64(1024))
|
||||
|
@ -335,14 +328,13 @@ func (b *BlobURLSuite) TestGetBlobRange(c *chk.C) {
|
|||
c.Assert(download, chk.DeepEquals, contentD[1024:])
|
||||
|
||||
c.Assert(resp.AcceptRanges(), chk.Equals, "bytes")
|
||||
c.Assert(resp.BlobCommittedBlockCount(), chk.Equals, "")
|
||||
c.Assert(resp.BlobCommittedBlockCount(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.BlobContentMD5(), chk.Not(chk.Equals), [md5.Size]byte{})
|
||||
c.Assert(resp.BlobSequenceNumber(), chk.Equals, "")
|
||||
c.Assert(resp.BlobSequenceNumber(), chk.Equals, int64(-1))
|
||||
c.Assert(resp.BlobType(), chk.Equals, azblob.BlobBlockBlob)
|
||||
c.Assert(resp.CacheControl(), chk.Equals, "")
|
||||
c.Assert(resp.ContentDisposition(), chk.Equals, "")
|
||||
c.Assert(resp.ContentEncoding(), chk.Equals, "")
|
||||
c.Assert(resp.ContentMD5(), chk.Equals, [md5.Size]byte{})
|
||||
c.Assert(resp.ContentRange(), chk.Equals, "bytes 1024-2047/2048")
|
||||
c.Assert(resp.ContentType(), chk.Equals, "application/octet-stream")
|
||||
c.Assert(resp.CopyCompletionTime().IsZero(), chk.Equals, true)
|
||||
|
|
|
@ -1,68 +1,68 @@
|
|||
package azblob_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
|
||||
"github.com/Azure/azure-storage-blob-go/2017-07-29/azblob"
|
||||
chk "gopkg.in/check.v1" // go get gopkg.in/check.v1
|
||||
)
|
||||
|
||||
type BlockBlobURLSuite struct{}
|
||||
|
||||
var _ = chk.Suite(&BlockBlobURLSuite{})
|
||||
|
||||
func (b *BlockBlobURLSuite) TestPutGetBlocks(c *chk.C) {
|
||||
bsu := getBSU()
|
||||
container, _ := createNewContainer(c, bsu)
|
||||
defer delContainer(c, container)
|
||||
|
||||
blob := container.NewBlockBlobURL(generateBlobName())
|
||||
|
||||
blockID := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%6d", 0)))
|
||||
|
||||
putResp, err := blob.PutBlock(context.Background(), blockID, getReaderToRandomBytes(1024), azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(putResp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(putResp.ContentMD5(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.Date().IsZero(), chk.Equals, false)
|
||||
|
||||
blockList, err := blob.GetBlockList(context.Background(), azblob.BlockListAll, azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blockList.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(blockList.LastModified().IsZero(), chk.Equals, true)
|
||||
c.Assert(blockList.ETag(), chk.Equals, azblob.ETagNone)
|
||||
c.Assert(blockList.ContentType(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.BlobContentLength(), chk.Equals, int64(-1))
|
||||
c.Assert(blockList.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(blockList.CommittedBlocks, chk.HasLen, 0)
|
||||
c.Assert(blockList.UncommittedBlocks, chk.HasLen, 1)
|
||||
|
||||
listResp, err := blob.PutBlockList(context.Background(), []string{blockID}, nil, azblob.BlobHTTPHeaders{}, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(listResp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(listResp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(listResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(listResp.ContentMD5(), chk.Not(chk.Equals), "")
|
||||
c.Assert(listResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(listResp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(listResp.Date().IsZero(), chk.Equals, false)
|
||||
|
||||
blockList, err = blob.GetBlockList(context.Background(), azblob.BlockListAll, azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blockList.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(blockList.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(blockList.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(blockList.ContentType(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.BlobContentLength(), chk.Equals, int64(1024))
|
||||
c.Assert(blockList.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(blockList.CommittedBlocks, chk.HasLen, 1)
|
||||
c.Assert(blockList.UncommittedBlocks, chk.HasLen, 0)
|
||||
}
|
||||
package azblob_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
|
||||
"github.com/Azure/azure-storage-blob-go/2017-07-29/azblob"
|
||||
chk "gopkg.in/check.v1" // go get gopkg.in/check.v1
|
||||
)
|
||||
|
||||
type BlockBlobURLSuite struct{}
|
||||
|
||||
var _ = chk.Suite(&BlockBlobURLSuite{})
|
||||
|
||||
func (b *BlockBlobURLSuite) TestPutGetBlocks(c *chk.C) {
|
||||
bsu := getBSU()
|
||||
container, _ := createNewContainer(c, bsu)
|
||||
defer delContainer(c, container)
|
||||
|
||||
blob := container.NewBlockBlobURL(generateBlobName())
|
||||
|
||||
blockID := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%6d", 0)))
|
||||
|
||||
putResp, err := blob.StageBlock(context.Background(), blockID, getReaderToRandomBytes(1024), azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(putResp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(putResp.ContentMD5(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.Date().IsZero(), chk.Equals, false)
|
||||
|
||||
blockList, err := blob.GetBlockList(context.Background(), azblob.BlockListAll, azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blockList.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(blockList.LastModified().IsZero(), chk.Equals, true)
|
||||
c.Assert(blockList.ETag(), chk.Equals, azblob.ETagNone)
|
||||
c.Assert(blockList.ContentType(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.BlobContentLength(), chk.Equals, int64(-1))
|
||||
c.Assert(blockList.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(blockList.CommittedBlocks, chk.HasLen, 0)
|
||||
c.Assert(blockList.UncommittedBlocks, chk.HasLen, 1)
|
||||
|
||||
listResp, err := blob.CommitBlockList(context.Background(), []string{blockID}, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(listResp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(listResp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(listResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(listResp.ContentMD5(), chk.Not(chk.Equals), "")
|
||||
c.Assert(listResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(listResp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(listResp.Date().IsZero(), chk.Equals, false)
|
||||
|
||||
blockList, err = blob.GetBlockList(context.Background(), azblob.BlockListAll, azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blockList.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(blockList.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(blockList.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(blockList.ContentType(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.BlobContentLength(), chk.Equals, int64(1024))
|
||||
c.Assert(blockList.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(blockList.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(blockList.CommittedBlocks, chk.HasLen, 1)
|
||||
c.Assert(blockList.UncommittedBlocks, chk.HasLen, 0)
|
||||
}
|
||||
|
|
|
@ -33,7 +33,7 @@ func (s *ContainerURLSuite) TestCreateDelete(c *chk.C) {
|
|||
c.Assert(cResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(cResp.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
containers, err := sa.ListContainers(context.Background(), azblob.Marker{}, azblob.ListContainersOptions{Prefix: containerPrefix})
|
||||
containers, err := sa.ListContainersSegment(context.Background(), azblob.Marker{}, azblob.ListContainersSegmentOptions{Prefix: containerPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(containers.Containers, chk.HasLen, 1)
|
||||
c.Assert(containers.Containers[0].Name, chk.Equals, containerName)
|
||||
|
@ -45,7 +45,7 @@ func (s *ContainerURLSuite) TestCreateDelete(c *chk.C) {
|
|||
c.Assert(dResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(dResp.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
containers, err = sa.ListContainers(context.Background(), azblob.Marker{}, azblob.ListContainersOptions{Prefix: containerPrefix})
|
||||
containers, err = sa.ListContainersSegment(context.Background(), azblob.Marker{}, azblob.ListContainersSegmentOptions{Prefix: containerPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(containers.Containers, chk.HasLen, 0)
|
||||
}
|
||||
|
@ -76,7 +76,7 @@ func (s *ContainerURLSuite) TestGetSetPermissions(c *chk.C) {
|
|||
Permission: "rw",
|
||||
},
|
||||
}}
|
||||
sResp, err := container.SetPermissions(context.Background(), azblob.PublicAccessNone, permissions, azblob.ContainerAccessConditions{})
|
||||
sResp, err := container.SetAccessPolicy(context.Background(), azblob.PublicAccessNone, permissions, azblob.ContainerAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(sResp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(sResp.Date().IsZero(), chk.Equals, false)
|
||||
|
@ -85,7 +85,7 @@ func (s *ContainerURLSuite) TestGetSetPermissions(c *chk.C) {
|
|||
c.Assert(sResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(sResp.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
gResp, err := container.GetPermissions(context.Background(), azblob.LeaseAccessConditions{})
|
||||
gResp, err := container.GetAccessPolicy(context.Background(), azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(gResp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(gResp.BlobPublicAccess(), chk.Equals, azblob.PublicAccessNone)
|
||||
|
@ -117,7 +117,7 @@ func (s *ContainerURLSuite) TestGetSetMetadata(c *chk.C) {
|
|||
c.Assert(sResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(sResp.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
gResp, err := container.GetPropertiesAndMetadata(context.Background(), azblob.LeaseAccessConditions{})
|
||||
gResp, err := container.GetProperties(context.Background(), azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(gResp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(gResp.Date().IsZero(), chk.Equals, false)
|
||||
|
@ -134,7 +134,7 @@ func (s *ContainerURLSuite) TestListBlobs(c *chk.C) {
|
|||
container, _ := createNewContainer(c, bsu)
|
||||
defer delContainer(c, container)
|
||||
|
||||
blobs, err := container.ListBlobs(context.Background(), azblob.Marker{}, azblob.ListBlobsOptions{})
|
||||
blobs, err := container.ListBlobsFlatSegment(context.Background(), azblob.Marker{}, azblob.ListBlobsSegmentOptions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blobs.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(blobs.ContentType(), chk.Not(chk.Equals), "")
|
||||
|
@ -151,15 +151,14 @@ func (s *ContainerURLSuite) TestListBlobs(c *chk.C) {
|
|||
|
||||
blob := container.NewBlockBlobURL(generateBlobName())
|
||||
|
||||
_, err = blob.PutBlob(context.Background(), nil, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
_, err = blob.Upload(context.Background(), nil, azblob.BlobHTTPHeaders{}, nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
blobs, err = container.ListBlobs(context.Background(), azblob.Marker{}, azblob.ListBlobsOptions{})
|
||||
blobs, err = container.ListBlobsFlatSegment(context.Background(), azblob.Marker{}, azblob.ListBlobsSegmentOptions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blobs.Blobs.BlobPrefix, chk.HasLen, 0)
|
||||
c.Assert(blobs.Blobs.Blob, chk.HasLen, 1)
|
||||
c.Assert(blobs.Blobs.Blob[0].Name, chk.NotNil)
|
||||
c.Assert(blobs.Blobs.Blob[0].Snapshot.IsZero(), chk.Equals, true)
|
||||
c.Assert(blobs.Blobs.Blob[0].Snapshot =="", chk.Equals, true)
|
||||
c.Assert(blobs.Blobs.Blob[0].Metadata, chk.HasLen, 0)
|
||||
c.Assert(blobs.Blobs.Blob[0].Properties, chk.NotNil)
|
||||
c.Assert(blobs.Blobs.Blob[0].Properties.LastModified, chk.NotNil)
|
||||
|
@ -191,28 +190,25 @@ func (s *ContainerURLSuite) TestLeaseAcquireRelease(c *chk.C) {
|
|||
container, _ := createNewContainer(c, bsu)
|
||||
defer delContainer(c, container)
|
||||
|
||||
resp, err := container.AcquireLease(context.Background(), "", 15, azblob.HTTPAccessConditions{})
|
||||
leaseID := resp.LeaseID()
|
||||
acq, err := container.AcquireLease(context.Background(), "", 15, azblob.HTTPAccessConditions{})
|
||||
leaseID := acq.LeaseID()
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, leaseID)
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(acq.StatusCode(), chk.Equals, 201)
|
||||
c.Assert(acq.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(acq.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(acq.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(acq.LeaseID(), chk.Equals, leaseID)
|
||||
c.Assert(acq.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(acq.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = container.ReleaseLease(context.Background(), leaseID, azblob.HTTPAccessConditions{})
|
||||
rel, err := container.ReleaseLease(context.Background(), leaseID, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, "")
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(rel.StatusCode(), chk.Equals, 200)
|
||||
c.Assert(rel.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(rel.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(rel.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(rel.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(rel.Version(), chk.Not(chk.Equals), "")
|
||||
}
|
||||
|
||||
func (s *ContainerURLSuite) TestLeaseRenewChangeBreak(c *chk.C) {
|
||||
|
@ -220,46 +216,42 @@ func (s *ContainerURLSuite) TestLeaseRenewChangeBreak(c *chk.C) {
|
|||
container, _ := createNewContainer(c, bsu)
|
||||
defer delContainer(c, container)
|
||||
|
||||
resp, err := container.AcquireLease(context.Background(), "", 15, azblob.HTTPAccessConditions{})
|
||||
leaseID := resp.LeaseID()
|
||||
al, err := container.AcquireLease(context.Background(), "", 15, azblob.HTTPAccessConditions{})
|
||||
leaseID := al.LeaseID()
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
newID := newUUID().String()
|
||||
resp, err = container.ChangeLease(context.Background(), leaseID, newID, azblob.HTTPAccessConditions{})
|
||||
newID = resp.LeaseID()
|
||||
cl, err := container.ChangeLease(context.Background(), leaseID, newID, azblob.HTTPAccessConditions{})
|
||||
newID = cl.LeaseID()
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(cl.StatusCode(), chk.Equals, 200)
|
||||
c.Assert(cl.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(cl.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(cl.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(cl.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(cl.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(cl.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = container.RenewLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
rl, err := container.RenewLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(resp.LeaseTime(), chk.Equals, int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(rl.StatusCode(), chk.Equals, 200)
|
||||
c.Assert(rl.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(rl.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(rl.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(rl.LeaseID(), chk.Equals, newID)
|
||||
c.Assert(rl.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(rl.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = container.BreakLease(context.Background(), newID, 5, azblob.HTTPAccessConditions{})
|
||||
bl, err := container.BreakLease(context.Background(), 5, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 202)
|
||||
c.Assert(resp.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(resp.LeaseID(), chk.Equals, "")
|
||||
c.Assert(resp.LeaseTime(), chk.Not(chk.Equals), int32(-1))
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(bl.StatusCode(), chk.Equals, 202)
|
||||
c.Assert(bl.Date().IsZero(), chk.Equals, false)
|
||||
c.Assert(bl.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(bl.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(bl.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(bl.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
resp, err = container.ReleaseLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
_, err = container.ReleaseLease(context.Background(), newID, azblob.HTTPAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
}
|
||||
|
||||
|
@ -281,7 +273,7 @@ func (s *ContainerURLSuite) TestListBlobsPaged(c *chk.C) {
|
|||
iterations := numBlobs / maxResultsPerPage
|
||||
|
||||
for i := 0; i < iterations; i++ {
|
||||
resp, err := container.ListBlobs(context.Background(), marker, azblob.ListBlobsOptions{MaxResults: maxResultsPerPage})
|
||||
resp, err := container.ListBlobsFlatSegment(context.Background(), marker, azblob.ListBlobsSegmentOptions{MaxResults: maxResultsPerPage})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Blobs.Blob, chk.HasLen, maxResultsPerPage)
|
||||
|
||||
|
@ -296,7 +288,7 @@ func (s *ContainerURLSuite) TestSetMetadataCondition(c *chk.C) {
|
|||
container, _ := createNewContainer(c, bsu)
|
||||
defer delContainer(c, container)
|
||||
time.Sleep(time.Second * 3)
|
||||
currTime := time.Now()
|
||||
currTime := time.Now().UTC()
|
||||
rResp, err := container.SetMetadata(context.Background(), azblob.Metadata{"foo": "bar"},
|
||||
azblob.ContainerAccessConditions{HTTPAccessConditions: azblob.HTTPAccessConditions{IfModifiedSince: currTime}})
|
||||
c.Assert(err, chk.NotNil)
|
||||
|
@ -304,7 +296,7 @@ func (s *ContainerURLSuite) TestSetMetadataCondition(c *chk.C) {
|
|||
se, ok := err.(azblob.StorageError)
|
||||
c.Assert(ok, chk.Equals, true)
|
||||
c.Assert(se.Response().StatusCode, chk.Equals, http.StatusPreconditionFailed)
|
||||
gResp, err := container.GetPropertiesAndMetadata(context.Background(), azblob.LeaseAccessConditions{})
|
||||
gResp, err := container.GetProperties(context.Background(), azblob.LeaseAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
md := gResp.NewMetadata()
|
||||
c.Assert(md, chk.HasLen, 0)
|
||||
|
@ -328,7 +320,7 @@ func (s *ContainerURLSuite) TestListBlobsWithPrefix(c *chk.C) {
|
|||
createBlockBlobWithPrefix(c, container, prefix)
|
||||
}
|
||||
|
||||
blobs, err := container.ListBlobs(context.Background(), azblob.Marker{}, azblob.ListBlobsOptions{Delimiter: "/"})
|
||||
blobs, err := container.ListBlobsHierarchySegment(context.Background(), azblob.Marker{}, "/", azblob.ListBlobsSegmentOptions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(blobs.Blobs.BlobPrefix, chk.HasLen, 3)
|
||||
c.Assert(blobs.Blobs.Blob, chk.HasLen, 0)
|
||||
|
|
|
@ -19,18 +19,18 @@ func (b *PageBlobURLSuite) TestPutGetPages(c *chk.C) {
|
|||
blob, _ := createNewPageBlob(c, container)
|
||||
|
||||
pageRange := azblob.PageRange{Start: 0, End: 1023}
|
||||
putResp, err := blob.PutPages(context.Background(), pageRange, getReaderToRandomBytes(1024), azblob.BlobAccessConditions{})
|
||||
putResp, err := blob.UploadPages(context.Background(), 0, getReaderToRandomBytes(1024), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(putResp.Response().StatusCode, chk.Equals, 201)
|
||||
c.Assert(putResp.LastModified().IsZero(), chk.Equals, false)
|
||||
c.Assert(putResp.ETag(), chk.Not(chk.Equals), azblob.ETagNone)
|
||||
c.Assert(putResp.ContentMD5(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.BlobSequenceNumber(), chk.Equals, int32(0))
|
||||
c.Assert(putResp.BlobSequenceNumber(), chk.Equals, int64(0))
|
||||
c.Assert(putResp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(putResp.Date().IsZero(), chk.Equals, false)
|
||||
|
||||
pageList, err := blob.GetPageRanges(context.Background(), azblob.BlobRange{Offset: 0, Count: 1023}, azblob.BlobAccessConditions{})
|
||||
pageList, err := blob.GetPageRanges(context.Background(), 0, 1023, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(pageList.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(pageList.LastModified().IsZero(), chk.Equals, false)
|
||||
|
@ -49,26 +49,26 @@ func (b *PageBlobURLSuite) TestClearDiffPages(c *chk.C) {
|
|||
defer delContainer(c, container)
|
||||
|
||||
blob, _ := createNewPageBlob(c, container)
|
||||
_, err := blob.PutPages(context.Background(), azblob.PageRange{Start: 0, End: 2047}, getReaderToRandomBytes(2048), azblob.BlobAccessConditions{})
|
||||
_, err := blob.UploadPages(context.Background(), 0, getReaderToRandomBytes(2048), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
snapshotResp, err := blob.CreateSnapshot(context.Background(), nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
_, err = blob.PutPages(context.Background(), azblob.PageRange{Start: 2048, End: 4095}, getReaderToRandomBytes(2048), azblob.BlobAccessConditions{})
|
||||
_, err = blob.UploadPages(context.Background(), 2048, getReaderToRandomBytes(2048), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
pageList, err := blob.GetPageRangesDiff(context.Background(), azblob.BlobRange{Offset: 0, Count: 4095}, snapshotResp.Snapshot(), azblob.BlobAccessConditions{})
|
||||
pageList, err := blob.GetPageRangesDiff(context.Background(), 0, 4096, snapshotResp.Snapshot(), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(pageList.PageRange, chk.HasLen, 1)
|
||||
c.Assert(pageList.PageRange[0].Start, chk.Equals, int32(2048))
|
||||
c.Assert(pageList.PageRange[0].End, chk.Equals, int32(4095))
|
||||
c.Assert(pageList.PageRange[0].Start, chk.Equals, int64(2048))
|
||||
c.Assert(pageList.PageRange[0].End, chk.Equals, int64(4095))
|
||||
|
||||
clearResp, err := blob.ClearPages(context.Background(), azblob.PageRange{Start: 2048, End: 4095}, azblob.BlobAccessConditions{})
|
||||
clearResp, err := blob.ClearPages(context.Background(), 2048, 2048, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(clearResp.Response().StatusCode, chk.Equals, 201)
|
||||
|
||||
pageList, err = blob.GetPageRangesDiff(context.Background(), azblob.BlobRange{Offset: 0, Count: 4095}, snapshotResp.Snapshot(), azblob.BlobAccessConditions{})
|
||||
pageList, err = blob.GetPageRangesDiff(context.Background(), 0, 4095, snapshotResp.Snapshot(), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(pageList.PageRange, chk.HasLen, 0)
|
||||
}
|
||||
|
@ -77,18 +77,18 @@ func (b *PageBlobURLSuite) TestIncrementalCopy(c *chk.C) {
|
|||
bsu := getBSU()
|
||||
container, _ := createNewContainer(c, bsu)
|
||||
defer delContainer(c, container)
|
||||
_, err := container.SetPermissions(context.Background(), azblob.PublicAccessBlob, nil, azblob.ContainerAccessConditions{})
|
||||
_, err := container.SetAccessPolicy(context.Background(), azblob.PublicAccessBlob, nil, azblob.ContainerAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
srcBlob, _ := createNewPageBlob(c, container)
|
||||
_, err = srcBlob.PutPages(context.Background(), azblob.PageRange{Start: 0, End: 1023}, getReaderToRandomBytes(1024), azblob.BlobAccessConditions{})
|
||||
_, err = srcBlob.UploadPages(context.Background(), 0, getReaderToRandomBytes(1024), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
snapshotResp, err := srcBlob.CreateSnapshot(context.Background(), nil, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
dstBlob := container.NewPageBlobURL(generateBlobName())
|
||||
|
||||
resp, err := dstBlob.StartIncrementalCopy(context.Background(), srcBlob.URL(), snapshotResp.Snapshot(), azblob.BlobAccessConditions{})
|
||||
resp, err := dstBlob.StartCopyIncremental(context.Background(), srcBlob.URL(), snapshotResp.Snapshot(), azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 202)
|
||||
c.Assert(resp.LastModified().IsZero(), chk.Equals, false)
|
||||
|
@ -116,7 +116,7 @@ func (b *PageBlobURLSuite) TestResizePageBlob(c *chk.C) {
|
|||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
|
||||
resp2, err := blob.GetPropertiesAndMetadata(ctx, azblob.BlobAccessConditions{})
|
||||
resp2, err := blob.GetProperties(ctx, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp2.ContentLength(), chk.Equals, int64(8192))
|
||||
}
|
||||
|
@ -128,15 +128,15 @@ func (b *PageBlobURLSuite) TestPageSequenceNumbers(c *chk.C) {
|
|||
|
||||
defer delContainer(c, container)
|
||||
|
||||
resp, err := blob.SetSequenceNumber(context.Background(), azblob.SequenceNumberActionIncrement, 0, azblob.BlobHTTPHeaders{}, azblob.BlobAccessConditions{})
|
||||
resp, err := blob.UpdateSequenceNumber(context.Background(), azblob.SequenceNumberActionIncrement, 0, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
|
||||
resp, err = blob.SetSequenceNumber(context.Background(), azblob.SequenceNumberActionMax, 7, azblob.BlobHTTPHeaders{}, azblob.BlobAccessConditions{})
|
||||
resp, err = blob.UpdateSequenceNumber(context.Background(), azblob.SequenceNumberActionMax, 7, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
|
||||
resp, err = blob.SetSequenceNumber(context.Background(), azblob.SequenceNumberActionUpdate, 11, azblob.BlobHTTPHeaders{}, azblob.BlobAccessConditions{})
|
||||
resp, err = blob.UpdateSequenceNumber(context.Background(), azblob.SequenceNumberActionUpdate, 11, azblob.BlobAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
}
|
||||
|
|
|
@ -1,109 +1,109 @@
|
|||
package azblob_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Azure/azure-storage-blob-go/2017-07-29/azblob"
|
||||
chk "gopkg.in/check.v1" // go get gopkg.in/check.v1
|
||||
)
|
||||
|
||||
type StorageAccountSuite struct{}
|
||||
|
||||
var _ = chk.Suite(&StorageAccountSuite{})
|
||||
|
||||
/*func (s *StorageAccountSuite) TestGetSetProperties(c *chk.C) {
|
||||
sa := getStorageAccount(c)
|
||||
setProps := StorageServiceProperties{}
|
||||
resp, err := sa.SetProperties(context.Background(), setProps)
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 202)
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
props, err := sa.GetProperties(context.Background())
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(props.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(props.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(props.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(props.Logging, chk.NotNil)
|
||||
c.Assert(props.HourMetrics, chk.NotNil)
|
||||
c.Assert(props.MinuteMetrics, chk.NotNil)
|
||||
c.Assert(props.Cors, chk.HasLen, 0)
|
||||
c.Assert(props.DefaultServiceVersion, chk.IsNil) // TODO: this seems like a bug
|
||||
}
|
||||
|
||||
func (s *StorageAccountSuite) TestGetStatus(c *chk.C) {
|
||||
sa := getStorageAccount(c)
|
||||
if !strings.Contains(sa.URL().Path, "-secondary") {
|
||||
c.Skip("only applicable on secondary storage accounts")
|
||||
}
|
||||
stats, err := sa.GetStats(context.Background())
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(stats, chk.NotNil)
|
||||
}*/
|
||||
|
||||
func (s *StorageAccountSuite) TestListContainers(c *chk.C) {
|
||||
sa := getBSU()
|
||||
resp, err := sa.ListContainers(context.Background(), azblob.Marker{}, azblob.ListContainersOptions{Prefix: containerPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Containers, chk.HasLen, 0)
|
||||
c.Assert(resp.ServiceEndpoint, chk.NotNil)
|
||||
|
||||
container, _ := createNewContainer(c, sa)
|
||||
defer delContainer(c, container)
|
||||
|
||||
md := azblob.Metadata{
|
||||
"foo": "foovalue",
|
||||
"bar": "barvalue",
|
||||
}
|
||||
_, err = container.SetMetadata(context.Background(), md, azblob.ContainerAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
resp, err = sa.ListContainers(context.Background(), azblob.Marker{}, azblob.ListContainersOptions{Detail: azblob.ListContainersDetail{Metadata: true}, Prefix: containerPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Containers, chk.HasLen, 1)
|
||||
c.Assert(resp.Containers[0].Name, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties.LastModified, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties.Etag, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties.LeaseStatus, chk.Equals, azblob.LeaseStatusUnlocked)
|
||||
c.Assert(resp.Containers[0].Properties.LeaseState, chk.Equals, azblob.LeaseStateAvailable)
|
||||
c.Assert(string(resp.Containers[0].Properties.LeaseDuration), chk.Equals, "")
|
||||
c.Assert(string(resp.Containers[0].Properties.PublicAccess), chk.Equals, string(azblob.PublicAccessNone))
|
||||
c.Assert(resp.Containers[0].Metadata, chk.DeepEquals, md)
|
||||
}
|
||||
|
||||
func (s *StorageAccountSuite) TestListContainersPaged(c *chk.C) {
|
||||
sa := getBSU()
|
||||
|
||||
const numContainers = 4
|
||||
const maxResultsPerPage = 2
|
||||
const pagedContainersPrefix = "azblobspagedtest"
|
||||
|
||||
containers := make([]azblob.ContainerURL, numContainers)
|
||||
for i := 0; i < numContainers; i++ {
|
||||
containers[i], _ = createNewContainerWithSuffix(c, sa, pagedContainersPrefix)
|
||||
}
|
||||
|
||||
defer func() {
|
||||
for i := range containers {
|
||||
delContainer(c, containers[i])
|
||||
}
|
||||
}()
|
||||
|
||||
marker := azblob.Marker{}
|
||||
iterations := numContainers / maxResultsPerPage
|
||||
|
||||
for i := 0; i < iterations; i++ {
|
||||
resp, err := sa.ListContainers(context.Background(), marker, azblob.ListContainersOptions{MaxResults: maxResultsPerPage, Prefix: containerPrefix + pagedContainersPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Containers, chk.HasLen, maxResultsPerPage)
|
||||
|
||||
hasMore := i < iterations-1
|
||||
c.Assert(resp.NextMarker.NotDone(), chk.Equals, hasMore)
|
||||
marker = resp.NextMarker
|
||||
}
|
||||
}
|
||||
package azblob_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/Azure/azure-storage-blob-go/2017-07-29/azblob"
|
||||
chk "gopkg.in/check.v1" // go get gopkg.in/check.v1
|
||||
)
|
||||
|
||||
type StorageAccountSuite struct{}
|
||||
|
||||
var _ = chk.Suite(&StorageAccountSuite{})
|
||||
|
||||
/*func (s *StorageAccountSuite) TestGetSetProperties(c *chk.C) {
|
||||
sa := getStorageAccount(c)
|
||||
setProps := StorageServiceProperties{}
|
||||
resp, err := sa.SetProperties(context.Background(), setProps)
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 202)
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
|
||||
props, err := sa.GetProperties(context.Background())
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(props.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(props.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(props.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(props.Logging, chk.NotNil)
|
||||
c.Assert(props.HourMetrics, chk.NotNil)
|
||||
c.Assert(props.MinuteMetrics, chk.NotNil)
|
||||
c.Assert(props.Cors, chk.HasLen, 0)
|
||||
c.Assert(props.DefaultServiceVersion, chk.IsNil) // TODO: this seems like a bug
|
||||
}
|
||||
|
||||
func (s *StorageAccountSuite) TestGetStatus(c *chk.C) {
|
||||
sa := getStorageAccount(c)
|
||||
if !strings.Contains(sa.URL().Path, "-secondary") {
|
||||
c.Skip("only applicable on secondary storage accounts")
|
||||
}
|
||||
stats, err := sa.GetStats(context.Background())
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(stats, chk.NotNil)
|
||||
}*/
|
||||
|
||||
func (s *StorageAccountSuite) TestListContainers(c *chk.C) {
|
||||
sa := getBSU()
|
||||
resp, err := sa.ListContainersSegment(context.Background(), azblob.Marker{}, azblob.ListContainersSegmentOptions{Prefix: containerPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Response().StatusCode, chk.Equals, 200)
|
||||
c.Assert(resp.RequestID(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Version(), chk.Not(chk.Equals), "")
|
||||
c.Assert(resp.Containers, chk.HasLen, 0)
|
||||
c.Assert(resp.ServiceEndpoint, chk.NotNil)
|
||||
|
||||
container, _ := createNewContainer(c, sa)
|
||||
defer delContainer(c, container)
|
||||
|
||||
md := azblob.Metadata{
|
||||
"foo": "foovalue",
|
||||
"bar": "barvalue",
|
||||
}
|
||||
_, err = container.SetMetadata(context.Background(), md, azblob.ContainerAccessConditions{})
|
||||
c.Assert(err, chk.IsNil)
|
||||
|
||||
resp, err = sa.ListContainersSegment(context.Background(), azblob.Marker{}, azblob.ListContainersSegmentOptions{Detail: azblob.ListContainersDetail{Metadata: true}, Prefix: containerPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Containers, chk.HasLen, 1)
|
||||
c.Assert(resp.Containers[0].Name, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties.LastModified, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties.Etag, chk.NotNil)
|
||||
c.Assert(resp.Containers[0].Properties.LeaseStatus, chk.Equals, azblob.LeaseStatusUnlocked)
|
||||
c.Assert(resp.Containers[0].Properties.LeaseState, chk.Equals, azblob.LeaseStateAvailable)
|
||||
c.Assert(string(resp.Containers[0].Properties.LeaseDuration), chk.Equals, "")
|
||||
c.Assert(string(resp.Containers[0].Properties.PublicAccess), chk.Equals, string(azblob.PublicAccessNone))
|
||||
c.Assert(resp.Containers[0].Metadata, chk.DeepEquals, md)
|
||||
}
|
||||
|
||||
func (s *StorageAccountSuite) TestListContainersPaged(c *chk.C) {
|
||||
sa := getBSU()
|
||||
|
||||
const numContainers = 4
|
||||
const maxResultsPerPage = 2
|
||||
const pagedContainersPrefix = "azblobspagedtest"
|
||||
|
||||
containers := make([]azblob.ContainerURL, numContainers)
|
||||
for i := 0; i < numContainers; i++ {
|
||||
containers[i], _ = createNewContainerWithSuffix(c, sa, pagedContainersPrefix)
|
||||
}
|
||||
|
||||
defer func() {
|
||||
for i := range containers {
|
||||
delContainer(c, containers[i])
|
||||
}
|
||||
}()
|
||||
|
||||
marker := azblob.Marker{}
|
||||
iterations := numContainers / maxResultsPerPage
|
||||
|
||||
for i := 0; i < iterations; i++ {
|
||||
resp, err := sa.ListContainersSegment(context.Background(), marker, azblob.ListContainersSegmentOptions{MaxResults: maxResultsPerPage, Prefix: containerPrefix + pagedContainersPrefix})
|
||||
c.Assert(err, chk.IsNil)
|
||||
c.Assert(resp.Containers, chk.HasLen, maxResultsPerPage)
|
||||
|
||||
hasMore := i < iterations-1
|
||||
c.Assert(resp.NextMarker.NotDone(), chk.Equals, hasMore)
|
||||
marker = resp.NextMarker
|
||||
}
|
||||
}
|
||||
|
|
|
@ -8,6 +8,7 @@ import (
|
|||
"fmt"
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"time"
|
||||
|
@ -27,8 +28,9 @@ func newAppendBlobsClient(url url.URL, p pipeline.Pipeline) appendBlobsClient {
|
|||
// Block operation is permitted only if the blob was created with x-ms-blob-type set to AppendBlob. Append Block is
|
||||
// supported only on version 2015-02-21 version or later.
|
||||
//
|
||||
// body is initial data body will be closed upon successful return. Callers should ensure closure when receiving an
|
||||
// error.timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// contentLength is the length of the request. body is initial data body will be closed upon successful return. Callers
|
||||
// should ensure closure when receiving an error.timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. maxSize is optional conditional header. The max length in bytes permitted for
|
||||
|
@ -43,16 +45,14 @@ func newAppendBlobsClient(url url.URL, p pipeline.Pipeline) appendBlobsClient {
|
|||
// operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a
|
||||
// matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded
|
||||
// in the analytics logs when storage analytics logging is enabled.
|
||||
func (client appendBlobsClient) AppendBlock(ctx context.Context, body io.ReadSeeker, timeout *int32, leaseID *string, maxSize *int32, appendPosition *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*AppendBlobsAppendBlockResponse, error) {
|
||||
func (client appendBlobsClient) AppendBlock(ctx context.Context, contentLength int64, body io.ReadSeeker, timeout *int32, leaseID *string, maxSize *int32, appendPosition *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*AppendBlobsAppendBlockResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: body,
|
||||
constraints: []constraint{{target: "body", name: null, rule: true, chain: nil}}},
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.appendBlockPreparer(body, timeout, leaseID, maxSize, appendPosition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
req, err := client.appendBlockPreparer(contentLength, body, timeout, leaseID, maxSize, appendPosition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
@ -64,7 +64,7 @@ func (client appendBlobsClient) AppendBlock(ctx context.Context, body io.ReadSee
|
|||
}
|
||||
|
||||
// appendBlockPreparer prepares the AppendBlock request.
|
||||
func (client appendBlobsClient) appendBlockPreparer(body io.ReadSeeker, timeout *int32, leaseID *string, maxSize *int32, appendPosition *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
func (client appendBlobsClient) appendBlockPreparer(contentLength int64, body io.ReadSeeker, timeout *int32, leaseID *string, maxSize *int32, appendPosition *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, body)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
|
@ -75,6 +75,7 @@ func (client appendBlobsClient) appendBlockPreparer(body io.ReadSeeker, timeout
|
|||
}
|
||||
params.Set("comp", "appendblock")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
req.Header.Set("Content-Length", fmt.Sprintf("%v", contentLength))
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
|
@ -109,5 +110,122 @@ func (client appendBlobsClient) appendBlockResponder(resp pipeline.Response) (pi
|
|||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &AppendBlobsAppendBlockResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// Create the Create Append Blob operation creates a new append blob.
|
||||
//
|
||||
// contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> blobContentType is optional. Sets the blob's content type. If specified,
|
||||
// this property is stored with the blob and returned with a read request. blobContentEncoding is optional. Sets the
|
||||
// blob's content encoding. If specified, this property is stored with the blob and returned with a read request.
|
||||
// blobContentLanguage is optional. Set the blob's content language. If specified, this property is stored with the
|
||||
// blob and returned with a read request. blobContentMD5 is optional. An MD5 hash of the blob content. Note that this
|
||||
// hash is not validated, as the hashes for the individual blocks were validated when each was uploaded.
|
||||
// blobCacheControl is optional. Sets the blob's cache control. If specified, this property is stored with the blob and
|
||||
// returned with a read request. metadata is optional. Specifies a user-defined name-value pair associated with the
|
||||
// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
|
||||
// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
|
||||
// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
|
||||
// metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing Containers, Blobs, and
|
||||
// Metadata for more information. leaseID is if specified, the operation only succeeds if the container's lease is
|
||||
// active and matches this ID. blobContentDisposition is optional. Sets the blob's Content-Disposition header.
|
||||
// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
|
||||
// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
|
||||
// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
|
||||
// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
|
||||
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
|
||||
// analytics logging is enabled.
|
||||
func (client appendBlobsClient) Create(ctx context.Context, contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*AppendBlobsCreateResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
|
||||
{targetValue: metadata,
|
||||
constraints: []constraint{{target: "metadata", name: null, rule: false,
|
||||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.createPreparer(contentLength, timeout, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, blobCacheControl, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*AppendBlobsCreateResponse), err
|
||||
}
|
||||
|
||||
// createPreparer prepares the Create request.
|
||||
func (client appendBlobsClient) createPreparer(contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
req.URL.RawQuery = params.Encode()
|
||||
req.Header.Set("Content-Length", fmt.Sprintf("%v", contentLength))
|
||||
if blobContentType != nil {
|
||||
req.Header.Set("x-ms-blob-content-type", *blobContentType)
|
||||
}
|
||||
if blobContentEncoding != nil {
|
||||
req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
|
||||
}
|
||||
if blobContentLanguage != nil {
|
||||
req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
|
||||
}
|
||||
if blobContentMD5 != nil {
|
||||
req.Header.Set("x-ms-blob-content-md5", fmt.Sprintf("%v", blobContentMD5))
|
||||
}
|
||||
if blobCacheControl != nil {
|
||||
req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
|
||||
}
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
req.Header.Set("x-ms-meta-"+k, v)
|
||||
}
|
||||
}
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if blobContentDisposition != nil {
|
||||
req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
req.Header.Set("x-ms-blob-type", "AppendBlob")
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// createResponder handles the response to the Create request.
|
||||
func (client appendBlobsClient) createResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &AppendBlobsCreateResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
|
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
@ -26,6 +26,133 @@ func newBlockBlobsClient(url url.URL, p pipeline.Pipeline) blockBlobsClient {
|
|||
return blockBlobsClient{newManagementClient(url, p)}
|
||||
}
|
||||
|
||||
// CommitBlockList the Commit Block List operation writes a blob by specifying the list of block IDs that make up the
|
||||
// blob. In order to be written as part of a blob, a block must have been successfully written to the server in a prior
|
||||
// Put Block operation. You can call Put Block List to update a blob by uploading only those blocks that have changed,
|
||||
// then committing the new and existing blocks together. You can do this by specifying whether to commit a block from
|
||||
// the committed block list or from the uncommitted block list, or to commit the most recently uploaded version of the
|
||||
// block, whichever list it may belong to.
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> blobCacheControl is optional. Sets the blob's cache control. If specified,
|
||||
// this property is stored with the blob and returned with a read request. blobContentType is optional. Sets the blob's
|
||||
// content type. If specified, this property is stored with the blob and returned with a read request.
|
||||
// blobContentEncoding is optional. Sets the blob's content encoding. If specified, this property is stored with the
|
||||
// blob and returned with a read request. blobContentLanguage is optional. Set the blob's content language. If
|
||||
// specified, this property is stored with the blob and returned with a read request. blobContentMD5 is optional. An
|
||||
// MD5 hash of the blob content. Note that this hash is not validated, as the hashes for the individual blocks were
|
||||
// validated when each was uploaded. metadata is optional. Specifies a user-defined name-value pair associated with the
|
||||
// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
|
||||
// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
|
||||
// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
|
||||
// metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing Containers, Blobs, and
|
||||
// Metadata for more information. leaseID is if specified, the operation only succeeds if the container's lease is
|
||||
// active and matches this ID. blobContentDisposition is optional. Sets the blob's Content-Disposition header.
|
||||
// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
|
||||
// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
|
||||
// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
|
||||
// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
|
||||
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
|
||||
// analytics logging is enabled.
|
||||
func (client blockBlobsClient) CommitBlockList(ctx context.Context, blocks BlockLookupList, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlockBlobsCommitBlockListResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
|
||||
{targetValue: metadata,
|
||||
constraints: []constraint{{target: "metadata", name: null, rule: false,
|
||||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.commitBlockListPreparer(blocks, timeout, blobCacheControl, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.commitBlockListResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*BlockBlobsCommitBlockListResponse), err
|
||||
}
|
||||
|
||||
// commitBlockListPreparer prepares the CommitBlockList request.
|
||||
func (client blockBlobsClient) commitBlockListPreparer(blocks BlockLookupList, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "blocklist")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if blobCacheControl != nil {
|
||||
req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
|
||||
}
|
||||
if blobContentType != nil {
|
||||
req.Header.Set("x-ms-blob-content-type", *blobContentType)
|
||||
}
|
||||
if blobContentEncoding != nil {
|
||||
req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
|
||||
}
|
||||
if blobContentLanguage != nil {
|
||||
req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
|
||||
}
|
||||
if blobContentMD5 != nil {
|
||||
req.Header.Set("x-ms-blob-content-md5", fmt.Sprintf("%v", blobContentMD5))
|
||||
}
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
req.Header.Set("x-ms-meta-"+k, v)
|
||||
}
|
||||
}
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if blobContentDisposition != nil {
|
||||
req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
b, err := xml.Marshal(blocks)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to marshal request body")
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/xml")
|
||||
err = req.SetBody(bytes.NewReader(b))
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to set request body")
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// commitBlockListResponder handles the response to the CommitBlockList request.
|
||||
func (client blockBlobsClient) commitBlockListResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &BlockBlobsCommitBlockListResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// GetBlockList the Get Block List operation retrieves the list of blocks that have been uploaded as part of a block
|
||||
// blob
|
||||
//
|
||||
|
@ -38,7 +165,7 @@ func newBlockBlobsClient(url url.URL, p pipeline.Pipeline) blockBlobsClient {
|
|||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
|
||||
// limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client blockBlobsClient) GetBlockList(ctx context.Context, listType BlockListType, snapshot *time.Time, timeout *int32, leaseID *string, requestID *string) (*BlockList, error) {
|
||||
func (client blockBlobsClient) GetBlockList(ctx context.Context, listType BlockListType, snapshot *string, timeout *int32, leaseID *string, requestID *string) (*BlockList, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
|
@ -57,14 +184,14 @@ func (client blockBlobsClient) GetBlockList(ctx context.Context, listType BlockL
|
|||
}
|
||||
|
||||
// getBlockListPreparer prepares the GetBlockList request.
|
||||
func (client blockBlobsClient) getBlockListPreparer(listType BlockListType, snapshot *time.Time, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
|
||||
func (client blockBlobsClient) getBlockListPreparer(listType BlockListType, snapshot *string, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if snapshot != nil {
|
||||
params.Set("snapshot", (*snapshot).Format(rfc3339Format))
|
||||
if snapshot != nil && len(*snapshot) > 0 {
|
||||
params.Set("snapshot", *snapshot)
|
||||
}
|
||||
params.Set("blocklisttype", fmt.Sprintf("%v", listType))
|
||||
if timeout != nil {
|
||||
|
@ -106,39 +233,37 @@ func (client blockBlobsClient) getBlockListResponder(resp pipeline.Response) (pi
|
|||
return result, nil
|
||||
}
|
||||
|
||||
// PutBlock the Put Block operation creates a new block to be committed as part of a blob
|
||||
// StageBlock the Stage Block operation creates a new block to be committed as part of a blob
|
||||
//
|
||||
// blockID is a valid Base64 string value that identifies the block. Prior to encoding, the string must be less than or
|
||||
// equal to 64 bytes in size. For a given blob, the length of the value specified for the blockid parameter must be the
|
||||
// same size for each block. body is initial data body will be closed upon successful return. Callers should ensure
|
||||
// closure when receiving an error.timeout is the timeout parameter is expressed in seconds. For more information, see
|
||||
// <a
|
||||
// same size for each block. contentLength is the length of the request. body is initial data body will be closed upon
|
||||
// successful return. Callers should ensure closure when receiving an error.timeout is the timeout parameter is
|
||||
// expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
|
||||
// limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client blockBlobsClient) PutBlock(ctx context.Context, blockID string, body io.ReadSeeker, timeout *int32, leaseID *string, requestID *string) (*BlockBlobsPutBlockResponse, error) {
|
||||
func (client blockBlobsClient) StageBlock(ctx context.Context, blockID string, contentLength int64, body io.ReadSeeker, timeout *int32, leaseID *string, requestID *string) (*BlockBlobsStageBlockResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: body,
|
||||
constraints: []constraint{{target: "body", name: null, rule: true, chain: nil}}},
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.putBlockPreparer(blockID, body, timeout, leaseID, requestID)
|
||||
req, err := client.stageBlockPreparer(blockID, contentLength, body, timeout, leaseID, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.putBlockResponder}, req)
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.stageBlockResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*BlockBlobsPutBlockResponse), err
|
||||
return resp.(*BlockBlobsStageBlockResponse), err
|
||||
}
|
||||
|
||||
// putBlockPreparer prepares the PutBlock request.
|
||||
func (client blockBlobsClient) putBlockPreparer(blockID string, body io.ReadSeeker, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
|
||||
// stageBlockPreparer prepares the StageBlock request.
|
||||
func (client blockBlobsClient) stageBlockPreparer(blockID string, contentLength int64, body io.ReadSeeker, timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, body)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
|
@ -150,6 +275,7 @@ func (client blockBlobsClient) putBlockPreparer(blockID string, body io.ReadSeek
|
|||
}
|
||||
params.Set("comp", "block")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
req.Header.Set("Content-Length", fmt.Sprintf("%v", contentLength))
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
|
@ -160,32 +286,34 @@ func (client blockBlobsClient) putBlockPreparer(blockID string, body io.ReadSeek
|
|||
return req, nil
|
||||
}
|
||||
|
||||
// putBlockResponder handles the response to the PutBlock request.
|
||||
func (client blockBlobsClient) putBlockResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
// stageBlockResponder handles the response to the StageBlock request.
|
||||
func (client blockBlobsClient) stageBlockResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &BlockBlobsPutBlockResponse{rawResponse: resp.Response()}, err
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &BlockBlobsStageBlockResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// PutBlockList the Put Block List operation writes a blob by specifying the list of block IDs that make up the blob.
|
||||
// In order to be written as part of a blob, a block must have been successfully written to the server in a prior Put
|
||||
// Block operation. You can call Put Block List to update a blob by uploading only those blocks that have changed, then
|
||||
// committing the new and existing blocks together. You can do this by specifying whether to commit a block from the
|
||||
// committed block list or from the uncommitted block list, or to commit the most recently uploaded version of the
|
||||
// block, whichever list it may belong to.
|
||||
// Upload the Upload Block Blob operation updates the content of an existing block blob. Updating an existing block
|
||||
// blob overwrites any existing metadata on the blob. Partial updates are not supported with Put Blob; the content of
|
||||
// the existing blob is overwritten with the content of the new blob. To perform a partial update of the content of a
|
||||
// block blob, use the Put Block List operation.
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// contentLength is the length of the request. body is initial data body will be closed upon successful return. Callers
|
||||
// should ensure closure when receiving an error.timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> blobCacheControl is optional. Sets the blob's cache control. If specified,
|
||||
// this property is stored with the blob and returned with a read request. blobContentType is optional. Sets the blob's
|
||||
// content type. If specified, this property is stored with the blob and returned with a read request.
|
||||
// blobContentEncoding is optional. Sets the blob's content encoding. If specified, this property is stored with the
|
||||
// blob and returned with a read request. blobContentLanguage is optional. Set the blob's content language. If
|
||||
// specified, this property is stored with the blob and returned with a read request. blobContentMD5 is optional. An
|
||||
// MD5 hash of the blob content. Note that this hash is not validated, as the hashes for the individual blocks were
|
||||
// validated when each was uploaded. metadata is optional. Specifies a user-defined name-value pair associated with the
|
||||
// Timeouts for Blob Service Operations.</a> blobContentType is optional. Sets the blob's content type. If specified,
|
||||
// this property is stored with the blob and returned with a read request. blobContentEncoding is optional. Sets the
|
||||
// blob's content encoding. If specified, this property is stored with the blob and returned with a read request.
|
||||
// blobContentLanguage is optional. Set the blob's content language. If specified, this property is stored with the
|
||||
// blob and returned with a read request. blobContentMD5 is optional. An MD5 hash of the blob content. Note that this
|
||||
// hash is not validated, as the hashes for the individual blocks were validated when each was uploaded.
|
||||
// blobCacheControl is optional. Sets the blob's cache control. If specified, this property is stored with the blob and
|
||||
// returned with a read request. metadata is optional. Specifies a user-defined name-value pair associated with the
|
||||
// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
|
||||
// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
|
||||
// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
|
||||
|
@ -198,7 +326,7 @@ func (client blockBlobsClient) putBlockResponder(resp pipeline.Response) (pipeli
|
|||
// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
|
||||
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
|
||||
// analytics logging is enabled.
|
||||
func (client blockBlobsClient) PutBlockList(ctx context.Context, blocks BlockLookupList, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlockBlobsPutBlockListResponse, error) {
|
||||
func (client blockBlobsClient) Upload(ctx context.Context, contentLength int64, body io.ReadSeeker, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlockBlobsUploadResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
|
@ -208,20 +336,20 @@ func (client blockBlobsClient) PutBlockList(ctx context.Context, blocks BlockLoo
|
|||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.putBlockListPreparer(blocks, timeout, blobCacheControl, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
req, err := client.uploadPreparer(contentLength, body, timeout, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, blobCacheControl, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.putBlockListResponder}, req)
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.uploadResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*BlockBlobsPutBlockListResponse), err
|
||||
return resp.(*BlockBlobsUploadResponse), err
|
||||
}
|
||||
|
||||
// putBlockListPreparer prepares the PutBlockList request.
|
||||
func (client blockBlobsClient) putBlockListPreparer(blocks BlockLookupList, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
// uploadPreparer prepares the Upload request.
|
||||
func (client blockBlobsClient) uploadPreparer(contentLength int64, body io.ReadSeeker, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, body)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
|
@ -229,11 +357,8 @@ func (client blockBlobsClient) putBlockListPreparer(blocks BlockLookupList, time
|
|||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "blocklist")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if blobCacheControl != nil {
|
||||
req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
|
||||
}
|
||||
req.Header.Set("Content-Length", fmt.Sprintf("%v", contentLength))
|
||||
if blobContentType != nil {
|
||||
req.Header.Set("x-ms-blob-content-type", *blobContentType)
|
||||
}
|
||||
|
@ -244,7 +369,10 @@ func (client blockBlobsClient) putBlockListPreparer(blocks BlockLookupList, time
|
|||
req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
|
||||
}
|
||||
if blobContentMD5 != nil {
|
||||
req.Header.Set("x-ms-blob-content-md5", *blobContentMD5)
|
||||
req.Header.Set("x-ms-blob-content-md5", fmt.Sprintf("%v", blobContentMD5))
|
||||
}
|
||||
if blobCacheControl != nil {
|
||||
req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
|
||||
}
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
|
@ -273,23 +401,17 @@ func (client blockBlobsClient) putBlockListPreparer(blocks BlockLookupList, time
|
|||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
b, err := xml.Marshal(blocks)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to marshal request body")
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/xml")
|
||||
err = req.SetBody(bytes.NewReader(b))
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to set request body")
|
||||
}
|
||||
req.Header.Set("x-ms-blob-type", "BlockBlob")
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// putBlockListResponder handles the response to the PutBlockList request.
|
||||
func (client blockBlobsClient) putBlockListResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
// uploadResponder handles the response to the Upload request.
|
||||
func (client blockBlobsClient) uploadResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &BlockBlobsPutBlockListResponse{rawResponse: resp.Response()}, err
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &BlockBlobsUploadResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
|
|
@ -4,9 +4,8 @@ package azblob
|
|||
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
|
||||
|
||||
import (
|
||||
"net/url"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"net/url"
|
||||
)
|
||||
|
||||
const (
|
||||
|
|
|
@ -1,702 +0,0 @@
|
|||
package azblob
|
||||
|
||||
// Code generated by Microsoft (R) AutoRest Code Generator.
|
||||
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"time"
|
||||
)
|
||||
|
||||
// containerClient is the client for the Container methods of the Azblob service.
|
||||
type containerClient struct {
|
||||
managementClient
|
||||
}
|
||||
|
||||
// newContainerClient creates an instance of the containerClient client.
|
||||
func newContainerClient(url url.URL, p pipeline.Pipeline) containerClient {
|
||||
return containerClient{newManagementClient(url, p)}
|
||||
}
|
||||
|
||||
// Create creates a new container under the specified account. If the container with the same name already exists, the
|
||||
// operation fails
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> metadata is optional. Specifies a user-defined name-value pair associated
|
||||
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
|
||||
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
|
||||
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
|
||||
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
|
||||
// Containers, Blobs, and Metadata for more information. access is specifies whether data in the container may be
|
||||
// accessed publicly and the level of access requestID is provides a client-generated, opaque value with a 1 KB
|
||||
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client containerClient) Create(ctx context.Context, timeout *int32, metadata map[string]string, access PublicAccessType, requestID *string) (*ContainerCreateResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
|
||||
{targetValue: metadata,
|
||||
constraints: []constraint{{target: "metadata", name: null, rule: false,
|
||||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.createPreparer(timeout, metadata, access, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ContainerCreateResponse), err
|
||||
}
|
||||
|
||||
// createPreparer prepares the Create request.
|
||||
func (client containerClient) createPreparer(timeout *int32, metadata map[string]string, access PublicAccessType, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
req.Header.Set("x-ms-meta-"+k, v)
|
||||
}
|
||||
}
|
||||
if access != PublicAccessNone {
|
||||
req.Header.Set("x-ms-blob-public-access", fmt.Sprintf("%v", access))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// createResponder handles the response to the Create request.
|
||||
func (client containerClient) createResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ContainerCreateResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// Delete operation marks the specified container for deletion. The container and any blobs contained within it are
|
||||
// later deleted during garbage collection
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it
|
||||
// has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
|
||||
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
|
||||
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
|
||||
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
|
||||
// analytics logs when storage analytics logging is enabled.
|
||||
func (client containerClient) Delete(ctx context.Context, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*ContainerDeleteResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.deletePreparer(timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.deleteResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ContainerDeleteResponse), err
|
||||
}
|
||||
|
||||
// deletePreparer prepares the Delete request.
|
||||
func (client containerClient) deletePreparer(timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("DELETE", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// deleteResponder handles the response to the Delete request.
|
||||
func (client containerClient) deleteResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ContainerDeleteResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// GetACL sends the get acl request.
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
|
||||
// limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client containerClient) GetACL(ctx context.Context, timeout *int32, leaseID *string, requestID *string) (*SignedIdentifiers, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.getACLPreparer(timeout, leaseID, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getACLResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*SignedIdentifiers), err
|
||||
}
|
||||
|
||||
// getACLPreparer prepares the GetACL request.
|
||||
func (client containerClient) getACLPreparer(timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
params.Set("comp", "acl")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// getACLResponder handles the response to the GetACL request.
|
||||
func (client containerClient) getACLResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
result := &SignedIdentifiers{rawResponse: resp.Response()}
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
defer resp.Response().Body.Close()
|
||||
b, err := ioutil.ReadAll(resp.Response().Body)
|
||||
if err != nil {
|
||||
return result, NewResponseError(err, resp.Response(), "failed to read response body")
|
||||
}
|
||||
if len(b) > 0 {
|
||||
err = xml.Unmarshal(b, result)
|
||||
if err != nil {
|
||||
return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// GetMetadata returns all user-defined metadata for the container
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
|
||||
// limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client containerClient) GetMetadata(ctx context.Context, timeout *int32, leaseID *string, requestID *string) (*ContainerGetMetadataResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.getMetadataPreparer(timeout, leaseID, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getMetadataResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ContainerGetMetadataResponse), err
|
||||
}
|
||||
|
||||
// getMetadataPreparer prepares the GetMetadata request.
|
||||
func (client containerClient) getMetadataPreparer(timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
params.Set("comp", "metadata")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// getMetadataResponder handles the response to the GetMetadata request.
|
||||
func (client containerClient) getMetadataResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ContainerGetMetadataResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// GetProperties returns all user-defined metadata and system properties for the specified container. The data returned
|
||||
// does not include the container's list of blobs
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. requestID is provides a client-generated, opaque value with a 1 KB character
|
||||
// limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client containerClient) GetProperties(ctx context.Context, timeout *int32, leaseID *string, requestID *string) (*ContainerGetPropertiesResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.getPropertiesPreparer(timeout, leaseID, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getPropertiesResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ContainerGetPropertiesResponse), err
|
||||
}
|
||||
|
||||
// getPropertiesPreparer prepares the GetProperties request.
|
||||
func (client containerClient) getPropertiesPreparer(timeout *int32, leaseID *string, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// getPropertiesResponder handles the response to the GetProperties request.
|
||||
func (client containerClient) getPropertiesResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ContainerGetPropertiesResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// Lease establishes and manages a lock on a container for delete operations. The lock duration can be 15 to 60
|
||||
// seconds, or can be infinite
|
||||
//
|
||||
// action is describes what lease action to take. timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. breakPeriod is for a break operation, proposed duration the lease should
|
||||
// continue before it is broken, in seconds, between 0 and 60. This break period is only used if it is shorter than the
|
||||
// time remaining on the lease. If longer, the time remaining on the lease is used. A new lease will not be available
|
||||
// before the break period has expired, but the lease may be held for longer than the break period. If this header does
|
||||
// not appear with a break operation, a fixed-duration lease breaks after the remaining lease period elapses, and an
|
||||
// infinite lease breaks immediately. duration is specifies the duration of the lease, in seconds, or negative one (-1)
|
||||
// for a lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease duration cannot be
|
||||
// changed using renew or change. proposedLeaseID is proposed lease ID, in a GUID string format. The Blob service
|
||||
// returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid Constructor (String)
|
||||
// for a list of valid GUID string formats. ifModifiedSince is specify this header value to operate only on a blob if
|
||||
// it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only
|
||||
// on a blob if it has not been modified since the specified date/time. requestID is provides a client-generated,
|
||||
// opaque value with a 1 KB character limit that is recorded in the analytics logs when storage analytics logging is
|
||||
// enabled.
|
||||
func (client containerClient) Lease(ctx context.Context, action LeaseActionType, timeout *int32, leaseID *string, breakPeriod *int32, duration *int32, proposedLeaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, requestID *string) (*ContainerLeaseResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.leasePreparer(action, timeout, leaseID, breakPeriod, duration, proposedLeaseID, ifModifiedSince, ifUnmodifiedSince, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.leaseResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ContainerLeaseResponse), err
|
||||
}
|
||||
|
||||
// leasePreparer prepares the Lease request.
|
||||
func (client containerClient) leasePreparer(action LeaseActionType, timeout *int32, leaseID *string, breakPeriod *int32, duration *int32, proposedLeaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "lease")
|
||||
params.Set("restype", "container")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
req.Header.Set("x-ms-lease-action", fmt.Sprintf("%v", action))
|
||||
if breakPeriod != nil {
|
||||
req.Header.Set("x-ms-lease-break-period", fmt.Sprintf("%v", *breakPeriod))
|
||||
}
|
||||
if duration != nil {
|
||||
req.Header.Set("x-ms-lease-duration", fmt.Sprintf("%v", *duration))
|
||||
}
|
||||
if proposedLeaseID != nil {
|
||||
req.Header.Set("x-ms-proposed-lease-id", *proposedLeaseID)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// leaseResponder handles the response to the Lease request.
|
||||
func (client containerClient) leaseResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated, http.StatusAccepted)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ContainerLeaseResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// ListBlobs the List Blobs operation returns a list of the blobs under the specified container
|
||||
//
|
||||
// prefix is filters the results to return only containers whose name begins with the specified prefix. delimiter is
|
||||
// when the request includes this parameter, the operation returns a BlobPrefix element in the response body that acts
|
||||
// as a placeholder for all blobs whose names begin with the same substring up to the appearance of the delimiter
|
||||
// character. The delimiter may be a single character or a string. marker is a string value that identifies the portion
|
||||
// of the list of containers to be returned with the next listing operation. The operation returns the NextMarker value
|
||||
// within the response body if the listing operation did not return all containers remaining to be listed with the
|
||||
// current page. The NextMarker value can be used as the value for the marker parameter in a subsequent call to request
|
||||
// the next page of list items. The marker value is opaque to the client. maxresults is specifies the maximum number of
|
||||
// containers to return. If the request does not specify maxresults, or specifies a value greater than 5000, the server
|
||||
// will return up to 5000 items. Note that if the listing operation crosses a partition boundary, then the service will
|
||||
// return a continuation token for retrieving the remainder of the results. For this reason, it is possible that the
|
||||
// service will return fewer results than specified by maxresults, or than the default of 5000. include is include this
|
||||
// parameter to specify one or more datasets to include in the response. timeout is the timeout parameter is expressed
|
||||
// in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
|
||||
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client containerClient) ListBlobs(ctx context.Context, prefix *string, delimiter *string, marker *string, maxresults *int32, include ListBlobsIncludeType, timeout *int32, requestID *string) (*ListBlobsResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: maxresults,
|
||||
constraints: []constraint{{target: "maxresults", name: null, rule: false,
|
||||
chain: []constraint{{target: "maxresults", name: inclusiveMinimum, rule: 1, chain: nil}}}}},
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.listBlobsPreparer(prefix, delimiter, marker, maxresults, include, timeout, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.listBlobsResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ListBlobsResponse), err
|
||||
}
|
||||
|
||||
// listBlobsPreparer prepares the ListBlobs request.
|
||||
func (client containerClient) listBlobsPreparer(prefix *string, delimiter *string, marker *string, maxresults *int32, include ListBlobsIncludeType, timeout *int32, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if prefix != nil {
|
||||
params.Set("prefix", *prefix)
|
||||
}
|
||||
if delimiter != nil {
|
||||
params.Set("delimiter", *delimiter)
|
||||
}
|
||||
if marker != nil {
|
||||
params.Set("marker", *marker)
|
||||
}
|
||||
if maxresults != nil {
|
||||
params.Set("maxresults", fmt.Sprintf("%v", *maxresults))
|
||||
}
|
||||
if include != ListBlobsIncludeNone {
|
||||
params.Set("include", fmt.Sprintf("%v", include))
|
||||
}
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
params.Set("comp", "list")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// listBlobsResponder handles the response to the ListBlobs request.
|
||||
func (client containerClient) listBlobsResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
result := &ListBlobsResponse{rawResponse: resp.Response()}
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
defer resp.Response().Body.Close()
|
||||
b, err := ioutil.ReadAll(resp.Response().Body)
|
||||
if err != nil {
|
||||
return result, NewResponseError(err, resp.Response(), "failed to read response body")
|
||||
}
|
||||
if len(b) > 0 {
|
||||
err = xml.Unmarshal(b, result)
|
||||
if err != nil {
|
||||
return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// SetACL sends the set acl request.
|
||||
//
|
||||
// containerACL is the acls for the container timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. access is specifies whether data in the container may be accessed publicly and
|
||||
// the level of access ifModifiedSince is specify this header value to operate only on a blob if it has been modified
|
||||
// since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has
|
||||
// not been modified since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a
|
||||
// matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is
|
||||
// provides a client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when
|
||||
// storage analytics logging is enabled.
|
||||
func (client containerClient) SetACL(ctx context.Context, containerACL []SignedIdentifier, timeout *int32, leaseID *string, access PublicAccessType, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*ContainerSetACLResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.setACLPreparer(containerACL, timeout, leaseID, access, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setACLResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ContainerSetACLResponse), err
|
||||
}
|
||||
|
||||
// setACLPreparer prepares the SetACL request.
|
||||
func (client containerClient) setACLPreparer(containerACL []SignedIdentifier, timeout *int32, leaseID *string, access PublicAccessType, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
params.Set("comp", "acl")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if access != PublicAccessNone {
|
||||
req.Header.Set("x-ms-blob-public-access", fmt.Sprintf("%v", access))
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
b, err := xml.Marshal(SignedIdentifiers{Value: containerACL})
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to marshal request body")
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/xml")
|
||||
err = req.SetBody(bytes.NewReader(b))
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to set request body")
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// setACLResponder handles the response to the SetACL request.
|
||||
func (client containerClient) setACLResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ContainerSetACLResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// SetMetadata operation sets one or more user-defined name-value pairs for the specified container.
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. metadata is optional. Specifies a user-defined name-value pair associated with
|
||||
// the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to
|
||||
// the destination blob. If one or more name-value pairs are specified, the destination blob is created with the
|
||||
// specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
|
||||
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
|
||||
// Containers, Blobs, and Metadata for more information. ifModifiedSince is specify this header value to operate only
|
||||
// on a blob if it has been modified since the specified date/time. requestID is provides a client-generated, opaque
|
||||
// value with a 1 KB character limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client containerClient) SetMetadata(ctx context.Context, timeout *int32, leaseID *string, metadata map[string]string, ifModifiedSince *time.Time, requestID *string) (*ContainerSetMetadataResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
|
||||
{targetValue: metadata,
|
||||
constraints: []constraint{{target: "metadata", name: null, rule: false,
|
||||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.setMetadataPreparer(timeout, leaseID, metadata, ifModifiedSince, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setMetadataResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ContainerSetMetadataResponse), err
|
||||
}
|
||||
|
||||
// setMetadataPreparer prepares the SetMetadata request.
|
||||
func (client containerClient) setMetadataPreparer(timeout *int32, leaseID *string, metadata map[string]string, ifModifiedSince *time.Time, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("restype", "container")
|
||||
params.Set("comp", "metadata")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
req.Header.Set("x-ms-meta-"+k, v)
|
||||
}
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// setMetadataResponder handles the response to the SetMetadata request.
|
||||
func (client containerClient) setMetadataResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &ContainerSetMetadataResponse{rawResponse: resp.Response()}, err
|
||||
}
|
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
@ -1,224 +0,0 @@
|
|||
package azblob
|
||||
|
||||
// Code generated by Microsoft (R) AutoRest Code Generator.
|
||||
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
|
||||
|
||||
import (
|
||||
"encoding/xml"
|
||||
"reflect"
|
||||
"time"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
const (
|
||||
rfc3339Format = "2006-01-02T15:04:05.0000000Z07:00"
|
||||
)
|
||||
|
||||
// used to convert times from UTC to GMT before sending across the wire
|
||||
var gmt = time.FixedZone("GMT", 0)
|
||||
|
||||
// internal type used for marshalling time in RFC1123 format
|
||||
type timeRFC1123 struct {
|
||||
time.Time
|
||||
}
|
||||
|
||||
// MarshalText implements the encoding.TextMarshaler interface for timeRFC1123.
|
||||
func (t timeRFC1123) MarshalText() ([]byte, error) {
|
||||
return []byte(t.Format(time.RFC1123)), nil
|
||||
}
|
||||
|
||||
// UnmarshalText implements the encoding.TextUnmarshaler interface for timeRFC1123.
|
||||
func (t *timeRFC1123) UnmarshalText(data []byte) (err error) {
|
||||
t.Time, err = time.Parse(time.RFC1123, string(data))
|
||||
return
|
||||
}
|
||||
|
||||
// internal type used for marshalling time in RFC3339 format
|
||||
type timeRFC3339 struct {
|
||||
time.Time
|
||||
}
|
||||
|
||||
// MarshalText implements the encoding.TextMarshaler interface for timeRFC3339.
|
||||
func (t timeRFC3339) MarshalText() ([]byte, error) {
|
||||
return []byte(t.Format(rfc3339Format)), nil
|
||||
}
|
||||
|
||||
// UnmarshalText implements the encoding.TextUnmarshaler interface for timeRFC3339.
|
||||
func (t *timeRFC3339) UnmarshalText(data []byte) (err error) {
|
||||
t.Time, err = time.Parse(rfc3339Format, string(data))
|
||||
return
|
||||
}
|
||||
|
||||
// internal type used for marshalling
|
||||
type accessPolicy struct {
|
||||
Start timeRFC3339 `xml:"Start"`
|
||||
Expiry timeRFC3339 `xml:"Expiry"`
|
||||
Permission string `xml:"Permission"`
|
||||
}
|
||||
|
||||
// MarshalXML implements the xml.Marshaler interface for AccessPolicy.
|
||||
func (ap AccessPolicy) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*AccessPolicy)(nil)).Elem().Size() != reflect.TypeOf((*accessPolicy)(nil)).Elem().Size() {
|
||||
panic("size mismatch between AccessPolicy and accessPolicy")
|
||||
}
|
||||
ap2 := (*accessPolicy)(unsafe.Pointer(&ap))
|
||||
return e.EncodeElement(*ap2, start)
|
||||
}
|
||||
|
||||
// UnmarshalXML implements the xml.Unmarshaler interface for AccessPolicy.
|
||||
func (ap *AccessPolicy) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*AccessPolicy)(nil)).Elem().Size() != reflect.TypeOf((*accessPolicy)(nil)).Elem().Size() {
|
||||
panic("size mismatch between AccessPolicy and accessPolicy")
|
||||
}
|
||||
ap2 := (*accessPolicy)(unsafe.Pointer(ap))
|
||||
err := d.DecodeElement(ap2, &start)
|
||||
if err != nil {
|
||||
ap = (*AccessPolicy)(unsafe.Pointer(ap2))
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// internal type used for marshalling
|
||||
type blobProperties struct {
|
||||
LastModified timeRFC1123 `xml:"Last-Modified"`
|
||||
Etag ETag `xml:"Etag"`
|
||||
ContentLength *int64 `xml:"Content-Length"`
|
||||
ContentType *string `xml:"Content-Type"`
|
||||
ContentEncoding *string `xml:"Content-Encoding"`
|
||||
ContentLanguage *string `xml:"Content-Language"`
|
||||
ContentMD5 *string `xml:"Content-MD5"`
|
||||
ContentDisposition *string `xml:"Content-Disposition"`
|
||||
CacheControl *string `xml:"Cache-Control"`
|
||||
BlobSequenceNumber *int32 `xml:"x-ms-blob-sequence-number"`
|
||||
BlobType BlobType `xml:"BlobType"`
|
||||
LeaseStatus LeaseStatusType `xml:"LeaseStatus"`
|
||||
LeaseState LeaseStateType `xml:"LeaseState"`
|
||||
LeaseDuration LeaseDurationType `xml:"LeaseDuration"`
|
||||
CopyID *string `xml:"CopyId"`
|
||||
CopyStatus CopyStatusType `xml:"CopyStatus"`
|
||||
CopySource *string `xml:"CopySource"`
|
||||
CopyProgress *string `xml:"CopyProgress"`
|
||||
CopyCompletionTime *timeRFC1123 `xml:"CopyCompletionTime"`
|
||||
CopyStatusDescription *string `xml:"CopyStatusDescription"`
|
||||
ServerEncrypted *bool `xml:"ServerEncrypted"`
|
||||
IncrementalCopy *bool `xml:"IncrementalCopy"`
|
||||
DestinationSnapshot *timeRFC3339 `xml:"DestinationSnapshot"`
|
||||
AccessTier AccessTierType `xml:"AccessTier"`
|
||||
AccessTierInferred *bool `xml:"AccessTierInferred"`
|
||||
ArchiveStatus ArchiveStatusType `xml:"ArchiveStatus"`
|
||||
DeletedTime *timeRFC1123 `xml:"DeletedTime"`
|
||||
RemainingRetentionDays *int32 `xml:"RemainingRetentionDays"`
|
||||
}
|
||||
|
||||
// MarshalXML implements the xml.Marshaler interface for BlobProperties.
|
||||
func (bp BlobProperties) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*BlobProperties)(nil)).Elem().Size() != reflect.TypeOf((*blobProperties)(nil)).Elem().Size() {
|
||||
panic("size mismatch between BlobProperties and blobProperties")
|
||||
}
|
||||
bp2 := (*blobProperties)(unsafe.Pointer(&bp))
|
||||
return e.EncodeElement(*bp2, start)
|
||||
}
|
||||
|
||||
// UnmarshalXML implements the xml.Unmarshaler interface for BlobProperties.
|
||||
func (bp *BlobProperties) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*BlobProperties)(nil)).Elem().Size() != reflect.TypeOf((*blobProperties)(nil)).Elem().Size() {
|
||||
panic("size mismatch between BlobProperties and blobProperties")
|
||||
}
|
||||
bp2 := (*blobProperties)(unsafe.Pointer(bp))
|
||||
err := d.DecodeElement(bp2, &start)
|
||||
if err != nil {
|
||||
bp = (*BlobProperties)(unsafe.Pointer(bp2))
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// internal type used for marshalling
|
||||
type blob struct {
|
||||
Name string `xml:"Name"`
|
||||
Deleted bool `xml:"Deleted"`
|
||||
Snapshot timeRFC3339 `xml:"Snapshot"`
|
||||
Properties BlobProperties `xml:"Properties"`
|
||||
Metadata Metadata `xml:"Metadata"`
|
||||
}
|
||||
|
||||
// MarshalXML implements the xml.Marshaler interface for Blob.
|
||||
func (b Blob) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*Blob)(nil)).Elem().Size() != reflect.TypeOf((*blob)(nil)).Elem().Size() {
|
||||
panic("size mismatch between Blob and blob")
|
||||
}
|
||||
b2 := (*blob)(unsafe.Pointer(&b))
|
||||
return e.EncodeElement(*b2, start)
|
||||
}
|
||||
|
||||
// UnmarshalXML implements the xml.Unmarshaler interface for Blob.
|
||||
func (b *Blob) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*Blob)(nil)).Elem().Size() != reflect.TypeOf((*blob)(nil)).Elem().Size() {
|
||||
panic("size mismatch between Blob and blob")
|
||||
}
|
||||
b2 := (*blob)(unsafe.Pointer(b))
|
||||
err := d.DecodeElement(b2, &start)
|
||||
if err != nil {
|
||||
b = (*Blob)(unsafe.Pointer(b2))
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// internal type used for marshalling
|
||||
type containerProperties struct {
|
||||
LastModified timeRFC1123 `xml:"Last-Modified"`
|
||||
Etag ETag `xml:"Etag"`
|
||||
LeaseStatus LeaseStatusType `xml:"LeaseStatus"`
|
||||
LeaseState LeaseStateType `xml:"LeaseState"`
|
||||
LeaseDuration LeaseDurationType `xml:"LeaseDuration"`
|
||||
PublicAccess PublicAccessType `xml:"PublicAccess"`
|
||||
}
|
||||
|
||||
// MarshalXML implements the xml.Marshaler interface for ContainerProperties.
|
||||
func (cp ContainerProperties) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*ContainerProperties)(nil)).Elem().Size() != reflect.TypeOf((*containerProperties)(nil)).Elem().Size() {
|
||||
panic("size mismatch between ContainerProperties and containerProperties")
|
||||
}
|
||||
cp2 := (*containerProperties)(unsafe.Pointer(&cp))
|
||||
return e.EncodeElement(*cp2, start)
|
||||
}
|
||||
|
||||
// UnmarshalXML implements the xml.Unmarshaler interface for ContainerProperties.
|
||||
func (cp *ContainerProperties) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*ContainerProperties)(nil)).Elem().Size() != reflect.TypeOf((*containerProperties)(nil)).Elem().Size() {
|
||||
panic("size mismatch between ContainerProperties and containerProperties")
|
||||
}
|
||||
cp2 := (*containerProperties)(unsafe.Pointer(cp))
|
||||
err := d.DecodeElement(cp2, &start)
|
||||
if err != nil {
|
||||
cp = (*ContainerProperties)(unsafe.Pointer(cp2))
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// internal type used for marshalling
|
||||
type geoReplication struct {
|
||||
Status GeoReplicationStatusType `xml:"Status"`
|
||||
LastSyncTime timeRFC1123 `xml:"LastSyncTime"`
|
||||
}
|
||||
|
||||
// MarshalXML implements the xml.Marshaler interface for GeoReplication.
|
||||
func (gr GeoReplication) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*GeoReplication)(nil)).Elem().Size() != reflect.TypeOf((*geoReplication)(nil)).Elem().Size() {
|
||||
panic("size mismatch between GeoReplication and geoReplication")
|
||||
}
|
||||
gr2 := (*geoReplication)(unsafe.Pointer(&gr))
|
||||
return e.EncodeElement(*gr2, start)
|
||||
}
|
||||
|
||||
// UnmarshalXML implements the xml.Unmarshaler interface for GeoReplication.
|
||||
func (gr *GeoReplication) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
||||
if reflect.TypeOf((*GeoReplication)(nil)).Elem().Size() != reflect.TypeOf((*geoReplication)(nil)).Elem().Size() {
|
||||
panic("size mismatch between GeoReplication and geoReplication")
|
||||
}
|
||||
gr2 := (*geoReplication)(unsafe.Pointer(gr))
|
||||
err := d.DecodeElement(gr2, &start)
|
||||
if err != nil {
|
||||
gr = (*GeoReplication)(unsafe.Pointer(gr2))
|
||||
}
|
||||
return err
|
||||
}
|
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
@ -25,6 +25,313 @@ func newPageBlobsClient(url url.URL, p pipeline.Pipeline) pageBlobsClient {
|
|||
return pageBlobsClient{newManagementClient(url, p)}
|
||||
}
|
||||
|
||||
// ClearPages the Clear Pages operation clears a set of pages from a page blob
|
||||
//
|
||||
// contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> rangeParameter is return only the bytes of the blob in the specified
|
||||
// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
|
||||
// ifSequenceNumberLessThanOrEqualTo is specify this header value to operate only on a blob if it has a sequence number
|
||||
// less than or equal to the specified. ifSequenceNumberLessThan is specify this header value to operate only on a blob
|
||||
// if it has a sequence number less than the specified. ifSequenceNumberEqualTo is specify this header value to operate
|
||||
// only on a blob if it has the specified sequence number. ifModifiedSince is specify this header value to operate only
|
||||
// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
|
||||
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
|
||||
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
|
||||
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
|
||||
// recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client pageBlobsClient) ClearPages(ctx context.Context, contentLength int64, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobsClearPagesResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.clearPagesPreparer(contentLength, timeout, rangeParameter, leaseID, ifSequenceNumberLessThanOrEqualTo, ifSequenceNumberLessThan, ifSequenceNumberEqualTo, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.clearPagesResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*PageBlobsClearPagesResponse), err
|
||||
}
|
||||
|
||||
// clearPagesPreparer prepares the ClearPages request.
|
||||
func (client pageBlobsClient) clearPagesPreparer(contentLength int64, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "page")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
req.Header.Set("Content-Length", fmt.Sprintf("%v", contentLength))
|
||||
if rangeParameter != nil {
|
||||
req.Header.Set("x-ms-range", *rangeParameter)
|
||||
}
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if ifSequenceNumberLessThanOrEqualTo != nil {
|
||||
req.Header.Set("x-ms-if-sequence-number-le", fmt.Sprintf("%v", *ifSequenceNumberLessThanOrEqualTo))
|
||||
}
|
||||
if ifSequenceNumberLessThan != nil {
|
||||
req.Header.Set("x-ms-if-sequence-number-lt", fmt.Sprintf("%v", *ifSequenceNumberLessThan))
|
||||
}
|
||||
if ifSequenceNumberEqualTo != nil {
|
||||
req.Header.Set("x-ms-if-sequence-number-eq", fmt.Sprintf("%v", *ifSequenceNumberEqualTo))
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
req.Header.Set("x-ms-page-write", "clear")
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// clearPagesResponder handles the response to the ClearPages request.
|
||||
func (client pageBlobsClient) clearPagesResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &PageBlobsClearPagesResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// CopyIncremental the Copy Incremental operation copies a snapshot of the source page blob to a destination page blob.
|
||||
// The snapshot is copied such that only the differential changes between the previously copied snapshot are
|
||||
// transferred to the destination. The copied snapshots are complete copies of the original snapshot and can be read or
|
||||
// copied from as usual. This API is supported since REST version 2016-05-31.
|
||||
//
|
||||
// copySource is specifies the name of the source page blob snapshot. This value is a URL of up to 2 KB in length that
|
||||
// specifies a page blob snapshot. The value should be URL-encoded as it would appear in a request URI. The source blob
|
||||
// must either be public or must be authenticated via a shared access signature. timeout is the timeout parameter is
|
||||
// expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> metadata is optional. Specifies a user-defined name-value pair associated
|
||||
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
|
||||
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
|
||||
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
|
||||
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
|
||||
// Containers, Blobs, and Metadata for more information. ifModifiedSince is specify this header value to operate only
|
||||
// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
|
||||
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
|
||||
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
|
||||
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
|
||||
// recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client pageBlobsClient) CopyIncremental(ctx context.Context, copySource string, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobsCopyIncrementalResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
|
||||
{targetValue: metadata,
|
||||
constraints: []constraint{{target: "metadata", name: null, rule: false,
|
||||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.copyIncrementalPreparer(copySource, timeout, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.copyIncrementalResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*PageBlobsCopyIncrementalResponse), err
|
||||
}
|
||||
|
||||
// copyIncrementalPreparer prepares the CopyIncremental request.
|
||||
func (client pageBlobsClient) copyIncrementalPreparer(copySource string, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "incrementalcopy")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
req.Header.Set("x-ms-meta-"+k, v)
|
||||
}
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-copy-source", copySource)
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// copyIncrementalResponder handles the response to the CopyIncremental request.
|
||||
func (client pageBlobsClient) copyIncrementalResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &PageBlobsCopyIncrementalResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// Create the Create operation creates a new page blob.
|
||||
//
|
||||
// contentLength is the length of the request. timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> blobContentType is optional. Sets the blob's content type. If specified,
|
||||
// this property is stored with the blob and returned with a read request. blobContentEncoding is optional. Sets the
|
||||
// blob's content encoding. If specified, this property is stored with the blob and returned with a read request.
|
||||
// blobContentLanguage is optional. Set the blob's content language. If specified, this property is stored with the
|
||||
// blob and returned with a read request. blobContentMD5 is optional. An MD5 hash of the blob content. Note that this
|
||||
// hash is not validated, as the hashes for the individual blocks were validated when each was uploaded.
|
||||
// blobCacheControl is optional. Sets the blob's cache control. If specified, this property is stored with the blob and
|
||||
// returned with a read request. metadata is optional. Specifies a user-defined name-value pair associated with the
|
||||
// blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or file to the
|
||||
// destination blob. If one or more name-value pairs are specified, the destination blob is created with the specified
|
||||
// metadata, and metadata is not copied from the source blob or file. Note that beginning with version 2009-09-19,
|
||||
// metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing Containers, Blobs, and
|
||||
// Metadata for more information. leaseID is if specified, the operation only succeeds if the container's lease is
|
||||
// active and matches this ID. blobContentDisposition is optional. Sets the blob's Content-Disposition header.
|
||||
// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
|
||||
// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
|
||||
// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
|
||||
// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. blobContentLength is this
|
||||
// header specifies the maximum size for the page blob, up to 1 TB. The page blob size must be aligned to a 512-byte
|
||||
// boundary. blobSequenceNumber is set for page blobs only. The sequence number is a user-controlled value that you can
|
||||
// use to track requests. The value of the sequence number must be between 0 and 2^63 - 1. requestID is provides a
|
||||
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
|
||||
// analytics logging is enabled.
|
||||
func (client pageBlobsClient) Create(ctx context.Context, contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentLength *int64, blobSequenceNumber *int64, requestID *string) (*PageBlobsCreateResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
|
||||
{targetValue: metadata,
|
||||
constraints: []constraint{{target: "metadata", name: null, rule: false,
|
||||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.createPreparer(contentLength, timeout, blobContentType, blobContentEncoding, blobContentLanguage, blobContentMD5, blobCacheControl, metadata, leaseID, blobContentDisposition, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, blobContentLength, blobSequenceNumber, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*PageBlobsCreateResponse), err
|
||||
}
|
||||
|
||||
// createPreparer prepares the Create request.
|
||||
func (client pageBlobsClient) createPreparer(contentLength int64, timeout *int32, blobContentType *string, blobContentEncoding *string, blobContentLanguage *string, blobContentMD5 []byte, blobCacheControl *string, metadata map[string]string, leaseID *string, blobContentDisposition *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentLength *int64, blobSequenceNumber *int64, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
req.URL.RawQuery = params.Encode()
|
||||
req.Header.Set("Content-Length", fmt.Sprintf("%v", contentLength))
|
||||
if blobContentType != nil {
|
||||
req.Header.Set("x-ms-blob-content-type", *blobContentType)
|
||||
}
|
||||
if blobContentEncoding != nil {
|
||||
req.Header.Set("x-ms-blob-content-encoding", *blobContentEncoding)
|
||||
}
|
||||
if blobContentLanguage != nil {
|
||||
req.Header.Set("x-ms-blob-content-language", *blobContentLanguage)
|
||||
}
|
||||
if blobContentMD5 != nil {
|
||||
req.Header.Set("x-ms-blob-content-md5", fmt.Sprintf("%v", blobContentMD5))
|
||||
}
|
||||
if blobCacheControl != nil {
|
||||
req.Header.Set("x-ms-blob-cache-control", *blobCacheControl)
|
||||
}
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
req.Header.Set("x-ms-meta-"+k, v)
|
||||
}
|
||||
}
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if blobContentDisposition != nil {
|
||||
req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
if blobContentLength != nil {
|
||||
req.Header.Set("x-ms-blob-content-length", fmt.Sprintf("%v", *blobContentLength))
|
||||
}
|
||||
if blobSequenceNumber != nil {
|
||||
req.Header.Set("x-ms-blob-sequence-number", fmt.Sprintf("%v", *blobSequenceNumber))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
req.Header.Set("x-ms-blob-type", "PageBlob")
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// createResponder handles the response to the Create request.
|
||||
func (client pageBlobsClient) createResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &PageBlobsCreateResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// GetPageRanges the Get Page Ranges operation returns the list of valid page ranges for a page blob or snapshot of a
|
||||
// page blob
|
||||
//
|
||||
|
@ -33,26 +340,22 @@ func newPageBlobsClient(url url.URL, p pipeline.Pipeline) pageBlobsClient {
|
|||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
|
||||
// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> prevsnapshot is optional in version 2015-07-08 and newer. The prevsnapshot
|
||||
// parameter is a DateTime value that specifies that the response will contain only pages that were changed between
|
||||
// target blob and previous snapshot. Changed pages include both updated and cleared pages. The target blob may be a
|
||||
// snapshot, as long as the snapshot specified by prevsnapshot is the older of the two. Note that incremental snapshots
|
||||
// are currently supported only for blobs created on or after January 1, 2016. rangeParameter is return only the bytes
|
||||
// of the blob in the specified range. leaseID is if specified, the operation only succeeds if the container's lease is
|
||||
// active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it has been
|
||||
// modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if
|
||||
// it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only on blobs
|
||||
// with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching value.
|
||||
// requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the analytics
|
||||
// logs when storage analytics logging is enabled.
|
||||
func (client pageBlobsClient) GetPageRanges(ctx context.Context, snapshot *time.Time, timeout *int32, prevsnapshot *time.Time, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageList, error) {
|
||||
// Timeouts for Blob Service Operations.</a> rangeParameter is return only the bytes of the blob in the specified
|
||||
// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
|
||||
// ifModifiedSince is specify this header value to operate only on a blob if it has been modified since the specified
|
||||
// date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if it has not been modified
|
||||
// since the specified date/time. ifMatches is specify an ETag value to operate only on blobs with a matching value.
|
||||
// ifNoneMatch is specify an ETag value to operate only on blobs without a matching value. requestID is provides a
|
||||
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
|
||||
// analytics logging is enabled.
|
||||
func (client pageBlobsClient) GetPageRanges(ctx context.Context, snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageList, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.getPageRangesPreparer(snapshot, timeout, prevsnapshot, rangeParameter, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
req, err := client.getPageRangesPreparer(snapshot, timeout, rangeParameter, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
@ -64,21 +367,18 @@ func (client pageBlobsClient) GetPageRanges(ctx context.Context, snapshot *time.
|
|||
}
|
||||
|
||||
// getPageRangesPreparer prepares the GetPageRanges request.
|
||||
func (client pageBlobsClient) getPageRangesPreparer(snapshot *time.Time, timeout *int32, prevsnapshot *time.Time, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
func (client pageBlobsClient) getPageRangesPreparer(snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if snapshot != nil {
|
||||
params.Set("snapshot", (*snapshot).Format(rfc3339Format))
|
||||
if snapshot != nil && len(*snapshot) > 0 {
|
||||
params.Set("snapshot", *snapshot)
|
||||
}
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
if prevsnapshot != nil {
|
||||
params.Set("prevsnapshot", (*prevsnapshot).Format(rfc3339Format))
|
||||
}
|
||||
params.Set("comp", "pagelist")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if rangeParameter != nil {
|
||||
|
@ -130,64 +430,67 @@ func (client pageBlobsClient) getPageRangesResponder(resp pipeline.Response) (pi
|
|||
return result, nil
|
||||
}
|
||||
|
||||
// IncrementalCopy the Incremental Copy Blob operation copies a snapshot of the source page blob to a destination page
|
||||
// blob. The snapshot is copied such that only the differential changes between the previously copied snapshot are
|
||||
// transferred to the destination. The copied snapshots are complete copies of the original snapshot and can be read or
|
||||
// copied from as usual. This API is supported since REST version 2016-05-31.
|
||||
// GetPageRangesDiff [Update] The Get Page Ranges Diff operation returns the list of valid page ranges for a page blob
|
||||
// that were changed between target blob and previous snapshot.
|
||||
//
|
||||
// copySource is specifies the name of the source page blob snapshot. This value is a URL of up to 2 KB in length that
|
||||
// specifies a page blob snapshot. The value should be URL-encoded as it would appear in a request URI. The source blob
|
||||
// must either be public or must be authenticated via a shared access signature. timeout is the timeout parameter is
|
||||
// expressed in seconds. For more information, see <a
|
||||
// snapshot is the snapshot parameter is an opaque DateTime value that, when present, specifies the blob snapshot to
|
||||
// retrieve. For more information on working with blob snapshots, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/creating-a-snapshot-of-a-blob">Creating
|
||||
// a Snapshot of a Blob.</a> timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> metadata is optional. Specifies a user-defined name-value pair associated
|
||||
// with the blob. If no name-value pairs are specified, the operation will copy the metadata from the source blob or
|
||||
// file to the destination blob. If one or more name-value pairs are specified, the destination blob is created with
|
||||
// the specified metadata, and metadata is not copied from the source blob or file. Note that beginning with version
|
||||
// 2009-09-19, metadata names must adhere to the naming rules for C# identifiers. See Naming and Referencing
|
||||
// Containers, Blobs, and Metadata for more information. ifModifiedSince is specify this header value to operate only
|
||||
// on a blob if it has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to
|
||||
// operate only on a blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value
|
||||
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
|
||||
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
|
||||
// recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client pageBlobsClient) IncrementalCopy(ctx context.Context, copySource string, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobsIncrementalCopyResponse, error) {
|
||||
// Timeouts for Blob Service Operations.</a> prevsnapshot is optional in version 2015-07-08 and newer. The prevsnapshot
|
||||
// parameter is a DateTime value that specifies that the response will contain only pages that were changed between
|
||||
// target blob and previous snapshot. Changed pages include both updated and cleared pages. The target blob may be a
|
||||
// snapshot, as long as the snapshot specified by prevsnapshot is the older of the two. Note that incremental snapshots
|
||||
// are currently supported only for blobs created on or after January 1, 2016. rangeParameter is return only the bytes
|
||||
// of the blob in the specified range. leaseID is if specified, the operation only succeeds if the container's lease is
|
||||
// active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it has been
|
||||
// modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a blob if
|
||||
// it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only on blobs
|
||||
// with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching value.
|
||||
// requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the analytics
|
||||
// logs when storage analytics logging is enabled.
|
||||
func (client pageBlobsClient) GetPageRangesDiff(ctx context.Context, snapshot *string, timeout *int32, prevsnapshot *string, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageList, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}},
|
||||
{targetValue: metadata,
|
||||
constraints: []constraint{{target: "metadata", name: null, rule: false,
|
||||
chain: []constraint{{target: "metadata", name: pattern, rule: `^[a-zA-Z]+$`, chain: nil}}}}}}); err != nil {
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.incrementalCopyPreparer(copySource, timeout, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
req, err := client.getPageRangesDiffPreparer(snapshot, timeout, prevsnapshot, rangeParameter, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.incrementalCopyResponder}, req)
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getPageRangesDiffResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*PageBlobsIncrementalCopyResponse), err
|
||||
return resp.(*PageList), err
|
||||
}
|
||||
|
||||
// incrementalCopyPreparer prepares the IncrementalCopy request.
|
||||
func (client pageBlobsClient) incrementalCopyPreparer(copySource string, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
// getPageRangesDiffPreparer prepares the GetPageRangesDiff request.
|
||||
func (client pageBlobsClient) getPageRangesDiffPreparer(snapshot *string, timeout *int32, prevsnapshot *string, rangeParameter *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if snapshot != nil && len(*snapshot) > 0 {
|
||||
params.Set("snapshot", *snapshot)
|
||||
}
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "incrementalcopy")
|
||||
if prevsnapshot != nil && len(*prevsnapshot) > 0 {
|
||||
params.Set("prevsnapshot", *prevsnapshot)
|
||||
}
|
||||
params.Set("comp", "pagelist")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if metadata != nil {
|
||||
for k, v := range metadata {
|
||||
req.Header.Set("x-ms-meta-"+k, v)
|
||||
}
|
||||
if rangeParameter != nil {
|
||||
req.Header.Set("x-ms-range", *rangeParameter)
|
||||
}
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
|
@ -201,7 +504,6 @@ func (client pageBlobsClient) incrementalCopyPreparer(copySource string, timeout
|
|||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-copy-source", copySource)
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
|
@ -209,24 +511,194 @@ func (client pageBlobsClient) incrementalCopyPreparer(copySource string, timeout
|
|||
return req, nil
|
||||
}
|
||||
|
||||
// incrementalCopyResponder handles the response to the IncrementalCopy request.
|
||||
func (client pageBlobsClient) incrementalCopyResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusAccepted)
|
||||
// getPageRangesDiffResponder handles the response to the GetPageRangesDiff request.
|
||||
func (client pageBlobsClient) getPageRangesDiffResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &PageBlobsIncrementalCopyResponse{rawResponse: resp.Response()}, err
|
||||
result := &PageList{rawResponse: resp.Response()}
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
defer resp.Response().Body.Close()
|
||||
b, err := ioutil.ReadAll(resp.Response().Body)
|
||||
if err != nil {
|
||||
return result, NewResponseError(err, resp.Response(), "failed to read response body")
|
||||
}
|
||||
if len(b) > 0 {
|
||||
err = xml.Unmarshal(b, result)
|
||||
if err != nil {
|
||||
return result, NewResponseError(err, resp.Response(), "failed to unmarshal response body")
|
||||
}
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
// PutPage the Put Page operation writes a range of pages to a page blob
|
||||
// Resize resize the Blob
|
||||
//
|
||||
// pageWrite is required. You may specify one of the following options:
|
||||
// - Update: Writes the bytes specified by the request body into the specified range. The Range and Content-Length
|
||||
// headers must match to perform the update.
|
||||
// - Clear: Clears the specified range and releases the space used in storage for that range. To clear a range, set the
|
||||
// Content-Length header to zero, and the Range header to a value that indicates the range to clear, up to maximum blob
|
||||
// size. optionalbody is initial data optionalbody will be closed upon successful return. Callers should ensure closure
|
||||
// when receiving an error.timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// blobContentLength is this header specifies the maximum size for the page blob, up to 1 TB. The page blob size must
|
||||
// be aligned to a 512-byte boundary. timeout is the timeout parameter is expressed in seconds. For more information,
|
||||
// see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it
|
||||
// has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
|
||||
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
|
||||
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
|
||||
// value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is recorded in the
|
||||
// analytics logs when storage analytics logging is enabled.
|
||||
func (client pageBlobsClient) Resize(ctx context.Context, blobContentLength int64, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobsResizeResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.resizePreparer(blobContentLength, timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.resizeResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*PageBlobsResizeResponse), err
|
||||
}
|
||||
|
||||
// resizePreparer prepares the Resize request.
|
||||
func (client pageBlobsClient) resizePreparer(blobContentLength int64, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "properties")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-blob-content-length", fmt.Sprintf("%v", blobContentLength))
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// resizeResponder handles the response to the Resize request.
|
||||
func (client pageBlobsClient) resizeResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &PageBlobsResizeResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// UpdateSequenceNumber update the sequence number of the blob
|
||||
//
|
||||
// sequenceNumberAction is required if the x-ms-blob-sequence-number header is set for the request. This property
|
||||
// applies to page blobs only. This property indicates how the service should modify the blob's sequence number timeout
|
||||
// is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> leaseID is if specified, the operation only succeeds if the container's
|
||||
// lease is active and matches this ID. ifModifiedSince is specify this header value to operate only on a blob if it
|
||||
// has been modified since the specified date/time. ifUnmodifiedSince is specify this header value to operate only on a
|
||||
// blob if it has not been modified since the specified date/time. ifMatches is specify an ETag value to operate only
|
||||
// on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs without a matching
|
||||
// value. blobSequenceNumber is set for page blobs only. The sequence number is a user-controlled value that you can
|
||||
// use to track requests. The value of the sequence number must be between 0 and 2^63 - 1. requestID is provides a
|
||||
// client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage
|
||||
// analytics logging is enabled.
|
||||
func (client pageBlobsClient) UpdateSequenceNumber(ctx context.Context, sequenceNumberAction SequenceNumberActionType, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobSequenceNumber *int64, requestID *string) (*PageBlobsUpdateSequenceNumberResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.updateSequenceNumberPreparer(sequenceNumberAction, timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, blobSequenceNumber, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.updateSequenceNumberResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*PageBlobsUpdateSequenceNumberResponse), err
|
||||
}
|
||||
|
||||
// updateSequenceNumberPreparer prepares the UpdateSequenceNumber request.
|
||||
func (client pageBlobsClient) updateSequenceNumberPreparer(sequenceNumberAction SequenceNumberActionType, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobSequenceNumber *int64, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if timeout != nil {
|
||||
params.Set("timeout", fmt.Sprintf("%v", *timeout))
|
||||
}
|
||||
params.Set("comp", "properties")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
if ifModifiedSince != nil {
|
||||
req.Header.Set("If-Modified-Since", (*ifModifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifUnmodifiedSince != nil {
|
||||
req.Header.Set("If-Unmodified-Since", (*ifUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
||||
}
|
||||
if ifMatches != nil {
|
||||
req.Header.Set("If-Match", string(*ifMatches))
|
||||
}
|
||||
if ifNoneMatch != nil {
|
||||
req.Header.Set("If-None-Match", string(*ifNoneMatch))
|
||||
}
|
||||
req.Header.Set("x-ms-sequence-number-action", fmt.Sprintf("%v", sequenceNumberAction))
|
||||
if blobSequenceNumber != nil {
|
||||
req.Header.Set("x-ms-blob-sequence-number", fmt.Sprintf("%v", *blobSequenceNumber))
|
||||
}
|
||||
req.Header.Set("x-ms-version", ServiceVersion)
|
||||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// updateSequenceNumberResponder handles the response to the UpdateSequenceNumber request.
|
||||
func (client pageBlobsClient) updateSequenceNumberResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &PageBlobsUpdateSequenceNumberResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
||||
// UploadPages the Upload Pages operation writes a range of pages to a page blob
|
||||
//
|
||||
// contentLength is the length of the request. body is initial data body will be closed upon successful return. Callers
|
||||
// should ensure closure when receiving an error.timeout is the timeout parameter is expressed in seconds. For more
|
||||
// information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> rangeParameter is return only the bytes of the blob in the specified
|
||||
// range. leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
|
||||
|
@ -239,26 +711,26 @@ func (client pageBlobsClient) incrementalCopyResponder(resp pipeline.Response) (
|
|||
// to operate only on blobs with a matching value. ifNoneMatch is specify an ETag value to operate only on blobs
|
||||
// without a matching value. requestID is provides a client-generated, opaque value with a 1 KB character limit that is
|
||||
// recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client pageBlobsClient) PutPage(ctx context.Context, pageWrite PageWriteType, body io.ReadSeeker, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int32, ifSequenceNumberLessThan *int32, ifSequenceNumberEqualTo *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobsPutPageResponse, error) {
|
||||
func (client pageBlobsClient) UploadPages(ctx context.Context, contentLength int64, body io.ReadSeeker, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*PageBlobsUploadPagesResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.putPagePreparer(pageWrite, body, timeout, rangeParameter, leaseID, ifSequenceNumberLessThanOrEqualTo, ifSequenceNumberLessThan, ifSequenceNumberEqualTo, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
req, err := client.uploadPagesPreparer(contentLength, body, timeout, rangeParameter, leaseID, ifSequenceNumberLessThanOrEqualTo, ifSequenceNumberLessThan, ifSequenceNumberEqualTo, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.putPageResponder}, req)
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.uploadPagesResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*PageBlobsPutPageResponse), err
|
||||
return resp.(*PageBlobsUploadPagesResponse), err
|
||||
}
|
||||
|
||||
// putPagePreparer prepares the PutPage request.
|
||||
func (client pageBlobsClient) putPagePreparer(pageWrite PageWriteType, body io.ReadSeeker, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int32, ifSequenceNumberLessThan *int32, ifSequenceNumberEqualTo *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
// uploadPagesPreparer prepares the UploadPages request.
|
||||
func (client pageBlobsClient) uploadPagesPreparer(contentLength int64, body io.ReadSeeker, timeout *int32, rangeParameter *string, leaseID *string, ifSequenceNumberLessThanOrEqualTo *int64, ifSequenceNumberLessThan *int64, ifSequenceNumberEqualTo *int64, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("PUT", client.url, body)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
|
@ -269,10 +741,10 @@ func (client pageBlobsClient) putPagePreparer(pageWrite PageWriteType, body io.R
|
|||
}
|
||||
params.Set("comp", "page")
|
||||
req.URL.RawQuery = params.Encode()
|
||||
req.Header.Set("Content-Length", fmt.Sprintf("%v", contentLength))
|
||||
if rangeParameter != nil {
|
||||
req.Header.Set("x-ms-range", *rangeParameter)
|
||||
}
|
||||
req.Header.Set("x-ms-page-write", fmt.Sprintf("%v", pageWrite))
|
||||
if leaseID != nil {
|
||||
req.Header.Set("x-ms-lease-id", *leaseID)
|
||||
}
|
||||
|
@ -301,14 +773,17 @@ func (client pageBlobsClient) putPagePreparer(pageWrite PageWriteType, body io.R
|
|||
if requestID != nil {
|
||||
req.Header.Set("x-ms-client-request-id", *requestID)
|
||||
}
|
||||
req.Header.Set("x-ms-page-write", "update")
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// putPageResponder handles the response to the PutPage request.
|
||||
func (client pageBlobsClient) putPageResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
// uploadPagesResponder handles the response to the UploadPages request.
|
||||
func (client pageBlobsClient) uploadPagesResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK, http.StatusCreated)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
return &PageBlobsPutPageResponse{rawResponse: resp.Response()}, err
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &PageBlobsUploadPagesResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
|
|
@ -9,6 +9,7 @@ import (
|
|||
"encoding/xml"
|
||||
"fmt"
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/url"
|
||||
|
@ -93,33 +94,33 @@ func (client serviceClient) getPropertiesResponder(resp pipeline.Response) (pipe
|
|||
return result, nil
|
||||
}
|
||||
|
||||
// GetStats retrieves statistics related to replication for the Blob service. It is only available on the secondary
|
||||
// location endpoint when read-access geo-redundant replication is enabled for the storage account.
|
||||
// GetStatistics retrieves statistics related to replication for the Blob service. It is only available on the
|
||||
// secondary location endpoint when read-access geo-redundant replication is enabled for the storage account.
|
||||
//
|
||||
// timeout is the timeout parameter is expressed in seconds. For more information, see <a
|
||||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
|
||||
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client serviceClient) GetStats(ctx context.Context, timeout *int32, requestID *string) (*StorageServiceStats, error) {
|
||||
func (client serviceClient) GetStatistics(ctx context.Context, timeout *int32, requestID *string) (*StorageServiceStats, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.getStatsPreparer(timeout, requestID)
|
||||
req, err := client.getStatisticsPreparer(timeout, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getStatsResponder}, req)
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.getStatisticsResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*StorageServiceStats), err
|
||||
}
|
||||
|
||||
// getStatsPreparer prepares the GetStats request.
|
||||
func (client serviceClient) getStatsPreparer(timeout *int32, requestID *string) (pipeline.Request, error) {
|
||||
// getStatisticsPreparer prepares the GetStatistics request.
|
||||
func (client serviceClient) getStatisticsPreparer(timeout *int32, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
|
@ -138,8 +139,8 @@ func (client serviceClient) getStatsPreparer(timeout *int32, requestID *string)
|
|||
return req, nil
|
||||
}
|
||||
|
||||
// getStatsResponder handles the response to the GetStats request.
|
||||
func (client serviceClient) getStatsResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
// getStatisticsResponder handles the response to the GetStatistics request.
|
||||
func (client serviceClient) getStatisticsResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
|
@ -162,7 +163,8 @@ func (client serviceClient) getStatsResponder(resp pipeline.Response) (pipeline.
|
|||
return result, nil
|
||||
}
|
||||
|
||||
// ListContainers the List Containers operation returns a list of the containers under the specified account
|
||||
// ListContainersSegment the List Containers Segment operation returns a list of the containers under the specified
|
||||
// account
|
||||
//
|
||||
// prefix is filters the results to return only containers whose name begins with the specified prefix. marker is a
|
||||
// string value that identifies the portion of the list of containers to be returned with the next listing operation.
|
||||
|
@ -179,7 +181,7 @@ func (client serviceClient) getStatsResponder(resp pipeline.Response) (pipeline.
|
|||
// href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
|
||||
// Timeouts for Blob Service Operations.</a> requestID is provides a client-generated, opaque value with a 1 KB
|
||||
// character limit that is recorded in the analytics logs when storage analytics logging is enabled.
|
||||
func (client serviceClient) ListContainers(ctx context.Context, prefix *string, marker *string, maxresults *int32, include ListContainersIncludeType, timeout *int32, requestID *string) (*ListContainersResponse, error) {
|
||||
func (client serviceClient) ListContainersSegment(ctx context.Context, prefix *string, marker *string, maxresults *int32, include ListContainersIncludeType, timeout *int32, requestID *string) (*ListContainersResponse, error) {
|
||||
if err := validate([]validation{
|
||||
{targetValue: maxresults,
|
||||
constraints: []constraint{{target: "maxresults", name: null, rule: false,
|
||||
|
@ -189,28 +191,28 @@ func (client serviceClient) ListContainers(ctx context.Context, prefix *string,
|
|||
chain: []constraint{{target: "timeout", name: inclusiveMinimum, rule: 0, chain: nil}}}}}}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := client.listContainersPreparer(prefix, marker, maxresults, include, timeout, requestID)
|
||||
req, err := client.listContainersSegmentPreparer(prefix, marker, maxresults, include, timeout, requestID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.listContainersResponder}, req)
|
||||
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.listContainersSegmentResponder}, req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return resp.(*ListContainersResponse), err
|
||||
}
|
||||
|
||||
// listContainersPreparer prepares the ListContainers request.
|
||||
func (client serviceClient) listContainersPreparer(prefix *string, marker *string, maxresults *int32, include ListContainersIncludeType, timeout *int32, requestID *string) (pipeline.Request, error) {
|
||||
// listContainersSegmentPreparer prepares the ListContainersSegment request.
|
||||
func (client serviceClient) listContainersSegmentPreparer(prefix *string, marker *string, maxresults *int32, include ListContainersIncludeType, timeout *int32, requestID *string) (pipeline.Request, error) {
|
||||
req, err := pipeline.NewRequest("GET", client.url, nil)
|
||||
if err != nil {
|
||||
return req, pipeline.NewError(err, "failed to create request")
|
||||
}
|
||||
params := req.URL.Query()
|
||||
if prefix != nil {
|
||||
if prefix != nil && len(*prefix) > 0 {
|
||||
params.Set("prefix", *prefix)
|
||||
}
|
||||
if marker != nil {
|
||||
if marker != nil && len(*marker) > 0 {
|
||||
params.Set("marker", *marker)
|
||||
}
|
||||
if maxresults != nil {
|
||||
|
@ -231,8 +233,8 @@ func (client serviceClient) listContainersPreparer(prefix *string, marker *strin
|
|||
return req, nil
|
||||
}
|
||||
|
||||
// listContainersResponder handles the response to the ListContainers request.
|
||||
func (client serviceClient) listContainersResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
// listContainersSegmentResponder handles the response to the ListContainersSegment request.
|
||||
func (client serviceClient) listContainersSegmentResponder(resp pipeline.Response) (pipeline.Response, error) {
|
||||
err := validateResponse(resp, http.StatusOK)
|
||||
if resp == nil {
|
||||
return nil, err
|
||||
|
@ -267,40 +269,26 @@ func (client serviceClient) SetProperties(ctx context.Context, storageServicePro
|
|||
if err := validate([]validation{
|
||||
{targetValue: storageServiceProperties,
|
||||
constraints: []constraint{{target: "storageServiceProperties.Logging", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.Logging.Version", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.Logging.Delete", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.Logging.Read", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.Logging.Write", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.Logging.RetentionPolicy", name: null, rule: true,
|
||||
chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy.Enabled", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.Logging.RetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
}},
|
||||
chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy", name: null, rule: true,
|
||||
chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.Logging.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
}},
|
||||
}},
|
||||
{target: "storageServiceProperties.HourMetrics", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.HourMetrics.Version", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.HourMetrics.Enabled", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.HourMetrics.IncludeAPIs", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.HourMetrics.RetentionPolicy", name: null, rule: true,
|
||||
chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy.Enabled", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.HourMetrics.RetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
}},
|
||||
chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.HourMetrics.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
}},
|
||||
}},
|
||||
{target: "storageServiceProperties.MinuteMetrics", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.Version", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.MinuteMetrics.Enabled", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.MinuteMetrics.IncludeAPIs", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy", name: null, rule: true,
|
||||
chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy.Enabled", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
}},
|
||||
chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.MinuteMetrics.RetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
}},
|
||||
}},
|
||||
{target: "storageServiceProperties.DeleteRetentionPolicy", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.DeleteRetentionPolicy.Enabled", name: null, rule: true, chain: nil},
|
||||
{target: "storageServiceProperties.DeleteRetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.DeleteRetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
chain: []constraint{{target: "storageServiceProperties.DeleteRetentionPolicy.Days", name: null, rule: false,
|
||||
chain: []constraint{{target: "storageServiceProperties.DeleteRetentionPolicy.Days", name: inclusiveMinimum, rule: 1, chain: nil}}},
|
||||
}}}},
|
||||
{targetValue: timeout,
|
||||
constraints: []constraint{{target: "timeout", name: null, rule: false,
|
||||
|
@ -353,5 +341,7 @@ func (client serviceClient) setPropertiesResponder(resp pipeline.Response) (pipe
|
|||
if resp == nil {
|
||||
return nil, err
|
||||
}
|
||||
io.Copy(ioutil.Discard, resp.Response().Body)
|
||||
resp.Response().Body.Close()
|
||||
return &ServiceSetPropertiesResponse{rawResponse: resp.Response()}, err
|
||||
}
|
||||
|
|
|
@ -5,11 +5,10 @@ package azblob
|
|||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
"github.com/Azure/azure-pipeline-go/pipeline"
|
||||
)
|
||||
|
||||
// Constraint stores constraint name, target field name
|
||||
|
@ -72,7 +71,6 @@ func validate(m []validation) error {
|
|||
err = validateFloat(v, constraint)
|
||||
case reflect.Array, reflect.Slice, reflect.Map:
|
||||
err = validateArrayMap(v, constraint)
|
||||
case reflect.Bool:
|
||||
default:
|
||||
err = createError(v, constraint, fmt.Sprintf("unknown type %v", v.Kind()))
|
||||
}
|
||||
|
|
|
@ -5,7 +5,7 @@ package azblob
|
|||
|
||||
// UserAgent returns the UserAgent string to use when sending http.Requests.
|
||||
func UserAgent() string {
|
||||
return "Azure-SDK-For-Go/0.0.0 arm-azblob/2017-07-29"
|
||||
return "Azure-SDK-For-Go/0.0.0 azblob/2017-07-29"
|
||||
}
|
||||
|
||||
// Version returns the semantic version (see http://semver.org) of the client.
|
||||
|
|
|
@ -1,40 +1,22 @@
|
|||
package azblob
|
||||
|
||||
import (
|
||||
"crypto/md5"
|
||||
"encoding/base64"
|
||||
"context"
|
||||
"io"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
// BlobHTTPHeaders contains read/writeable blob properties.
|
||||
type BlobHTTPHeaders struct {
|
||||
ContentType string
|
||||
ContentMD5 [md5.Size]byte
|
||||
ContentMD5 []byte
|
||||
ContentEncoding string
|
||||
ContentLanguage string
|
||||
ContentDisposition string
|
||||
CacheControl string
|
||||
}
|
||||
|
||||
func (h BlobHTTPHeaders) contentMD5Pointer() *string {
|
||||
if h.ContentMD5 == [md5.Size]byte{} {
|
||||
return nil
|
||||
}
|
||||
str := base64.StdEncoding.EncodeToString(h.ContentMD5[:])
|
||||
return &str
|
||||
}
|
||||
|
||||
// NewHTTPHeaders returns the user-modifiable properties for this blob.
|
||||
func (gr GetResponse) NewHTTPHeaders() BlobHTTPHeaders {
|
||||
return BlobHTTPHeaders{
|
||||
ContentType: gr.ContentType(),
|
||||
ContentEncoding: gr.ContentEncoding(),
|
||||
ContentLanguage: gr.ContentLanguage(),
|
||||
ContentDisposition: gr.ContentDisposition(),
|
||||
CacheControl: gr.CacheControl(),
|
||||
ContentMD5: gr.ContentMD5(),
|
||||
}
|
||||
}
|
||||
|
||||
// NewHTTPHeaders returns the user-modifiable properties for this blob.
|
||||
func (bgpr BlobsGetPropertiesResponse) NewHTTPHeaders() BlobHTTPHeaders {
|
||||
return BlobHTTPHeaders{
|
||||
|
@ -47,54 +29,211 @@ func (bgpr BlobsGetPropertiesResponse) NewHTTPHeaders() BlobHTTPHeaders {
|
|||
}
|
||||
}
|
||||
|
||||
func md5StringToMD5(md5String string) (hash [md5.Size]byte) {
|
||||
if md5String == "" {
|
||||
return
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// NewHTTPHeaders returns the user-modifiable properties for this blob.
|
||||
func (dr downloadResponse) NewHTTPHeaders() BlobHTTPHeaders {
|
||||
return BlobHTTPHeaders{
|
||||
ContentType: dr.ContentType(),
|
||||
ContentEncoding: dr.ContentEncoding(),
|
||||
ContentLanguage: dr.ContentLanguage(),
|
||||
ContentDisposition: dr.ContentDisposition(),
|
||||
CacheControl: dr.CacheControl(),
|
||||
ContentMD5: dr.ContentMD5(),
|
||||
}
|
||||
md5Slice, err := base64.StdEncoding.DecodeString(md5String)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// DownloadResponse wraps AutoRest generated downloadResponse and helps to provide info for retry.
|
||||
type DownloadResponse struct {
|
||||
r *downloadResponse
|
||||
ctx context.Context
|
||||
b BlobURL
|
||||
getInfo HTTPGetterInfo
|
||||
}
|
||||
|
||||
// Body constructs new RetryReader stream for reading data. If a connection failes
|
||||
// while reading, it will make additional requests to reestablish a connection and
|
||||
// continue reading. Specifying a RetryReaderOption's with MaxRetryRequests set to 0
|
||||
// (the default), returns the original response body and no retries will be performed.
|
||||
func (r *DownloadResponse) Body(o RetryReaderOptions) io.ReadCloser {
|
||||
if o.MaxRetryRequests == 0 { // No additional retries
|
||||
return r.Response().Body
|
||||
}
|
||||
copy(hash[:], md5Slice)
|
||||
return
|
||||
return NewRetryReader(r.ctx, r.Response(), r.getInfo, o,
|
||||
func(ctx context.Context, getInfo HTTPGetterInfo) (*http.Response, error) {
|
||||
resp, err := r.b.Download(ctx, getInfo.Offset, getInfo.Count,
|
||||
BlobAccessConditions{
|
||||
HTTPAccessConditions: HTTPAccessConditions{IfMatch: getInfo.ETag},
|
||||
},
|
||||
false)
|
||||
return resp.Response(), err
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
// ContentMD5 returns the value for header Content-MD5.
|
||||
func (ababr AppendBlobsAppendBlockResponse) ContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(ababr.rawResponse.Header.Get("Content-MD5"))
|
||||
// Response returns the raw HTTP response object.
|
||||
func (r DownloadResponse) Response() *http.Response {
|
||||
return r.r.Response()
|
||||
}
|
||||
|
||||
// ContentMD5 returns the value for header Content-MD5.
|
||||
func (bgpr BlobsGetPropertiesResponse) ContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(bgpr.rawResponse.Header.Get("Content-MD5"))
|
||||
}
|
||||
|
||||
// ContentMD5 returns the value for header Content-MD5.
|
||||
func (bpr BlobsPutResponse) ContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(bpr.rawResponse.Header.Get("Content-MD5"))
|
||||
}
|
||||
|
||||
// ContentMD5 returns the value for header Content-MD5.
|
||||
func (bbpblr BlockBlobsPutBlockListResponse) ContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(bbpblr.rawResponse.Header.Get("Content-MD5"))
|
||||
}
|
||||
|
||||
// ContentMD5 returns the value for header Content-MD5.
|
||||
func (bbpbr BlockBlobsPutBlockResponse) ContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(bbpbr.rawResponse.Header.Get("Content-MD5"))
|
||||
// NewHTTPHeaders returns the user-modifiable properties for this blob.
|
||||
func (r DownloadResponse) NewHTTPHeaders() BlobHTTPHeaders {
|
||||
return r.r.NewHTTPHeaders()
|
||||
}
|
||||
|
||||
// BlobContentMD5 returns the value for header x-ms-blob-content-md5.
|
||||
func (gr GetResponse) BlobContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(gr.rawResponse.Header.Get("x-ms-blob-content-md5"))
|
||||
func (r DownloadResponse) BlobContentMD5() []byte {
|
||||
return r.r.BlobContentMD5()
|
||||
}
|
||||
|
||||
// ContentMD5 returns the value for header Content-MD5.
|
||||
func (gr GetResponse) ContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(gr.rawResponse.Header.Get("Content-MD5"))
|
||||
func (r DownloadResponse) ContentMD5() []byte {
|
||||
return r.r.ContentMD5()
|
||||
}
|
||||
|
||||
// ContentMD5 returns the value for header Content-MD5.
|
||||
func (pbppr PageBlobsPutPageResponse) ContentMD5() [md5.Size]byte {
|
||||
return md5StringToMD5(pbppr.rawResponse.Header.Get("Content-MD5"))
|
||||
// StatusCode returns the HTTP status code of the response, e.g. 200.
|
||||
func (r DownloadResponse) StatusCode() int {
|
||||
return r.r.StatusCode()
|
||||
}
|
||||
|
||||
// Status returns the HTTP status message of the response, e.g. "200 OK".
|
||||
func (r DownloadResponse) Status() string {
|
||||
return r.r.Status()
|
||||
}
|
||||
|
||||
// AcceptRanges returns the value for header Accept-Ranges.
|
||||
func (r DownloadResponse) AcceptRanges() string {
|
||||
return r.r.AcceptRanges()
|
||||
}
|
||||
|
||||
// BlobCommittedBlockCount returns the value for header x-ms-blob-committed-block-count.
|
||||
func (r DownloadResponse) BlobCommittedBlockCount() int32 {
|
||||
return r.r.BlobCommittedBlockCount()
|
||||
}
|
||||
|
||||
// BlobSequenceNumber returns the value for header x-ms-blob-sequence-number.
|
||||
func (r DownloadResponse) BlobSequenceNumber() int64 {
|
||||
return r.r.BlobSequenceNumber()
|
||||
}
|
||||
|
||||
// BlobType returns the value for header x-ms-blob-type.
|
||||
func (r DownloadResponse) BlobType() BlobType {
|
||||
return r.r.BlobType()
|
||||
}
|
||||
|
||||
// CacheControl returns the value for header Cache-Control.
|
||||
func (r DownloadResponse) CacheControl() string {
|
||||
return r.r.CacheControl()
|
||||
}
|
||||
|
||||
// ContentDisposition returns the value for header Content-Disposition.
|
||||
func (r DownloadResponse) ContentDisposition() string {
|
||||
return r.r.ContentDisposition()
|
||||
}
|
||||
|
||||
// ContentEncoding returns the value for header Content-Encoding.
|
||||
func (r DownloadResponse) ContentEncoding() string {
|
||||
return r.r.ContentEncoding()
|
||||
}
|
||||
|
||||
// ContentLanguage returns the value for header Content-Language.
|
||||
func (r DownloadResponse) ContentLanguage() string {
|
||||
return r.r.ContentLanguage()
|
||||
}
|
||||
|
||||
// ContentLength returns the value for header Content-Length.
|
||||
func (r DownloadResponse) ContentLength() int64 {
|
||||
return r.r.ContentLength()
|
||||
}
|
||||
|
||||
// ContentRange returns the value for header Content-Range.
|
||||
func (r DownloadResponse) ContentRange() string {
|
||||
return r.r.ContentRange()
|
||||
}
|
||||
|
||||
// ContentType returns the value for header Content-Type.
|
||||
func (r DownloadResponse) ContentType() string {
|
||||
return r.r.ContentType()
|
||||
}
|
||||
|
||||
// CopyCompletionTime returns the value for header x-ms-copy-completion-time.
|
||||
func (r DownloadResponse) CopyCompletionTime() time.Time {
|
||||
return r.r.CopyCompletionTime()
|
||||
}
|
||||
|
||||
// CopyID returns the value for header x-ms-copy-id.
|
||||
func (r DownloadResponse) CopyID() string {
|
||||
return r.r.CopyID()
|
||||
}
|
||||
|
||||
// CopyProgress returns the value for header x-ms-copy-progress.
|
||||
func (r DownloadResponse) CopyProgress() string {
|
||||
return r.r.CopyProgress()
|
||||
}
|
||||
|
||||
// CopySource returns the value for header x-ms-copy-source.
|
||||
func (r DownloadResponse) CopySource() string {
|
||||
return r.r.CopySource()
|
||||
}
|
||||
|
||||
// CopyStatus returns the value for header x-ms-copy-status.
|
||||
func (r DownloadResponse) CopyStatus() CopyStatusType {
|
||||
return r.r.CopyStatus()
|
||||
}
|
||||
|
||||
// CopyStatusDescription returns the value for header x-ms-copy-status-description.
|
||||
func (r DownloadResponse) CopyStatusDescription() string {
|
||||
return r.r.CopyStatusDescription()
|
||||
}
|
||||
|
||||
// Date returns the value for header Date.
|
||||
func (r DownloadResponse) Date() time.Time {
|
||||
return r.r.Date()
|
||||
}
|
||||
|
||||
// ETag returns the value for header ETag.
|
||||
func (r DownloadResponse) ETag() ETag {
|
||||
return r.r.ETag()
|
||||
}
|
||||
|
||||
// IsServerEncrypted returns the value for header x-ms-server-encrypted.
|
||||
func (r DownloadResponse) IsServerEncrypted() string {
|
||||
return r.r.IsServerEncrypted()
|
||||
}
|
||||
|
||||
// LastModified returns the value for header Last-Modified.
|
||||
func (r DownloadResponse) LastModified() time.Time {
|
||||
return r.r.LastModified()
|
||||
}
|
||||
|
||||
// LeaseDuration returns the value for header x-ms-lease-duration.
|
||||
func (r DownloadResponse) LeaseDuration() LeaseDurationType {
|
||||
return r.r.LeaseDuration()
|
||||
}
|
||||
|
||||
// LeaseState returns the value for header x-ms-lease-state.
|
||||
func (r DownloadResponse) LeaseState() LeaseStateType {
|
||||
return r.r.LeaseState()
|
||||
}
|
||||
|
||||
// LeaseStatus returns the value for header x-ms-lease-status.
|
||||
func (r DownloadResponse) LeaseStatus() LeaseStatusType {
|
||||
return r.r.LeaseStatus()
|
||||
}
|
||||
|
||||
// RequestID returns the value for header x-ms-request-id.
|
||||
func (r DownloadResponse) RequestID() string {
|
||||
return r.r.RequestID()
|
||||
}
|
||||
|
||||
// Version returns the value for header x-ms-version.
|
||||
func (r DownloadResponse) Version() string {
|
||||
return r.r.Version()
|
||||
}
|
||||
|
||||
// NewMetadata returns user-defined key/value pairs.
|
||||
func (r DownloadResponse) NewMetadata() Metadata {
|
||||
return r.r.NewMetadata()
|
||||
}
|
||||
|
|
|
@ -1,21 +1,21 @@
|
|||
# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
|
||||
|
||||
|
||||
[[projects]]
|
||||
name = "github.com/Azure/azure-pipeline-go"
|
||||
packages = ["pipeline"]
|
||||
revision = "9804b770d6810999e2bcb7480fb509504e72b2ba"
|
||||
version = "0.1.4"
|
||||
|
||||
[[projects]]
|
||||
branch = "v1"
|
||||
name = "gopkg.in/check.v1"
|
||||
packages = ["."]
|
||||
revision = "20d25e2804050c1cd24a7eea1e7a6447dd0e74ec"
|
||||
|
||||
[solve-meta]
|
||||
analyzer-name = "dep"
|
||||
analyzer-version = 1
|
||||
inputs-digest = "31410b00fb3923035bcfdfb37ad828c04e176bd86f7367b5f8df9548e5cc93a2"
|
||||
solver-name = "gps-cdcl"
|
||||
solver-version = 1
|
||||
# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
|
||||
|
||||
|
||||
[[projects]]
|
||||
name = "github.com/Azure/azure-pipeline-go"
|
||||
packages = ["pipeline"]
|
||||
revision = "0f0dbf237bd47d5688310dbd3fac369353f280d0"
|
||||
version = "0.1.5"
|
||||
|
||||
[[projects]]
|
||||
branch = "v1"
|
||||
name = "gopkg.in/check.v1"
|
||||
packages = ["."]
|
||||
revision = "20d25e2804050c1cd24a7eea1e7a6447dd0e74ec"
|
||||
|
||||
[solve-meta]
|
||||
analyzer-name = "dep"
|
||||
analyzer-version = 1
|
||||
inputs-digest = "a6aef008d020b1455ef28ec8264c056f69bc26c0d32f711127c05dde5802f737"
|
||||
solver-name = "gps-cdcl"
|
||||
solver-version = 1
|
||||
|
|
|
@ -1,8 +1,38 @@
|
|||
# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
|
||||
[[constraint]]
|
||||
name = "github.com/Azure/azure-pipeline-go"
|
||||
branch = "master"
|
||||
|
||||
[[constraint]]
|
||||
name = "gopkg.in/check.v1" # This project is only needed if you run "go test" on the Azure Storage packages
|
||||
branch = "v1" # Project version constraint
|
||||
# Gopkg.toml example
|
||||
#
|
||||
# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
|
||||
# for detailed Gopkg.toml documentation.
|
||||
#
|
||||
# required = ["github.com/user/thing/cmd/thing"]
|
||||
# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
|
||||
#
|
||||
# [[constraint]]
|
||||
# name = "github.com/user/project"
|
||||
# version = "1.0.0"
|
||||
#
|
||||
# [[constraint]]
|
||||
# name = "github.com/user/project2"
|
||||
# branch = "dev"
|
||||
# source = "github.com/myfork/project2"
|
||||
#
|
||||
# [[override]]
|
||||
# name = "github.com/x/y"
|
||||
# version = "2.4.0"
|
||||
#
|
||||
# [prune]
|
||||
# non-go = false
|
||||
# go-tests = true
|
||||
# unused-packages = true
|
||||
|
||||
|
||||
[[constraint]]
|
||||
name = "github.com/Azure/azure-pipeline-go"
|
||||
version = "0.1.5"
|
||||
|
||||
[[constraint]]
|
||||
branch = "v1"
|
||||
name = "gopkg.in/check.v1"
|
||||
|
||||
[prune]
|
||||
go-tests = true
|
||||
unused-packages = true
|
||||
|
|
Загрузка…
Ссылка в новой задаче