/// <summary>
/// Asynchronously creates new StreamingFilter.
/// </summary>
/// <param name="name">filter name</param>
/// <param name="timeRange">filter boundaries</param>
/// <param name="trackConditions">filter track conditions</param>
/// <returns>The task to create the filter.</returns>
public Task <IStreamingAssetFilter> CreateAsync(string name, PresentationTimeRange timeRange, IList <FilterTrackSelectStatement> trackConditions)
{
if (String.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
AssetFilterData filter = new AssetFilterData(_parentAsset.Id, name, timeRange, trackConditions);
filter.SetMediaContext(MediaContext);
IMediaDataServiceContext dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(AssetFilterSet, filter);
MediaRetryPolicy retryPolicy = MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync(() => dataContext.SaveChangesAsync(filter))
.ContinueWith <IStreamingAssetFilter>(
t =>
{
t.ThrowIfFaulted();
return (AssetFilterData)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
private Task <IIngestManifestAsset> CreateAsync(IIngestManifest ingestManifest, IAsset asset, CancellationToken token, Action <IngestManifestAssetData> continueWith)
{
IngestManifestCollection.VerifyManifest(ingestManifest);
IMediaDataServiceContext dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
var data = new IngestManifestAssetData
{
ParentIngestManifestId = ingestManifest.Id
};
dataContext.AddObject(IngestManifestAssetCollection.EntitySet, data);
dataContext.AttachTo(AssetCollection.AssetSet, asset);
dataContext.SetLink(data, "Asset", asset);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy();
Task <IIngestManifestAsset> task = retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(data))
.ContinueWith <IIngestManifestAsset>(t =>
{
t.ThrowIfFaulted();
token.ThrowIfCancellationRequested();
IngestManifestAssetData ingestManifestAsset = (IngestManifestAssetData)t.Result.AsyncState;
continueWith(ingestManifestAsset);
return(ingestManifestAsset);
}, TaskContinuationOptions.ExecuteSynchronously);
return(task);
}
/// <summary>
/// Creates the manifest async.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="storageAccountName">The name of storage account </param>
/// <returns><see cref="Task"/> of type <see cref="IIngestManifest"/></returns>
public Task <IIngestManifest> CreateAsync(string name, string storageAccountName)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (storageAccountName == null)
{
throw new ArgumentNullException("storageAccountName");
}
IngestManifestData ingestManifestData = new IngestManifestData
{
Name = name,
StorageAccountName = storageAccountName
};
ingestManifestData.SetMediaContext(this.MediaContext);
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(EntitySet, ingestManifestData);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(ingestManifestData))
.ContinueWith <IIngestManifest>(
t =>
{
t.ThrowIfFaulted();
IngestManifestData data = (IngestManifestData)t.Result.AsyncState;
return data;
}));
}
/// <summary>
/// Creates a notification endpoint asynchronously
/// </summary>
/// <param name="name">Name of notification endpoint</param>
/// <param name="endPointType">Notification endpoint type</param>
/// <param name="endPointAddress">Notification endpoint address</param>
/// <returns>Task of creating notification endpoint.</returns>
public Task <INotificationEndPoint> CreateAsync(string name, NotificationEndPointType endPointType,
string endPointAddress)
{
NotificationEndPoint notificationEndPoint = new NotificationEndPoint
{
Name = name,
EndPointType = (int)endPointType,
EndPointAddress = endPointAddress
};
notificationEndPoint.SetMediaContext(MediaContext);
IMediaDataServiceContext dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(NotificationEndPoints, notificationEndPoint);
MediaRetryPolicy retryPolicy =
this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(
() => dataContext.SaveChangesAsync(notificationEndPoint))
.ContinueWith <INotificationEndPoint>(
t =>
{
t.ThrowIfFaulted();
return (NotificationEndPoint)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// Asynchronously creates an <see cref="IContentKeyAuthorizationPolicyOption"/> with the provided name and permissions, valid for the provided duration.
/// </summary>
/// <param name="name">Specifies a friendly name for the PolicyOption.</param>
/// <param name="deliveryType">Delivery method of the content key to the client.</param>
/// <param name="restrictions">Authorization restrictions.</param>
/// <param name="keyDeliveryConfiguration">Xml data, specific to the key delivery type that defines how the key is delivered to the client.</param>
/// <returns>A function delegate that returns the future result to be available through the Task<IContentKeyAuthorizationPolicyOption>.</returns>
public Task <IContentKeyAuthorizationPolicyOption> CreateAsync(
string name,
ContentKeyDeliveryType deliveryType,
List <ContentKeyAuthorizationPolicyRestriction> restrictions,
string keyDeliveryConfiguration)
{
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
var policyOption = new ContentKeyAuthorizationPolicyOptionData
{
Name = name,
Restrictions = restrictions,
KeyDeliveryConfiguration = keyDeliveryConfiguration
};
((IContentKeyAuthorizationPolicyOption)policyOption).KeyDeliveryType = deliveryType;
policyOption.SetMediaContext(this.MediaContext);
dataContext.AddObject(ContentKeyAuthorizationPolicyOptionSet, policyOption);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(policyOption))
.ContinueWith <IContentKeyAuthorizationPolicyOption>(
t =>
{
t.ThrowIfFaulted();
return (ContentKeyAuthorizationPolicyOptionData)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// Asynchronously creates an <see cref="IAssetDeliveryPolicy"/>.
/// </summary>
/// <param name="name">Friendly name for the policy.</param>
/// <param name="policyType">Type of the policy.</param>
/// <param name="deliveryProtocol">Delivery protocol.</param>
/// <param name="configuration">Configuration.</param>
/// <returns>An <see cref="IAssetDeliveryPolicy"/>.</returns>
public Task <IAssetDeliveryPolicy> CreateAsync(
string name,
AssetDeliveryPolicyType policyType,
AssetDeliveryProtocol deliveryProtocol,
Dictionary <AssetDeliveryPolicyConfigurationKey, string> configuration)
{
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
var policy = new AssetDeliveryPolicyData
{
Name = name,
};
((IAssetDeliveryPolicy)policy).AssetDeliveryPolicyType = policyType;
((IAssetDeliveryPolicy)policy).AssetDeliveryProtocol = deliveryProtocol;
((IAssetDeliveryPolicy)policy).AssetDeliveryConfiguration = configuration;
policy.SetMediaContext(this.MediaContext);
dataContext.AddObject(DeliveryPolicySet, policy);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(policy))
.ContinueWith <IAssetDeliveryPolicy>(
t =>
{
t.ThrowIfFaulted();
return (AssetDeliveryPolicyData)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
private void InnerSave(IMediaDataServiceContext dataContext)
{
X509Certificate2 certToUse = null;
dataContext.AddObject(JobTemplateBaseCollection.JobTemplateSet, this);
foreach (TaskTemplateData taskTemplate in this.TaskTemplates)
{
dataContext.AddRelatedObject(this, TaskTemplatesPropertyName, taskTemplate);
if (((ITaskTemplate)taskTemplate).Options.HasFlag(TaskOptions.ProtectedConfiguration) && (taskTemplate.Configuration != taskTemplate.ConfigurationCopied))
{
ProtectTaskConfiguration((TaskTemplateData)taskTemplate, ref certToUse, dataContext);
}
}
MatchCollection matches = Regex.Matches(this.JobTemplateBodyCopied, @"taskTemplateId=""nb:ttid:UUID:([a-zA-Z0-9\-]+)""");
this.JobTemplateBody = this.JobTemplateBodyCopied;
for (int i = 0; i < matches.Count; i++)
{
string taskTemplateId = Guid.NewGuid().ToString();
this.TaskTemplates[i].Id = string.Concat("nb:ttid:UUID:", taskTemplateId);
this.JobTemplateBody = this.JobTemplateBody.Replace(matches[i].Groups[1].Value, taskTemplateId);
}
}
/// <summary>
/// Creates the manifest asset file asynchronously.
/// </summary>
/// <param name="ingestManifestAsset">The parent manifest asset.</param>
/// <param name="filePath">The file path.</param>
/// <param name="token"><see cref="CancellationToken"/></param>
/// <returns><see cref="Task"/>of type <see cref="IIngestManifestFile"/></returns>
public Task <IIngestManifestFile> CreateAsync(IIngestManifestAsset ingestManifestAsset, string filePath, CancellationToken token)
{
if (ingestManifestAsset == null)
{
throw new ArgumentNullException("ingestManifestAsset");
}
if (string.IsNullOrWhiteSpace(filePath))
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, StringTable.ErrorCreatingIngestManifestFileEmptyFilePath));
}
AssetCreationOptions options = ingestManifestAsset.Asset.Options;
Task <IIngestManifestFile> rootTask = new Task <IIngestManifestFile>(() =>
{
token.ThrowIfCancellationRequested();
IngestManifestAssetCollection.VerifyManifestAsset(ingestManifestAsset);
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
// Set a MIME type based on the extension of the file name
string mimeType = AssetFileData.GetMimeType(filePath);
IngestManifestFileData data = new IngestManifestFileData
{
Name = Path.GetFileName(filePath),
MimeType = mimeType,
ParentIngestManifestId = ingestManifestAsset.ParentIngestManifestId,
ParentIngestManifestAssetId = ingestManifestAsset.Id,
Path = filePath,
};
SetEncryptionSettings(ingestManifestAsset, options, data);
dataContext.AddObject(EntitySet, data);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
Task <IIngestManifestFile> task = retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(data))
.ContinueWith <IIngestManifestFile>(t =>
{
t.ThrowIfFaulted();
token.ThrowIfCancellationRequested();
IngestManifestFileData ingestManifestFile = (IngestManifestFileData)t.Result.AsyncState;
return(ingestManifestFile);
});
return(task.Result);
});
rootTask.Start();
return(rootTask);
}
/// <summary>
/// Create a notification endpoint object in asynchronous mode.
/// </summary>
/// <param name="name">Name of notification endpoint</param>
/// <param name="endPointType">Notification endpoint type</param>
/// <param name="endPointAddress">Notification endpoint address</param>
/// <param name="credential"></param>
/// <returns>Task of creating notification endpoint.</returns>
public Task <INotificationEndPoint> CreateAsync(string name, NotificationEndPointType endPointType,
string endPointAddress, byte[] credential)
{
if (credential == null || credential.Length == 0)
{
throw new ArgumentNullException("credential");
}
if (endPointType != NotificationEndPointType.WebHook)
{
throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, StringTable.SupportWebHookWithCredentialOnly, "endPointType"));
}
IMediaDataServiceContext dataContext =
this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
string protectionKeyId = ContentKeyBaseCollection.GetProtectionKeyIdForContentKey(MediaContext,
ContentKeyType.ConfigurationEncryption);
X509Certificate2 certToUse = ContentKeyBaseCollection.GetCertificateForProtectionKeyId(MediaContext, protectionKeyId);
byte[] encryptedContentKey = EncryptionUtils.EncryptSymmetricKeyData(certToUse, credential);
NotificationEndPoint notificationEndPoint = new NotificationEndPoint
{
Name = name,
EndPointType = (int)endPointType,
EndPointAddress = endPointAddress,
CredentialType = (int)NotificationEndPointCredentialType.SigningKey,
EncryptedEndPointCredential = Convert.ToBase64String(encryptedContentKey),
ProtectionKeyType = (int)ProtectionKeyType.X509CertificateThumbprint,
ProtectionKeyId = protectionKeyId
};
notificationEndPoint.SetMediaContext(MediaContext);
dataContext.AddObject(NotificationEndPoints, notificationEndPoint);
MediaRetryPolicy retryPolicy =
this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(
() => dataContext.SaveChangesAsync(notificationEndPoint))
.ContinueWith <INotificationEndPoint>(
t =>
{
t.ThrowIfFaulted();
return (NotificationEndPoint)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// Asynchronously creates a content key with the specifies key identifier and value.
/// </summary>
/// <param name="keyId">The key identifier.</param>
/// <param name="contentKey">The value of the content key.</param>
/// <param name="name">A friendly name for the content key.</param>
/// <param name="contentKeyType">Type of content key to create.</param>
/// <returns>
/// A function delegate that returns the future result to be available through the Task<IContentKey>.
/// </returns>
public override Task <IContentKey> CreateAsync(Guid keyId, byte[] contentKey, string name, ContentKeyType contentKeyType)
{
if ((contentKeyType != ContentKeyType.CommonEncryption) && (contentKeyType != ContentKeyType.EnvelopeEncryption))
{
throw new ArgumentException(StringTable.ErrorUnsupportedContentKeyType, "contentKey");
}
if (keyId == Guid.Empty)
{
throw new ArgumentException(StringTable.ErrorCreateKey_EmptyGuidNotAllowed, "keyId");
}
if (contentKey == null)
{
throw new ArgumentNullException("contentKey");
}
if (contentKey.Length != EncryptionUtils.KeySizeInBytesForAes128)
{
throw new ArgumentException(StringTable.ErrorCommonEncryptionKeySize, "contentKey");
}
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
X509Certificate2 certToUse = GetCertificateToEncryptContentKey(MediaContext, ContentKeyType.CommonEncryption);
ContentKeyData contentKeyData = null;
if (contentKeyType == ContentKeyType.CommonEncryption)
{
contentKeyData = InitializeCommonContentKey(keyId, contentKey, name, certToUse);
}
else if (contentKeyType == ContentKeyType.EnvelopeEncryption)
{
contentKeyData = InitializeEnvelopeContentKey(keyId, contentKey, name, certToUse);
}
dataContext.AddObject(ContentKeySet, contentKeyData);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(contentKeyData))
.ContinueWith <IContentKey>(
t =>
{
t.ThrowIfFaulted();
return (ContentKeyData)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
private Task <IMediaDataServiceResponse> CreateChannelAsync(ChannelCreationOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (string.IsNullOrEmpty(options.Name))
{
throw new ArgumentException(Resources.ErrorEmptyChannelName);
}
if (options.Input == null ||
options.Input.AccessControl == null ||
options.Input.AccessControl.IPAllowList == null)
{
throw new ArgumentException(Resources.ErrorEmptyChannelInputIPAllowList);
}
var channelData = new ChannelData
{
Name = options.Name,
Description = options.Description,
CrossSiteAccessPolicies = options.CrossSiteAccessPolicies,
Slate = options.Slate,
};
IChannel channel = channelData;
channel.Input = options.Input;
channel.Preview = options.Preview;
channel.Output = options.Output;
channel.EncodingType = options.EncodingType;
channel.Encoding = options.Encoding;
channelData.ValidateSettings();
channelData.SetMediaContext(MediaContext);
IMediaDataServiceContext dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(ChannelSet, channel);
MediaRetryPolicy retryPolicy = MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync(() => dataContext.SaveChangesAsync(channel)));
}
private Task <IJobTemplate> CreateJobTemplate(string templateName, JobTemplateType templateType, params ITaskTemplate[] taskTemplates)
{
X509Certificate2 certToUse = null;
IMediaDataServiceContext dataContext = this.GetMediaContext().MediaServicesClassFactory.CreateDataServiceContext();
JobTemplateData jobTemplateData = new JobTemplateData {
Name = templateName, TemplateType = (int)templateType
};
jobTemplateData.SetMediaContext(this.GetMediaContext());
dataContext.AddObject(JobTemplateBaseCollection.JobTemplateSet, jobTemplateData);
foreach (ITaskTemplate taskTemplate in taskTemplates)
{
Verify(taskTemplate);
dataContext.AddRelatedObject(jobTemplateData, TaskTemplatesPropertyName, taskTemplate);
if (taskTemplate.Options.HasFlag(TaskOptions.ProtectedConfiguration) && string.IsNullOrWhiteSpace(this.Id))
{
ProtectTaskConfiguration((TaskTemplateData)taskTemplate, ref certToUse, dataContext);
}
}
AssetNamingSchemeResolver <AssetData, OutputAsset> assetIdMap = new AssetNamingSchemeResolver <AssetData, OutputAsset>();
jobTemplateData.JobTemplateBody = CreateJobTemplateBody(assetIdMap, taskTemplates);
jobTemplateData.NumberofInputAssets = string.IsNullOrWhiteSpace(this.Id)
? assetIdMap.Inputs.Count
: ((IJob)this).InputMediaAssets.Count;
MediaRetryPolicy retryPolicy = this.GetMediaContext().MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(SaveChangesOptions.Batch, jobTemplateData))
.ContinueWith <IJobTemplate>(
t =>
{
t.ThrowIfFaulted();
JobTemplateData data = (JobTemplateData)t.Result.AsyncState;
IJobTemplate jobTemplateToReturn = this.GetMediaContext().JobTemplates.Where(c => c.Id == data.Id).First();
return jobTemplateToReturn;
}));
}
/// <summary>
/// Creates the locator async.
/// </summary>
/// <param name="locatorId">The locator Id.</param>
/// <param name="locatorType">Type of the locator.</param>
/// <param name="asset">The asset.</param>
/// <param name="accessPolicy">The access policy.</param>
/// <param name="startTime">The start time.</param>
/// <param name="name">The name.</param>
/// <returns>A function delegate that returns the future result to be available through the Task<ILocator>.</returns>
public Task <ILocator> CreateLocatorAsync(string locatorId, LocatorType locatorType, IAsset asset, IAccessPolicy accessPolicy, DateTime?startTime, string name = null)
{
AccessPolicyBaseCollection.VerifyAccessPolicy(accessPolicy);
AssetCollection.VerifyAsset(asset);
AssetData assetData = (AssetData)asset;
LocatorData locator = new LocatorData
{
AccessPolicy = (AccessPolicyData)accessPolicy,
Asset = assetData,
Type = (int)locatorType,
StartTime = startTime,
Name = name
};
if (locatorId != null)
{
locator.Id = LocatorData.NormalizeLocatorId(locatorId);
}
locator.SetMediaContext(this.MediaContext);
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AttachTo(AssetCollection.AssetSet, asset);
dataContext.AttachTo(AccessPolicyBaseCollection.AccessPolicySet, accessPolicy);
dataContext.AddObject(LocatorSet, locator);
dataContext.SetLink(locator, AccessPolicyPropertyName, accessPolicy);
dataContext.SetLink(locator, AssetPropertyName, asset);
MediaRetryPolicy retryPolicy =
this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(locator))
.ContinueWith <ILocator>(
t =>
{
t.ThrowIfFaulted();
assetData.InvalidateLocatorsCollection();
return (LocatorData)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// Asynchronously creates new Program.
/// </summary>
/// <param name="options">Program creation options.</param>
/// <returns>The task to create the program.</returns>
public Task <IProgram> CreateAsync(ProgramCreationOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (string.IsNullOrEmpty(options.Name))
{
throw new ArgumentException(Resources.ErrorEmptyProgramName);
}
if (_parentChannel == null)
{
throw new InvalidOperationException(Resources.ErrorOrphanProgram);
}
var program = new ProgramData
{
Name = options.Name,
Description = options.Description,
ChannelId = _parentChannel.Id,
AssetId = options.AssetId,
ArchiveWindowLength = options.ArchiveWindowLength,
ManifestName = options.ManifestName
};
program.SetMediaContext(MediaContext);
IMediaDataServiceContext dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(ProgramSet, program);
MediaRetryPolicy retryPolicy = MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync(() => dataContext.SaveChangesAsync(program))
.ContinueWith <IProgram>(t =>
{
t.ThrowIfFaulted();
return (ProgramData)t.Result.AsyncState;
}));
}
private ContentKeyData CreateStorageContentKey(AssetData tempAsset, NullableFileEncryption fileEncryption, IMediaDataServiceContext dataContext)
{
// Create the content key.
fileEncryption.Init();
// Encrypt it for delivery to Nimbus.
X509Certificate2 certToUse = ContentKeyCollection.GetCertificateToEncryptContentKey(MediaContext, ContentKeyType.StorageEncryption);
ContentKeyData contentKeyData = ContentKeyBaseCollection.InitializeStorageContentKey(fileEncryption.FileEncryption, certToUse);
dataContext.AddObject(ContentKeyBaseCollection.ContentKeySet, contentKeyData);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
retryPolicy.ExecuteAction <IMediaDataServiceResponse>(() => dataContext.SaveChanges());
// Associate it with the asset.
((IAsset)tempAsset).ContentKeys.Add(contentKeyData);
return(contentKeyData);
}
private Task <IMediaDataServiceResponse> CreateStreamingEndpointAsync(StreamingEndpointCreationOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (string.IsNullOrEmpty(options.Name))
{
throw new ArgumentException(Resources.ErrorEmptyStreamingEndpointName);
}
var streamingEndpoint = new StreamingEndpointData
{
Name = options.Name,
Description = options.Description,
ScaleUnits = options.ScaleUnits,
CrossSiteAccessPolicies = options.CrossSiteAccessPolicies
};
if (options.CustomHostNames != null)
{
streamingEndpoint.CustomHostNames = (options.CustomHostNames as IList <string>) ??
options.CustomHostNames.ToList();
}
((IStreamingEndpoint)streamingEndpoint).AccessControl = options.AccessControl;
((IStreamingEndpoint)streamingEndpoint).CacheControl = options.CacheControl;
streamingEndpoint.ValidateSettings();
streamingEndpoint.SetMediaContext(MediaContext);
IMediaDataServiceContext dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(StreamingEndpointSet, streamingEndpoint);
MediaRetryPolicy retryPolicy = MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync(() => dataContext.SaveChangesAsync(streamingEndpoint)));
}
/// <summary>
/// Creates the authorization policy asynchronously.
/// </summary>
/// <param name="name">The name.</param>
/// <returns></returns>
public virtual Task <IContentKeyAuthorizationPolicy> CreateAsync(string name)
{
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
var authorizationPolicyData = new ContentKeyAuthorizationPolicyData
{
Name = name
};
authorizationPolicyData.SetMediaContext(this.MediaContext);
dataContext.AddObject(ContentKeyAuthorizationPolicySet, authorizationPolicyData);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(authorizationPolicyData))
.ContinueWith <IContentKeyAuthorizationPolicy>(
t =>
{
return (ContentKeyAuthorizationPolicyData)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
private void ProtectTaskConfiguration(TaskTemplateData taskTemplate, ref X509Certificate2 certToUse, IMediaDataServiceContext dataContext)
{
using (ConfigurationEncryption configEncryption = new ConfigurationEncryption())
{
// Update the task template with the required data.
taskTemplate.Configuration = configEncryption.Encrypt(taskTemplate.Configuration);
taskTemplate.EncryptionKeyId = configEncryption.GetKeyIdentifierAsString();
taskTemplate.EncryptionScheme = ConfigurationEncryption.SchemeName;
taskTemplate.EncryptionVersion = ConfigurationEncryption.SchemeVersion;
taskTemplate.InitializationVector = configEncryption.GetInitializationVectorAsString();
if (certToUse == null)
{
// Get the certificate to use to encrypt the configuration encryption key.
certToUse = ContentKeyBaseCollection.GetCertificateToEncryptContentKey(GetMediaContext(), ContentKeyType.ConfigurationEncryption);
}
// Create a content key object to hold the encryption key.
ContentKeyData contentKeyData = ContentKeyBaseCollection.InitializeConfigurationContentKey(configEncryption, certToUse);
dataContext.AddObject(ContentKeyBaseCollection.ContentKeySet, contentKeyData);
}
}
/// <summary>
/// Asynchronously creates an asset for specified storage account. Asset does not contain any files and <see cref="AssetState" /> is Initialized.
/// </summary>
/// <param name="assetName">The asset name.</param>
/// <param name="storageAccountName">The storage account name</param>
/// <param name="options">A <see cref="AssetCreationOptions" /> which will be associated with created asset.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// An <see cref="Task" /> of type <see cref="IAsset" />, where IAsset created according to the specified creation <paramref name="options" />.
/// </returns>
public override Task <IAsset> CreateAsync(string assetName, string storageAccountName, AssetCreationOptions options, CancellationToken cancellationToken)
{
AssetData emptyAsset = new AssetData
{
Name = assetName,
Options = (int)options,
StorageAccountName = storageAccountName
};
emptyAsset.SetMediaContext(this.MediaContext);
cancellationToken.ThrowIfCancellationRequested();
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(AssetSet, (IAsset)emptyAsset);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(emptyAsset))
.ContinueWith <IAsset>(
t =>
{
t.ThrowIfFaulted();
cancellationToken.ThrowIfCancellationRequested();
AssetData data = (AssetData)t.Result.AsyncState;
if (options.HasFlag(AssetCreationOptions.StorageEncrypted))
{
using (var fileEncryption = new NullableFileEncryption())
{
CreateStorageContentKey(data, fileEncryption, dataContext);
}
}
return data;
}));
}
private Task <IMediaDataServiceResponse> CreateStreamingEndpointAsync(StreamingEndpointCreationOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (string.IsNullOrEmpty(options.Name))
{
throw new ArgumentException(Resources.ErrorEmptyStreamingEndpointName);
}
var streamingEndpoint = new StreamingEndpointData(options);
streamingEndpoint.SetMediaContext(MediaContext);
IMediaDataServiceContext dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(StreamingEndpointSet, streamingEndpoint);
MediaRetryPolicy retryPolicy = MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync(() => dataContext.SaveChangesAsync(streamingEndpoint)));
}
/// <summary>
/// Asynchronously creates an <see cref="IAccessPolicy"/> with the provided name and permissions, valid for the provided duration.
/// </summary>
/// <param name="name">Specifies a friendly name for the AccessPolicy.</param>
/// <param name="duration">Specifies the duration that locators created from this AccessPolicy will be valid for.</param>
/// <param name="permissions">Specifies permissions for the created AccessPolicy.</param>
/// <returns>A function delegate that returns the future result to be available through the Task<IAccessPolicy>.</returns>
public Task <IAccessPolicy> CreateAsync(string name, TimeSpan duration, AccessPermissions permissions)
{
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
AccessPolicyData accessPolicy = new AccessPolicyData
{
Name = name,
DurationInMinutes = AccessPolicyData.GetInternalDuration(duration),
Permissions = AccessPolicyData.GetInternalPermissions(permissions)
};
dataContext.AddObject(AccessPolicySet, accessPolicy);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return(retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() => dataContext.SaveChangesAsync(accessPolicy))
.ContinueWith <IAccessPolicy>(
t =>
{
t.ThrowIfFaulted();
return (AccessPolicyData)t.Result.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
private ContentKeyData CreateStorageContentKey(AssetData tempAsset, NullableFileEncryption fileEncryption, IMediaDataServiceContext dataContext)
{
// Create the content key.
fileEncryption.Init();
// Encrypt it for delivery to Nimbus.
X509Certificate2 certToUse = ContentKeyCollection.GetCertificateToEncryptContentKey(dataContext, ContentKeyType.StorageEncryption);
ContentKeyData contentKeyData = ContentKeyBaseCollection.CreateStorageContentKey(fileEncryption.FileEncryption, certToUse);
dataContext.AddObject(ContentKeyCollection.ContentKeySet, contentKeyData);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy();
retryPolicy.ExecuteAction<IMediaDataServiceResponse>(() => dataContext.SaveChanges());
// Associate it with the asset.
((IAsset) tempAsset).ContentKeys.Add(contentKeyData);
return contentKeyData;
}
private void InnerSubmit(IMediaDataServiceContext dataContext)
{
if (!string.IsNullOrWhiteSpace(this.TemplateId))
{
dataContext.AddObject(JobBaseCollection.JobSet, this);
foreach (IAsset asset in this.InputMediaAssets)
{
AssetData target = asset as AssetData;
if (target == null)
{
throw new ArgumentException(StringTable.ErrorInputTypeNotSupported);
}
dataContext.AttachTo(AssetCollection.AssetSet, asset);
dataContext.AddLink(this, InputMediaAssetsPropertyName, target);
}
}
else
{
X509Certificate2 certToUse = null;
Verify(this);
dataContext.AddObject(JobBaseCollection.JobSet, this);
List <AssetData> inputAssets = new List <AssetData>();
AssetNamingSchemeResolver <AssetData, OutputAsset> assetNamingSchemeResolver = new AssetNamingSchemeResolver <AssetData, OutputAsset>(inputAssets);
foreach (ITask task in ((IJob)this).Tasks)
{
Verify(task);
TaskData taskData = (TaskData)task;
if (task.Options.HasFlag(TaskOptions.ProtectedConfiguration))
{
ProtectTaskConfiguration(taskData, ref certToUse, dataContext);
}
taskData.TaskBody = CreateTaskBody(assetNamingSchemeResolver, task.InputAssets.ToArray(), task.OutputAssets.ToArray());
taskData.InputMediaAssets.AddRange(task.InputAssets.OfType <AssetData>().ToArray());
taskData.OutputMediaAssets.AddRange(
task.OutputAssets
.OfType <OutputAsset>()
.Select(
c =>
{
AssetData assetData = new AssetData {
Name = c.Name, Options = (int)c.Options, AlternateId = c.AlternateId
};
assetData.SetMediaContext(this.GetMediaContext());
return(assetData);
})
.ToArray());
dataContext.AddRelatedObject(this, TasksPropertyName, taskData);
}
foreach (IAsset asset in inputAssets)
{
dataContext.AttachTo(AssetCollection.AssetSet, asset);
dataContext.AddLink(this, InputMediaAssetsPropertyName, asset);
}
}
}
public override Task <IAssetFile> CreateAsync(string name, CancellationToken cancelation)
{
if (_parentAsset == null)
{
throw new InvalidOperationException(StringTable.AssetFileCreateParentAssetIsNull);
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, StringTable.ErrorCreatingAssetFileEmptyFileName));
}
cancelation.ThrowIfCancellationRequested();
IMediaDataServiceContext dataContext = null;
AssetFileData assetFile = null;
return(Task.Factory.StartNew(() =>
{
cancelation.ThrowIfCancellationRequested();
dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
FileEncryption fileEncryption = null;
// Set a MIME type based on the extension of the file name
string mimeType = AssetFileData.GetMimeType(name);
assetFile = new AssetFileData
{
Name = name,
ParentAssetId = _parentAsset.Id,
MimeType = mimeType,
};
try
{
// Update the files associated with the asset with the encryption related metadata.
if (_parentAsset.Options.HasFlag(AssetCreationOptions.StorageEncrypted))
{
IContentKey storageEncryptionKey = _parentAsset.ContentKeys.Where(c => c.ContentKeyType == ContentKeyType.StorageEncryption).FirstOrDefault();
cancelation.ThrowIfCancellationRequested();
if (storageEncryptionKey == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, StringTable.StorageEncryptionContentKeyIsMissing, _parentAsset.Id));
}
fileEncryption = new FileEncryption(storageEncryptionKey.GetClearKeyValue(), EncryptionUtils.GetKeyIdAsGuid(storageEncryptionKey.Id));
AssetBaseCollection.AddEncryptionMetadataToAssetFile(assetFile, fileEncryption);
}
else if (_parentAsset.Options.HasFlag(AssetCreationOptions.CommonEncryptionProtected))
{
AssetBaseCollection.SetAssetFileForCommonEncryption(assetFile);
}
else if (_parentAsset.Options.HasFlag(AssetCreationOptions.EnvelopeEncryptionProtected))
{
AssetBaseCollection.SetAssetFileForEnvelopeEncryption(assetFile);
}
}
finally
{
if (fileEncryption != null)
{
fileEncryption.Dispose();
}
}
dataContext.AddObject(FileSet, assetFile);
cancelation.ThrowIfCancellationRequested();
cancelation.ThrowIfCancellationRequested();
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() =>
{
cancelation.ThrowIfCancellationRequested();
return dataContext.SaveChangesAsync(assetFile);
}, cancelation).Result;
}, cancelation)
.ContinueWith <IAssetFile>(t =>
{
t.ThrowIfFaulted();
AssetFileData data = (AssetFileData)t.Result.AsyncState;
return data;
}, cancelation));
}
public override Task <IAssetFile> CreateAsync(string name, CancellationToken cancelation)
{
if (_parentAsset == null)
{
throw new InvalidOperationException(StringTable.AssetFileCreateParentAssetIsNull);
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, StringTable.ErrorCreatingAssetFileEmptyFileName));
}
cancelation.ThrowIfCancellationRequested();
IMediaDataServiceContext dataContext = null;
AssetFileData assetFile = null;
return(Task.Factory.StartNew(() =>
{
cancelation.ThrowIfCancellationRequested();
dataContext = MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
bool isEncrypted = _parentAsset.Options.HasFlag(AssetCreationOptions.CommonEncryptionProtected) || _parentAsset.Options.HasFlag(AssetCreationOptions.StorageEncrypted) ||
_parentAsset.Options.HasFlag(AssetCreationOptions.EnvelopeEncryptionProtected);
string scheme = null;
string schemeVersion = null;
string encryptionKeyId = null;
if (_parentAsset.Options.HasFlag(AssetCreationOptions.StorageEncrypted))
{
IContentKey storageEncryptionKey = _parentAsset.ContentKeys.Where(c => c.ContentKeyType == ContentKeyType.StorageEncryption).FirstOrDefault();
cancelation.ThrowIfCancellationRequested();
if (storageEncryptionKey != null)
{
encryptionKeyId = storageEncryptionKey.Id.ToString();
}
else
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, StringTable.StorageEncryptionContentKeyIsMissing, _parentAsset.Id));
}
scheme = FileEncryption.SchemeName;
schemeVersion = FileEncryption.SchemeVersion;
}
else if (_parentAsset.Options.HasFlag(AssetCreationOptions.CommonEncryptionProtected))
{
scheme = CommonEncryption.SchemeName;
schemeVersion = CommonEncryption.SchemeVersion;
}
else if (_parentAsset.Options.HasFlag(AssetCreationOptions.EnvelopeEncryptionProtected))
{
scheme = EnvelopeEncryption.SchemeName;
schemeVersion = EnvelopeEncryption.SchemeVersion;
}
// Set a MIME type based on the extension of the file name
string mimeType = AssetFileData.GetMimeType(name);
assetFile = new AssetFileData
{
Name = name,
IsEncrypted = isEncrypted,
EncryptionScheme = scheme,
EncryptionVersion = schemeVersion,
EncryptionKeyId = encryptionKeyId,
ParentAssetId = _parentAsset.Id,
MimeType = mimeType,
};
dataContext.AddObject(AssetFileCollection.FileSet, assetFile);
cancelation.ThrowIfCancellationRequested();
cancelation.ThrowIfCancellationRequested();
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy(dataContext as IRetryPolicyAdapter);
return retryPolicy.ExecuteAsync <IMediaDataServiceResponse>(() =>
{
cancelation.ThrowIfCancellationRequested();
return dataContext.SaveChangesAsync(assetFile);
}, cancelation).Result;
}, cancelation)
.ContinueWith <IAssetFile>(t =>
{
t.ThrowIfFaulted();
AssetFileData data = (AssetFileData)t.Result.AsyncState;
return data;
}, cancelation));
}