Beispiel #1
0
        /// <summary>
        /// Creates a BlobContainerClient.  Called when one does not exist yet.
        /// </summary>
        /// <param name="uri">The target Uri.</param>
        /// <param name="context">The context.</param>
        /// <returns>
        /// A BlobContainerClient object.
        /// </returns>
        internal StorageContainerClientSleeve CreateBlobContainerClientForUri(
            Uri uri,
            StorageClientProviderContext context)
        {
            // set up a copy of the Context...
            var ctxCopy = new StorageClientProviderContext(context);

            BlobContainerClient blobContainerClient;
            BlobUriBuilder      containerUriBuilder;
            BlobClientOptions   clientOptions;

            try
            {
                containerUriBuilder = new BlobUriBuilder(uri);
                clientOptions       = new BlobClientOptions();
                var clientRequestIdPolicy = new BlobClientPipelinePolicy(ctxCopy);
                var uriC = StorageHelpers.BuildBlobStorageUri(containerUriBuilder.AccountName, containerUriBuilder.BlobContainerName);
                blobContainerClient = new BlobContainerClient(uriC, _identity, clientOptions);
            }
            catch (Exception fe) when(fe is ArgumentNullException || fe is UriFormatException)
            {
                var aex = new ArgumentException(LogEventIds.BlobContainerClientProviderUriMissingAccountName.Name, fe);

                _log.LogExceptionObject(LogEventIds.BlobContainerClientProviderUriMissingAccountName, aex, uri);
                throw aex;
            }
            catch (Exception e)
            {
                _log.LogExceptionObject(LogEventIds.BlobContainerClientProviderFailedToCreateBlobContainerClient, e, uri);
                throw;
            }


            try
            {
                var accountUri = StorageHelpers.BuildStorageAccountUri(containerUriBuilder.AccountName, buildForBlobService: true);
                var sleeve     = new StorageContainerClientSleeve(blobContainerClient,
                                                                  new BlobServiceClient(accountUri, _identity, clientOptions),
                                                                  ctxCopy);
                return(sleeve);
            }
            catch (ArgumentException aex)
            {
                _log.LogExceptionObject(LogEventIds.BlobContainerClientProviderUriMissingAccountName, aex, uri);
                throw;
            }
        }
Beispiel #2
0
        public void BuildStorageAccountUri_Test(string accountName, bool buildForBlobService, string expectedResult, Type expectedExceptionType)
        {
            Uri res;

            try
            {
                res = StorageHelpers.BuildStorageAccountUri(accountName, buildForBlobService);
            }
            catch (Exception e)
            {
                expectedExceptionType.ShouldNotBeNull();
                e.ShouldBeOfType(expectedExceptionType);
                return;
            }

            expectedExceptionType.ShouldBeNull();
            res.ToString().ShouldBe(expectedResult);
        }
        /// <summary>
        /// Creates a BlobClientSleeve (BlobBaseClient + Context).  Called when one does not exist yet.
        /// </summary>
        /// <param name="blobUri">The target Uri.</param>
        /// <param name="ctx">The context.</param>
        /// <returns>
        /// A BlobBaseClient object.
        /// </returns>
        internal StorageBlobClientSleeve CreateBlobClientSleeveForUri(Uri blobUri, StorageClientProviderContext ctx)
        {
            BlobBaseClient blobBaseClient;
            BlobUriBuilder blobUriBuilder;

            var contextCopy       = new StorageClientProviderContext(ctx);
            var blobClientOptions = new BlobClientOptions();

            try
            {
                blobUriBuilder = new BlobUriBuilder(blobUri);
                var clientRequestIdPolicy = new BlobClientPipelinePolicy(contextCopy);
                blobClientOptions.AddPolicy(clientRequestIdPolicy, HttpPipelinePosition.PerCall);
                blobBaseClient = new BlobBaseClient(blobUri, _identity, blobClientOptions);
            }
            catch (Exception e)
            {
                _log.LogExceptionObject(LogEventIds.BlobBaseClientProviderFailedToCreateBlobBaseClient, e, blobUri);
                throw;
            }

            try
            {
                // BlobUriBuilder SDK class will just give null for Accountname if URL is malformed, so let flow upwards
                _ = StringHelpers.NullIfNullOrWhiteSpace(blobUriBuilder.AccountName) ?? throw new UriFormatException($@"Malformed Azure Storage URL: {blobUri}");

                var accountUri = StorageHelpers.BuildStorageAccountUri(blobUriBuilder.AccountName, buildForBlobService: true);
                var newSleeve  = new StorageBlobClientSleeve(blobBaseClient,
                                                             new BlobServiceClient(accountUri, _identity, blobClientOptions),
                                                             contextCopy);
                return(newSleeve);
            }
            catch (UriFormatException uriex)
            {
                _log.LogExceptionObject(LogEventIds.BlobBaseClientProviderUriMissingAccountName, uriex, blobUri);
                throw new ArgumentException(LogEventIds.BlobBaseClientProviderUriMissingAccountName.Name, nameof(blobUri), uriex);
            }
            catch (ArgumentException aex)
            {
                _log.LogExceptionObject(LogEventIds.BlobBaseClientProviderUriMissingAccountName, aex, blobUri);
                throw;
            }
        }