public void EncryptManifestFilesAndVerifyThemAfterDecryption() { List <IIngestManifestFile> files; IIngestManifest ingestManifestCreated; string path = null; try { path = CreateManifestEncryptFiles(out files, out ingestManifestCreated); IIngestManifestAsset ingestManifestAsset = ingestManifestCreated.IngestManifestAssets.ToList().Where(c => c.Asset.Options == AssetCreationOptions.StorageEncrypted).FirstOrDefault(); IIngestManifestFile mFile = ingestManifestAsset.IngestManifestFiles.Where(c => c.Name == "File0.txt").FirstOrDefault(); Dictionary <string, string> filePaths = new Dictionary <string, string>(); foreach (var filePath in new[] { TestFile1, TestFile2 }) { FileInfo fileInfo = new FileInfo(filePath); filePaths.Add(fileInfo.Name, filePath); } var encryptedPath = Path.Combine(path, mFile.Name); Assert.IsTrue(File.Exists(encryptedPath)); var decryptedPath = DecryptedFile(mFile, encryptedPath, _mediaContext); Assert.IsTrue(AssetTests.CompareFiles(decryptedPath, filePaths[mFile.Name]), "Original file and Decrypted are not same"); } finally { AssetFilesTests.CleanDirectory(path); } }
public void ShouldThrowKeyNotFoundExceptionDuringEncryptIfKeyIsMissing() { var sourcePath = DeploymentFolder1; Assert.IsTrue(Directory.Exists(sourcePath)); List <string> files = Directory.EnumerateFiles(sourcePath, "*.txt").ToList(); //Creating empty manifest const string manifestName = "Manifest 1"; IIngestManifest ingestManifestCreated = _context.IngestManifests.Create(manifestName); //Adding manifest asset info with multiple file IAsset emptyAsset = _context.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted); IIngestManifestAsset ingestManifestAsset = ingestManifestCreated.IngestManifestAssets.CreateAsync(emptyAsset, files.ToArray(), CancellationToken.None).Result; Assert.IsNotNull(ingestManifestAsset); //According to last REST implementation breaking a link //also deleting a key on server side if no other links are found emptyAsset.ContentKeys.RemoveAt(0); var path = @".\Resources\TestFiles\" + Guid.NewGuid(); Directory.CreateDirectory(path); try { ingestManifestCreated.EncryptFiles(path); } catch (AggregateException ex) { Assert.AreEqual(1, ex.InnerExceptions.Count); throw ex.InnerExceptions[0]; } }
public void ListAssetsAndFilesForNewlyCreatedManifests() { IIngestManifest ingestManifest = CreateEmptyManifestAndVerifyIt(); IAsset asset = _mediaContext.Assets.Create("name", AssetCreationOptions.None); Assert.IsNotNull(asset); IIngestManifestAsset ingestManifestAsset = ingestManifest.IngestManifestAssets.Create(asset, new[] { TestFile1 }); VerifyManifestAsset(ingestManifestAsset); IIngestManifestAsset firstAsset = ingestManifest.IngestManifestAssets.FirstOrDefault(); VerifyManifestAsset(firstAsset); Assert.AreEqual(ingestManifestAsset.Id, firstAsset.Id); _mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); IIngestManifest sameIngestManifest = _mediaContext.IngestManifests.Where(c => c.Id == ingestManifest.Id).FirstOrDefault(); Assert.IsNotNull(sameIngestManifest); Assert.AreEqual(1, sameIngestManifest.IngestManifestAssets.Count(), "Manifest asset count is not matching expecting value 1"); firstAsset = sameIngestManifest.IngestManifestAssets.FirstOrDefault(); VerifyManifestAsset(firstAsset); Assert.AreEqual(1, firstAsset.IngestManifestFiles.Count(), "Manifest file count is not matching expecting value 1"); IIngestManifestFile firstFile = firstAsset.IngestManifestFiles.FirstOrDefault(); Assert.AreEqual("text/plain", firstFile.MimeType, "IngestManifestFile's MimeType is wrong"); VerifyManifestFile(firstFile); }
private static string DecryptedFile(IIngestManifestFile ingestManifestFile, string encryptedPath, CloudMediaContext context) { IIngestManifestAsset ingestManifestAsset = context.IngestManifestAssets.Where(a => a.Id == ingestManifestFile.ParentIngestManifestAssetId).FirstOrDefault(); Assert.IsNotNull(ingestManifestAsset); IList <IContentKey> keys = ingestManifestAsset.Asset.ContentKeys.Where(c => c.ContentKeyType == ContentKeyType.StorageEncryption).ToList(); Assert.AreEqual(1, keys.Count, "Expecting only one storage key per asset"); IContentKey key = keys.FirstOrDefault(); Assert.IsNotNull(ingestManifestAsset); Guid keyId = EncryptionUtils.GetKeyIdAsGuid(key.Id); FileEncryption fileEncryption = new FileEncryption(key.GetClearKeyValue(), keyId); ulong iv = Convert.ToUInt64(ingestManifestFile.InitializationVector, CultureInfo.InvariantCulture); var decryptedPath = @".\Resources\TestFiles\Decrypted" + Guid.NewGuid(); if (!Directory.Exists(decryptedPath)) { Directory.CreateDirectory(decryptedPath); } decryptedPath = Path.Combine(decryptedPath, ingestManifestFile.Name); FileInfo fileInfo = new FileInfo(encryptedPath); var maxblocksize = GetBlockSize(fileInfo.Length); List <string> blockList = new List <string>(); int numberOfthreads = 1; var queue = PreapreDownloadQueue(maxblocksize, fileInfo.Length, ref numberOfthreads, out blockList); using (var fs = new FileStream(decryptedPath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read)) { KeyValuePair <int, int> block; while (queue.TryDequeue(out block)) { fs.Seek(block.Key * maxblocksize, SeekOrigin.Begin); using (FileStream stream = File.OpenRead(encryptedPath)) { byte[] buffer = new byte[block.Value]; stream.Seek(block.Key * maxblocksize, SeekOrigin.Begin); int read = stream.Read(buffer, 0, (int)block.Value); if (fileEncryption != null) { lock (fileEncryption) { using (FileEncryptionTransform encryptor = fileEncryption.GetTransform(iv, block.Key * maxblocksize)) { encryptor.TransformBlock(inputBuffer: buffer, inputOffset: 0, inputCount: buffer.Length, outputBuffer: buffer, outputOffset: 0); } } } fs.Write(buffer, 0, buffer.Length); } } } return(decryptedPath); }
public void EncryptManifestTestDisableOverwriteExistingFile() { CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); var sourcePath = DeploymentFolder1; Assert.IsTrue(Directory.Exists(sourcePath)); List <string> files = Directory.EnumerateFiles(sourcePath, "*.txt").ToList(); const string manifestName = "Manifest 1"; IIngestManifest ingestManifestCreated = context.IngestManifests.Create(manifestName); //Adding manifest asset info with multiple file IAsset emptyAsset = context.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted); IIngestManifestAsset ingestManifestAsset = ingestManifestCreated.IngestManifestAssets.Create(emptyAsset, files.ToArray()); var path = @".\Resources\TestFiles\" + Guid.NewGuid(); try { Directory.CreateDirectory(path); string dupFileName = Path.Combine(path, Path.GetFileName(files[0])); File.WriteAllText(dupFileName, ""); ingestManifestCreated.EncryptFiles(path, false); } catch (AggregateException ax) { var expectedExcpetion = ax.GetBaseException() as IOException; throw expectedExcpetion; } finally { AssetFilesTests.CleanDirectory(path); } }
private static void EncryptFilesDecryptAndCompare(List <string> files) { CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); //Creating empty manifest const string manifestName = "Manifest 1"; IIngestManifest ingestManifestCreated = context.IngestManifests.Create(manifestName); //Adding manifest asset info with multiple file IAsset emptyAsset = context.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted); IIngestManifestAsset ingestManifestAsset = ingestManifestCreated.IngestManifestAssets.CreateAsync(emptyAsset, files.ToArray(), CancellationToken.None).Result; var path = @".\Resources\TestFiles\" + Guid.NewGuid(); Directory.CreateDirectory(path); ingestManifestCreated.EncryptFiles(path); Dictionary <string, string> filePaths = new Dictionary <string, string>(); foreach (var filePath in files) { FileInfo fileInfo = new FileInfo(filePath); filePaths.Add(fileInfo.Name, filePath); } foreach (var assetFile in ingestManifestAsset.IngestManifestFiles) { var encryptedPath = Path.Combine(path, assetFile.Name); Assert.IsTrue(File.Exists(encryptedPath)); var decryptedPath = DecryptedFile(assetFile, encryptedPath, context); Assert.IsTrue(AssetTests.CompareFiles(decryptedPath, filePaths[assetFile.Name]), "Original file and Decrypted are not same"); } }
/// <summary> /// Creates the manifest asset file asynchronously. /// </summary> /// <param name="ingestManifestAsset">The parent manifest asset.</param> /// <param name="filePath">The file path.</param> /// <param name="token"><see cref="CancellationToken"/></param> /// <returns><see cref="Task"/>of type <see cref="IIngestManifestFile"/></returns> public Task <IIngestManifestFile> CreateAsync(IIngestManifestAsset ingestManifestAsset, string filePath, CancellationToken token) { if (ingestManifestAsset == null) { throw new ArgumentNullException("ingestManifestAsset"); } if (string.IsNullOrWhiteSpace(filePath)) { throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, StringTable.ErrorCreatingIngestManifestFileEmptyFilePath)); } AssetCreationOptions options = ingestManifestAsset.Asset.Options; Task <IIngestManifestFile> rootTask = new Task <IIngestManifestFile>(() => { token.ThrowIfCancellationRequested(); IngestManifestAssetCollection.VerifyManifestAsset(ingestManifestAsset); if (!File.Exists(filePath)) { throw new FileNotFoundException(String.Format(CultureInfo.InvariantCulture, StringTable.BulkIngestProvidedFileDoesNotExist, filePath)); } FileInfo info = new FileInfo(filePath); DataServiceContext dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext(); // Set a MIME type based on the extension of the file name string mimeType = AssetFileData.GetMimeType(filePath); IngestManifestFileData data = new IngestManifestFileData { Name = info.Name, MimeType = mimeType, ParentIngestManifestId = ingestManifestAsset.ParentIngestManifestId, ParentIngestManifestAssetId = ingestManifestAsset.Id, Path = filePath, }; SetEncryptionSettings(ingestManifestAsset, info, options, data); dataContext.AddObject(EntitySet, data); Task <IIngestManifestFile> task = dataContext.SaveChangesAsync(data).ContinueWith <IIngestManifestFile>(t => { t.ThrowIfFaulted(); token.ThrowIfCancellationRequested(); IngestManifestFileData ingestManifestFile = (IngestManifestFileData)t.AsyncState; return(ingestManifestFile); }); return(task.Result); }); rootTask.Start(); return(rootTask); }
/// <summary> /// Initializes a new instance of the <see cref="IngestManifestFileCollection"/> class. /// </summary> /// <param name="cloudMediaContext">The <seealso cref="CloudMediaContext"/> instance.</param> /// <param name="parentIngestManifestAsset">The parent manifest asset.</param> internal IngestManifestFileCollection(CloudMediaContext cloudMediaContext, IIngestManifestAsset parentIngestManifestAsset) { this._cloudMediaContext = cloudMediaContext; this._dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext(); this._query = new Lazy <IQueryable <IIngestManifestFile> >(() => this._dataContext.CreateQuery <IngestManifestFileData>(EntitySet)); if (parentIngestManifestAsset != null) { this._parentIngestManifestAsset = (IngestManifestAssetData)parentIngestManifestAsset; } }
/// <summary> /// Creates the manifest asset file asynchronously. /// </summary> /// <param name="ingestManifestAsset">The parent manifest asset.</param> /// <param name="filePath">The file path.</param> /// <param name="token"><see cref="CancellationToken"/></param> /// <returns><see cref="Task"/>of type <see cref="IIngestManifestFile"/></returns> public Task <IIngestManifestFile> CreateAsync(IIngestManifestAsset ingestManifestAsset, string filePath, CancellationToken token) { if (ingestManifestAsset == null) { throw new ArgumentNullException("ingestManifestAsset"); } if (string.IsNullOrWhiteSpace(filePath)) { throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, StringTable.ErrorCreatingIngestManifestFileEmptyFilePath)); } AssetCreationOptions options = ingestManifestAsset.Asset.Options; Task <IIngestManifestFile> rootTask = new Task <IIngestManifestFile>(() => { token.ThrowIfCancellationRequested(); IngestManifestAssetCollection.VerifyManifestAsset(ingestManifestAsset); IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext(); // Set a MIME type based on the extension of the file name string mimeType = AssetFileData.GetMimeType(filePath); IngestManifestFileData data = new IngestManifestFileData { Name = Path.GetFileName(filePath), MimeType = mimeType, ParentIngestManifestId = ingestManifestAsset.ParentIngestManifestId, ParentIngestManifestAssetId = ingestManifestAsset.Id, Path = filePath, }; SetEncryptionSettings(ingestManifestAsset, options, data); dataContext.AddObject(EntitySet, data); MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter); Task <IIngestManifestFile> task = retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(data)) .ContinueWith <IIngestManifestFile>(t => { t.ThrowIfFaulted(); token.ThrowIfCancellationRequested(); IngestManifestFileData ingestManifestFile = (IngestManifestFileData)t.Result.AsyncState; return(ingestManifestFile); }); return(task.Result); }); rootTask.Start(); return(rootTask); }
private static IContentKey VerifyContentKey(IIngestManifestAsset asset1) { IAsset asset = asset1.Asset; IContentKey key = asset.ContentKeys.Where(c => c.ContentKeyType == ContentKeyType.StorageEncryption).FirstOrDefault(); if (key == null) { throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, StringTable.StorageEncryptionContentKeyIsMissing, asset.Id)); } return(key); }
/// <summary> /// Initializes a new instance of the <see cref="IngestManifestFileCollection"/> class. /// </summary> /// <param name="mediaContext"></param> /// <param name="parentIngestManifestAsset">The parent manifest asset.</param> internal IngestManifestFileCollection(MediaContextBase mediaContext, IIngestManifestAsset parentIngestManifestAsset) : base(mediaContext) { MediaServicesClassFactory factory = this.MediaContext.MediaServicesClassFactory; this._query = new Lazy <IQueryable <IIngestManifestFile> >(() => factory.CreateDataServiceContext().CreateQuery <IIngestManifestFile, IngestManifestFileData>(EntitySet)); if (parentIngestManifestAsset != null) { this._parentIngestManifestAsset = (IngestManifestAssetData)parentIngestManifestAsset; } }
public static void UploadByBlock(string manifestName, AssetCreationOptions options, string[] files) { CloudMediaContext context = CloudContextHelper.GetContext(); IIngestManifest manifest = context.IngestManifests.Create(manifestName); IAsset asset = context.Assets.Create(manifestName + "_Asset", options); IIngestManifestAsset bulkAsset = manifest.IngestManifestAssets.Create(asset, files); UploadBlobFile(manifest.BlobStorageUriForUpload, files); MonitorBulkManifest(manifest.Id); }
/// <summary> /// Encrypts manifest files asyncroniously. /// </summary> /// <param name="outputPath">The output path where all encrypted files will be located.</param> /// <param name="overwriteExistingEncryptedFiles">if set to <c>true</c> method will override files in ouput folder.</param> /// <param name="cancellationToken"><see cref="CancellationToken"/></param> /// <returns><see cref="Task"/></returns> public Task EncryptFilesAsync(string outputPath, bool overwriteExistingEncryptedFiles, CancellationToken cancellationToken) { if (!Directory.Exists(outputPath)) { throw new DirectoryNotFoundException(outputPath); } var _this = (IIngestManifest)this; //we are forming two arrays of tasks: validation of keys and encryption tasks var assetEncryptionTasks = new List <Task>(); var assetCheckKeyTasks = new List <Task>(); var keys = new ConcurrentDictionary <string, IContentKey>(); foreach (IIngestManifestAsset manifestAsset in _this.IngestManifestAssets) { IIngestManifestAsset asset = manifestAsset; Action checkKeyAction = (() => { var key = VerifyContentKey(asset); //Adding keys which we found for assets.If key has not been found thread throwing exception from VerifyContentKey keys.TryAdd(asset.Id, key); }); //Starting validation tasks as soon as we create it assetCheckKeyTasks.Add(Task.Factory.StartNew(checkKeyAction, cancellationToken)); //Creating encryption tasks without starting it assetEncryptionTasks.Add(new Task(() => AssetEncryptAction(outputPath, overwriteExistingEncryptedFiles, cancellationToken, keys, asset))); } return(Task.Factory.StartNew(() => { //Wait until all key verification is done Task.WaitAll(assetCheckKeyTasks.ToArray()); //Starting all encryption tasks foreach (var encryptTask in assetEncryptionTasks) { encryptTask.Start(); } //Waiting all encryption tasks for completion Task.WaitAll(assetEncryptionTasks.ToArray()); }, cancellationToken)); }
public void AddingAdditionalAssetInfoesToExistingManifest() { CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); IIngestManifest ingestManifestCreated = CreateManifestWithAssetsAndVerifyIt(context); context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); IIngestManifest ingestManifest = context.IngestManifests.Where(c => c.Id == ingestManifestCreated.Id).FirstOrDefault(); Assert.AreNotSame(0, ingestManifest.IngestManifestAssets.Count()); IAsset asset1 = context.Assets.Create("Asset1", AssetCreationOptions.StorageEncrypted); Task <IIngestManifestAsset> task1 = ingestManifest.IngestManifestAssets.CreateAsync(asset1, new string[1] { InterviewWmv }, CancellationToken.None); IIngestManifestAsset assetInfo1 = task1.Result; Assert.AreEqual(1, assetInfo1.IngestManifestFiles.Count()); }
private static IIngestManifest CreateManifestWithAssetsAndVerifyIt(CloudMediaContext context) { //Creating empty manifest const string manifestName = "Manifest 1"; IIngestManifest ingestManifest = context.IngestManifests.Create(manifestName); Assert.AreEqual(IngestManifestState.Inactive, ingestManifest.State, "Expecting empty manifest to be inactive"); //Adding manifest asset info with multiple file IAsset asset2 = context.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted); var files2 = new string[2] { TestFile1, TestFile2 }; IIngestManifestAsset ingestManifestAssetInfo2 = ingestManifest.IngestManifestAssets.Create(asset2, files2); Assert.AreEqual(1, asset2.ContentKeys.Count, "No keys associated with asset"); VerifyManifestAsset(ingestManifestAssetInfo2); Assert.AreEqual(2, ingestManifestAssetInfo2.IngestManifestFiles.Count(), "Files collection size is not matching expectations"); return(ingestManifest); }
public void DeleteAssetShouldDeleteAllManifestAssetsFiles() { CloudMediaContext context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); IIngestManifest ingestManifest = CreateManifestWithAssetsAndVerifyIt(context); VerifyExistenceofAssetsAndFilesForManifest(ingestManifest, context); IIngestManifestAsset asset = ingestManifest.IngestManifestAssets.FirstOrDefault(); VerifyManifestAsset(asset); int filescount = context.IngestManifestFiles.Where(c => c.ParentIngestManifestAssetId == asset.Id).Count(); Assert.IsTrue(filescount > 0, "Expecting to have files for given asset"); asset.Delete(); context = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext(); VerifyAssetIsNotExist(asset, context); filescount = context.IngestManifestFiles.Where(c => c.ParentIngestManifestAssetId == asset.Id).Count(); Assert.AreEqual(0, filescount, "There are files belonging to manifest assets after asset deletion"); }
private static void SetEncryptionSettings(IIngestManifestAsset ingestManifestAsset, AssetCreationOptions options, IngestManifestFileData data) { if (options.HasFlag(AssetCreationOptions.StorageEncrypted)) { var contentKeyData = ingestManifestAsset.Asset.ContentKeys.Where(c => c.ContentKeyType == ContentKeyType.StorageEncryption).FirstOrDefault(); if (contentKeyData == null) { throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, StringTable.StorageEncryptionContentKeyIsMissing, ingestManifestAsset.Asset.Id)); } using (var fileEncryption = new FileEncryption(contentKeyData.GetClearKeyValue(), EncryptionUtils.GetKeyIdAsGuid(contentKeyData.Id))) { if (!fileEncryption.IsInitializationVectorPresent(data.Name)) { fileEncryption.CreateInitializationVectorForFile(data.Name); } ulong iv = fileEncryption.GetInitializationVectorForFile(data.Name); data.IsEncrypted = true; data.EncryptionKeyId = fileEncryption.GetKeyIdentifierAsString(); data.EncryptionScheme = FileEncryption.SchemeName; data.EncryptionVersion = FileEncryption.SchemeVersion; data.InitializationVector = iv.ToString(CultureInfo.InvariantCulture); } } else if (options.HasFlag(AssetCreationOptions.CommonEncryptionProtected)) { data.IsEncrypted = true; data.EncryptionScheme = CommonEncryption.SchemeName; data.EncryptionVersion = CommonEncryption.SchemeVersion; } else if (options.HasFlag(AssetCreationOptions.EnvelopeEncryptionProtected)) { data.IsEncrypted = true; data.EncryptionScheme = EnvelopeEncryption.SchemeName; data.EncryptionVersion = EnvelopeEncryption.SchemeVersion; } }
private void VerifyAssetIsNotExist(IIngestManifestAsset asset, CloudMediaContext context) { Assert.AreEqual(0, context.IngestManifestAssets.Where(c => c.Id == asset.Id).Count(), "Manifest Asset exists.Expected result that asset is not returned by REST API"); }
private static void VerifyManifestAsset(IIngestManifestAsset ingestManifestAsset) { Assert.IsNotNull(ingestManifestAsset); Assert.IsFalse(String.IsNullOrEmpty(ingestManifestAsset.Id), "Manifest asset id is is null or empty"); Assert.IsFalse(String.IsNullOrEmpty(ingestManifestAsset.ParentIngestManifestId), "ParentManifestId is null or empty"); }
private static void VerifyManifestAsset(IIngestManifestAsset ingestManifestAsset) { Assert.IsNotNull(ingestManifestAsset); Assert.IsFalse(String.IsNullOrEmpty(ingestManifestAsset.Id), "Manifest asset id is is null or empty"); Assert.IsFalse(String.IsNullOrEmpty(ingestManifestAsset.ParentIngestManifestId), "ParentManifestId is null or empty"); }
private static IContentKey VerifyContentKey(IIngestManifestAsset asset1) { IAsset asset = asset1.Asset; IContentKey key = asset.ContentKeys.Where(c => c.ContentKeyType == ContentKeyType.StorageEncryption).FirstOrDefault(); if (key == null) { throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, StringTable.StorageEncryptionContentKeyIsMissing, asset.Id)); } return key; }
private void VerifyAssetIsNotExist(IIngestManifestAsset asset, CloudMediaContext context) { Assert.AreEqual(0, context.IngestManifestAssets.Where(c => c.Id == asset.Id).Count(), "Manifest Asset exists.Expected result that asset is not returned by REST API"); }
private void AssetEncryptAction(string outputPath, bool overwriteExistingEncryptedFiles, CancellationToken cancellationToken, ConcurrentDictionary <string, IContentKey> keys, IIngestManifestAsset asset) { cancellationToken.ThrowIfCancellationRequested(); List <Task> encryptTasks = new List <Task>(); AssetCreationOptions assetCreationOptions = asset.Asset.Options; if (assetCreationOptions.HasFlag(AssetCreationOptions.StorageEncrypted)) { IContentKey contentKeyData = keys[asset.Id]; var fileEncryption = new FileEncryption(contentKeyData.GetClearKeyValue(), EncryptionUtils.GetKeyIdAsGuid(contentKeyData.Id)); foreach (IngestManifestFileData file in asset.IngestManifestFiles) { ulong iv = Convert.ToUInt64(file.InitializationVector, CultureInfo.InvariantCulture); fileEncryption.SetInitializationVectorForFile(file.Name, iv); FileInfo fileInfo = null; fileInfo = TrackedFilesPaths.ContainsKey(file.Id) ? new FileInfo(TrackedFilesPaths[file.Id]) : new FileInfo(file.Name); string destinationPath = Path.Combine(outputPath, fileInfo.Name); if (File.Exists(destinationPath)) { if (overwriteExistingEncryptedFiles) { File.Delete(destinationPath); } else { throw new IOException(string.Format(CultureInfo.InvariantCulture, StringTable.BulkIngestFileExists, destinationPath)); } } long fileSize = fileInfo.Length; int maxBlockSize = GetBlockSize(fileSize); int numThreads = MaxNumberOfEncryptionThreadsForFilePerCore * Environment.ProcessorCount; ConcurrentQueue <Tuple <int, int> > queue = PrepareUploadQueue(maxBlockSize, fileSize); if (queue.Count < numThreads) { numThreads = queue.Count; } File.Create(destinationPath).Dispose(); Action action = GetEncryptionAction(cancellationToken, fileEncryption, file, destinationPath, fileInfo, queue, maxBlockSize); for (int i = 0; i < numThreads; i++) { encryptTasks.Add(Task.Factory.StartNew((action), cancellationToken)); } } try { Task.WaitAll(encryptTasks.ToArray()); } finally { fileEncryption.Dispose(); } } }
private void AssetEncryptAction(string outputPath, bool overwriteExistingEncryptedFiles, CancellationToken cancellationToken, ConcurrentDictionary<string, IContentKey> keys, IIngestManifestAsset asset) { cancellationToken.ThrowIfCancellationRequested(); List<Task> encryptTasks = new List<Task>(); AssetCreationOptions assetCreationOptions = asset.Asset.Options; if (assetCreationOptions.HasFlag(AssetCreationOptions.StorageEncrypted)) { IContentKey contentKeyData = keys[asset.Id]; var fileEncryption = new FileEncryption(contentKeyData.GetClearKeyValue(), EncryptionUtils.GetKeyIdAsGuid(contentKeyData.Id)); foreach (IngestManifestFileData file in asset.IngestManifestFiles) { ulong iv = Convert.ToUInt64(file.InitializationVector, CultureInfo.InvariantCulture); fileEncryption.SetInitializationVectorForFile(file.Name, iv); FileInfo fileInfo = null; fileInfo = TrackedFilesPaths.ContainsKey(file.Id) ? new FileInfo(TrackedFilesPaths[file.Id]) : new FileInfo(file.Name); string destinationPath = Path.Combine(outputPath, fileInfo.Name); if (File.Exists(destinationPath)) { if (overwriteExistingEncryptedFiles) { File.Delete(destinationPath); } else { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, StringTable.BulkIngestFileExists, destinationPath)); } } long fileSize = fileInfo.Length; int maxBlockSize = GetBlockSize(fileSize); int numThreads = MaxNumberOfEncryptionThreadsForFilePerCore*Environment.ProcessorCount; ConcurrentQueue<Tuple<int, int>> queue = PrepareUploadQueue(maxBlockSize, fileSize); if (queue.Count < numThreads) { numThreads = queue.Count; } File.Create(destinationPath).Dispose(); Action action = GetEncryptionAction(cancellationToken, fileEncryption, file, destinationPath, fileInfo, queue, maxBlockSize); for (int i = 0; i < numThreads; i++) { encryptTasks.Add(Task.Factory.StartNew((action), cancellationToken)); } } try { Task.WaitAll(encryptTasks.ToArray()); } finally { fileEncryption.Dispose(); } } }