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); }