public void ShouldThrowArgumentExceptionWhenUploadAsyncFileNameNotEqualToAssetFileName()
{
IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None);
string fileUploaded = _smallWmv;
IAssetFile fileInfo = asset.AssetFiles.Create("test.txt");
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(1),
AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.Sas, asset, policy);
try
{
fileInfo.UploadAsync(fileUploaded,
new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
},
locator,
CancellationToken.None);
}
catch (ArgumentException ex)
{
AssertFileMismatchException(fileUploaded, ex);
throw;
}
}
public void ShouldCreateAssetFileArrayWithEncryption()
{
var filePaths = new[] { WindowsAzureMediaServicesTestConfiguration.SmallWmv, WindowsAzureMediaServicesTestConfiguration.SmallWmv2 };
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
var blobclient = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
foreach (string filePath in filePaths)
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
file.UploadAsync(filePath, blobclient, locator, CancellationToken.None).Wait();
}
// Associate an access policy with the asset so we can download the files associated with it
policy = _mediaContext.AccessPolicies.Create("Test", TimeSpan.FromMinutes(10), AccessPermissions.Read);
_mediaContext.Locators.CreateSasLocator(asset, policy);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID should not be null");
Assert.IsTrue(asset.Options == AssetCreationOptions.StorageEncrypted, "AssetCreationOptions did not have the expected value");
VerifyFileAndContentKeyMetadataForStorageEncryption(asset, _mediaContext);
VerifyStorageEncryptionOnFiles(asset, filePaths);
}
internal static async Task <IAssetFile> CreateAssetFileFromLocalFileAsync(this IAsset asset, string filePath, ILocator sasLocator, EventHandler <UploadProgressChangedEventArgs> uploadProgressChangedEventArgs, CancellationToken cancellationToken)
{
string assetFileName = Path.GetFileName(filePath);
IAssetFile assetFile = await asset.AssetFiles.CreateAsync(assetFileName, cancellationToken).ConfigureAwait(false);
MediaContextBase context = asset.GetMediaContext();
assetFile.UploadProgressChanged += uploadProgressChangedEventArgs;
BlobTransferClient blobTransferClient = new BlobTransferClient
{
NumberOfConcurrentTransfers = context.NumberOfConcurrentTransfers,
ParallelTransferThreadCount = context.ParallelTransferThreadCount
};
await assetFile.UploadAsync(filePath, blobTransferClient, sasLocator, cancellationToken).ConfigureAwait(false);
assetFile.UploadProgressChanged -= uploadProgressChangedEventArgs;
if (assetFileName.EndsWith(ILocatorExtensions.ManifestFileExtension, StringComparison.OrdinalIgnoreCase))
{
assetFile.IsPrimary = true;
await assetFile.UpdateAsync().ConfigureAwait(false);
}
return(assetFile);
}
private IAsset CreateAssetAndUploadNFilesUsingAsyncCall(int expected)
{
IAsset asset = _dataContext.Assets.Create("TestWithMultipleFiles", AssetCreationOptions.None);
VerifyAsset(asset);
DirectoryInfo info = Directory.CreateDirectory(Guid.NewGuid().ToString());
var files = new List <Task>();
var client = new BlobTransferClient();
IAccessPolicy policy = _dataContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(20), AccessPermissions.Write);
ILocator locator = _dataContext.Locators.CreateSasLocator(asset, policy);
for (int i = 0; i < expected; i++)
{
string fileName;
string fullFilePath = CreateNewFileFromOriginal(info, out fileName);
IAssetFile file = asset.AssetFiles.Create(fileName);
files.Add(file.UploadAsync(fullFilePath, client, locator, CancellationToken.None));
}
Task.WaitAll(files.ToArray());
foreach (Task task in files)
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
Assert.IsNull(task.Exception);
}
return(asset);
}
public void ShouldCreateEncryptedInitilizedAsset()
{
IAsset asset = _mediaContext.Assets.Create("Test", AssetCreationOptions.StorageEncrypted);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null");
Assert.AreEqual(0, asset.AssetFiles.Count(), "Asset has files");
Assert.AreEqual(AssetState.Initialized, asset.State, "Expecting initilized state");
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
IAssetFile file = asset.AssetFiles.Create(Path.GetFileName(_smallWmv));
Task task = file.UploadAsync(_smallWmv,
_mediaContext.MediaServicesClassFactory.GetBlobTransferClient(),
locator,
CancellationToken.None);
task.Wait();
Assert.IsTrue(task.IsCompleted);
Assert.IsTrue(!task.IsFaulted);
locator.Delete();
policy.Delete();
IAsset refreshedAsset = _mediaContext.Assets.Where(c => c.Id == asset.Id).FirstOrDefault();
Assert.AreEqual(asset.Name, refreshedAsset.Name);
Assert.AreEqual(AssetState.Initialized, refreshedAsset.State);
Assert.AreEqual(1, refreshedAsset.AssetFiles.Count(), "file count wrong");
VerifyAndDownloadAsset(refreshedAsset, 1, false);
ContentKeyTests.VerifyFileAndContentKeyMetadataForStorageEncryption(refreshedAsset, _mediaContext);
}
public void ShouldReportProgressForFile()
{
string fileName = _smallWmv;
bool reportedProgress = false;
IAsset asset = _dataContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
IAccessPolicy policy = _dataContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = _dataContext.Locators.CreateSasLocator(asset, policy);
var info = new FileInfo(fileName);
IAssetFile file = asset.AssetFiles.Create(info.Name);
var blobclient = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
blobclient.TransferProgressChanged += (s, e) =>
{
Assert.AreEqual(fileName, e.LocalFile);
Assert.IsTrue(e.BytesTransferred <= e.TotalBytesToTransfer);
reportedProgress = true;
};
file.UploadAsync(fileName, blobclient, locator, CancellationToken.None).Wait();
Assert.IsTrue(reportedProgress);
}
private IAsset CreateSmoothAsset(string[] filePaths)
{
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
var blobclient = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
foreach (string filePath in filePaths)
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
file.UploadAsync(filePath, blobclient, locator, CancellationToken.None).Wait();
if (WindowsAzureMediaServicesTestConfiguration.SmallIsm == filePath)
{
file.IsPrimary = true;
file.Update();
}
}
return(asset);
}
public void ShouldCreateAssetAsyncWithMultipleFiles()
{
string[] files = Directory.GetFiles("TestFiles");
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.None);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
var blobclient = _mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
var tasks = new List <Task>();
foreach (string filePath in files)
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
tasks.Add(file.UploadAsync(filePath, blobclient, locator, CancellationToken.None));
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(AssetState.Initialized, asset.State);
Assert.AreEqual(files.Length, asset.AssetFiles.Count());
Assert.AreEqual(1, asset.Locators.Count);
foreach (IAssetFile assetFile in asset.AssetFiles)
{
Assert.IsTrue(files.Any(f => Path.GetFileName(f).Equals(assetFile.Name, StringComparison.OrdinalIgnoreCase)));
}
}
public void ShouldCreateAssetFile()
{
IAsset asset = _mediaContext.Assets.Create("Empty", AssetCreationOptions.StorageEncrypted);
IAssetFile file = asset.AssetFiles.CreateAsync(Path.GetFileName(_smallWmv), CancellationToken.None).Result;
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
BlobTransferClient blobTransferClient = _mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
bool transferCompletedFired = false;
blobTransferClient.TransferCompleted += (sender, args) =>
{
transferCompletedFired = true;
Assert.AreEqual(BlobTransferType.Upload, args.TransferType, "file.UploadAsync Transfer completed expected BlobTransferType is Upload");
};
file.UploadAsync(_smallWmv, blobTransferClient, locator, CancellationToken.None).Wait();
Assert.IsNotNull(asset, "Asset should be non null");
Assert.IsTrue(transferCompletedFired, "TransferCompleted event has not been fired");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null");
Assert.AreEqual(AssetState.Initialized, asset.State, "Asset state wrong");
foreach (IAssetFile ifile in asset.AssetFiles)
{
if (ifile.IsPrimary)
{
Assert.IsTrue(string.Compare(Path.GetFileName(_smallWmv), ifile.Name, StringComparison.InvariantCultureIgnoreCase) == 0, "Main file is wrong");
break;
}
}
}
public void ShouldCreateAssetFileArrayWithPlayReadyEncryption()
{
// Note that these files are not really PlayReady encrypted. For the purposes of this test that is okay.
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.CommonEncryptionProtected);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
var blobclient = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
foreach (string filePath in new[] { WindowsAzureMediaServicesTestConfiguration.SmallWmv, WindowsAzureMediaServicesTestConfiguration.SmallWmv2 })
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
file.UploadAsync(filePath, blobclient, locator, CancellationToken.None).Wait();
}
Guid keyId = Guid.NewGuid();
byte[] contentKey = GetRandomBuffer(16);
IContentKey key = _mediaContext.ContentKeys.Create(keyId, contentKey);
asset.ContentKeys.Add(key);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID should not be null");
Assert.IsTrue(asset.Options == AssetCreationOptions.CommonEncryptionProtected, "AssetCreationOptions did not have the expected value");
VerifyFileAndContentKeyMetadataForCommonEncryption(asset);
VerifyContentKeyVersusExpectedValue2(asset, contentKey, keyId);
}
private static void UploadFile(ILocator locator, IAsset asset, string filePath, CloudMediaContext mediaContext)
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
BlobTransferClient blobTransferClient = mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
Task task = file.UploadAsync(filePath, blobTransferClient, locator, CancellationToken.None);
task.Wait();
Assert.IsTrue(task.IsCompleted);
Assert.IsTrue(!task.IsFaulted);
}
public void When_Uploading_Multiple_Files_The_Progress_Event_Should_Only_Be_For_The_Bound_AssetFile()
{
IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None);
string fileUploaded = _smallWmv;
var file = new FileInfo(fileUploaded);
IAssetFile fileInfo = asset.AssetFiles.Create(Path.GetFileName(_smallWmv));
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(10),
AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.Sas, asset, policy);
var btc = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
int allProgressEventsFiredCount = 0;
btc.TransferProgressChanged += (sender, args) => { allProgressEventsFiredCount++; };
bool progressFired = false;
bool wrongFileSize = true;
int fileProgressEventsCount = 0;
fileInfo.UploadProgressChanged += (s, e) =>
{
progressFired = true;
wrongFileSize = e.TotalBytes != file.Length;
fileProgressEventsCount++;
};
Task uploadTask = fileInfo.UploadAsync(fileUploaded, btc, locator, CancellationToken.None);
string competingFile = WindowsAzureMediaServicesTestConfiguration.GetVideoSampleFilePath(TestContext,
WindowsAzureMediaServicesTestConfiguration.SmallMp41);
var retryPolicy =
_mediaContext.MediaServicesClassFactory.GetBlobStorageClientRetryPolicy()
.AsAzureStorageClientRetryPolicy();
btc.UploadBlob(CreateUrl(locator, Path.GetFileName(competingFile)), competingFile, null, null,
CancellationToken.None, retryPolicy).Wait();
uploadTask.Wait();
Assert.IsTrue(progressFired, "No upload progress event fired");
Assert.IsFalse(wrongFileSize, "Received the wrong file size from the upload progress event");
Assert.IsTrue(condition: fileProgressEventsCount < allProgressEventsFiredCount,
message:
"Unexpected number of fired events, it should be more than the events fired for the uploaded file.");
}
private static void UploadFile(ILocator locator, IAsset asset, string filePath)
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
Task task = file.UploadAsync(filePath,
new BlobTransferClient
{
NumberOfConcurrentTransfers = 10,
ParallelTransferThreadCount = 10
},
locator,
CancellationToken.None);
task.Wait();
Assert.IsTrue(task.IsCompleted);
Assert.IsTrue(!task.IsFaulted);
}
public void ShouldThrowArgumentExceptionOnAssetUploadWhenLocalFileNameNotMatchingAssetFileName()
{
IAsset asset = _mediaContext.Assets.Create("Empty", AssetCreationOptions.StorageEncrypted);
IAssetFile file = asset.AssetFiles.CreateAsync(Guid.NewGuid().ToString(), CancellationToken.None).Result;
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
try
{
file.UploadAsync(_smallWmv, _mediaContext.MediaServicesClassFactory.GetBlobTransferClient(), locator, CancellationToken.None).Wait();
}
catch (ArgumentException ex)
{
var finfo = new FileInfo(_smallWmv);
Assert.IsTrue(ex.Message.Contains("File name mismatch detected"));
Assert.IsTrue(ex.Message.Contains(finfo.Name.ToUpperInvariant()));
throw;
}
}
public static IAsset CreateAsset(CloudMediaContext datacontext, string filePath, AssetCreationOptions options)
{
IAsset asset = datacontext.Assets.Create(Guid.NewGuid().ToString(), options);
IAccessPolicy policy = datacontext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = datacontext.Locators.CreateSasLocator(asset, policy);
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
BlobTransferClient blobTransferClient = datacontext.MediaServicesClassFactory.GetBlobTransferClient();
blobTransferClient.NumberOfConcurrentTransfers = 5;
blobTransferClient.ParallelTransferThreadCount = 5;
file.UploadAsync(filePath,
blobTransferClient,
locator,
CancellationToken.None).Wait();
file.IsPrimary = true;
file.Update();
return(asset);
}
public static IAsset CreateAssetAndUploadNFilesUsingAsyncCall(int expected, CloudMediaContext mediaContext, string sourceFileName)
{
IAsset asset = mediaContext.Assets.Create("TestWithMultipleFiles", AssetCreationOptions.None);
VerifyAsset(asset);
DirectoryInfo info = null;
try
{
info = Directory.CreateDirectory(Guid.NewGuid().ToString());
var files = new List <Task>();
BlobTransferClient blobTransferClient = mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
IAccessPolicy policy = mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(20), AccessPermissions.Write);
ILocator locator = mediaContext.Locators.CreateSasLocator(asset, policy);
for (int i = 0; i < expected; i++)
{
string fileName;
string fullFilePath = CreateNewFileFromOriginal(info, sourceFileName, out fileName);
IAssetFile file = asset.AssetFiles.Create(fileName);
files.Add(file.UploadAsync(fullFilePath, blobTransferClient, locator, CancellationToken.None));
}
Task.WaitAll(files.ToArray());
foreach (Task task in files)
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
Assert.IsNull(task.Exception);
}
}
finally
{
if (info != null)
{
info.Delete(recursive: true);
}
}
return(asset);
}
public IAsset CreateAsset(string authToken, string assetName, string storageAccount, bool storageEncryption, string[] fileNames)
{
AssetCreationOptions assetEncryption = storageEncryption ? AssetCreationOptions.StorageEncrypted : AssetCreationOptions.None;
IAsset asset = _media.Assets.Create(assetName, storageAccount, assetEncryption);
BlobClient blobClient = new BlobClient(authToken, storageAccount);
string sourceContainer = Constant.Storage.Blob.Container.FileUpload;
if (fileNames.Length == 1)
{
string fileName = fileNames[0];
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainer, null, fileName, true);
Stream sourceStream = sourceBlob.OpenRead();
assetFile.Upload(sourceStream);
foreach (ILocator locator in asset.Locators)
{
locator.Delete();
}
}
else
{
BlobTransferClient transferClient = new BlobTransferClient();
ILocator sasLocator = CreateLocator(LocatorType.Sas, asset, true);
List <Task> uploadTasks = new List <Task>();
foreach (string fileName in fileNames)
{
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainer, null, fileName, true);
Stream sourceStream = sourceBlob.OpenRead();
Task uploadTask = assetFile.UploadAsync(sourceStream, transferClient, sasLocator, CancellationToken.None);
uploadTasks.Add(uploadTask);
}
Task.WaitAll(uploadTasks.ToArray());
sasLocator.Delete();
}
SetPrimaryFile(asset);
return(asset);
}
public void ShouldThrowArgumentExceptionWhenUploadAsyncFileNameNotEqualToAssetFileName()
{
IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None);
string fileUploaded = _smallWmv;
IAssetFile fileInfo = asset.AssetFiles.Create("test.txt");
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(1), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.Sas, asset, policy);
try
{
BlobTransferClient blobTransferClient = _mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
fileInfo.UploadAsync(fileUploaded,
blobTransferClient,
locator,
CancellationToken.None);
}
catch (ArgumentException ex)
{
AssertFileMismatchException(fileUploaded, ex);
throw;
}
}
public void ShouldCreateEncryptedInitilizedAsset()
{
IAsset asset = _dataContext.Assets.Create("Test", AssetCreationOptions.StorageEncrypted);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null");
Assert.AreEqual(0, asset.AssetFiles.Count(), "Asset has files");
Assert.AreEqual(AssetState.Initialized, asset.State, "Expecting initilized state");
IAccessPolicy policy = _dataContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _dataContext.Locators.CreateSasLocator(asset, policy);
IAssetFile file = asset.AssetFiles.Create(Path.GetFileName(_smallWmv));
Task task = file.UploadAsync(_smallWmv,
new BlobTransferClient
{
NumberOfConcurrentTransfers = 10,
ParallelTransferThreadCount = 10
},
locator,
CancellationToken.None);
task.Wait();
Assert.IsTrue(task.IsCompleted);
Assert.IsTrue(!task.IsFaulted);
locator.Delete();
policy.Delete();
IAsset refreshedAsset = _dataContext.Assets.Where(c => c.Id == asset.Id).FirstOrDefault();
Assert.AreEqual(asset.Name, refreshedAsset.Name);
Assert.AreEqual(AssetState.Initialized, refreshedAsset.State);
Assert.AreEqual(1, refreshedAsset.AssetFiles.Count(), "file count wrong");
// TODO: Task 27827: Design and implement a KeyOracle Role to hold the Private key or keys used to protect content keys
//VerifyAndDownloadAsset(refreshedAsset);
ContentKeyTests.VerifyFileAndContentKeyMetadataForStorageEncryption(refreshedAsset, _dataContext);
}
public static async Task <IAsset> UploadVideo(CloudMediaContext context, string name, string address)
{
IAsset uploadAsset =
await
context.Assets.CreateAsync(Path.GetFileNameWithoutExtension(name), AssetCreationOptions.None,
CancellationToken.None);
IAssetFile assetFile = await uploadAsset.AssetFiles.CreateAsync(name, CancellationToken.None);
IAccessPolicy accessPolicy = context.AccessPolicies.Create(uploadAsset.Name, TimeSpan.FromMinutes(5),
AccessPermissions.Write);
ILocator locator = context.Locators.CreateSasLocator(uploadAsset, accessPolicy);
BlobTransferClient client = new BlobTransferClient()
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
await assetFile.UploadAsync(address, client, locator, CancellationToken.None);
locator.Delete();
accessPolicy.Delete();
return(uploadAsset);
}
