public void ShouldCreateOutputAssetWithAccountSelectionStrategy()
{
CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, true);
string inputAssetFilePath = Path.Combine(Directory.GetCurrentDirectory(), smallWmv);
string inputAssetFileName = Path.GetFileName(inputAssetFilePath);
this.inputAsset = context.Assets.Create("InputAsset", strategy, AssetCreationOptions.StorageEncrypted);
IAssetFile file = this.inputAsset.AssetFiles.Create(inputAssetFileName);
file.Upload(inputAssetFilePath);
IJob job = context.Jobs.Create("Job to test using an account selection strategy for an output asset");
ITask task = job.Tasks.AddNew(
"Task to test using an account selection strategy for an output asset",
context.MediaProcessors.GetLatestMediaProcessorByName(MediaProcessorNames.MediaEncoderStandard),
MediaEncoderStandardTaskPresetStrings.H264SingleBitrate4x3SD,
TaskOptions.None);
task.InputAssets.Add(this.inputAsset);
task.OutputAssets.AddNew("OutputAsset", strategy, AssetCreationOptions.None);
job.Submit();
job.GetExecutionProgressTask(CancellationToken.None).Wait();
Assert.IsNotNull(job);
Assert.AreEqual(1, job.Tasks.Count, "Unexpected number of tasks in job");
Assert.AreEqual(1, job.OutputMediaAssets.Count, "Unexpected number of output assets in the job");
this.outputAsset = job.OutputMediaAssets[0];
Assert.IsNotNull(outputAsset.StorageAccountName, "Storage account name in output assset is null");
}
/// <summary>
/// Upload an Asset
/// </summary>
/// <param name="filePath">Path of the video</param>
/// <param name="uploadHandler">Handler to retrieve the progress</param>
/// <returns></returns>
public async Task <IAsset> UploadAsset(string filePath, EventHandler <UploadProgressChangedEventArgs> uploadHandler = null)
{
Task <IAsset> uploadTask = Task.Run(() =>
{
// Retrieve filename
string assetName = Path.GetFileName(filePath);
// Create a new asset in the context
IAsset asset = _mediaContext.Assets.Create(assetName, AssetCreationOptions.None);
// Create a new asset file
IAssetFile file = asset.AssetFiles.Create(assetName);
// Hook-up the event if handler is specified
if (uploadHandler != null)
{
file.UploadProgressChanged += uploadHandler;
}
// Upload the video
file.Upload(filePath);
return(asset);
});
await uploadTask;
return(uploadTask.Result);
// Snippet when you want to use the Microsoft Azure Media Services extensions
//return await _mediaContext.Assets.CreateFromFileAsync(filePath, AssetCreationOptions.None, cancellationToken);
}
private void CopyAssetFiles(IAsset myAssetTo, List <IAssetFile> files)
{
foreach (var assetFile in files)
{
string magicName = assetFile.Name;
assetFile.Download(magicName);
try
{
Trace.TraceInformation("Copying {0}", magicName);
IAssetFile newFile = myAssetTo.AssetFiles.Create(assetFile.Name);
newFile.Upload(magicName);
newFile.Update();
}
catch (Exception X)
{
Trace.TraceError("Error CopyAssetFiles " + X.Message);
if (File.Exists(magicName))
{
System.IO.File.Delete(magicName);
}
throw X;
}
System.IO.File.Delete(magicName);
}
myAssetTo.Update();
}
private void CreateAssetAndUploadNFilesSync(int expected)
{
IAsset asset = _mediaContext.Assets.Create("TestWithMultipleFiles", AssetCreationOptions.None);
VerifyAsset(asset);
DirectoryInfo info = null;
try
{
info = Directory.CreateDirectory(Guid.NewGuid().ToString());
for (int i = 0; i < expected; i++)
{
string fullFilePath = null;
string fileName;
fullFilePath = CreateNewFileFromOriginal(info, out fileName);
IAssetFile file = asset.AssetFiles.Create(fileName);
file.Upload(fullFilePath);
}
Assert.AreEqual(expected, _mediaContext.Files.Where(c => c.ParentAssetId == asset.Id).Count());
}
finally
{
if (info != null)
{
info.Delete(recursive: true);
}
}
}
public void ShouldCreateOutputAssetWithAccountSelectionStrategy()
{
CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, true);
string inputAssetFilePath = Path.Combine(TestContext.TestDeploymentDir, smallWmv);
string inputAssetFileName = Path.GetFileName(inputAssetFilePath);
IAsset inputAsset = context.Assets.Create("", strategy, AssetCreationOptions.StorageEncrypted);
IAssetFile file = inputAsset.AssetFiles.Create(inputAssetFileName);
file.Upload(inputAssetFilePath);
IJob job = context.Jobs.Create("Job to test using an account selection strategy for an output asset");
ITask task = job.Tasks.AddNew("Task to test using an account selection strategy for an output asset", GetMediaProcessor(Encoder), Preset, TaskOptions.None);
task.InputAssets.Add(inputAsset);
task.OutputAssets.AddNew("OutputAsset", strategy, AssetCreationOptions.None);
job.Submit();
// Note that we don't want for the job to finish. We just need the submit to succeed.
IJob refreshedJob = context.Jobs.Where(c => c.Id == job.Id).FirstOrDefault();
Assert.IsNotNull(refreshedJob);
Assert.AreEqual(1, refreshedJob.Tasks.Count, "Unexpected number of tasks in job");
Assert.AreEqual(1, refreshedJob.Tasks[0].OutputAssets.Count, "Unexpected number of output assets in the job");
Assert.IsNotNull(refreshedJob.Tasks[0].OutputAssets[0].StorageAccountName, "Storage account name in output assset is null");
}
public void ShouldDownloadEnvelopeEncryptionProtectedAssetFile()
{
IAsset asset = _mediaContext.Assets.Create(_smallWmv, AssetCreationOptions.EnvelopeEncryptionProtected);
string name = Path.GetFileName(_smallWmv);
IAssetFile file = asset.AssetFiles.Create(name);
file.Upload(_smallWmv);
VerifyAndDownloadAsset(asset, 1);
}
/// <summary>
/// Creates the asset. Note, there is a breaking change in the new SDK!
/// You have to first create the Asset, which is always empty.
/// Then create a file within that asset, then upload a content the newly created file
/// </summary>
/// <param name="pathToFile">The path to file.</param>
public void CreateAsset(string pathToFile)
{
IAsset newAsset = this.MediaService.MediaContext.Assets.Create(System.IO.Path.GetFileName(pathToFile), AssetCreationOptions.None);
// note, the file to be uploaded must match (case insensitive)
// to the Name property of the IAssetFile instance we are uploading to
IAssetFile file = newAsset.AssetFiles.Create(System.IO.Path.GetFileName(pathToFile));
file.Upload(pathToFile);
}
public void ShouldCreateSingleFileAssetWithNoLocatorUsingOveloadSync()
{
IAsset asset = _mediaContext.Assets.Create("Empty", AssetCreationOptions.StorageEncrypted);
IAssetFile file = asset.AssetFiles.Create(Path.GetFileName(_smallWmv));
file.Upload(_smallWmv);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null");
Assert.AreEqual(AssetState.Initialized, asset.State, "Asset state wrong");
}
private void ProcessUploadFileToAsset(string SafeFileName, string FileName, IAsset MyAsset)
{
try
{
IAssetFile UploadedAssetFile = MyAsset.AssetFiles.Create(SafeFileName);
UploadedAssetFile.UploadProgressChanged += MyUploadProgressChanged;
UploadedAssetFile.Upload(FileName as string);
}
catch
{
MessageBox.Show("Error when uploading the file");
}
}
public void ShouldThrowArgumentExceptionWhenUploadSyncFileNameNotEqualToAssetFileName()
{
IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None);
string fileUploaded = _smallWmv;
IAssetFile fileInfo = asset.AssetFiles.Create("test.txt");
try
{
fileInfo.Upload(fileUploaded);
}
catch (ArgumentException ex)
{
AssertFileMismatchException(fileUploaded, ex);
throw;
}
}
private void CopyCaptions(IAsset myAssetFrom, IAsset myAssetTo)
{
foreach (var assetFile in myAssetFrom.AssetFiles)
{
if (assetFile.Name.EndsWith(".ttml") || assetFile.Name.EndsWith(".vtt"))
{
string magicName = assetFile.Name;
assetFile.Download(magicName);
IAssetFile newFile = myAssetTo.AssetFiles.Create(assetFile.Name);
newFile.Upload(magicName);
System.IO.File.Delete(magicName);
newFile.Update();
}
}
myAssetTo.Update();
}
public void ShouldGetClearConfigurationFromTask()
{
var filePaths = new[] { WindowsAzureMediaServicesTestConfiguration.SmallIsm, WindowsAzureMediaServicesTestConfiguration.SmallIsmc, WindowsAzureMediaServicesTestConfiguration.SmallIsmv };
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
foreach (string filePath in filePaths)
{
string filename = Path.GetFileName(filePath);
IAssetFile file = asset.AssetFiles.Create(filename);
file.Upload(filePath);
if (WindowsAzureMediaServicesTestConfiguration.SmallIsm == filePath)
{
file.IsPrimary = true;
file.Update();
}
}
string originalConfiguration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.PlayReadyConfig);
IMediaProcessor processor = JobTests.GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncryptorName);
IJob job = _mediaContext.Jobs.Create("PlayReady protect a smooth streaming asset for GetClearConfigurationFromTask");
ITask task = job.Tasks.AddNew("SmoothProtectTask", processor, originalConfiguration, TaskOptions.ProtectedConfiguration);
task.InputAssets.Add(asset);
task.OutputAssets.AddNew("Job OutPut", AssetCreationOptions.None);
// Verify that we can get the configuration back before we create a job template. Note that is the point that things actually get encrypted
Assert.AreEqual(String.CompareOrdinal(task.GetClearConfiguration(), originalConfiguration), 0);
job.Submit();
Assert.AreEqual(job.Tasks.Count, 1);
Assert.AreEqual(TaskOptions.ProtectedConfiguration, job.Tasks[0].Options);
Assert.IsNotNull(job.Tasks[0].InitializationVector);
Assert.IsFalse(String.IsNullOrEmpty(job.Tasks[0].EncryptionKeyId));
Assert.AreEqual(ConfigurationEncryption.SchemeName, job.Tasks[0].EncryptionScheme);
Assert.AreEqual(ConfigurationEncryption.SchemeVersion, job.Tasks[0].EncryptionVersion);
JobTests.WaitForJob(job.Id, JobState.Finished, JobTests.VerifyAllTasksFinished);
// Verify that the configuration isn't clear
Assert.AreNotEqual(String.CompareOrdinal(job.Tasks[0].Configuration, originalConfiguration), 0);
// Verify that we can decrypt the configuration and get the correct clear value
string decryptedConfiguration = job.Tasks[0].GetClearConfiguration();
Assert.AreEqual(String.CompareOrdinal(decryptedConfiguration, originalConfiguration), 0);
}
private static void CallUpdateUploadDownloadAndDelete(IAssetFile file, string name)
{
file.Update();
file.UpdateAsync();
var uploadFile = Path.Combine(Path.GetTempPath(), name);
try
{
File.CreateText(uploadFile).Close();
file.Upload(uploadFile);
}
finally
{
File.Delete(uploadFile);
}
file.Download(Path.GetTempFileName());
file.Delete();
}
private void CopyCaptions(IAsset myAssetFrom, IAsset myAssetTo)
{
var captionFileList = (from f in myAssetFrom.AssetFiles select f).Where(f =>
f.Name.EndsWith(".ttml") ||
f.Name.EndsWith(".vtt") ||
f.Name.EndsWith(".kw.xml")
);
foreach (var assetFile in captionFileList)
{
string magicName = assetFile.Name;
assetFile.Download(magicName);
IAssetFile newFile = myAssetTo.AssetFiles.Create(assetFile.Name);
newFile.Upload(magicName);
System.IO.File.Delete(magicName);
newFile.Update();
}
myAssetTo.Update();
}
private IAsset ProcessUploadFile(string SafeFileName, string FileName, string storageaccount = null)
{
if (storageaccount == null)
{
storageaccount = MyContext.DefaultStorageAccount.Name; // no storage account or null, then let's take the default one
}
IAsset asset = null;
IAccessPolicy policy = null;
ILocator locator = null;
try
{
asset = MyContext.Assets.Create(SafeFileName as string, storageaccount, AssetCreationOptions.None);
IAssetFile file = asset.AssetFiles.Create(SafeFileName);
policy = MyContext.AccessPolicies.Create(
SafeFileName,
TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
locator = MyContext.Locators.CreateLocator(LocatorType.Sas, asset, policy);
file.UploadProgressChanged += file_UploadProgressChanged;
file.Upload(FileName);
AssetInfo.SetFileAsPrimary(asset, SafeFileName);
}
catch
{
asset = null;
}
finally
{
if (locator != null)
{
locator.Delete();
}
if (policy != null)
{
policy.Delete();
}
}
return(asset);
}
private static void PublishTextTracks(BlobClient blobClient, ITask jobTask, IAsset encoderOutput)
{
if (encoderOutput != null)
{
IAsset speechOutput = jobTask.OutputAssets[0];
IAssetFile[] webVttFiles = GetAssetFiles(speechOutput, Constant.Media.FileExtension.WebVtt);
foreach (IAssetFile webVttFile in webVttFiles)
{
JObject processorConfig = JObject.Parse(jobTask.Configuration);
string languageId = Language.GetLanguageId(processorConfig);
string fileName = string.Concat(languageId, Constant.Media.FileExtension.WebVtt);
string sourceContainer = webVttFile.Asset.Uri.Segments[1];
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainer, null, webVttFile.Name);
using (Stream sourceStream = sourceBlob.OpenRead())
{
IAssetFile destinationFile = encoderOutput.AssetFiles.Create(fileName);
destinationFile.Upload(sourceStream);
}
}
}
}
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);
}
private static void PublishAnalytics(BlobClient blobClient, DocumentClient documentClient, MediaPublish contentPublish, ITask jobTask, IAsset encoderOutput)
{
foreach (IAsset outputAsset in jobTask.OutputAssets)
{
string[] fileNames = GetFileNames(outputAsset, Constant.Media.FileExtension.Json);
foreach (string fileName in fileNames)
{
string documentData = string.Empty;
string sourceContainerName = outputAsset.Uri.Segments[1];
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainerName, null, fileName);
using (Stream sourceStream = sourceBlob.OpenRead())
{
StreamReader streamReader = new StreamReader(sourceStream);
documentData = streamReader.ReadToEnd();
}
JObject document = JObject.Parse(documentData);
document = DocumentClient.SetContext(document, contentPublish.MediaAccount, outputAsset.Id);
MediaProcessor?mediaProcessor = Processor.GetMediaProcessor(jobTask.MediaProcessorId);
string documentId = UpsertDocument(documentClient, document, mediaProcessor.Value, outputAsset, fileName);
if (encoderOutput != null)
{
string assetFileName = mediaProcessor.Value.ToString();
if (!string.IsNullOrEmpty(documentId))
{
assetFileName = string.Concat(assetFileName, Constant.TextDelimiter.Identifier, documentId);
}
assetFileName = string.Concat(assetFileName, Constant.Media.FileExtension.Json);
IAssetFile assetFile = encoderOutput.AssetFiles.Create(assetFileName);
using (Stream sourceStream = sourceBlob.OpenRead())
{
StreamReader streamReader = new StreamReader(sourceStream);
assetFile.Upload(sourceStream);
}
}
}
}
}
public IAsset CreateAsset(string authToken, string assetName, string storageAccount, bool storageEncryption, string[] fileNames)
{
AssetCreationOptions creationOptions = storageEncryption ? AssetCreationOptions.StorageEncrypted : AssetCreationOptions.None;
IAsset asset = _media.Assets.Create(assetName, storageAccount, creationOptions);
BlobClient blobClient = new BlobClient(authToken, storageAccount);
string sourceContainerName = Constants.Storage.Blob.Container.Upload;
if (storageEncryption)
{
foreach (string fileName in fileNames)
{
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainerName, null, fileName, false);
Stream sourceStream = sourceBlob.OpenRead();
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
assetFile.Upload(sourceStream);
}
}
else
{
string destinationContainerName = asset.Uri.Segments[1];
foreach (string fileName in fileNames)
{
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainerName, null, fileName, true);
CloudBlockBlob destinationBlob = blobClient.GetBlob(destinationContainerName, null, fileName, false);
blobClient.CopyBlob(sourceBlob, destinationBlob, false);
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
assetFile.ContentFileSize = sourceBlob.Properties.Length;
assetFile.Update();
}
}
SetPrimaryFile(asset);
asset.Update();
return(asset);
}
static IAsset CreateAssetAndProtectedStreamingLocatorInV2(CloudMediaContext v2Client, ConfigWrapper config, string assetNameOrDescription)
{
// Create the input Asset
IAsset originalAsset = v2Client.Assets.Create("input asset", AssetCreationOptions.None);
string filename = Path.GetFileName(config.FilePathToUpload);
IAssetFile assetFile = originalAsset.AssetFiles.Create(filename);
assetFile.Upload(config.FilePathToUpload);
// Submit a job to encode the single input file into an adaptive streaming set
IJob job = v2Client.Jobs.Create("Media Encoder Standard Job");
IMediaProcessor processor = GetMediaEncoderStandardProcessor(v2Client);
ITask task = job.Tasks.AddNew("Adaptive Streaming encode", processor, "Adaptive Streaming", TaskOptions.None);
task.InputAssets.Add(originalAsset);
task.OutputAssets.AddNew(assetNameOrDescription, AssetCreationOptions.None);
job.Submit();
job.GetExecutionProgressTask(CancellationToken.None).Wait();
// Get the output asset to publish
job.Refresh();
IAsset assetToPublish = v2Client.Assets.Where(a => a.Id == job.Tasks[0].OutputAssets[0].Id).First();
// Create the content key
Guid keyId = Guid.NewGuid();
byte[] contentKey = GetRandomBuffer(16);
IContentKey key = v2Client.ContentKeys.Create(keyId, contentKey, "ContentKey", ContentKeyType.EnvelopeEncryption);
// Create ContentKeyAuthorizationPolicy with Open restriction and create authorization policy
IContentKeyAuthorizationPolicy policy = v2Client.ContentKeyAuthorizationPolicies.CreateAsync("Open Authorization Policy").Result;
ContentKeyAuthorizationPolicyRestriction restriction =
new ContentKeyAuthorizationPolicyRestriction
{
Name = "Open Authorization Policy",
KeyRestrictionType = (int)ContentKeyRestrictionType.Open,
Requirements = null
};
List <ContentKeyAuthorizationPolicyRestriction> restrictions = new List <ContentKeyAuthorizationPolicyRestriction>();
restrictions.Add(restriction);
var policyOption = v2Client.ContentKeyAuthorizationPolicyOptions.Create("policy", ContentKeyDeliveryType.BaselineHttp, restrictions, "");
policy.Options.Add(policyOption);
// Add ContentKeyAuthorizationPolicy to ContentKey
key.AuthorizationPolicyId = policy.Id;
key.Update();
assetToPublish.ContentKeys.Add(key);
Uri keyAcquisitionUri = key.GetKeyDeliveryUrl(ContentKeyDeliveryType.BaselineHttp);
UriBuilder uriBuilder = new UriBuilder(keyAcquisitionUri);
uriBuilder.Query = String.Empty;
keyAcquisitionUri = uriBuilder.Uri;
// The following policy configuration specifies:
// key url that will have KID=<Guid> appended to the envelope and
// the Initialization Vector (IV) to use for the envelope encryption.
var assetDeliveryPolicyConfiguration = new Dictionary <AssetDeliveryPolicyConfigurationKey, string>
{
{ AssetDeliveryPolicyConfigurationKey.EnvelopeBaseKeyAcquisitionUrl, keyAcquisitionUri.ToString() },
};
var assetDeliveryPolicy = v2Client.AssetDeliveryPolicies.Create("AssetDeliveryPolicy",
AssetDeliveryPolicyType.DynamicEnvelopeEncryption,
AssetDeliveryProtocol.SmoothStreaming | AssetDeliveryProtocol.HLS | AssetDeliveryProtocol.Dash,
assetDeliveryPolicyConfiguration);
// Add AssetDelivery Policy to the asset
assetToPublish.DeliveryPolicies.Add(assetDeliveryPolicy);
// Create a 30-day readonly access policy.
// You cannot create a streaming locator using an AccessPolicy that includes write or delete permissions.
IAccessPolicy accessPolicy = v2Client.AccessPolicies.Create("Streaming Access Policy", TimeSpan.FromDays(365 * 100), AccessPermissions.Read);
// Create a locator to the streaming content on an origin.
ILocator originLocator = v2Client.Locators.CreateLocator(LocatorType.OnDemandOrigin, assetToPublish, accessPolicy, DateTime.UtcNow.AddMinutes(-5));
// remove the original input asset as we don't need it for demonstration purposes
originalAsset.Delete();
return(assetToPublish);
}
private static void CallUpdateUploadDownloadAndDelete(IAssetFile file, string name)
{
file.Update();
file.UpdateAsync();
var uploadFile = Path.Combine(Path.GetTempPath(), name);
try
{
File.CreateText(uploadFile).Close();
file.Upload(uploadFile);
}
finally
{
File.Delete(uploadFile);
}
file.Download(Path.GetTempFileName());
file.Delete();
}
