mirror of https://github.com/poanetwork/quorum.git
1234 lines
62 KiB
Go
1234 lines
62 KiB
Go
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 (
|
|
"context"
|
|
"encoding/base64"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/Azure/azure-pipeline-go/pipeline"
|
|
)
|
|
|
|
// blobClient is the client for the Blob methods of the Azblob service.
|
|
type blobClient struct {
|
|
managementClient
|
|
}
|
|
|
|
// newBlobClient creates an instance of the blobClient client.
|
|
func newBlobClient(url url.URL, p pipeline.Pipeline) blobClient {
|
|
return blobClient{newManagementClient(url, p)}
|
|
}
|
|
|
|
// AbortCopyFromURL the Abort Copy From URL operation aborts a pending Copy From URL operation, and leaves a
|
|
// destination blob with zero length and full metadata.
|
|
//
|
|
// copyID is the copy identifier provided in the x-ms-copy-id header of the original Copy Blob operation. 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 blobClient) AbortCopyFromURL(ctx context.Context, copyID string, timeout *int32, leaseID *string, requestID *string) (*BlobAbortCopyFromURLResponse, 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.abortCopyFromURLPreparer(copyID, timeout, leaseID, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.abortCopyFromURLResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobAbortCopyFromURLResponse), err
|
|
}
|
|
|
|
// abortCopyFromURLPreparer prepares the AbortCopyFromURL request.
|
|
func (client blobClient) abortCopyFromURLPreparer(copyID string, timeout *int32, leaseID *string, 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()
|
|
params.Set("copyid", copyID)
|
|
if timeout != nil {
|
|
params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "copy")
|
|
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)
|
|
}
|
|
req.Header.Set("x-ms-copy-action", "abort")
|
|
return req, nil
|
|
}
|
|
|
|
// abortCopyFromURLResponder handles the response to the AbortCopyFromURL request.
|
|
func (client blobClient) abortCopyFromURLResponder(resp pipeline.Response) (pipeline.Response, error) {
|
|
err := validateResponse(resp, http.StatusOK, http.StatusNoContent)
|
|
if resp == nil {
|
|
return nil, err
|
|
}
|
|
io.Copy(ioutil.Discard, resp.Response().Body)
|
|
resp.Response().Body.Close()
|
|
return &BlobAbortCopyFromURLResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// AcquireLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
|
|
// operations
|
|
//
|
|
// 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> 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. 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 blobClient) AcquireLease(ctx context.Context, timeout *int32, duration *int32, proposedLeaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobAcquireLeaseResponse, 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.acquireLeasePreparer(timeout, duration, proposedLeaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.acquireLeaseResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobAcquireLeaseResponse), err
|
|
}
|
|
|
|
// acquireLeasePreparer prepares the AcquireLease request.
|
|
func (client blobClient) acquireLeasePreparer(timeout *int32, duration *int32, proposedLeaseID *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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "lease")
|
|
req.URL.RawQuery = params.Encode()
|
|
if duration != nil {
|
|
req.Header.Set("x-ms-lease-duration", strconv.FormatInt(int64(*duration), 10))
|
|
}
|
|
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))
|
|
}
|
|
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-lease-action", "acquire")
|
|
return req, nil
|
|
}
|
|
|
|
// acquireLeaseResponder handles the response to the AcquireLease request.
|
|
func (client blobClient) acquireLeaseResponder(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 &BlobAcquireLeaseResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// BreakLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
|
|
// operations
|
|
//
|
|
// 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> 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. 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 blobClient) BreakLease(ctx context.Context, timeout *int32, breakPeriod *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobBreakLeaseResponse, 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.breakLeasePreparer(timeout, breakPeriod, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.breakLeaseResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobBreakLeaseResponse), err
|
|
}
|
|
|
|
// breakLeasePreparer prepares the BreakLease request.
|
|
func (client blobClient) breakLeasePreparer(timeout *int32, breakPeriod *int32, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "lease")
|
|
req.URL.RawQuery = params.Encode()
|
|
if breakPeriod != nil {
|
|
req.Header.Set("x-ms-lease-break-period", strconv.FormatInt(int64(*breakPeriod), 10))
|
|
}
|
|
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-lease-action", "break")
|
|
return req, nil
|
|
}
|
|
|
|
// breakLeaseResponder handles the response to the BreakLease request.
|
|
func (client blobClient) breakLeaseResponder(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 &BlobBreakLeaseResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// ChangeLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
|
|
// operations
|
|
//
|
|
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID.
|
|
// 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. 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> 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 blobClient) ChangeLease(ctx context.Context, leaseID string, proposedLeaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobChangeLeaseResponse, 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.changeLeasePreparer(leaseID, proposedLeaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.changeLeaseResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobChangeLeaseResponse), err
|
|
}
|
|
|
|
// changeLeasePreparer prepares the ChangeLease request.
|
|
func (client blobClient) changeLeasePreparer(leaseID string, proposedLeaseID string, timeout *int32, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "lease")
|
|
req.URL.RawQuery = params.Encode()
|
|
req.Header.Set("x-ms-lease-id", leaseID)
|
|
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))
|
|
}
|
|
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-lease-action", "change")
|
|
return req, nil
|
|
}
|
|
|
|
// changeLeaseResponder handles the response to the ChangeLease request.
|
|
func (client blobClient) changeLeaseResponder(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 &BlobChangeLeaseResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// CreateSnapshot the Create Snapshot operation creates a read-only snapshot of a blob
|
|
//
|
|
// 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. 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 blobClient) CreateSnapshot(ctx context.Context, timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, requestID *string) (*BlobCreateSnapshotResponse, 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.createSnapshotPreparer(timeout, metadata, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, leaseID, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.createSnapshotResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobCreateSnapshotResponse), err
|
|
}
|
|
|
|
// createSnapshotPreparer prepares the CreateSnapshot request.
|
|
func (client blobClient) createSnapshotPreparer(timeout *int32, metadata map[string]string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "snapshot")
|
|
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))
|
|
}
|
|
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
|
|
}
|
|
|
|
// createSnapshotResponder handles the response to the CreateSnapshot request.
|
|
func (client blobClient) createSnapshotResponder(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 &BlobCreateSnapshotResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// Delete if the storage account's soft delete feature is disabled then, when a blob is deleted, it is permanently
|
|
// removed from the storage account. If the storage account's soft delete feature is enabled, then, when a blob is
|
|
// deleted, it is marked for deletion and becomes inaccessible immediately. However, the blob service retains the blob
|
|
// or snapshot for the number of days specified by the DeleteRetentionPolicy section of [Storage service properties]
|
|
// (Set-Blob-Service-Properties.md). After the specified number of days has passed, the blob's data is permanently
|
|
// removed from the storage account. Note that you continue to be charged for the soft-deleted blob's storage until it
|
|
// is permanently removed. Use the List Blobs API and specify the "include=deleted" query parameter to discover which
|
|
// blobs and snapshots have been soft deleted. You can then use the Undelete Blob API to restore a soft-deleted blob.
|
|
// All other operations on a soft-deleted blob or snapshot causes the service to return an HTTP status code of 404
|
|
// (ResourceNotFound).
|
|
//
|
|
// 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> leaseID is if specified, the operation only succeeds if the container's
|
|
// lease is active and matches this ID. deleteSnapshots is required if the blob has associated snapshots. Specify one
|
|
// of the following two options: include: Delete the base blob and all of its snapshots. only: Delete only the blob's
|
|
// snapshots and not the blob itself 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 blobClient) Delete(ctx context.Context, snapshot *string, timeout *int32, leaseID *string, deleteSnapshots DeleteSnapshotsOptionType, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobDeleteResponse, 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(snapshot, timeout, leaseID, deleteSnapshots, 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.(*BlobDeleteResponse), err
|
|
}
|
|
|
|
// deletePreparer prepares the Delete request.
|
|
func (client blobClient) deletePreparer(snapshot *string, timeout *int32, leaseID *string, deleteSnapshots DeleteSnapshotsOptionType, 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 snapshot != nil && len(*snapshot) > 0 {
|
|
params.Set("snapshot", *snapshot)
|
|
}
|
|
if timeout != nil {
|
|
params.Set("timeout", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
req.URL.RawQuery = params.Encode()
|
|
if leaseID != nil {
|
|
req.Header.Set("x-ms-lease-id", *leaseID)
|
|
}
|
|
if deleteSnapshots != DeleteSnapshotsOptionNone {
|
|
req.Header.Set("x-ms-delete-snapshots", string(deleteSnapshots))
|
|
}
|
|
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 blobClient) deleteResponder(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 &BlobDeleteResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// Download the Download operation reads or downloads a blob from the system, including its metadata and properties.
|
|
// You can also call Download to read a snapshot.
|
|
//
|
|
// 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> 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.
|
|
// rangeGetContentMD5 is when set to true and specified together with the Range, the service returns the MD5 hash for
|
|
// the range, as long as the range is less than or equal to 4 MB in size. 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 blobClient) Download(ctx context.Context, snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, rangeGetContentMD5 *bool, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*downloadResponse, 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.downloadPreparer(snapshot, timeout, rangeParameter, leaseID, rangeGetContentMD5, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.downloadResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*downloadResponse), err
|
|
}
|
|
|
|
// downloadPreparer prepares the Download request.
|
|
func (client blobClient) downloadPreparer(snapshot *string, timeout *int32, rangeParameter *string, leaseID *string, rangeGetContentMD5 *bool, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
req.URL.RawQuery = params.Encode()
|
|
if rangeParameter != nil {
|
|
req.Header.Set("x-ms-range", *rangeParameter)
|
|
}
|
|
if leaseID != nil {
|
|
req.Header.Set("x-ms-lease-id", *leaseID)
|
|
}
|
|
if rangeGetContentMD5 != nil {
|
|
req.Header.Set("x-ms-range-get-content-md5", strconv.FormatBool(*rangeGetContentMD5))
|
|
}
|
|
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
|
|
}
|
|
|
|
// downloadResponder handles the response to the Download request.
|
|
func (client blobClient) downloadResponder(resp pipeline.Response) (pipeline.Response, error) {
|
|
err := validateResponse(resp, http.StatusOK, http.StatusPartialContent)
|
|
if resp == nil {
|
|
return nil, err
|
|
}
|
|
return &downloadResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// GetProperties the Get Properties operation returns all user-defined metadata, standard HTTP properties, and system
|
|
// properties for the blob. It does not return the content of the blob.
|
|
//
|
|
// 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> 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 blobClient) GetProperties(ctx context.Context, snapshot *string, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobGetPropertiesResponse, 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(snapshot, timeout, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, 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.(*BlobGetPropertiesResponse), err
|
|
}
|
|
|
|
// getPropertiesPreparer prepares the GetProperties request.
|
|
func (client blobClient) getPropertiesPreparer(snapshot *string, timeout *int32, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (pipeline.Request, error) {
|
|
req, err := pipeline.NewRequest("HEAD", 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
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
|
|
}
|
|
|
|
// getPropertiesResponder handles the response to the GetProperties request.
|
|
func (client blobClient) getPropertiesResponder(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 &BlobGetPropertiesResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// ReleaseLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
|
|
// operations
|
|
//
|
|
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID. 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> 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 blobClient) ReleaseLease(ctx context.Context, leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobReleaseLeaseResponse, 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.releaseLeasePreparer(leaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.releaseLeaseResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobReleaseLeaseResponse), err
|
|
}
|
|
|
|
// releaseLeasePreparer prepares the ReleaseLease request.
|
|
func (client blobClient) releaseLeasePreparer(leaseID string, timeout *int32, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "lease")
|
|
req.URL.RawQuery = params.Encode()
|
|
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)
|
|
}
|
|
req.Header.Set("x-ms-lease-action", "release")
|
|
return req, nil
|
|
}
|
|
|
|
// releaseLeaseResponder handles the response to the ReleaseLease request.
|
|
func (client blobClient) releaseLeaseResponder(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 &BlobReleaseLeaseResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// RenewLease [Update] The Lease Blob operation establishes and manages a lock on a blob for write and delete
|
|
// operations
|
|
//
|
|
// leaseID is if specified, the operation only succeeds if the container's lease is active and matches this ID. 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> 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 blobClient) RenewLease(ctx context.Context, leaseID string, timeout *int32, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobRenewLeaseResponse, 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.renewLeasePreparer(leaseID, timeout, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.renewLeaseResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobRenewLeaseResponse), err
|
|
}
|
|
|
|
// renewLeasePreparer prepares the RenewLease request.
|
|
func (client blobClient) renewLeasePreparer(leaseID string, timeout *int32, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "lease")
|
|
req.URL.RawQuery = params.Encode()
|
|
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)
|
|
}
|
|
req.Header.Set("x-ms-lease-action", "renew")
|
|
return req, nil
|
|
}
|
|
|
|
// renewLeaseResponder handles the response to the RenewLease request.
|
|
func (client blobClient) renewLeaseResponder(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 &BlobRenewLeaseResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// SetHTTPHeaders the Set HTTP Headers operation sets system properties on the blob
|
|
//
|
|
// 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. 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. 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. 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.
|
|
// blobContentDisposition is optional. Sets the blob's Content-Disposition header. 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 blobClient) SetHTTPHeaders(ctx context.Context, timeout *int32, blobCacheControl *string, blobContentType *string, blobContentMD5 []byte, blobContentEncoding *string, blobContentLanguage *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentDisposition *string, requestID *string) (*BlobSetHTTPHeadersResponse, 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.setHTTPHeadersPreparer(timeout, blobCacheControl, blobContentType, blobContentMD5, blobContentEncoding, blobContentLanguage, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, blobContentDisposition, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setHTTPHeadersResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobSetHTTPHeadersResponse), err
|
|
}
|
|
|
|
// setHTTPHeadersPreparer prepares the SetHTTPHeaders request.
|
|
func (client blobClient) setHTTPHeadersPreparer(timeout *int32, blobCacheControl *string, blobContentType *string, blobContentMD5 []byte, blobContentEncoding *string, blobContentLanguage *string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, blobContentDisposition *string, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "properties")
|
|
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 blobContentMD5 != nil {
|
|
req.Header.Set("x-ms-blob-content-md5", base64.StdEncoding.EncodeToString(blobContentMD5))
|
|
}
|
|
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 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))
|
|
}
|
|
if blobContentDisposition != nil {
|
|
req.Header.Set("x-ms-blob-content-disposition", *blobContentDisposition)
|
|
}
|
|
req.Header.Set("x-ms-version", ServiceVersion)
|
|
if requestID != nil {
|
|
req.Header.Set("x-ms-client-request-id", *requestID)
|
|
}
|
|
return req, nil
|
|
}
|
|
|
|
// setHTTPHeadersResponder handles the response to the SetHTTPHeaders request.
|
|
func (client blobClient) setHTTPHeadersResponder(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 &BlobSetHTTPHeadersResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// SetMetadata the Set Blob Metadata operation sets user-defined metadata for the specified blob as one or more
|
|
// name-value pairs
|
|
//
|
|
// 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. 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 blobClient) SetMetadata(ctx context.Context, timeout *int32, metadata map[string]string, leaseID *string, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, requestID *string) (*BlobSetMetadataResponse, 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, metadata, leaseID, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, 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.(*BlobSetMetadataResponse), err
|
|
}
|
|
|
|
// setMetadataPreparer prepares the SetMetadata request.
|
|
func (client blobClient) setMetadataPreparer(timeout *int32, metadata map[string]string, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "metadata")
|
|
req.URL.RawQuery = params.Encode()
|
|
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 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
|
|
}
|
|
|
|
// setMetadataResponder handles the response to the SetMetadata request.
|
|
func (client blobClient) setMetadataResponder(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 &BlobSetMetadataResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// SetTier the Set Tier 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.
|
|
//
|
|
// tier is indicates the tier to be set on the blob. 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 blobClient) SetTier(ctx context.Context, tier AccessTierType, timeout *int32, requestID *string) (*BlobSetTierResponse, 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.setTierPreparer(tier, timeout, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.setTierResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobSetTierResponse), err
|
|
}
|
|
|
|
// setTierPreparer prepares the SetTier request.
|
|
func (client blobClient) setTierPreparer(tier AccessTierType, timeout *int32, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "tier")
|
|
req.URL.RawQuery = params.Encode()
|
|
req.Header.Set("x-ms-access-tier", string(tier))
|
|
req.Header.Set("x-ms-version", ServiceVersion)
|
|
if requestID != nil {
|
|
req.Header.Set("x-ms-client-request-id", *requestID)
|
|
}
|
|
return req, nil
|
|
}
|
|
|
|
// setTierResponder handles the response to the SetTier request.
|
|
func (client blobClient) setTierResponder(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 &BlobSetTierResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// StartCopyFromURL the Start Copy From URL operation copies a blob or an internet resource to a new blob.
|
|
//
|
|
// 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. sourceIfModifiedSince is specify this header value to operate
|
|
// only on a blob if it has been modified since the specified date/time. sourceIfUnmodifiedSince is specify this header
|
|
// value to operate only on a blob if it has not been modified since the specified date/time. sourceIfMatches is
|
|
// specify an ETag value to operate only on blobs with a matching value. sourceIfNoneMatch is specify an ETag value to
|
|
// operate only on blobs without a matching value. 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. leaseID is if specified, the operation only succeeds if the container's lease is active
|
|
// and matches this ID. sourceLeaseID is specify this header to perform the operation only if the lease ID given
|
|
// matches the active lease ID of the source blob. 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 blobClient) StartCopyFromURL(ctx context.Context, copySource string, timeout *int32, metadata map[string]string, sourceIfModifiedSince *time.Time, sourceIfUnmodifiedSince *time.Time, sourceIfMatches *ETag, sourceIfNoneMatch *ETag, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, sourceLeaseID *string, requestID *string) (*BlobStartCopyFromURLResponse, 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.startCopyFromURLPreparer(copySource, timeout, metadata, sourceIfModifiedSince, sourceIfUnmodifiedSince, sourceIfMatches, sourceIfNoneMatch, ifModifiedSince, ifUnmodifiedSince, ifMatches, ifNoneMatch, leaseID, sourceLeaseID, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.startCopyFromURLResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobStartCopyFromURLResponse), err
|
|
}
|
|
|
|
// startCopyFromURLPreparer prepares the StartCopyFromURL request.
|
|
func (client blobClient) startCopyFromURLPreparer(copySource string, timeout *int32, metadata map[string]string, sourceIfModifiedSince *time.Time, sourceIfUnmodifiedSince *time.Time, sourceIfMatches *ETag, sourceIfNoneMatch *ETag, ifModifiedSince *time.Time, ifUnmodifiedSince *time.Time, ifMatches *ETag, ifNoneMatch *ETag, leaseID *string, sourceLeaseID *string, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
req.URL.RawQuery = params.Encode()
|
|
if metadata != nil {
|
|
for k, v := range metadata {
|
|
req.Header.Set("x-ms-meta-"+k, v)
|
|
}
|
|
}
|
|
if sourceIfModifiedSince != nil {
|
|
req.Header.Set("x-ms-source-if-modified-since", (*sourceIfModifiedSince).In(gmt).Format(time.RFC1123))
|
|
}
|
|
if sourceIfUnmodifiedSince != nil {
|
|
req.Header.Set("x-ms-source-if-unmodified-since", (*sourceIfUnmodifiedSince).In(gmt).Format(time.RFC1123))
|
|
}
|
|
if sourceIfMatches != nil {
|
|
req.Header.Set("x-ms-source-if-match", string(*sourceIfMatches))
|
|
}
|
|
if sourceIfNoneMatch != nil {
|
|
req.Header.Set("x-ms-source-if-none-match", string(*sourceIfNoneMatch))
|
|
}
|
|
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)
|
|
if leaseID != nil {
|
|
req.Header.Set("x-ms-lease-id", *leaseID)
|
|
}
|
|
if sourceLeaseID != nil {
|
|
req.Header.Set("x-ms-source-lease-id", *sourceLeaseID)
|
|
}
|
|
req.Header.Set("x-ms-version", ServiceVersion)
|
|
if requestID != nil {
|
|
req.Header.Set("x-ms-client-request-id", *requestID)
|
|
}
|
|
return req, nil
|
|
}
|
|
|
|
// startCopyFromURLResponder handles the response to the StartCopyFromURL request.
|
|
func (client blobClient) startCopyFromURLResponder(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 &BlobStartCopyFromURLResponse{rawResponse: resp.Response()}, err
|
|
}
|
|
|
|
// Undelete undelete a blob that was previously soft deleted
|
|
//
|
|
// 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 blobClient) Undelete(ctx context.Context, timeout *int32, requestID *string) (*BlobUndeleteResponse, 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.undeletePreparer(timeout, requestID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := client.Pipeline().Do(ctx, responderPolicyFactory{responder: client.undeleteResponder}, req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return resp.(*BlobUndeleteResponse), err
|
|
}
|
|
|
|
// undeletePreparer prepares the Undelete request.
|
|
func (client blobClient) undeletePreparer(timeout *int32, 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", strconv.FormatInt(int64(*timeout), 10))
|
|
}
|
|
params.Set("comp", "undelete")
|
|
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
|
|
}
|
|
|
|
// undeleteResponder handles the response to the Undelete request.
|
|
func (client blobClient) undeleteResponder(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 &BlobUndeleteResponse{rawResponse: resp.Response()}, err
|
|
}
|