datalake_options.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/storage/blobs/rest_client.hpp"
#include "azure/storage/files/datalake/rest_client.hpp"
 
#include <azure/core/nullable.hpp>
#include <azure/storage/blobs/blob_options.hpp>
#include <azure/storage/common/access_conditions.hpp>
 
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace Azure { namespace Storage { namespace Files { namespace DataLake {
 
  namespace Models {
    using PathHttpHeaders = Blobs::Models::BlobHttpHeaders;
    using ListFileSystemsIncludeFlags = Blobs::Models::ListBlobContainersIncludeFlags;
    using SignedIdentifier = Blobs::Models::SignedIdentifier;
    using FileQueryArrowField = Blobs::Models::BlobQueryArrowField;
    using FileQueryArrowFieldType = Blobs::Models::BlobQueryArrowFieldType;
    using EncryptionAlgorithmType = Blobs::Models::EncryptionAlgorithmType;
 
    struct Acl final
    {
      std::string Scope;
 
      std::string Type;
 
      std::string Id;
 
      std::string Permissions;
 
      static Acl FromString(const std::string& aclString);
 
      static std::string ToString(const Acl& acl);
 
      static std::vector<Acl> DeserializeAcls(const std::string& aclsString);
 
      static std::string SerializeAcls(const std::vector<Acl>& aclsArray);
    };
  } // namespace Models
 
  using DownloadFileToOptions = Blobs::DownloadBlobToOptions;
  using GetUserDelegationKeyOptions = Blobs::GetUserDelegationKeyOptions;
  using GetServicePropertiesOptions = Blobs::GetServicePropertiesOptions;
  using SetServicePropertiesOptions = Blobs::SetServicePropertiesOptions;
  using EncryptionKey = Blobs::EncryptionKey;
 
  namespace _detail {
    struct DatalakeClientConfiguration
    {
 
      std::string ApiVersion;
 
      std::shared_ptr<const Core::Credentials::TokenCredential> TokenCredential;
 
      Azure::Nullable<EncryptionKey> CustomerProvidedKey;
 
      Azure::Nullable<Azure::Core::Url> FileSystemUrl;
    };
  } // namespace _detail
 
  class DataLakeAudience final
      : public Azure::Core::_internal::ExtendableEnumeration<DataLakeAudience> {
  public:
    explicit DataLakeAudience(std::string dataLakeAudience)
        : ExtendableEnumeration(std::move(dataLakeAudience))
    {
    }
 
    static DataLakeAudience CreateDataLakeServiceAccountAudience(
        const std::string& storageAccountName)
    {
      return DataLakeAudience("https://" + storageAccountName + ".blob.core.windows.net/");
    }
 
    AZ_STORAGE_FILES_DATALAKE_DLLEXPORT const static DataLakeAudience DefaultAudience;
  };
 
  struct DataLakeClientOptions final : Azure::Core::_internal::ClientOptions
  {
    std::string SecondaryHostForRetryReads;
 
    std::string ApiVersion;
 
    Azure::Nullable<EncryptionKey> CustomerProvidedKey;
 
    bool EnableTenantDiscovery = false;
 
    Azure::Nullable<DataLakeAudience> Audience;
  };
 
  struct FileSystemAccessConditions final : public Azure::ModifiedConditions,
                                            public LeaseAccessConditions
  {
  };
 
  struct PathAccessConditions final : public Azure::ModifiedConditions,
                                      public Azure::MatchConditions,
                                      public LeaseAccessConditions
  {
  };
 
  struct ListFileSystemsOptions final
  {
    Azure::Nullable<std::string> Prefix;
 
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
 
    Models::ListFileSystemsIncludeFlags Include = Models::ListFileSystemsIncludeFlags::None;
  };
 
  struct CreateFileSystemOptions final
  {
    Storage::Metadata Metadata;
 
    Models::PublicAccessType AccessType = Models::PublicAccessType::None;
 
    Azure::Nullable<std::string> DefaultEncryptionScope;
 
    Azure::Nullable<bool> PreventEncryptionScopeOverride;
  };
 
  struct DeleteFileSystemOptions final
  {
    FileSystemAccessConditions AccessConditions;
  };
 
  struct GetFileSystemPropertiesOptions final
  {
    LeaseAccessConditions AccessConditions;
  };
 
  struct SetFileSystemMetadataOptions final
  {
    struct : public LeaseAccessConditions
    {
      Azure::Nullable<Azure::DateTime> IfModifiedSince;
    } 
    AccessConditions;
  };
 
  struct ListPathsOptions final
  {
    Azure::Nullable<bool> UserPrincipalName;
 
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
  };
 
  struct ListDeletedPathsOptions final
  {
    Azure::Nullable<std::string> Prefix;
 
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
  };
 
  struct UndeletePathOptions final
  {
  };
 
  struct GetFileSystemAccessPolicyOptions final
  {
    LeaseAccessConditions AccessConditions;
  };
 
  struct SetFileSystemAccessPolicyOptions final
  {
    Models::PublicAccessType AccessType = Models::PublicAccessType::None;
 
    std::vector<Models::SignedIdentifier> SignedIdentifiers;
 
    FileSystemAccessConditions AccessConditions;
  };
 
  struct RenameDirectoryOptions final
  {
    Azure::Nullable<std::string> DestinationFileSystem;
 
    PathAccessConditions AccessConditions;
 
    PathAccessConditions SourceAccessConditions;
  };
 
  struct AppendFileOptions final
  {
    Azure::Nullable<Storage::ContentHash> TransactionalContentHash;
 
    LeaseAccessConditions AccessConditions;
 
    Azure::Nullable<bool> Flush;
 
    Azure::Nullable<Models::LeaseAction> LeaseAction;
 
    Azure::Nullable<std::string> LeaseId;
 
    Azure::Nullable<std::chrono::seconds> LeaseDuration;
  };
 
  struct FlushFileOptions final
  {
    Azure::Nullable<bool> RetainUncommittedData;
 
    Azure::Nullable<bool> Close;
 
    Azure::Nullable<Storage::ContentHash> ContentHash;
 
    Models::PathHttpHeaders HttpHeaders;
 
    PathAccessConditions AccessConditions;
 
    Azure::Nullable<Models::LeaseAction> LeaseAction;
 
    Azure::Nullable<std::string> LeaseId;
 
    Azure::Nullable<std::chrono::seconds> LeaseDuration;
  };
 
  struct SetPathAccessControlListOptions final
  {
    Azure::Nullable<std::string> Owner;
 
    Azure::Nullable<std::string> Group;
 
    PathAccessConditions AccessConditions;
  };
 
  struct SetPathPermissionsOptions final
  {
    Azure::Nullable<std::string> Owner;
 
    Azure::Nullable<std::string> Group;
 
    PathAccessConditions AccessConditions;
  };
 
  struct SetPathHttpHeadersOptions final
  {
    PathAccessConditions AccessConditions;
  };
 
  struct SetPathMetadataOptions final
  {
    PathAccessConditions AccessConditions;
  };
 
  using ScheduleFileExpiryOriginType = Blobs::Models::ScheduleBlobExpiryOriginType;
 
  struct ScheduleFileDeletionOptions final
  {
    Azure::Nullable<std::chrono::milliseconds> TimeToExpire;
 
    Azure::Nullable<DateTime> ExpiresOn;
  };
 
  using SchedulePathDeletionOptions = ScheduleFileDeletionOptions;
 
  struct CreatePathOptions final
  {
    Models::PathHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    Azure::Nullable<std::string> Umask;
 
    Azure::Nullable<std::string> Permissions;
 
    Azure::Nullable<std::string> Owner;
 
    Azure::Nullable<std::string> Group;
 
    Azure::Nullable<std::vector<Models::Acl>> Acls;
 
    Azure::Nullable<std::string> LeaseId;
 
    Azure::Nullable<std::chrono::seconds> LeaseDuration;
 
    SchedulePathDeletionOptions ScheduleDeletionOptions;
 
    PathAccessConditions AccessConditions;
 
    Azure::Nullable<std::string> EncryptionContext;
  };
 
  struct DeletePathOptions final
  {
    Azure::Nullable<bool> Recursive;
 
    PathAccessConditions AccessConditions;
  };
 
  struct GetPathPropertiesOptions final
  {
    PathAccessConditions AccessConditions;
 
    Nullable<bool> IncludeUserPrincipalName;
  };
 
  struct GetPathAccessControlListOptions final
  {
    PathAccessConditions AccessConditions;
 
    Nullable<bool> IncludeUserPrincipalName;
  };
 
  struct DownloadFileOptions final
  {
    Azure::Nullable<Core::Http::HttpRange> Range;
 
    Azure::Nullable<HashAlgorithm> RangeHashAlgorithm;
 
    PathAccessConditions AccessConditions;
 
    Nullable<bool> IncludeUserPrincipalName;
  };
 
  struct RenameFileOptions final
  {
    Azure::Nullable<std::string> DestinationFileSystem;
 
    PathAccessConditions AccessConditions;
 
    PathAccessConditions SourceAccessConditions;
  };
 
  struct DeleteFileOptions final
  {
    PathAccessConditions AccessConditions;
  };
 
  using RenameSubdirectoryOptions = RenameDirectoryOptions;
 
  struct DeleteDirectoryOptions final
  {
    PathAccessConditions AccessConditions;
  };
 
  struct SetPathAccessControlListRecursiveOptions final
  {
    Azure::Nullable<std::string> ContinuationToken;
 
    Azure::Nullable<int32_t> PageSizeHint;
 
    Azure::Nullable<bool> ContinueOnFailure;
  };
 
  using UpdatePathAccessControlListRecursiveOptions = SetPathAccessControlListRecursiveOptions;
 
  using RemovePathAccessControlListRecursiveOptions = SetPathAccessControlListRecursiveOptions;
 
  using CreateFileOptions = CreatePathOptions;
  using CreateDirectoryOptions = CreatePathOptions;
 
  struct UploadFileFromOptions final
  {
    Models::PathHttpHeaders HttpHeaders;
 
    Storage::Metadata Metadata;
 
    struct
    {
      int64_t SingleUploadThreshold = 256 * 1024 * 1024;
 
      Azure::Nullable<int64_t> ChunkSize;
 
      int32_t Concurrency = 5;
    } TransferOptions;
  };
 
  using AcquireLeaseOptions = Blobs::AcquireLeaseOptions;
  using BreakLeaseOptions = Blobs::BreakLeaseOptions;
  using RenewLeaseOptions = Blobs::RenewLeaseOptions;
  using ReleaseLeaseOptions = Blobs::ReleaseLeaseOptions;
  using ChangeLeaseOptions = Blobs::ChangeLeaseOptions;
 
  using FileQueryInputTextOptions = Blobs::BlobQueryInputTextOptions;
  using FileQueryOutputTextOptions = Blobs::BlobQueryOutputTextOptions;
  using FileQueryError = Blobs::BlobQueryError;
 
  struct QueryFileOptions final
  {
    FileQueryInputTextOptions InputTextConfiguration;
    FileQueryOutputTextOptions OutputTextConfiguration;
    PathAccessConditions AccessConditions;
    std::function<void(int64_t, int64_t)> ProgressHandler;
    std::function<void(FileQueryError)> ErrorHandler;
  };
}}}} // namespace Azure::Storage::Files::DataLake