blob_options.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/storage/blobs/rest_client.hpp"
 
#include <azure/core/internal/client_options.hpp>
#include <azure/core/internal/extendable_enumeration.hpp>
#include <azure/core/match_conditions.hpp>
#include <azure/core/modified_conditions.hpp>
#include <azure/storage/common/access_conditions.hpp>
#include <azure/storage/common/crypt.hpp>
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <numeric>
#include <string>
#include <vector>
 
namespace Azure { namespace Storage { namespace Blobs {
 
  class BlobAudience final : public Azure::Core::_internal::ExtendableEnumeration<BlobAudience> {
  public:
    explicit BlobAudience(std::string blobAudience) : ExtendableEnumeration(std::move(blobAudience))
    {
    }
 
    static BlobAudience CreateBlobServiceAccountAudience(const std::string& storageAccountName)
    {
      return BlobAudience("https://" + storageAccountName + ".blob.core.windows.net/");
    }
 
    AZ_STORAGE_BLOBS_DLLEXPORT const static BlobAudience DefaultAudience;
  };
 
  struct BlobContainerAccessConditions final : public Azure::ModifiedConditions,
                                               public LeaseAccessConditions
  {
  };
 
  struct TagAccessConditions
  {
    virtual ~TagAccessConditions() = default;
 
    Azure::Nullable<std::string> TagConditions;
  };
 
  struct BlobAccessConditions : public Azure::ModifiedConditions,
                                public Azure::MatchConditions,
                                public LeaseAccessConditions,
                                public TagAccessConditions
  {
  };
 
  struct LeaseBlobAccessConditions final : public Azure::ModifiedConditions,
                                           public Azure::MatchConditions,
                                           public TagAccessConditions
  {
  };
 
  struct AppendBlobAccessConditions final : public BlobAccessConditions
  {
    Azure::Nullable<int64_t> IfMaxSizeLessThanOrEqual;
 
    Azure::Nullable<int64_t> IfAppendPositionEqual;
  };
 
  struct PageBlobAccessConditions final : public BlobAccessConditions
  {
    Azure::Nullable<int64_t> IfSequenceNumberLessThan;
 
    Azure::Nullable<int64_t> IfSequenceNumberLessThanOrEqual;
 
    Azure::Nullable<int64_t> IfSequenceNumberEqual;
  };
 
  struct EncryptionKey final
  {
    std::string Key;
 
    std::vector<uint8_t> KeyHash;
 
    Models::EncryptionAlgorithmType Algorithm;
  };
 
  struct BlobClientOptions final : Azure::Core::_internal::ClientOptions
  {
    Azure::Nullable<EncryptionKey> CustomerProvidedKey;
 
    Azure::Nullable<std::string> EncryptionScope;
 
    std::string SecondaryHostForRetryReads;
 
    std::string ApiVersion;
 
    bool EnableTenantDiscovery = false;
 
    Azure::Nullable<BlobAudience> Audience;
  };
 
  struct ListBlobContainersOptions final
  {
    Azure::Nullable<std::string> Prefix;
 
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
 
    Models::ListBlobContainersIncludeFlags Include = Models::ListBlobContainersIncludeFlags::None;
  };
 
  struct GetUserDelegationKeyOptions final
  {
    Azure::DateTime StartsOn = std::chrono::system_clock::now();
  };
 
  struct SetServicePropertiesOptions final
  {
  };
 
  struct GetServicePropertiesOptions final
  {
  };
 
  struct GetAccountInfoOptions final
  {
  };
 
  struct GetBlobServiceStatisticsOptions final
  {
  };
 
  struct FindBlobsByTagsOptions final
  {
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
  };
 
  struct CreateBlobContainerOptions final
  {
    Models::PublicAccessType AccessType = Models::PublicAccessType::None;
 
    Storage::Metadata Metadata;
 
    Azure::Nullable<std::string> DefaultEncryptionScope;
 
    Azure::Nullable<bool> PreventEncryptionScopeOverride;
  };
 
  struct DeleteBlobContainerOptions final
  {
    BlobContainerAccessConditions AccessConditions;
  };
 
  struct UndeleteBlobContainerOptions final
  {
  };
 
  struct RenameBlobContainerOptions final
  {
    LeaseAccessConditions SourceAccessConditions;
  };
 
  struct GetBlobContainerPropertiesOptions final
  {
    LeaseAccessConditions AccessConditions;
  };
 
  struct SetBlobContainerMetadataOptions final
  {
    struct : public LeaseAccessConditions
    {
      Azure::Nullable<Azure::DateTime> IfModifiedSince;
    } 
    AccessConditions;
  };
 
  struct ListBlobsOptions final
  {
    Azure::Nullable<std::string> Prefix;
 
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
 
    Models::ListBlobsIncludeFlags Include = Models::ListBlobsIncludeFlags::None;
  };
 
  struct GetBlobContainerAccessPolicyOptions final
  {
    LeaseAccessConditions AccessConditions;
  };
 
  struct SetBlobContainerAccessPolicyOptions final
  {
    Models::PublicAccessType AccessType = Models::PublicAccessType::None;
 
    std::vector<Models::SignedIdentifier> SignedIdentifiers;
 
    BlobContainerAccessConditions AccessConditions;
  };
 
  struct GetBlobPropertiesOptions final
  {
    BlobAccessConditions AccessConditions;
  };
 
  struct SetBlobHttpHeadersOptions final
  {
    BlobAccessConditions AccessConditions;
  };
 
  struct SetBlobMetadataOptions final
  {
    BlobAccessConditions AccessConditions;
  };
 
  struct SetBlobAccessTierOptions final
  {
    Azure::Nullable<Models::RehydratePriority> RehydratePriority;
    struct : public LeaseAccessConditions, public TagAccessConditions
    {
    } 
    AccessConditions;
  };
 
  struct StartBlobCopyFromUriOptions final
  {
    Storage::Metadata Metadata;
 
    std::map<std::string, std::string> Tags;
 
    BlobAccessConditions AccessConditions;
 
    struct : public Azure::ModifiedConditions,
             public Azure::MatchConditions,
             public LeaseAccessConditions,
             public TagAccessConditions
    {
    } 
    SourceAccessConditions;
 
    Azure::Nullable<Models::AccessTier> AccessTier;
 
    Azure::Nullable<Models::RehydratePriority> RehydratePriority;
 
    Azure::Nullable<bool> ShouldSealDestination;
 
    Azure::Nullable<Models::BlobImmutabilityPolicy> ImmutabilityPolicy;
 
    Azure::Nullable<bool> HasLegalHold;
  };
 
  struct CopyBlobFromUriOptions
  {
    Storage::Metadata Metadata;
 
    std::map<std::string, std::string> Tags;
 
    BlobAccessConditions AccessConditions;
 
    struct : public Azure::ModifiedConditions, public Azure::MatchConditions
    {
    } 
    SourceAccessConditions;
 
    Azure::Nullable<Models::AccessTier> AccessTier;
 
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    Azure::Nullable<Models::BlobImmutabilityPolicy> ImmutabilityPolicy;
    Azure::Nullable<bool> HasLegalHold;
 
    Models::BlobCopySourceTagsMode CopySourceTagsMode;
 
    std::string SourceAuthorization;
  };
 
  struct AbortBlobCopyFromUriOptions final
  {
    LeaseAccessConditions AccessConditions;
  };
 
  struct DownloadBlobOptions final
  {
    Azure::Nullable<Core::Http::HttpRange> Range;
 
    Azure::Nullable<HashAlgorithm> RangeHashAlgorithm;
 
    BlobAccessConditions AccessConditions;
  };
 
  struct DownloadBlobToOptions final
  {
    Azure::Nullable<Core::Http::HttpRange> Range;
 
    struct
    {
      int64_t InitialChunkSize = 256 * 1024 * 1024;
 
      int64_t ChunkSize = 4 * 1024 * 1024;
 
      int32_t Concurrency = 5;
    } TransferOptions;
  };
 
  struct CreateBlobSnapshotOptions final
  {
    Storage::Metadata Metadata;
 
    BlobAccessConditions AccessConditions;
  };
 
  struct DeleteBlobOptions final
  {
    Azure::Nullable<Models::DeleteSnapshotsOption> DeleteSnapshots;
 
    BlobAccessConditions AccessConditions;
  };
 
  struct UndeleteBlobOptions final
  {
  };
 
  struct AcquireLeaseOptions final
  {
    LeaseBlobAccessConditions AccessConditions;
  };
 
  struct RenewLeaseOptions final
  {
    LeaseBlobAccessConditions AccessConditions;
  };
 
  struct ChangeLeaseOptions final
  {
    LeaseBlobAccessConditions AccessConditions;
  };
 
  struct ReleaseLeaseOptions final
  {
    LeaseBlobAccessConditions AccessConditions;
  };
 
  struct BreakLeaseOptions final
  {
    Azure::Nullable<std::chrono::seconds> BreakPeriod;
 
    LeaseBlobAccessConditions AccessConditions;
  };
 
  struct SetBlobTagsOptions final
  {
    struct : public LeaseAccessConditions, public TagAccessConditions
    {
    } 
    AccessConditions;
  };
 
  struct GetBlobTagsOptions final
  {
    struct : public LeaseAccessConditions, public TagAccessConditions
    {
    } 
    AccessConditions;
  };
 
  struct UploadBlockBlobOptions final
  {
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    Models::BlobHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    std::map<std::string, std::string> Tags;
 
    Azure::Nullable<Models::AccessTier> AccessTier;
 
    BlobAccessConditions AccessConditions;
 
    Azure::Nullable<Models::BlobImmutabilityPolicy> ImmutabilityPolicy;
 
    Azure::Nullable<bool> HasLegalHold;
  };
 
  struct UploadBlockBlobFromOptions final
  {
    Models::BlobHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    std::map<std::string, std::string> Tags;
 
    Azure::Nullable<Models::AccessTier> AccessTier;
 
    struct
    {
      int64_t SingleUploadThreshold = 256 * 1024 * 1024;
 
      Azure::Nullable<int64_t> ChunkSize;
 
      int32_t Concurrency = 5;
    } TransferOptions;
 
    Azure::Nullable<Models::BlobImmutabilityPolicy> ImmutabilityPolicy;
 
    Azure::Nullable<bool> HasLegalHold;
  };
 
  struct UploadBlockBlobFromUriOptions final
  {
    bool CopySourceBlobProperties = true;
 
    Models::BlobHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    std::map<std::string, std::string> Tags;
 
    Azure::Nullable<Models::AccessTier> AccessTier;
 
    BlobAccessConditions AccessConditions;
 
    struct : public Azure::ModifiedConditions,
             public Azure::MatchConditions,
             public TagAccessConditions
    {
    } 
    SourceAccessConditions;
 
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    Models::BlobCopySourceTagsMode CopySourceTagsMode;
 
    std::string SourceAuthorization;
  };
 
  struct StageBlockOptions final
  {
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    LeaseAccessConditions AccessConditions;
  };
 
  struct StageBlockFromUriOptions final
  {
    Azure::Nullable<Core::Http::HttpRange> SourceRange;
 
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    LeaseAccessConditions AccessConditions;
 
    struct : public Azure::ModifiedConditions, public Azure::MatchConditions
    {
    } 
    SourceAccessConditions;
 
    std::string SourceAuthorization;
  };
 
  struct CommitBlockListOptions final
  {
    Models::BlobHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    std::map<std::string, std::string> Tags;
 
    Azure::Nullable<Models::AccessTier> AccessTier;
 
    BlobAccessConditions AccessConditions;
 
    Azure::Nullable<Models::BlobImmutabilityPolicy> ImmutabilityPolicy;
 
    Azure::Nullable<bool> HasLegalHold;
  };
 
  struct GetBlockListOptions final
  {
    Models::BlockListType ListType = Models::BlockListType::Committed;
 
    struct : public LeaseAccessConditions, public TagAccessConditions
    {
    } 
    AccessConditions;
  };
 
  class BlobQueryInputTextOptions final {
  public:
    static BlobQueryInputTextOptions CreateCsvTextOptions(
        const std::string& recordSeparator = std::string(),
        const std::string& columnSeparator = std::string(),
        const std::string& quotationCharacter = std::string(),
        const std::string& escapeCharacter = std::string(),
        bool hasHeaders = false);
    static BlobQueryInputTextOptions CreateJsonTextOptions(
        const std::string& recordSeparator = std::string());
    static BlobQueryInputTextOptions CreateParquetTextOptions();
 
  private:
    Models::_detail::QueryFormatType m_format;
    std::string m_recordSeparator;
    std::string m_columnSeparator;
    std::string m_quotationCharacter;
    std::string m_escapeCharacter;
    bool m_hasHeaders = false;
 
    friend class BlockBlobClient;
  };
 
  class BlobQueryOutputTextOptions final {
  public:
    static BlobQueryOutputTextOptions CreateCsvTextOptions(
        const std::string& recordSeparator = std::string(),
        const std::string& columnSeparator = std::string(),
        const std::string& quotationCharacter = std::string(),
        const std::string& escapeCharacter = std::string(),
        bool hasHeaders = false);
    static BlobQueryOutputTextOptions CreateJsonTextOptions(
        const std::string& recordSeparator = std::string());
    static BlobQueryOutputTextOptions CreateArrowTextOptions(
        std::vector<Models::BlobQueryArrowField> schema);
 
  private:
    Models::_detail::QueryFormatType m_format;
    std::string m_recordSeparator;
    std::string m_columnSeparator;
    std::string m_quotationCharacter;
    std::string m_escapeCharacter;
    bool m_hasHeaders = false;
    std::vector<Models::BlobQueryArrowField> m_schema;
 
    friend class BlockBlobClient;
  };
 
  struct BlobQueryError final
  {
    std::string Name;
    std::string Description;
    bool IsFatal = false;
    int64_t Position;
  };
 
  struct QueryBlobOptions final
  {
    BlobQueryInputTextOptions InputTextConfiguration;
    BlobQueryOutputTextOptions OutputTextConfiguration;
    BlobAccessConditions AccessConditions;
    std::function<void(int64_t, int64_t)> ProgressHandler;
    std::function<void(BlobQueryError)> ErrorHandler;
  };
 
  struct CreateAppendBlobOptions final
  {
    Models::BlobHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    std::map<std::string, std::string> Tags;
 
    BlobAccessConditions AccessConditions;
 
    Azure::Nullable<Models::BlobImmutabilityPolicy> ImmutabilityPolicy;
 
    Azure::Nullable<bool> HasLegalHold;
  };
 
  struct AppendBlockOptions final
  {
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    AppendBlobAccessConditions AccessConditions;
  };
 
  struct AppendBlockFromUriOptions final
  {
    Azure::Nullable<Core::Http::HttpRange> SourceRange;
 
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    AppendBlobAccessConditions AccessConditions;
 
    std::string SourceAuthorization;
  };
 
  struct SealAppendBlobOptions final
  {
    AppendBlobAccessConditions AccessConditions;
  };
 
  struct CreatePageBlobOptions final
  {
    Azure::Nullable<int64_t> SequenceNumber;
 
    Models::BlobHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    Azure::Nullable<Models::AccessTier> AccessTier;
 
    std::map<std::string, std::string> Tags;
 
    BlobAccessConditions AccessConditions;
 
    Azure::Nullable<Models::BlobImmutabilityPolicy> ImmutabilityPolicy;
 
    Azure::Nullable<bool> HasLegalHold;
  };
 
  struct UploadPagesOptions final
  {
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    PageBlobAccessConditions AccessConditions;
  };
 
  struct UploadPagesFromUriOptions final
  {
    Azure::Nullable<ContentHash> TransactionalContentHash;
 
    PageBlobAccessConditions AccessConditions;
 
    struct : public Azure::ModifiedConditions, public Azure::MatchConditions
    {
    } 
    SourceAccessConditions;
 
    std::string SourceAuthorization;
  };
 
  struct ClearPagesOptions final
  {
    PageBlobAccessConditions AccessConditions;
  };
 
  struct ResizePageBlobOptions final
  {
    BlobAccessConditions AccessConditions;
  };
 
  struct UpdatePageBlobSequenceNumberOptions final
  {
    Azure::Nullable<int64_t> SequenceNumber;
 
    BlobAccessConditions AccessConditions;
  };
 
  struct GetPageRangesOptions final
  {
    Azure::Nullable<Core::Http::HttpRange> Range;
 
    BlobAccessConditions AccessConditions;
 
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
  };
 
  struct StartBlobCopyIncrementalOptions final
  {
    BlobAccessConditions AccessConditions;
  };
 
  struct SetBlobLegalHoldOptions final
  {
  };
 
  struct SetBlobImmutabilityPolicyOptions final
  {
    struct
    {
      Azure::Nullable<Azure::DateTime> IfUnmodifiedSince;
    } AccessConditions;
  };
 
  struct DeleteBlobImmutabilityPolicyOptions final
  {
  };
 
  struct SubmitBlobBatchOptions final
  {
  };
 
  namespace _detail {
    inline std::string TagsToString(const std::map<std::string, std::string>& tags)
    {
      return std::accumulate(
          tags.begin(),
          tags.end(),
          std::string(),
          [](const std::string& a, const std::pair<std::string, std::string>& b) {
            return a + (a.empty() ? "" : "&") + _internal::UrlEncodeQueryParameter(b.first) + "="
                + _internal::UrlEncodeQueryParameter(b.second);
          });
    }
  } // namespace _detail
}}} // namespace Azure::Storage::Blobs