private static void AddFileToExistingManifestAssetInfo(CloudMediaContext context, string id)
{
IIngestManifest ingestManifest = context.IngestManifests.Where(c => c.Id == id).FirstOrDefault();
Assert.IsNotNull(ingestManifest);
Assert.IsNotNull(ingestManifest.IngestManifestAssets);
int expectedFilesCount = context.IngestManifestFiles.Where(c => c.ParentIngestManifestId == ingestManifest.Id).Count();
foreach (IIngestManifestAsset assetInfo in ingestManifest.IngestManifestAssets)
{
Assert.IsNotNull(assetInfo.IngestManifestFiles);
//Enumerating through all files
foreach (IIngestManifestFile file in assetInfo.IngestManifestFiles)
{
VerifyManifestFile(file);
}
//Adding new file to collection
}
var firstOrDefault = ingestManifest.IngestManifestAssets.FirstOrDefault();
Assert.IsNotNull(firstOrDefault);
IIngestManifestFile addedFile = firstOrDefault.IngestManifestFiles.Create(InterviewWmv);
VerifyManifestFile(addedFile);
expectedFilesCount++;
int filesCountFinal = context.IngestManifestFiles.Where(c => c.ParentIngestManifestId == ingestManifest.Id).Count();
Assert.AreEqual(expectedFilesCount, filesCountFinal);
}
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 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 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);
}
public void TestIngestManifestFileCreateFailedRetry()
{
var expected = new IngestManifestFileData {
Name = "testData"
};
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 10, expected);
dataContextMock.Setup((ctxt) => ctxt.AddObject("IngestManifestFiles", It.IsAny <object>()));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
var parent = new IngestManifestAssetData {
Asset = new AssetData {
}
};
var ingestManifestFiles = new IngestManifestFileCollection(_mediaContext, parent);
var tempFile = "a:\\wherever\\whatever.mp3";
try
{
IIngestManifestFile actual = ingestManifestFiles.Create(tempFile);
}
catch (AggregateException ax)
{
WebException x = (WebException)ax.GetBaseException();
dataContextMock.Verify((ctxt) => ctxt.SaveChangesAsync(It.IsAny <object>()), Times.AtLeast(3));
Assert.AreEqual(fakeException, x);
throw x;
}
Assert.Fail("Expected exception");
}
public void TestIngestManifestFileCreateRetry()
{
var expected = new IngestManifestFileData {
Name = "testData"
};
var fakeException = new WebException("test", WebExceptionStatus.ConnectionClosed);
var dataContextMock = TestMediaServicesClassFactory.CreateSaveChangesMock(fakeException, 2, expected);
dataContextMock.Setup((ctxt) => ctxt.AddObject("IngestManifestFiles", It.IsAny <object>()));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
var parent = new IngestManifestAssetData {
Asset = new AssetData {
}
};
var ingestManifestFiles = new IngestManifestFileCollection(_mediaContext, parent);
var tempFile = "a:\\wherever\\whatever.mp3";
IIngestManifestFile actual = ingestManifestFiles.Create(tempFile);
Assert.AreEqual(expected.Name, actual.Name);
dataContextMock.Verify((ctxt) => ctxt.SaveChangesAsync(It.IsAny <object>()), Times.Exactly(2));
}
private static void VerifyManifestFile(IIngestManifestFile ingestManifestFile)
{
Assert.IsNotNull(ingestManifestFile);
Assert.IsFalse(String.IsNullOrEmpty(ingestManifestFile.Id), "File Is is null or empty");
Assert.IsFalse(String.IsNullOrEmpty(ingestManifestFile.Name), "File Is is null or empty");
}
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;
}
private static void VerifyManifestFile(IIngestManifestFile ingestManifestFile)
{
Assert.IsNotNull(ingestManifestFile);
Assert.IsFalse(String.IsNullOrEmpty(ingestManifestFile.Id), "File Is is null or empty");
Assert.IsFalse(String.IsNullOrEmpty(ingestManifestFile.Name), "File Is is null or empty");
}
