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); }
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)); }
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); }