public void ShouldThrowStartExecutionProgressTaskIfContextIsNull()
{
MediaContextBase nullContext = null;
IJob job = this.context.Jobs.Create("TestJob");
nullContext.StartExecutionProgressTask(job, j => { }, CancellationToken.None);
}
internal ContentKeyAuthorizationPolicyOptionCollection(MediaContextBase context)
: base(context)
{
MediaServicesClassFactory factory = this.MediaContext.MediaServicesClassFactory;
this.Queryable = factory.CreateDataServiceContext().CreateQuery <IContentKeyAuthorizationPolicyOption, ContentKeyAuthorizationPolicyOptionData>(ContentKeyAuthorizationPolicyOptionSet);
}
private static async Task AddFairPlayEncryption(MediaContextBase context, IAsset asset)
{
var commonEncryptionCbcsKey = await CreateCommonEncryptionCbcsKey(context, asset);
var commonEncryptionCbcsAuthPolicy = context.ContentKeyAuthorizationPolicies
.Where(p => p.Name == Environment.GetEnvironmentVariable("CommonEncryptionCbcsAuthorizationPolicyName"))
.FirstOrDefault();
if (commonEncryptionCbcsAuthPolicy == null)
{
return;
}
commonEncryptionCbcsKey.AuthorizationPolicyId = commonEncryptionCbcsAuthPolicy.Id;
commonEncryptionCbcsKey = await commonEncryptionCbcsKey.UpdateAsync();
var dynamicCommonEncryptionCbcsDeliveryPolicy = context.AssetDeliveryPolicies
.Where(p => p.Name == Environment.GetEnvironmentVariable("DynamicCommonEncryptionCbcsDeliveryPolicyName"))
.FirstOrDefault();
if (dynamicCommonEncryptionCbcsDeliveryPolicy == null)
{
return;
}
asset.DeliveryPolicies.Add(dynamicCommonEncryptionCbcsDeliveryPolicy);
}
internal AssetDeliveryPolicyCollection(MediaContextBase context)
: base(context)
{
MediaServicesClassFactory factory = this.MediaContext.MediaServicesClassFactory;
this.Queryable = factory.CreateDataServiceContext().CreateQuery <IAssetDeliveryPolicy, AssetDeliveryPolicyData>(DeliveryPolicySet);
}
public void CapacityBasedShouldFromAccountsShouldFilterBasedOnInputArray()
{
List <IStorageAccount> storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _evenBytesUsedValues);
// Copy 3 of the 4 names to the filter array
string[] filterArray = new string[_fourStorageAccountNameArray.Length - 1];
Array.Copy(_fourStorageAccountNameArray, filterArray, filterArray.Length);
// save the name of the skipped entry
string nameSkipped = _fourStorageAccountNameArray[_fourStorageAccountNameArray.Length - 1];
// Create the CapacityBasedAccountSelectionStrategy
MediaContextBase context = GetMediaContextBase(storageAccountList);
CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, maximumStorageAccountCapacity: oneGB, storageAccountNames: filterArray);
// Now ensure that the internal list only has the expected number of entries.
IList <CapacityBasedAccountSelectionStrategyListEntry> accountListFromStrategy = strategy.GetStorageAccounts();
Assert.AreEqual(filterArray.Length, accountListFromStrategy.Count);
foreach (CapacityBasedAccountSelectionStrategyListEntry entry in accountListFromStrategy)
{
Assert.AreNotEqual(nameSkipped, entry.StorageAccount.Name);
}
// Add the name previously skipped
strategy.AddStorageAccountByName(nameSkipped, false, oneGB);
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, oneGB, false);
// Now verify that if I have names in the filter array that don't exist in the account no exception occurs
strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, maximumStorageAccountCapacity: oneGB, storageAccountNames: _fiveStorageAccountNameArray);
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, oneGB, false);
}
/// <summary>
/// Initializes a new instance of the <see cref="MediaProcessorBaseCollection"/> class.
/// </summary>
/// <param name="mediaContext">The media context.</param>
internal StorageAccountBaseCollection(MediaContextBase mediaContext)
: base(mediaContext)
{
MediaContext = mediaContext;
MediaServicesClassFactory factory = MediaContext.MediaServicesClassFactory;
Queryable = factory.CreateDataServiceContext().CreateQuery <IStorageAccount, StorageAccountData>(EntitySet);
}
/// <summary>
/// Initializes a new instance of the <see cref="EncodingReservedUnitCollection"/> class.
/// </summary>
/// <param name="mediaContext">The media context.</param>
internal EncodingReservedUnitCollection(MediaContextBase mediaContext)
: base(mediaContext)
{
MediaContext = mediaContext;
MediaServicesClassFactory factory = MediaContext.MediaServicesClassFactory;
this.Queryable = factory.CreateDataServiceContext().CreateQuery <IEncodingReservedUnit, EncodingReservedUnitData>(EncodingReservedUnitSet);
}
public void CapacityBasedShouldPickAccountsBasedOnWeightedDistribution()
{
// Try even weighting
List <IStorageAccount> storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _evenBytesUsedValues);
MediaContextBase context = GetMediaContextBase(storageAccountList);
CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context);
strategy.Random = new RandomNumberGeneratorMock(_valuesForRandomNumberGeneratorToReturnEven);
for (int i = 0; i < storageAccountList.Count; i++)
{
string accountNameToUse = strategy.SelectAccountForAsset();
Assert.AreEqual(storageAccountList[i].Name, accountNameToUse);
}
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, CapacityBasedAccountSelectionStrategy.oneHundredEightyTB, false);
// Try skewed weighting
// Note that the first account and the last account in the list are almost full. With the "random" numbers we picked
// we will always pick the two middle accounts.
storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _skewedBytesUsedValues);
context = GetMediaContextBase(storageAccountList);
strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, maximumStorageAccountCapacity: oneGB);
strategy.Random = new RandomNumberGeneratorMock(_valuesForRandomNumberGeneratorToReturnEven);
string[] expectedAccountNames = new string[] { _fiveStorageAccountNameArray[1], _fiveStorageAccountNameArray[1], _fiveStorageAccountNameArray[2], _fiveStorageAccountNameArray[2] };
for (int i = 0; i < storageAccountList.Count; i++)
{
string accountNameToUse = strategy.SelectAccountForAsset();
Assert.AreEqual(expectedAccountNames[i], accountNameToUse);
}
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, oneGB, false);
// Try skewed weighting again but change the "random" numbers we generate to be very small and very large so that
// we pick the first and last account even though they are almost full.
storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _skewedBytesUsedValues);
context = GetMediaContextBase(storageAccountList);
strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, maximumStorageAccountCapacity: oneGB);
strategy.Random = new RandomNumberGeneratorMock(_valuesForRandomNumberGeneratorToReturnTopAndBottom);
expectedAccountNames = new string[] { _fiveStorageAccountNameArray[0], _fiveStorageAccountNameArray[0], _fiveStorageAccountNameArray[3], _fiveStorageAccountNameArray[3] };
for (int i = 0; i < storageAccountList.Count; i++)
{
string accountNameToUse = strategy.SelectAccountForAsset();
Assert.AreEqual(expectedAccountNames[i], accountNameToUse);
}
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, oneGB, false);
}
public static async Task <INotificationEndPoint> GetOrCreateQueueNotificationEndpoint(
MediaContextBase context, string name, string queueName)
{
var notificationEndpoint = context.NotificationEndPoints.Where(e => e.Name == name).FirstOrDefault();
if (notificationEndpoint == null)
{
notificationEndpoint = await context.NotificationEndPoints.CreateAsync(
name, NotificationEndPointType.AzureQueue, queueName).ConfigureAwait(false);
}
return(notificationEndpoint);
}
public void CapacityBasedShouldThrowIfNoAccounts()
{
MediaContextBase context = GetMediaContextBase(null);
CapacityBasedAccountSelectionStrategy strategy = new CapacityBasedAccountSelectionStrategy(context);
try
{
strategy.SelectAccountForAsset();
}
catch (InvalidOperationException e)
{
Assert.AreEqual("No storage accounts configured to select from.", e.Message);
throw;
}
}
public void CapacityBasedShouldOmitAccountsWithNoDataByDefault()
{
List <IStorageAccount> storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _oneZeroBytesUsedValues);
MediaContextBase context = GetMediaContextBase(storageAccountList);
CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, maximumStorageAccountCapacity: oneGB);
string accountNameToUse = strategy.SelectAccountForAsset();
Assert.IsNotNull(accountNameToUse);
Assert.AreEqual(0, _oneZeroBytesUsedValues[1].Value);
Assert.AreEqual(_fourStorageAccountNameArray[1], accountNameToUse);
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, oneGB, false);
}
public static async Task <IContentKey> CreateCommonEncryptionKey(MediaContextBase context, IAsset asset)
{
var keyId = Guid.NewGuid();
var contentKey = GetRandomBuffer(16);
var key = await context.ContentKeys.CreateAsync(
keyId,
contentKey,
"CommonEncryptionContentKey",
ContentKeyType.CommonEncryption);
// Associate the key with the asset.
asset.ContentKeys.Add(key);
return(key);
}
public void CapacityBasedShouldIncludeAccountsWithNoDataWhenEnabled()
{
List <IStorageAccount> storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _oneNullBytesUsedValues);
MediaContextBase context = GetMediaContextBase(storageAccountList);
CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, includeAccountsWithNoCapacityData: true, maximumStorageAccountCapacity: oneGB);
strategy.Random = new RandomNumberGeneratorMock(_valuesForRandomNumberGeneratorToReturnEven);
for (int i = 0; i < storageAccountList.Count; i++)
{
string accountNameToUse = strategy.SelectAccountForAsset();
Assert.AreEqual(storageAccountList[i].Name, accountNameToUse);
}
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, oneGB, true);
}
public void CapacityBasedShouldThrowWhenNoAccountCanBeSelected()
{
List <IStorageAccount> storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _evenBytesUsedValues);
MediaContextBase context = GetMediaContextBase(storageAccountList);
CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, maximumStorageAccountCapacity: oneGB);
VerifyStrategyEntriesMatchExpectations(storageAccountList, strategy, oneGB, false);
try
{
string accountNameToUse = strategy.SelectAccountForAsset();
}
catch (InvalidOperationException e)
{
Assert.AreEqual("Unable to find any storage accounts with available capacity!", e.Message);
throw;
}
}
public void CapacityBasedShouldThrowIfAccountNamesCannotBeFound()
{
List <IStorageAccount> storageAccountList = GetStorageAccountList(_fourStorageAccountNameArray, _evenBytesUsedValues);
MediaContextBase context = GetMediaContextBase(storageAccountList);
CapacityBasedAccountSelectionStrategy strategy = new CapacityBasedAccountSelectionStrategy(context);
try
{
foreach (string accountName in _fiveStorageAccountNameArray)
{
strategy.AddStorageAccountByName(accountName);
}
}
catch (ArgumentException ae)
{
Assert.IsTrue(ae.Message.Contains("Unable to find a storage account with name \"account5\""));
Assert.AreEqual("storageAccountName", ae.ParamName);
throw;
}
}
public void SetupTest()
{
_mediaContext = Helper.GetMediaDataServiceContextForUnitTests();
}
public TestRestEntity(MediaContextBase context)
{
SetMediaContext(context);
}
public TestCloudMediaDataContext(MediaContextBase mediaContextBase)
{
_mediaContextBase = mediaContextBase;
}
public TestCloudMediaDataContext(MediaContextBase mediaContextBase, int delaymilliseconds)
{
_mediaContextBase = mediaContextBase;
this._delaymilliseconds = delaymilliseconds;
}
public void SetupTest()
{
Trace.Listeners.Add(_consoleTraceListener);
_mediaConext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
}
public AccessPolicyFactoryBase(TimeSpan duration, AccessPermissions permissions)
{
mediaContext = new CloudMediaContext("videolibraryprototype", "9Dg80l+1mdAgou+O9/bzahxBzaYnIlod85dMdJm7908=");
this.duration = duration;
this.permissions = permissions;
}
public void SetupTest()
{
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
}
internal JobTemplateBaseCollection(MediaContextBase cloudMediaContext)
: base(cloudMediaContext)
{
this.Queryable = cloudMediaContext.MediaServicesClassFactory.CreateDataServiceContext().CreateQuery <IJobTemplate, JobTemplateData>(JobTemplateSet);
}
public void SetupTest()
{
Trace.Listeners.Add(_consoleTraceListener);
_mediaConext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
}
private static Task <IAsset> CreateEmptyAsset(MediaContextBase context, string assetName, AssetCreationOptions assetCreationOptions)
{
return(context.Assets.CreateAsync(assetName, assetCreationOptions, CancellationToken.None));
}
private static async Task CreateCommonEncryptionCbcsPoliciesAsync(MediaContextBase context, List <ContentKeyAuthorizationPolicyRestriction> restrictions)
{
var fairPlayEnabled = bool.Parse(ConfigurationManager.AppSettings["FairPlayEnabled"]);
if (!fairPlayEnabled)
{
Console.WriteLine("Skipping Common Encryption CBCS (FairPlay) policies configuration (disabled by conf)");
return;
}
// Content Key Authorization Policy
var authorizationPolicyName = ConfigurationManager.AppSettings["CommonEncryptionCbcsAuthorizationPolicyName"];
var authorizationPolicy = context.ContentKeyAuthorizationPolicies.Where(p => p.Name == authorizationPolicyName).FirstOrDefault();
if (authorizationPolicy == null)
{
authorizationPolicy = await context.ContentKeyAuthorizationPolicies.CreateAsync(authorizationPolicyName);
}
var fairPlayAuthorizationPolicyOptionName = ConfigurationManager.AppSettings["FairPlayAuthorizationPolicyOptionName"];
var fairPlayConfiguration = await GetFairPlayConfigurationAsync(context);
var fairPlayAuthorizationPolicyOption = authorizationPolicy.Options.Where(o => o.Name == fairPlayAuthorizationPolicyOptionName).FirstOrDefault();
if (fairPlayAuthorizationPolicyOption == null)
{
fairPlayAuthorizationPolicyOption = await context.ContentKeyAuthorizationPolicyOptions.CreateAsync(
fairPlayAuthorizationPolicyOptionName,
ContentKeyDeliveryType.FairPlay,
restrictions,
JsonConvert.SerializeObject(fairPlayConfiguration));
authorizationPolicy.Options.Add(fairPlayAuthorizationPolicyOption);
}
else
{
fairPlayAuthorizationPolicyOption.KeyDeliveryType = ContentKeyDeliveryType.FairPlay;
fairPlayAuthorizationPolicyOption.Restrictions = restrictions;
fairPlayAuthorizationPolicyOption.KeyDeliveryConfiguration = JsonConvert.SerializeObject(fairPlayConfiguration);
await fairPlayAuthorizationPolicyOption.UpdateAsync();
}
// Asset Delivery Policy
var commonEncryptionCbcsKey = await CreateCommonEncryptionCbcsContentKeyAsync(context);
var acquisitionUri = (new UriBuilder(await commonEncryptionCbcsKey.GetKeyDeliveryUrlAsync(ContentKeyDeliveryType.FairPlay))
{
Query = string.Empty
}).Uri;
await commonEncryptionCbcsKey.DeleteAsync();
var deliveryPolicyConfiguration = new Dictionary <AssetDeliveryPolicyConfigurationKey, string>
{
{ AssetDeliveryPolicyConfigurationKey.FairPlayBaseLicenseAcquisitionUrl, acquisitionUri.ToString().Replace("https://", "skd://") },
{ AssetDeliveryPolicyConfigurationKey.CommonEncryptionIVForCbcs, fairPlayConfiguration.ContentEncryptionIV }
};
var deliveryPolicyName = ConfigurationManager.AppSettings["DynamicCommonEncryptionCbcsDeliveryPolicyName"];
var deliveryPolicy = context.AssetDeliveryPolicies.Where(p => p.Name == deliveryPolicyName).FirstOrDefault();
if (deliveryPolicy == null)
{
deliveryPolicy = await context.AssetDeliveryPolicies.CreateAsync(
deliveryPolicyName,
AssetDeliveryPolicyType.DynamicCommonEncryptionCbcs,
AssetDeliveryProtocol.HLS,
deliveryPolicyConfiguration);
}
else
{
deliveryPolicy.AssetDeliveryPolicyType = AssetDeliveryPolicyType.DynamicCommonEncryptionCbcs;
deliveryPolicy.AssetDeliveryProtocol = AssetDeliveryProtocol.HLS;
deliveryPolicy.AssetDeliveryConfiguration = deliveryPolicyConfiguration;
await deliveryPolicy.UpdateAsync();
}
}
private static async Task <IContentKey> CreateCommonEncryptionCbcsContentKeyAsync(MediaContextBase context)
{
var keyId = Guid.NewGuid();
var contentKey = GetRandomBuffer(CommonEncryptionContentKeyLength);
return(await context.ContentKeys.CreateAsync(keyId, contentKey, CommonEncryptionCbcsContentKeyName, ContentKeyType.CommonEncryptionCbcs));
}
public void SetupTest()
{
_mediaContext = Helper.GetMediaDataServiceContextForUnitTests();
}
private static async Task <FairPlayConfiguration> GetFairPlayConfigurationAsync(MediaContextBase context)
{
var previousAskKey = default(IContentKey);
var askKeyId = Guid.NewGuid();
var askKeyName = ConfigurationManager.AppSettings["FairPlayASKContentKeyName"];
var askBytes = HexadecimalStringToByteArray(ConfigurationManager.AppSettings["FairPlayASKHexadecimal"]);
var askKey = context.ContentKeys.Where(k => k.Name == askKeyName).FirstOrDefault();
if (askKey == null)
{
askKey = await context.ContentKeys.CreateAsync(askKeyId, askBytes, askKeyName, ContentKeyType.FairPlayASk);
}
else
{
if (!askBytes.SequenceEqual(await askKey.GetClearKeyValueAsync()) || (askKey.ContentKeyType != ContentKeyType.FairPlayASk))
{
previousAskKey = askKey;
askKey = await context.ContentKeys.CreateAsync(askKeyId, askBytes, askKeyName, ContentKeyType.FairPlayASk);
}
askKeyId = Guid.Parse(askKey.Id.Replace(ContentKeyPrefix, string.Empty));
}
var previousAppCertPasswordKey = default(IContentKey);
var appCertPasswordKeyId = Guid.NewGuid();
var appCertPasswordKeyName = ConfigurationManager.AppSettings["FairPlayAppCertPasswordContentKeyName"];
var appCertPassword = ConfigurationManager.AppSettings["FairPlayAppCertPassword"];
var appCertPasswordBytes = Encoding.UTF8.GetBytes(appCertPassword);
var appCertPasswordKey = context.ContentKeys.Where(k => k.Name == appCertPasswordKeyName).FirstOrDefault();
if (appCertPasswordKey == null)
{
appCertPasswordKey = await context.ContentKeys.CreateAsync(appCertPasswordKeyId, appCertPasswordBytes, appCertPasswordKeyName, ContentKeyType.FairPlayPfxPassword);
}
else
{
if (!appCertPasswordBytes.SequenceEqual(await appCertPasswordKey.GetClearKeyValueAsync()) || (appCertPasswordKey.ContentKeyType != ContentKeyType.FairPlayPfxPassword))
{
previousAppCertPasswordKey = appCertPasswordKey;
appCertPasswordKey = await context.ContentKeys.CreateAsync(appCertPasswordKeyId, appCertPasswordBytes, appCertPasswordKeyName, ContentKeyType.FairPlayPfxPassword);
}
appCertPasswordKeyId = Guid.Parse(appCertPasswordKey.Id.Replace(ContentKeyPrefix, string.Empty));
}
var contentEncryptionIv = Guid.NewGuid().ToByteArray();
var appCert = new X509Certificate2(ConfigurationManager.AppSettings["FairPlayAppCertPath"], appCertPassword, X509KeyStorageFlags.Exportable);
var configuration = FairPlayConfiguration.CreateSerializedFairPlayOptionConfiguration(
appCert,
appCertPassword,
appCertPasswordKeyId,
askKeyId,
contentEncryptionIv);
if (previousAskKey != null)
{
await previousAskKey.DeleteAsync();
}
if (previousAppCertPasswordKey != null)
{
await previousAppCertPasswordKey.DeleteAsync();
}
return(JsonConvert.DeserializeObject <FairPlayConfiguration>(configuration));
}
private static async Task CreateCommonEncryptionPoliciesAsync(MediaContextBase context, List <ContentKeyAuthorizationPolicyRestriction> restrictions)
{
// Content Key Authorization Policy
var authorizationPolicyName = ConfigurationManager.AppSettings["CommonEncryptionAuthorizationPolicyName"];
var authorizationPolicy = context.ContentKeyAuthorizationPolicies.Where(p => p.Name == authorizationPolicyName).FirstOrDefault();
if (authorizationPolicy == null)
{
authorizationPolicy = await context.ContentKeyAuthorizationPolicies.CreateAsync(authorizationPolicyName);
}
var widevineAuthorizationPolicyOptionName = ConfigurationManager.AppSettings["WidevineAuthorizationPolicyOptionName"];
var widevineLicenseTemplate = GetWidevineLicenseTemplateConfiguration();
var widevineAuthorizationPolicyOption = authorizationPolicy.Options.Where(o => o.Name == widevineAuthorizationPolicyOptionName).FirstOrDefault();
if (widevineAuthorizationPolicyOption == null)
{
widevineAuthorizationPolicyOption = await context.ContentKeyAuthorizationPolicyOptions.CreateAsync(
widevineAuthorizationPolicyOptionName,
ContentKeyDeliveryType.Widevine,
restrictions,
widevineLicenseTemplate);
authorizationPolicy.Options.Add(widevineAuthorizationPolicyOption);
}
else
{
widevineAuthorizationPolicyOption.KeyDeliveryType = ContentKeyDeliveryType.Widevine;
widevineAuthorizationPolicyOption.Restrictions = restrictions;
widevineAuthorizationPolicyOption.KeyDeliveryConfiguration = widevineLicenseTemplate;
await widevineAuthorizationPolicyOption.UpdateAsync();
}
var playReadyAuthorizationPolicyOptionName = ConfigurationManager.AppSettings["PlayReadyAuthorizationPolicyOptionName"];
var playReadyLicenseTemplate = GetPlayReadyLicenseTemplateConfiguration();
var playReadyAuthorizationPolicyOption = authorizationPolicy.Options.Where(o => o.Name == playReadyAuthorizationPolicyOptionName).FirstOrDefault();
if (playReadyAuthorizationPolicyOption == null)
{
playReadyAuthorizationPolicyOption = await context.ContentKeyAuthorizationPolicyOptions.CreateAsync(
playReadyAuthorizationPolicyOptionName,
ContentKeyDeliveryType.PlayReadyLicense,
restrictions,
playReadyLicenseTemplate);
authorizationPolicy.Options.Add(playReadyAuthorizationPolicyOption);
}
else
{
playReadyAuthorizationPolicyOption.KeyDeliveryType = ContentKeyDeliveryType.PlayReadyLicense;
playReadyAuthorizationPolicyOption.Restrictions = restrictions;
playReadyAuthorizationPolicyOption.KeyDeliveryConfiguration = playReadyLicenseTemplate;
await playReadyAuthorizationPolicyOption.UpdateAsync();
}
// Asset Delivery Policy
var commonEncryptionKey = await CreateCommonEncryptionContentKeyAsync(context);
var playReadyLicenseAcquisitionUri = await commonEncryptionKey.GetKeyDeliveryUrlAsync(ContentKeyDeliveryType.PlayReadyLicense);
var widevineUri = (new UriBuilder(await commonEncryptionKey.GetKeyDeliveryUrlAsync(ContentKeyDeliveryType.Widevine))
{
Query = string.Empty
}).Uri;
await commonEncryptionKey.DeleteAsync();
var deliveryPolicyConfiguration = new Dictionary <AssetDeliveryPolicyConfigurationKey, string>
{
{ AssetDeliveryPolicyConfigurationKey.PlayReadyLicenseAcquisitionUrl, playReadyLicenseAcquisitionUri.ToString() },
{ AssetDeliveryPolicyConfigurationKey.WidevineBaseLicenseAcquisitionUrl, widevineUri.ToString() }
};
var deliveryPolicyName = ConfigurationManager.AppSettings["DynamicCommonEncryptionDeliveryPolicyName"];
var deliveryPolicy = context.AssetDeliveryPolicies.Where(p => p.Name == deliveryPolicyName).FirstOrDefault();
if (deliveryPolicy == null)
{
deliveryPolicy = await context.AssetDeliveryPolicies.CreateAsync(
deliveryPolicyName,
AssetDeliveryPolicyType.DynamicCommonEncryption,
(AssetDeliveryProtocol.Dash | AssetDeliveryProtocol.SmoothStreaming),
deliveryPolicyConfiguration);
}
else
{
deliveryPolicy.AssetDeliveryPolicyType = AssetDeliveryPolicyType.DynamicCommonEncryption;
deliveryPolicy.AssetDeliveryProtocol = (AssetDeliveryProtocol.Dash | AssetDeliveryProtocol.SmoothStreaming);
deliveryPolicy.AssetDeliveryConfiguration = deliveryPolicyConfiguration;
await deliveryPolicy.UpdateAsync();
}
}
internal MediaProcessorBaseCollection(MediaContextBase cloudMediaContext)
: base(cloudMediaContext)
{
this.Queryable = cloudMediaContext.MediaServicesClassFactory.CreateDataServiceContext().CreateQuery <IMediaProcessor, MediaProcessorData>(MediaProcessorSet);
}
public void SetupTest()
{
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
}
