public void ShouldDeleteAssetAndKeepAzureContainer()
{
IAsset asset = CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None);
Assert.AreEqual(AssetState.Initialized, asset.State);
foreach (ILocator locator in asset.Locators)
{
locator.Delete();
}
var result = asset.DeleteAsync(true).Result;
Assert.IsNull(_mediaContext.Assets.Where(a => a.Id == asset.Id).SingleOrDefault());
CloudMediaContext newContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
Assert.IsNull(newContext.Assets.Where(a => a.Id == asset.Id).SingleOrDefault());
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(WindowsAzureMediaServicesTestConfiguration.ClientStorageConnectionString);
string containername = asset.Id.Replace("nb:cid:UUID:", "asset-");
var client = storageAccount.CreateCloudBlobClient();
var container = client.GetContainerReference(containername);
Assert.IsTrue(container.Exists(), "Asset container {0} can't be found", container);
}
public async Task DeleteAssetAsync(IAsset asset)
{
Logger.Debug("DeleteAssetAsync() invoked for asset '{0}'.", asset.Name);
try {
var locators = asset.Locators.ToArray();
var accessPolicies = Context.AccessPolicies.ToArray();
var accessPolicyIdsToDelete =
from locator in locators
where locator.AccessPolicyId != null
select locator.AccessPolicyId;
await asset.DeleteAsync().ConfigureAwait(continueOnCapturedContext: false);
var accessPolicyDeleteTasksQuery =
from accessPolicy in accessPolicies
where accessPolicyIdsToDelete.Contains(accessPolicy.Id)
select accessPolicy.DeleteAsync();
await Task.WhenAll(accessPolicyDeleteTasksQuery).ConfigureAwait(continueOnCapturedContext: false);
Logger.Information("Asset '{0}' was deleted.", asset.Name);
}
catch (Exception ex) {
Logger.Error(ex, "Error while deleting asset '{0}'.", asset.Name);
throw;
}
}
public async Task <AzureMediaServiceItem> PublishMP4(string title, Stream mp4, DateTimeOffset expiryDate, CancellationToken cancellationToken)
{
IAsset unencodedAsset = null;
IAsset encodedAsset = null;
try
{
var id = Guid.NewGuid().ToString();
var publishedAt = DateTimeOffset.UtcNow;
cancellationToken.ThrowIfCancellationRequested();
unencodedAsset = await _azureMediaService.CreateAssetAndUploadSingleFile(AssetCreationOptions.None, title, $"{id}_{publishedAt}.mp4", mp4, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
encodedAsset = await _azureMediaService.EncodeToAdaptiveBitrateMP4Set(unencodedAsset, title, cancellationToken).ConfigureAwait(false);
var azureMediaServiceFileName = encodedAsset.Name;
var mediaServicesAssetId = encodedAsset.Id;
var mediaAssetUri = encodedAsset.Uri;
cancellationToken.ThrowIfCancellationRequested();
await _azureMediaService.CreateStreamingEndpoint().ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
var locator = await _azureMediaService.PublishMedia(encodedAsset, expiryDate.Subtract(DateTimeOffset.UtcNow)).ConfigureAwait(false);
var(manifestUri, hlsUri, mpegDashUri) = _azureMediaService.BuildStreamingURLs(encodedAsset, locator);
var blobStorageMediaUrl = $"{mediaAssetUri}/{_azureMediaService.GetMP4FileName(encodedAsset)}";
return(new AzureMediaServiceItem(blobStorageMediaUrl, expiryDate, azureMediaServiceFileName, hlsUri, id, manifestUri, mediaAssetUri, mediaServicesAssetId, mpegDashUri, publishedAt, title));
}
catch
{
await Task.WhenAll(unencodedAsset?.DeleteAsync(false) ?? Task.CompletedTask,
encodedAsset?.DeleteAsync(false) ?? Task.CompletedTask).ConfigureAwait(false);
throw;
}
finally
{
await(unencodedAsset?.DeleteAsync(false) ?? Task.CompletedTask).ConfigureAwait(false);
}
}
public VideoState GetStreamUrl(string assetId)
{
VideoState state = TrackEncodeProgress(assetId);
if (state.State.Equals("Finished", StringComparison.InvariantCultureIgnoreCase))
{
ITask encodingTask = GetEncodeTask(assetId);
IAsset encodedAsset = encodingTask.OutputAssets.FirstOrDefault();
string streamUrl = PublishOnDemand(encodedAsset);
IAsset originalVideo = GetAssetById(assetId);
if (originalVideo != null)
{
originalVideo.DeleteAsync(false);
}
state.StreamUrl = streamUrl.Replace("http:", "https:");
}
return(state);
}
public async Task DeleteAssetAsync(IAsset asset) {
Logger.Debug("DeleteAssetAsync() invoked for asset '{0}'.", asset.Name);
try {
var locators = asset.Locators.ToArray();
var accessPolicies = Context.AccessPolicies.ToArray();
var accessPolicyIdsToDelete =
from locator in locators
where locator.AccessPolicyId != null
select locator.AccessPolicyId;
await asset.DeleteAsync().ConfigureAwait(continueOnCapturedContext: false);
var accessPolicyDeleteTasksQuery =
from accessPolicy in accessPolicies
where accessPolicyIdsToDelete.Contains(accessPolicy.Id)
select accessPolicy.DeleteAsync();
await Task.WhenAll(accessPolicyDeleteTasksQuery).ConfigureAwait(continueOnCapturedContext: false);
Logger.Information("Asset '{0}' was deleted.", asset.Name);
}
catch (Exception ex) {
Logger.Error(ex, "Error while deleting asset '{0}'.", asset.Name);
throw;
}
}
public void ApplyDynamicManifestFilter()
{
const string typeAudio = "Type=\"audio\"";
const string typeVideo = "Type=\"video\"";
string configuration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.DefaultMp4ToSmoothConfig);
IAsset inputAsset = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.None);
IMediaProcessor mediaProcessor = JobTests.GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpPackagerName);
IJob job = JobTests.CreateAndSubmitOneTaskJob(_mediaContext, "ApplyDynamicManifestFilter" + Guid.NewGuid().ToString().Substring(0, 5), mediaProcessor, configuration, inputAsset, TaskOptions.None);
JobTests.WaitForJob(job.Id, JobState.Finished, JobTests.VerifyAllTasksFinished);
var outputAsset = job.OutputMediaAssets.FirstOrDefault();
outputAsset = _mediaContext.Assets.Where(c => c.Id == outputAsset.Id).FirstOrDefault();
var assetFile = outputAsset.AssetFiles.Where(c => c.Name.EndsWith(".ism")).First();
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("ApplyDynamicManifestFilter" + Guid.NewGuid().ToString().Substring(0, 5), TimeSpan.FromDays(30), AccessPermissions.Read);
ILocator originLocator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, outputAsset, policy, DateTime.UtcNow.AddMinutes(-5));
string urlForClientStreaming = originLocator.Path + assetFile.Name + "/manifest";
HttpClient client = new HttpClient();
var message = client.GetAsync(urlForClientStreaming).Result;
var content = message.Content;
var result = content.ReadAsStringAsync().Result;
Assert.AreEqual(message.StatusCode, HttpStatusCode.OK);
Assert.IsTrue(result.Length > 0);
Assert.IsTrue(result.Contains(typeAudio));
Assert.IsTrue(result.Contains(typeVideo));
var manifestLength = result.Length;
// string filterName = "ApplyDynamicManifestFilter_" + DateTime.Now;
string filterName = "ApplyDynamicManifestFilter_" + Guid.NewGuid().ToString().Substring(0, 5);
List <FilterTrackSelectStatement> filterTrackSelectStatements = new List <FilterTrackSelectStatement>();
FilterTrackSelectStatement filterTrackSelectStatement = new FilterTrackSelectStatement();
filterTrackSelectStatement.PropertyConditions = new List <IFilterTrackPropertyCondition>();
filterTrackSelectStatement.PropertyConditions.Add(new FilterTrackTypeCondition(FilterTrackType.Video, FilterTrackCompareOperator.NotEqual));
filterTrackSelectStatements.Add(filterTrackSelectStatement);
IStreamingFilter filter = _mediaContext.Filters.Create(filterName, new PresentationTimeRange(), filterTrackSelectStatements);
Assert.IsNotNull(filter);
var filterUrlForClientStreaming = originLocator.Path + assetFile.Name + String.Format("/manifest(filter={0})", filterName);
HttpClient filterclient = new HttpClient();
var filtermessage = filterclient.GetAsync(filterUrlForClientStreaming).Result;
Assert.AreEqual(filtermessage.StatusCode, HttpStatusCode.OK);
var filtercontent = filtermessage.Content;
var filterresult = filtercontent.ReadAsStringAsync().Result;
Assert.IsTrue(filterresult.Length > 0);
Assert.AreNotEqual(manifestLength, filterresult);
Assert.IsTrue(filterresult.Contains(typeAudio));
Assert.IsFalse(filterresult.Contains(typeVideo));
outputAsset.DeleteAsync();
inputAsset.DeleteAsync();
job.DeleteAsync();
filter.DeleteAsync();
}
// Optionally delete the files from the backup account after the encode job completes.
private static void CleanupBackupAccount(IAsset asset, IJob job)
{
asset.DeleteAsync();
job.OutputMediaAssets.FirstOrDefault().DeleteAsync();
job.DeleteAsync();
}
