public static IAsset CreateAssetAndUploadSingleFile(this CloudMediaContext cloudMediaContext, AssetCreationOptions assetCreationOptions, string singleFilePath)
{
var fileName = Path.GetFileName(singleFilePath);
var assetName = fileName; // +"-" + DateTime.UtcNow.ToString("o");
var asset = cloudMediaContext.CreateEmptyAsset(assetName, assetCreationOptions);
var assetFile = asset.AssetFiles.Create(fileName);
//Console.WriteLine("Created assetFile {0}", assetFile.Name);
var accessPolicy = cloudMediaContext.AccessPolicies.Create(assetName, TimeSpan.FromDays(3),
AccessPermissions.Write | AccessPermissions.List);
var locator = cloudMediaContext.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
//Console.WriteLine("Upload {0}", assetFile.Name);
assetFile.Upload(singleFilePath);
//Console.WriteLine("Done uploading of {0} using Upload()", assetFile.Name);
locator.Delete();
accessPolicy.Delete();
return asset;
}
static public IAsset EncodeToAdaptiveBitrateMP4s(IAsset asset, AssetCreationOptions options)
{
// Prepare a job with a single task to transcode the specified asset
// into a multi-bitrate asset.
IJob job = _context.Jobs.CreateWithSingleTask(
MediaProcessorNames.AzureMediaEncoder,
MediaEncoderTaskPresetStrings.H264AdaptiveBitrateMP4Set720p,
asset,
"Adaptive Bitrate MP4",
options);
Console.WriteLine("Submitting transcoding job...");
// Submit the job and wait until it is completed.
job.Submit();
job = job.StartExecutionProgressTask(
j =>
{
Console.WriteLine("Job state: {0}", j.State);
Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress());
},
CancellationToken.None).Result;
Console.WriteLine("Transcoding job finished.");
IAsset outputAsset = job.OutputMediaAssets[0];
return(outputAsset);
}
static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
// For the AssetCreationOptions you can specify the following encryption options.
// None: no encryption. By default, storage encryption is used. If you want to
// create an unencrypted asset, you must set this option.
// StorageEncrypted: storage encryption. Encrypts a clear input file
// before it is uploaded to Azure storage.
// CommonEncryptionProtected: for Common Encryption Protected (CENC) files. An
// example is a set of files that are already PlayReady encrypted.
var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
var asset = CreateEmptyAsset(assetName, assetCreationOptions);
var fileName = Path.GetFileName(singleFilePath);
var assetFile = asset.AssetFiles.Create(fileName);
Console.WriteLine("Created assetFile {0}", assetFile.Name);
var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
Console.WriteLine("Upload {0}", assetFile.Name);
assetFile.Upload(singleFilePath);
Console.WriteLine("Done uploading {0}", assetFile.Name);
locator.Delete();
accessPolicy.Delete();
return asset;
}
static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
CloudMediaContext _context = CloudContextHelper.GetContext();
if (!File.Exists(singleFilePath))
{
Console.WriteLine("File does not exist.");
return(null);
}
var assetName = Path.GetFileNameWithoutExtension(singleFilePath);
IAsset inputAsset = _context.Assets.Create(assetName, assetCreationOptions);
var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(singleFilePath));
Console.WriteLine("Created assetFile {0}", assetFile.Name);
var policy = _context.AccessPolicies.Create(
assetName,
TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = _context.Locators.CreateLocator(LocatorType.Sas, inputAsset, policy);
Console.WriteLine("Upload {0}", assetFile.Name);
assetFile.Upload(singleFilePath);
Console.WriteLine("Done uploading {0}", assetFile.Name);
locator.Delete();
policy.Delete();
return(inputAsset);
}
/// <summary>
/// Uploads the destinationPath with given path asynchronously
/// </summary>
/// <param name="path">The path of a destinationPath to upload</param>
/// <param name="blobTransferClient">The <see cref="BlobTransferClient"/> which is used to upload files.</param>
/// <param name="locator">An asset <see cref="ILocator"/> which defines permissions associated with the Asset.</param>
/// <param name="token">A <see cref="CancellationToken"/> to use for canceling upload operation.</param>
/// <returns>A function delegate that returns the future result to be available through the Task.</returns>
public Task UploadAsync(string path, BlobTransferClient blobTransferClient, ILocator locator, CancellationToken token)
{
if (blobTransferClient == null)
{
throw new ArgumentNullException("blobTransferClient");
}
if (locator == null)
{
throw new ArgumentNullException("locator");
}
if (path == null)
{
throw new ArgumentNullException("path");
}
if (!File.Exists(path))
{
throw new FileNotFoundException(path);
}
ValidateFileName(path);
IContentKey contentKeyData = null;
FileEncryption fileEncryption = null;
AssetCreationOptions assetCreationOptions = this.Asset.Options;
if (assetCreationOptions.HasFlag(AssetCreationOptions.StorageEncrypted))
{
contentKeyData = this.Asset.ContentKeys.Where(c => c.ContentKeyType == ContentKeyType.StorageEncryption).FirstOrDefault();
if (contentKeyData == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, StringTable.StorageEncryptionContentKeyIsMissing, this.Asset.Id));
}
fileEncryption = new FileEncryption(contentKeyData.GetClearKeyValue(), EncryptionUtils.GetKeyIdAsGuid(contentKeyData.Id));
}
EventHandler <BlobTransferProgressChangedEventArgs> handler = (s, e) => OnUploadProgressChanged(path, e);
blobTransferClient.TransferProgressChanged += handler;
MediaRetryPolicy retryPolicy = this.GetMediaContext().MediaServicesClassFactory.GetBlobStorageClientRetryPolicy();
return(blobTransferClient.UploadBlob(
new Uri(locator.BaseUri),
path,
null,
fileEncryption,
token,
retryPolicy.AsAzureStorageClientRetryPolicy(),
() => locator.ContentAccessComponent)
.ContinueWith(
ts =>
{
blobTransferClient.TransferProgressChanged -= handler;
this.PostUploadAction(ts, path, fileEncryption, assetCreationOptions, token);
}));
}
/// <summary>
/// Asynchronously creates an asset that does not contain any files and <see cref="AssetState"/> is Initialized.
/// </summary>
/// <param name="assetName">The asset 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"/>created according to the specified creation <paramref name="options"/>.
/// </returns>
public override Task<IAsset> CreateAsync(string assetName, AssetCreationOptions options,CancellationToken cancellationToken)
{
AssetData emptyAsset = new AssetData
{
Name = assetName,
Options = (int) options
};
emptyAsset.InitCloudMediaContext(this._cloudMediaContext);
cancellationToken.ThrowIfCancellationRequested();
DataServiceContext dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext();
dataContext.AddObject(AssetSet, emptyAsset);
return dataContext
.SaveChangesAsync(emptyAsset)
.ContinueWith<IAsset>(
t =>
{
t.ThrowIfFaulted();
cancellationToken.ThrowIfCancellationRequested();
AssetData data = (AssetData) t.AsyncState;
if (options.HasFlag(AssetCreationOptions.StorageEncrypted))
{
using (var fileEncryption = new NullableFileEncryption())
{
CreateStorageContentKey(data, fileEncryption, dataContext);
}
}
return data;
});
}
private IAsset CreateHlsFromSmoothAsset(IAsset sourceAsset, AssetCreationOptions options)
{
IJob job = _mediaContext.Jobs.Create("Smooth to Hls Job");
IMediaProcessor mediaProcessor = JobTests.GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncryptorName);
string smoothToHlsConfiguration = null;
if (options == AssetCreationOptions.EnvelopeEncryptionProtected)
{
smoothToHlsConfiguration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.SmoothToEncryptHlsConfig);
}
else
{
smoothToHlsConfiguration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.SmoothToHlsConfig);
}
ITask task = job.Tasks.AddNew("Smooth to Hls conversion task", mediaProcessor, smoothToHlsConfiguration, TaskOptions.None);
task.InputAssets.Add(sourceAsset);
task.OutputAssets.AddNew("JobOutput", options);
job.Submit();
job.GetExecutionProgressTask(CancellationToken.None).Wait();
job.Refresh();
return(job.OutputMediaAssets[0]);
}
static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
// For the AssetCreationOptions you can specify the following encryption options.
// None: no encryption. By default, storage encryption is used. If you want to
// create an unencrypted asset, you must set this option.
// StorageEncrypted: storage encryption. Encrypts a clear input file
// before it is uploaded to Azure storage.
// CommonEncryptionProtected: for Common Encryption Protected (CENC) files. An
// example is a set of files that are already PlayReady encrypted.
var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
var asset = CreateEmptyAsset(assetName, assetCreationOptions);
var fileName = Path.GetFileName(singleFilePath);
var assetFile = asset.AssetFiles.Create(fileName);
Console.WriteLine("Created assetFile {0}", assetFile.Name);
var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
Console.WriteLine("Upload {0}", assetFile.Name);
assetFile.Upload(singleFilePath);
Console.WriteLine("Done uploading {0}", assetFile.Name);
locator.Delete();
accessPolicy.Delete();
return(asset);
}
private IAsset CreateAssetAndUploadSingleFile(string assetName, AssetCreationOptions options)
{
IAsset asset = null;
_log.Info("Entered Find File");
try
{
if (_context.Assets.Count() > 0)
{
_log.Info("Searching for asset");
//foreach (IAsset temp in _context.Assets)
//{
// logWriter.Info(temp.Name);
//}
asset = _context.Assets.Where(x => x.Name == assetName).First();
_log.Info("File available");
}
else
{
_log.Info("No files in Assets");
}
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
}
return(asset);
}
private IAsset CreateMbrMp4Asset(AssetCreationOptions options)
{
IMediaProcessor encoder = JobTests.GetEncoderMediaProcessor(_mediaContext);
IJob job = _mediaContext.Jobs.Create("Job for ValidateEffectiveEncryptionStatusOfMultiBitRateMP4");
ITask adpativeBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task",
encoder,
"H264 Adaptive Bitrate MP4 Set 720p",
TaskOptions.None);
// Specify the input Asset
IAsset asset = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.None);
adpativeBitrateTask.InputAssets.Add(asset);
// Add an output asset to contain the results of the job.
// This output is specified as AssetCreationOptions.None, which
// means the output asset is in the clear (unencrypted).
IAsset abrAsset = adpativeBitrateTask.OutputAssets.AddNew("Multibitrate MP4s", options);
job.Submit();
job.GetExecutionProgressTask(CancellationToken.None).Wait();
job.Refresh();
return(job.OutputMediaAssets[0]);
}
public static IAsset EncodeToAdaptiveBitrateMP4s(IAsset asset, AssetCreationOptions options)
{
// Prepare a job with a single task to transcode the specified asset
// into a multi-bitrate asset.
IJob job = _context.Jobs.CreateWithSingleTask(
MediaProcessorNames.AzureMediaEncoder,
MediaEncoderTaskPresetStrings.H264AdaptiveBitrateMP4Set720p,
asset,
"Adaptive Bitrate MP4",
options);
Console.WriteLine("Submitting transcoding job...");
// Submit the job and wait until it is completed.
job.Submit();
job = job.StartExecutionProgressTask(
j =>
{
Console.WriteLine("Job state: {0}", j.State);
Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress());
},
CancellationToken.None).Result;
Console.WriteLine("Transcoding job finished.");
IAsset outputAsset = job.OutputMediaAssets[0];
return outputAsset;
}
static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
/*
* if (!File.Exists(singleFilePath))
* {
* Console.WriteLine("File does not exist.");
* return null;
* }
*/
var _context = new CloudMediaContext("aamediaservice1", "uIux27Hig96nRLkGZEZcareBz0x5t2gPPA533riDgTo=");
var assetName = Path.GetFileNameWithoutExtension(singleFilePath);
IAsset inputAsset = _context.Assets.Create(assetName, assetCreationOptions);
var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(singleFilePath));
Console.WriteLine("Created assetFile {0}", assetFile.Name);
var policy = _context.AccessPolicies.Create(
assetName,
TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = _context.Locators.CreateLocator(LocatorType.Sas, inputAsset, policy);
Console.WriteLine("Upload {0}", assetFile.Name);
assetFile.Upload(singleFilePath);
Console.WriteLine("Done uploading {0}", assetFile.Name);
locator.Delete();
policy.Delete();
return(inputAsset);
}
public static IAsset EncodeToAdaptiveBitrateMP4s(IAsset asset, AssetCreationOptions assetCreationOptions)
{
if (_context == null)
{
InitContext();
}
IJob job = _context.Jobs.Create(asset.Name + "-MES_H264_Multiple_Bitrate_720p");
//get the standard media processor
var processor = _context.MediaProcessors.Where(p => p.Name == "Media Encoder Standard").ToList().OrderBy(p => new Version(p.Version)).LastOrDefault();
ITask task = job.Tasks.AddNew("My encoding task",
processor,
"H264 Multiple Bitrate 720p",
TaskOptions.None);
task.InputAssets.Add(asset);
task.OutputAssets.AddNew(GetEncodedAssetNameByAssetName(asset.Name), AssetCreationOptions.None);
job.Submit();
job.GetExecutionProgressTask(System.Threading.CancellationToken.None).Wait();
return(job.OutputMediaAssets[0]);
}
static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
var asset = CreateEmptyAsset(assetName, assetCreationOptions);
var fileName = Path.GetFileName(singleFilePath);
var assetFile = asset.AssetFiles.Create(fileName);
Console.WriteLine("Created assetFile {0}", assetFile.Name);
var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
Console.WriteLine("Upload {0}", assetFile.Name);
assetFile.Upload(singleFilePath);
Console.WriteLine("Done uploading {0}", assetFile.Name);
locator.Delete();
accessPolicy.Delete();
return(asset);
}
public void t()
{
var context = new CloudMediaContext("medulawmedia", "H9jZUXCx7zX0Jihemd4yoSDZ6XWFKiIfpCGOQiOXzIQ=");
// The local path to the file to upload to the new asset.
string filePath = @"D:\DNN\Helium5\DesktopModules\MVC\purplecs\DNNGameBoard\video\17_Augmentation Mammoplasty.mp4";
var assetName = Path.GetFileName(filePath);
// The options for creating the new asset.
AssetCreationOptions assetCreationOptions = AssetCreationOptions.None;
// Create a new asset and upload a local file using a single extension method.
IAsset asset = context.Assets.Create(assetName, assetCreationOptions);
var assetFile = asset.AssetFiles.Create(assetName);
assetFile.IsPrimary = true;
var storeage = asset.StorageAccountName;
var policy = context.AccessPolicies.Create(
assetName,
TimeSpan.FromDays(30000),
AccessPermissions.List | AccessPermissions.Read);
var locator = context.Locators.CreateLocator(LocatorType.Sas, asset, policy);
var rul = asset.Uri;
assetFile.Upload(filePath);
Console.WriteLine("Done uploading {0}", assetFile.Name);
var url = locator.BaseUri + assetName + locator.ContentAccessComponent;
locator.Delete();
policy.Delete();
}
public static IAsset CreateAssetAndUploadSingleFile(string singleFilePath, AssetCreationOptions assetCreationOptions)
{
if (!File.Exists(singleFilePath))
{
return(null);
}
//Get original File Name
var assetName = Path.GetFileNameWithoutExtension(singleFilePath);
//Format file name with adding timestamp
string uniqueAssetName = GetTimeStamp.ToString(assetName);
if (_context == null)
{
InitContext();
}
IAsset inputAsset = null;
try
{
inputAsset = _context.Assets.Create(uniqueAssetName, assetCreationOptions);
// add asset files to this asset
var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(singleFilePath));
assetFile.Upload(singleFilePath);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(inputAsset);
}
static public IAsset UploadAssetFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
//Create Asset
var assetName = Path.GetFileName(singleFilePath) + "_UTC " + DateTime.UtcNow.ToString();
var asset = CreateEmptyAsset(assetName, assetCreationOptions);
//Create Asset File
var fileName = Path.GetFileName(singleFilePath);
var assetFile = asset.AssetFiles.Create(fileName);
Console.WriteLine("\tCreated assetFile {0}", assetFile.Name);
//Create Access Policy
var accessPolicy = context.AccessPolicies.Create(assetName, TimeSpan.FromDays(3), AccessPermissions.Write | AccessPermissions.List);
//Create Locator
var locator = context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
//Upload AssetFile
Console.WriteLine("\tUploading {0}...", assetFile.Name);
assetFile.Upload(singleFilePath);
Console.WriteLine("\t\tDone");
//CLeanup
locator.Delete();
accessPolicy.Delete();
return(asset);
}
static public IAsset EncodeToAudioOnly(IAsset asset, AssetCreationOptions options)
{
// Load the XML (or JSON) from the local file.
string configuration = File.ReadAllText(Path.Combine(_presetFiles, @"AudioOnlyPreset_JSON.json"));
IJob job = _context.Jobs.CreateWithSingleTask(
"Media Encoder Standard",
configuration,
asset,
"Audio only",
options);
Console.WriteLine("Submitting transcoding job...");
// Submit the job and wait until it is completed.
job.Submit();
job = job.StartExecutionProgressTask(
j =>
{
Console.WriteLine("Job state: {0}", j.State);
Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress());
},
CancellationToken.None).Result;
Console.WriteLine("Transcoding job finished.");
IAsset outputAsset = job.OutputMediaAssets[0];
return(outputAsset);
}
static public IAsset EncodeToAdaptiveBitrateMP4s(IAsset asset, AssetCreationOptions options)
{
// Prepare a job with a single task to transcode the specified asset
// into a multi-bitrate asset.
IJob job = _context.Jobs.CreateWithSingleTask(
"Media Encoder Standard",
"Adaptive Streaming",
asset,
"Adaptive Bitrate MP4",
options);
Debug.Write("Submitting transcoding job...");
// Submit the job and wait until it is completed.
job.Submit();
job = job.StartExecutionProgressTask(
j =>
{
Debug.Write($"Job state: {j.State}");
Debug.Write($"Job progress: 0:0.{j.GetOverallProgress()}");
},
CancellationToken.None).Result;
Debug.Write("Transcoding job finished.");
IAsset outputAsset = job.OutputMediaAssets[0];
return(outputAsset);
}
public static IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
var asset = CreateEmptyAsset(assetName, assetCreationOptions);
var fileName = Path.GetFileName(singleFilePath);
var assetFile = asset.AssetFiles.Create(fileName);
Console.WriteLine("Created assetFile {0}", assetFile.Name);
var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
Console.WriteLine("Upload {0}", assetFile.Name);
assetFile.Upload(singleFilePath);
Console.WriteLine("Done uploading {0}", assetFile.Name);
locator.Delete();
accessPolicy.Delete();
return asset;
}
static private IAsset CreateEmptyAsset(string assetName, AssetCreationOptions assetCreationOptions)
{
var asset = context.Assets.Create(assetName, assetCreationOptions);
Console.WriteLine("Asset name: " + asset.Name);
Console.WriteLine("Time cerated: " + asset.Created.Date.ToString());
return(asset);
}
/// <summary>
/// Adds the new output asset.
/// </summary>
/// <param name="assetName">The asset name.</param>
/// <param name="options">The options.</param>
/// <returns>The new asset.</returns>
public IAsset AddNew(string assetName, AssetCreationOptions options)
{
if (this._cloudMediaContext.DefaultStorageAccount == null)
{
throw new InvalidOperationException(StringTable.DefaultStorageAccountIsNull);
}
return(this.AddNew(assetName, _cloudMediaContext.DefaultStorageAccount.Name, options));
}
/// <summary>
/// Creates an asset that does not contain any files and <see cref="AssetState"/> is Initialized.
/// </summary>
/// <param name="assetName">The asset name.</param>
/// <param name="options">A <see cref="AssetCreationOptions"/> which will be associated with created asset.</param>
/// <returns>The created asset.</returns>
public override IAsset Create(string assetName, AssetCreationOptions options)
{
IStorageAccount defaultStorageAccount = this.MediaContext.DefaultStorageAccount;
if (defaultStorageAccount == null)
{
throw new InvalidOperationException(StringTable.DefaultStorageAccountIsNull);
}
return this.Create(assetName, defaultStorageAccount.Name, options);
}
static private IAsset CreateEmptyAsset(string assetName, AssetCreationOptions assetCreationOptions)
{
var asset = _context.Assets.Create(assetName, assetCreationOptions);
Console.WriteLine("Asset name: " + asset.Name);
Console.WriteLine("Time created: " + asset.Created.Date.ToString());
return asset;
}
/// <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);
if (!File.Exists(filePath))
{
throw new FileNotFoundException(String.Format(CultureInfo.InvariantCulture, StringTable.BulkIngestProvidedFileDoesNotExist, filePath));
}
FileInfo info = new FileInfo(filePath);
DataServiceContext dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext();
// Set a MIME type based on the extension of the file name
string mimeType = AssetFileData.GetMimeType(filePath);
IngestManifestFileData data = new IngestManifestFileData
{
Name = info.Name,
MimeType = mimeType,
ParentIngestManifestId = ingestManifestAsset.ParentIngestManifestId,
ParentIngestManifestAssetId = ingestManifestAsset.Id,
Path = filePath,
};
SetEncryptionSettings(ingestManifestAsset, info, options, data);
dataContext.AddObject(EntitySet, data);
Task <IIngestManifestFile> task = dataContext.SaveChangesAsync(data).ContinueWith <IIngestManifestFile>(t =>
{
t.ThrowIfFaulted();
token.ThrowIfCancellationRequested();
IngestManifestFileData ingestManifestFile = (IngestManifestFileData)t.AsyncState;
return(ingestManifestFile);
});
return(task.Result);
});
rootTask.Start();
return(rootTask);
}
private IAsset GetTestAsset(AssetCreationOptions options, AssetType assetType, AssetDeliveryProtocol protocol, AssetDeliveryPolicyType deliveryType)
{
IAsset asset = _mediaContext.Assets.Create("Test", options);
AddTestAssetFiles(asset, assetType);
AddTestDeliveryPolicies(asset, protocol, deliveryType);
return(asset);
}
/// <summary>
/// Creates an asset that does not contain any files and <see cref="AssetState"/> is Initialized.
/// </summary>
/// <param name="assetName">The asset name.</param>
/// <param name="options">A <see cref="AssetCreationOptions"/> which will be associated with created asset.</param>
/// <returns>The created asset.</returns>
public override IAsset Create(string assetName, AssetCreationOptions options)
{
IStorageAccount defaultStorageAccount = this.MediaContext.DefaultStorageAccount;
if (defaultStorageAccount == null)
{
throw new InvalidOperationException(StringTable.DefaultStorageAccountIsNull);
}
return(this.Create(assetName, defaultStorageAccount.Name, options));
}
/// <summary>
/// Asynchronously creates an asset that does not contain any files and <see cref="AssetState"/> is Initialized.
/// </summary>
/// <param name="assetName">The asset 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"/>created according to the specified creation <paramref name="options"/>.
/// </returns>
public override Task <IAsset> CreateAsync(string assetName, AssetCreationOptions options, CancellationToken cancellationToken)
{
IStorageAccount defaultStorageAccount = this.MediaContext.DefaultStorageAccount;
if (defaultStorageAccount == null)
{
throw new InvalidOperationException(StringTable.DefaultStorageAccountIsNull);
}
return(this.CreateAsync(assetName, defaultStorageAccount.Name, options, cancellationToken));
}
/// <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);
}
private IAsset UploadFile(string fileName, AssetCreationOptions options)
{
IAsset inputAsset = _context.Assets.CreateFromFile(
fileName,
options,
(af, p) =>
{
});
return(inputAsset);
}
public static void UploadByBlock(string manifestName, AssetCreationOptions options, string[] files)
{
CloudMediaContext context = CloudContextHelper.GetContext();
IIngestManifest manifest = context.IngestManifests.Create(manifestName);
IAsset asset = context.Assets.Create(manifestName + "_Asset", options);
IIngestManifestAsset bulkAsset = manifest.IngestManifestAssets.Create(asset, files);
UploadBlobFile(manifest.BlobStorageUriForUpload, files);
MonitorBulkManifest(manifest.Id);
}
/// <summary>
/// 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"></param>
/// <param name="options">A <see cref="AssetCreationOptions" /> which will be associated with created asset.</param>
/// <returns>
/// The created asset.
/// </returns>
public override IAsset Create(string assetName, string storageAccountName, AssetCreationOptions options)
{
try
{
Task <IAsset> task = this.CreateAsync(assetName, storageAccountName, options, CancellationToken.None);
task.Wait();
return(task.Result);
}
catch (AggregateException exception)
{
throw exception.InnerException;
}
}
public async Task <IAsset> CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string mediaTitle, string fileName, Stream mediaStream, CancellationToken token)
{
var inputAsset = await _cloudMediaContext.Assets.CreateAsync(mediaTitle, assetCreationOptions, token).ConfigureAwait(false);
var assetFile = await inputAsset.AssetFiles.CreateAsync(fileName, token).ConfigureAwait(false);
return(await Task.Run(() =>
{
assetFile.Upload(mediaStream);
return inputAsset;
}).ConfigureAwait(false));
}
static public IAsset CreateAssetAndUploadMultipleFiles(AssetCreationOptions assetCreationOptions, string folderPath)
{
CloudMediaContext _context = CloudContextHelper.GetContext();
var assetName = "UploadMultipleFiles_" + DateTime.UtcNow.ToString();
IAsset asset = _context.Assets.Create(assetName, assetCreationOptions);
var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
var blobTransferClient = new BlobTransferClient();
blobTransferClient.NumberOfConcurrentTransfers = 20;
blobTransferClient.ParallelTransferThreadCount = 20;
blobTransferClient.TransferProgressChanged += blobTransferClient_TransferProgressChanged;
var filePaths = Directory.EnumerateFiles(folderPath);
Console.WriteLine("There are {0} files in {1}", filePaths.Count(), folderPath);
if (!filePaths.Any())
{
throw new FileNotFoundException(String.Format("No files in directory, check folderPath: {0}", folderPath));
}
var uploadTasks = new List <Task>();
foreach (var filePath in filePaths)
{
var assetFile = asset.AssetFiles.Create(Path.GetFileName(filePath));
Console.WriteLine("Created assetFile {0}", assetFile.Name);
// It is recommended to validate AccestFiles before upload.
Console.WriteLine("Start uploading of {0}", assetFile.Name);
uploadTasks.Add(assetFile.UploadAsync(filePath, blobTransferClient, locator, CancellationToken.None));
}
Task.WaitAll(uploadTasks.ToArray());
Console.WriteLine("Done uploading the files");
blobTransferClient.TransferProgressChanged -= blobTransferClient_TransferProgressChanged;
locator.Delete();
accessPolicy.Delete();
return(asset);
}
static public IAsset UploadFile(string fileName, AssetCreationOptions options)
{
IAsset inputAsset = _context.Assets.CreateFromFile(
fileName,
options,
(af, p) =>
{
Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
Console.WriteLine("Asset {0} created.", inputAsset.Id);
return(inputAsset);
}
static public IAsset UploadFile(string fileName, AssetCreationOptions options)
{
IAsset inputAsset = _context.Assets.CreateFromFile(
fileName,
options,
(af, p) =>
{
Debug.Write($"Uploading {af.Name} - Progress: 1:0.{p.Progress}%");
});
Debug.Write("Asset {0} created.", inputAsset.Id);
return(inputAsset);
}
/// <summary>
/// Uploads a single file.
/// </summary>
/// <param name="fileDir">The location of the files.</param>
/// <param name="assetCreationOptions">
/// You can specify the following encryption options for the AssetCreationOptions.
/// None: no encryption.
/// StorageEncrypted: storage encryption. Encrypts a clear input file
/// before it is uploaded to Azure storage.
/// CommonEncryptionProtected: for Common Encryption Protected (CENC) files.
/// For example, a set of files that are already PlayReady encrypted.
/// EnvelopeEncryptionProtected: for HLS with AES encryption files.
/// NOTE: The files must have been encoded and encrypted by Transform Manager.
/// </param>
/// <returns>Returns an asset that contains a single file.</returns>
/// </summary>
/// <returns></returns>
private static IAsset IngestSingleMP4File(string fileDir, AssetCreationOptions assetCreationOptions)
{
// Use the SDK extension method to create a new asset by
// uploading a mezzanine file from a local path.
IAsset asset = _context.Assets.CreateFromFile(
fileDir,
assetCreationOptions,
(af, p) =>
{
Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
return(asset);
}
/// <summary>
/// Returns a new empty <see cref="IAsset"/> within one selected storage account from <paramref name="storageAccountNames"/> based on the default <see cref="IAccountSelectionStrategy"/>.
/// </summary>
/// <param name="assets">The <see cref="AssetBaseCollection"/> instance.</param>
/// <param name="assetName">The asset name.</param>
/// <param name="strategy">The <see cref="IAccountSelectionStrategy"/> used to select a storage account for the new output asset.</param>
/// <param name="options">The <see cref="AssetCreationOptions"/>.</param>
/// <returns>A new empty <see cref="IAsset"/> within one selected storage account from the provided <see cref="IAccountSelectionStrategy"/>.</returns>
public static IAsset AddNew(this OutputAssetCollection collection, string assetName, IAccountSelectionStrategy strategy, AssetCreationOptions options)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (strategy == null)
{
throw new ArgumentNullException("strategy");
}
string storageAccount = strategy.SelectAccountForAsset();
return collection.AddNew(assetName, storageAccount, options);
}
/// <summary>
/// Returns a <see cref="System.Threading.Tasks.Task<IAsset>"/> instance for a new empty <see cref="IAsset"/> asset within one selected storage account from <paramref name="storageAccountNames"/> based on the default <see cref="IAccountSelectionStrategy"/>.
/// </summary>
/// <param name="assets">The <see cref="AssetBaseCollection"/> instance.</param>
/// <param name="assetName">The asset name.</param>
/// <param name="strategy">The <see cref="IAccountSelectionStrategy"/> used to select a storage account for the new asset.</param>
/// <param name="options">The <see cref="AssetCreationOptions"/>.</param>
/// <param name="token">The <see cref="System.Threading.CancellationToken"/> instance used for cancellation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task<IAsset>"/> instance for a new empty <see cref="IAsset"/> within one selected storage account from the given <see cref="IAccountSelectionStrategy"/>.</returns>
public static Task<IAsset> CreateAsync(this AssetBaseCollection assets, string assetName, IAccountSelectionStrategy strategy, AssetCreationOptions options, CancellationToken token)
{
if (assets == null)
{
throw new ArgumentNullException("assets");
}
if (strategy == null)
{
throw new ArgumentNullException("strategy");
}
string storageAccountName = strategy.SelectAccountForAsset();
return assets.CreateAsync(assetName, storageAccountName, options, token);
}
/// <summary>
/// Returns a new empty <see cref="IAsset"/> within one selected storage account from <paramref name="storageAccountNames"/> based on the default <see cref="IAccountSelectionStrategy"/>.
/// </summary>
/// <param name="assets">The <see cref="AssetBaseCollection"/> instance.</param>
/// <param name="assetName">The asset name.</param>
/// <param name="strategy">The <see cref="IAccountSelectionStrategy"/> used to select a storage account for the new asset.</param>
/// <param name="options">The <see cref="AssetCreationOptions"/>.</param>
/// <returns>A new empty <see cref="IAsset"/> within one selected storage account from the provided <see cref="IAccountSelectionStrategy"/>.</returns>
public static IAsset Create(this AssetBaseCollection assets, string assetName, IAccountSelectionStrategy strategy, AssetCreationOptions options)
{
if (assets == null)
{
throw new ArgumentNullException("assets");
}
if (strategy == null)
{
throw new ArgumentNullException("strategy");
}
string storageAccountName = strategy.SelectAccountForAsset();
return assets.Create(assetName, storageAccountName, options);
}
public static IAsset CreateAssetAndUploadMultipleFiles(this CloudMediaContext cloudMediaContext, AssetCreationOptions assetCreationOptions, string folderPath)
{
var assetName = "UploadMultipleFiles_" + DateTime.UtcNow.ToString();
var asset = cloudMediaContext.CreateEmptyAsset(assetName, assetCreationOptions);
var accessPolicy = cloudMediaContext.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
var locator = cloudMediaContext.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
var blobTransferClient = new BlobTransferClient();
blobTransferClient.NumberOfConcurrentTransfers = 20;
blobTransferClient.ParallelTransferThreadCount = 20;
blobTransferClient.TransferProgressChanged += blobTransferClient_TransferProgressChanged;
var filePaths = Directory.EnumerateFiles(folderPath);
Console.WriteLine("There are {0} files in {1}", filePaths.Count(), folderPath);
if (!filePaths.Any())
{
throw new FileNotFoundException(String.Format("No files in directory, check folderPath: {0}", folderPath));
}
var uploadTasks = new List<Task>();
foreach (var filePath in filePaths)
{
var assetFile = asset.AssetFiles.Create(Path.GetFileName(filePath));
Console.WriteLine("Created assetFile {0}", assetFile.Name);
// It is recommended to validate AccestFiles before upload.
Console.WriteLine("Start uploading of {0}", assetFile.Name);
uploadTasks.Add(assetFile.UploadAsync(filePath, blobTransferClient, locator, CancellationToken.None));
}
Task.WaitAll(uploadTasks.ToArray());
Console.WriteLine("Done uploading the files");
blobTransferClient.TransferProgressChanged -= blobTransferClient_TransferProgressChanged;
locator.Delete();
accessPolicy.Delete();
return asset;
}
public static IAsset CreateAsset(CloudMediaContext datacontext, string filePath, AssetCreationOptions options)
{
IAsset asset = datacontext.Assets.Create(Guid.NewGuid().ToString(), options);
IAccessPolicy policy = datacontext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = datacontext.Locators.CreateSasLocator(asset, policy);
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
BlobTransferClient blobTransferClient = datacontext.MediaServicesClassFactory.GetBlobTransferClient();
blobTransferClient.NumberOfConcurrentTransfers = 5;
blobTransferClient.ParallelTransferThreadCount = 5;
file.UploadAsync(filePath,
blobTransferClient,
locator,
CancellationToken.None).Wait();
file.IsPrimary = true;
file.Update();
return asset;
}
/// <summary>
/// Returns a <see cref="IJob"/> instance with a single <see cref="ITask"/> ready to be submitted.
/// </summary>
/// <param name="jobs">The <see cref="JobBaseCollection"/> instance.</param>
/// <param name="mediaProcessorName">The name of the media processor.</param>
/// <param name="taskConfiguration">The task configuration.</param>
/// <param name="inputAsset">The input <see cref="IAsset"/> instance.</param>
/// <param name="outputAssetName">The name of the output asset.</param>
/// <param name="outputAssetStorageAccountName">The name of the Storage Account where to store the output asset.</param>
/// <param name="outputAssetOptions">The <see cref="AssetCreationOptions"/> of the output asset.</param>
/// <returns>A <see cref="IJob"/> instance with a single <see cref="ITask"/> ready to be submitted.</returns>
public static IJob CreateWithSingleTask(this JobBaseCollection jobs, string mediaProcessorName, string taskConfiguration, IAsset inputAsset, string outputAssetName, string outputAssetStorageAccountName, AssetCreationOptions outputAssetOptions)
{
if (jobs == null)
{
throw new ArgumentNullException("jobs", "The jobs collection cannot be null.");
}
if (inputAsset == null)
{
throw new ArgumentNullException("inputAsset", "The input asset cannot be null.");
}
MediaContextBase context = jobs.MediaContext;
IMediaProcessor processor = context.MediaProcessors.GetLatestMediaProcessorByName(mediaProcessorName);
if (processor == null)
{
throw new ArgumentException(
string.Format(CultureInfo.InvariantCulture, "Unknown media processor: '{0}'", mediaProcessorName), "mediaProcessorName");
}
IJob job = jobs.Create(string.Format(CultureInfo.InvariantCulture, "Job for {0}", inputAsset.Name));
ITask task = job.Tasks.AddNew(
string.Format(CultureInfo.InvariantCulture, "Task for {0}", inputAsset.Name),
processor,
taskConfiguration,
TaskOptions.ProtectedConfiguration);
task.InputAssets.Add(inputAsset);
if (string.IsNullOrWhiteSpace(outputAssetStorageAccountName))
{
outputAssetStorageAccountName = context.DefaultStorageAccount.Name;
}
task.OutputAssets.AddNew(outputAssetName, outputAssetStorageAccountName, outputAssetOptions);
return job;
}
/// <summary>
/// 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"></param>
/// <param name="options">A <see cref="AssetCreationOptions" /> which will be associated with created asset.</param>
/// <returns>
/// The created asset.
/// </returns>
public override IAsset Create(string assetName, string storageAccountName, AssetCreationOptions options)
{
try
{
Task<IAsset> task = this.CreateAsync(assetName,storageAccountName, options, CancellationToken.None);
task.Wait();
return task.Result;
}
catch (AggregateException exception)
{
throw exception.InnerException;
}
}
/// <summary>
/// Creates an asset that does not contain any files and <see cref="AssetState"/> is Initialized.
/// </summary>
/// <param name="assetName">The asset name.</param>
/// <param name="options">A <see cref="AssetCreationOptions"/> which will be associated with created asset.</param>
/// <returns>The created asset.</returns>
public override IAsset Create(string assetName, AssetCreationOptions options)
{
return this.Create(assetName, this.MediaContext.DefaultStorageAccount.Name, options);
}
/// <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
};
cancellationToken.ThrowIfCancellationRequested();
IMediaDataServiceContext dataContext = this.MediaContext.MediaServicesClassFactory.CreateDataServiceContext();
dataContext.AddObject(AssetSet, (IAsset)emptyAsset);
MediaRetryPolicy retryPolicy = this.MediaContext.MediaServicesClassFactory.GetSaveChangesRetryPolicy();
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;
});
}
/// <summary>
/// Asynchronously creates an asset that does not contain any files and <see cref="AssetState"/> is Initialized.
/// </summary>
/// <param name="assetName">The asset 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"/>created according to the specified creation <paramref name="options"/>.
/// </returns>
public override Task<IAsset> CreateAsync(string assetName, AssetCreationOptions options,CancellationToken cancellationToken)
{
return this.CreateAsync(assetName, this.MediaContext.DefaultStorageAccount.Name, options, cancellationToken);
}
private async Task ProcessUploadFileAndMore(object name, int index, AssetCreationOptions assetcreationoptions, WatchFolderSettings watchfoldersettings = null, string storageaccount = null)
{
// If upload in the queue, let's wait our turn
DoGridTransferWaitIfNeeded(index);
if (storageaccount == null) storageaccount = _context.DefaultStorageAccount.Name; // no storage account or null, then let's take the default one
TextBoxLogWriteLine("Starting upload of file '{0}'", name);
bool Error = false;
IAsset asset = null;
try
{
asset = _context.Assets.CreateFromFile(
name as string,
storageaccount,
assetcreationoptions,
(af, p) =>
{
DoGridTransferUpdateProgress(p.Progress, index);
}
);
AssetInfo.SetFileAsPrimary(asset, Path.GetFileName(name as string));
}
catch (Exception e)
{
Error = true;
DoGridTransferDeclareError(index, e);
TextBoxLogWriteLine("Error when uploading '{0}'", name, true);
TextBoxLogWriteLine(e);
if (watchfoldersettings != null && watchfoldersettings.SendEmailToRecipient != null)
{
Program.CreateAndSendOutlookMail(watchfoldersettings.SendEmailToRecipient, "Explorer Watchfolder: upload error " + name, e.Message);
}
}
if (!Error)
{
DoGridTransferDeclareCompleted(index, asset.Id);
if (watchfoldersettings != null && watchfoldersettings.DeleteFile) //user checked the box "delete the file"
{
try
{
File.Delete(name as string);
TextBoxLogWriteLine("File '{0}' deleted.", name);
}
catch (Exception e)
{
TextBoxLogWriteLine("Error when deleting '{0}'", name, true);
if (watchfoldersettings.SendEmailToRecipient != null) Program.CreateAndSendOutlookMail(watchfoldersettings.SendEmailToRecipient, "Explorer Watchfolder: Error when deleting " + asset.Name, e.Message);
}
}
if (watchfoldersettings != null && watchfoldersettings.JobTemplate != null) // option with watchfolder to run a job based on a job template
{
string jobname = string.Format("Processing of {0} with template {1}", asset.Name, watchfoldersettings.JobTemplate.Name);
List<IAsset> assetlist = new List<IAsset>() { asset };
// if user wants to insert a workflow or other asstes as asset #0
if (watchfoldersettings.TypeInputExtraInput != TypeInputExtraInput.None)
{
if (watchfoldersettings.ExtraInputAssets != null) assetlist.InsertRange(0, watchfoldersettings.ExtraInputAssets);
}
TextBoxLogWriteLine(string.Format("Submitting job '{0}'", jobname));
// Submit the job
IJob job = _context.Jobs.Create(jobname, watchfoldersettings.JobTemplate, assetlist, Properties.Settings.Default.DefaultJobPriority);
try
{
job.Submit();
}
catch (Exception e)
{
// Add useful information to the exception
TextBoxLogWriteLine("There has been a problem when submitting the job '{0}'", job.Name, true);
TextBoxLogWriteLine(e);
if (watchfoldersettings.SendEmailToRecipient != null)
{
Program.CreateAndSendOutlookMail(watchfoldersettings.SendEmailToRecipient, "Explorer Watchfolder: Error when submitting job for asset " + asset.Name, e.Message);
}
return;
}
DoRefreshGridJobV(false);
IJob myjob = GetJob(job.Id);
while (myjob.State == JobState.Processing || myjob.State == JobState.Queued || myjob.State == JobState.Scheduled)
{
System.Threading.Thread.Sleep(1000);
myjob = GetJob(job.Id);
}
if (myjob.State == JobState.Finished)
{
// job template does not rename the output assets. As a fix, we do this:
int taskind = 1;
foreach (var task in myjob.Tasks)
{
int outputind = 1;
foreach (var outputasset in task.OutputAssets)
{
IAsset oasset = AssetInfo.GetAsset(outputasset.Id, _context);
try
{
oasset.Name = string.Format("{0} processed with {1}", asset.Name, watchfoldersettings.JobTemplate.Name);
if (myjob.Tasks.Count > 1)
{
oasset.Name += string.Format(" - task {0}", taskind);
}
if (task.OutputAssets.Count > 1)
{
oasset.Name += string.Format(" - output asset {0}", outputind);
}
oasset.Update();
TextBoxLogWriteLine("Output asset {0} renamed.", oasset.Name);
}
catch (Exception e)
{
TextBoxLogWriteLine("Error when renaming an output asset", true);
TextBoxLogWriteLine(e);
}
outputind++;
}
taskind++;
}
if (watchfoldersettings.PublishOutputAssets) //user wants to publish the output asset when it has been processed by the job
{
IAccessPolicy policy = _context.AccessPolicies.Create("AP:" + myjob.Name, TimeSpan.FromDays(Properties.Settings.Default.DefaultLocatorDurationDaysNew), AccessPermissions.Read);
foreach (var oasset in myjob.OutputMediaAssets)
{
ILocator MyLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, oasset, policy, null);
if (watchfoldersettings.SendEmailToRecipient != null)
{
IStreamingEndpoint SelectedSE = AssetInfo.GetBestStreamingEndpoint(_context);
StringBuilder sb = new StringBuilder();
Uri SmoothUri = MyLocator.GetSmoothStreamingUri();
if (SmoothUri != null)
{
string playbackurl = AssetInfo.DoPlayBackWithStreamingEndpoint(PlayerType.AzureMediaPlayer, SmoothUri.AbsoluteUri, _context, this, oasset, launchbrowser: false, UISelectSEFiltersAndProtocols: false);
sb.AppendLine("Link to playback the asset:");
sb.AppendLine(playbackurl);
sb.AppendLine();
}
sb.Append(AssetInfo.GetStat(oasset, SelectedSE));
Program.CreateAndSendOutlookMail(watchfoldersettings.SendEmailToRecipient, "Explorer Watchfolder: Output asset published for asset " + asset.Name, sb.ToString());
}
}
}
else // no publication
{
foreach (var oasset in myjob.OutputMediaAssets)
{
if (watchfoldersettings.SendEmailToRecipient != null)
{
StringBuilder sb = new StringBuilder();
sb.Append(AssetInfo.GetStat(oasset));
Program.CreateAndSendOutlookMail(watchfoldersettings.SendEmailToRecipient, "Explorer Watchfolder: asset uploaded and processed " + asset.Name, sb.ToString());
}
}
}
}
else // not completed successfuly
{
if (watchfoldersettings.SendEmailToRecipient != null)
{
StringBuilder sb = new StringBuilder();
sb.Append((new JobInfo(job).GetStats()));
Program.CreateAndSendOutlookMail(watchfoldersettings.SendEmailToRecipient, "Explorer Watchfolder: job " + job.State.ToString() + " for asset " + asset.Name, sb.ToString());
}
}
}
else // user selected no processing. Upload successfull
{
if (watchfoldersettings != null && watchfoldersettings.SendEmailToRecipient != null)
{
StringBuilder sb = new StringBuilder();
sb.Append(AssetInfo.GetStat(asset));
Program.CreateAndSendOutlookMail(watchfoldersettings.SendEmailToRecipient, "Explorer Watchfolder: upload successful " + asset.Name, sb.ToString());
}
}
}
DoRefreshGridAssetV(false);
}
private void CreateEncryptUpdateDelete(AssetCreationOptions assetCreationOptions)
{
var manifest = _mediaContext.IngestManifests.Create(Guid.NewGuid().ToString(), _mediaContext.DefaultStorageAccount.Name);
Assert.IsNotNull(manifest);
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), assetCreationOptions);
string tempFileName = Path.GetTempFileName();
try
{
var ingestManifestAsset = manifest.IngestManifestAssets.Create(asset, new[] {tempFileName});
Assert.IsNotNull(ingestManifestAsset);
Assert.IsNotNull(ingestManifestAsset.IngestManifestFiles);
Assert.IsNotNull(ingestManifestAsset.Asset);
Assert.AreEqual(1, ingestManifestAsset.IngestManifestFiles.Count());
var assetfile = ingestManifestAsset.IngestManifestFiles.FirstOrDefault();
Assert.IsFalse(string.IsNullOrEmpty(assetfile.Name));
Assert.AreEqual(IngestManifestFileState.Pending, assetfile.State);
var output = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()));
try
{
Assert.AreEqual(0, output.GetFiles().Count(), "Expecting 0 files before manifest encryption");
File.WriteAllText(tempFileName, Guid.NewGuid().ToString());
manifest.EncryptFiles(output.FullName);
Assert.AreEqual(1, output.GetFiles().Count(), "Expecting 1 file after manifest encryption");
Assert.IsTrue(output.GetFiles().FirstOrDefault().Length > 0);
}
finally
{
output.Delete(true);
}
manifest.Name = Guid.NewGuid().ToString();
manifest.Update();
assetfile.Delete();
ingestManifestAsset.Delete();
manifest.Delete();
}
finally
{
File.Delete(tempFileName);
}
}
private IAsset GetTestAsset(AssetCreationOptions options, AssetType assetType, AssetDeliveryProtocol protocol, AssetDeliveryPolicyType deliveryType)
{
IAsset asset = _mediaContext.Assets.Create("Test", options);
AddTestAssetFiles(asset, assetType);
AddTestDeliveryPolicies(asset, protocol, deliveryType);
return asset;
}
private IAsset CreateMbrMp4Asset(AssetCreationOptions options)
{
IMediaProcessor encoder = JobTests.GetEncoderMediaProcessor(_mediaContext);
IJob job = _mediaContext.Jobs.Create("Job for ValidateEffectiveEncryptionStatusOfMultiBitRateMP4");
ITask adpativeBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task",
encoder,
"H264 Adaptive Bitrate MP4 Set 720p",
TaskOptions.None);
// Specify the input Asset
IAsset asset = AssetTests.CreateAsset(_mediaContext, WindowsAzureMediaServicesTestConfiguration.SmallMp41, AssetCreationOptions.None);
adpativeBitrateTask.InputAssets.Add(asset);
// Add an output asset to contain the results of the job.
// This output is specified as AssetCreationOptions.None, which
// means the output asset is in the clear (unencrypted).
IAsset abrAsset = adpativeBitrateTask.OutputAssets.AddNew("Multibitrate MP4s", options);
job.Submit();
job.GetExecutionProgressTask(CancellationToken.None).Wait();
job.Refresh();
return job.OutputMediaAssets[0];
}
/// <summary>
/// Asynchronously creates an asset that does not contain any files and <see cref="AssetState"/> is Initialized.
/// </summary>
/// <param name="assetName">The asset 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"/>created according to the specified creation <paramref name="options"/>.
/// </returns>
public override Task<IAsset> CreateAsync(string assetName, AssetCreationOptions options, CancellationToken cancellationToken)
{
IStorageAccount defaultStorageAccount = this.MediaContext.DefaultStorageAccount;
if (defaultStorageAccount == null)
{
throw new InvalidOperationException(StringTable.DefaultStorageAccountIsNull);
}
return this.CreateAsync(assetName, defaultStorageAccount.Name, options, cancellationToken);
}
private async Task ProcessUploadFromFolder(object folderPath, int index, AssetCreationOptions assetcreationoption, string storageaccount = null)
{
// If upload in the queue, let's wait our turn
DoGridTransferWaitIfNeeded(index);
if (storageaccount == null) storageaccount = _context.DefaultStorageAccount.Name; // no storage account or null, then let's take the default one
var filePaths = Directory.EnumerateFiles(folderPath as string);
TextBoxLogWriteLine("There are {0} files in {1}", filePaths.Count().ToString(), (folderPath as string));
if (!filePaths.Any())
{
throw new FileNotFoundException(String.Format("No files in directory, check folderPath: {0}", folderPath));
}
bool Error = false;
IAsset asset = null;
var progress = new Dictionary<string, double>(); // used to store progress of all files
filePaths.ToList().ForEach(f => progress[Path.GetFileName(f)] = 0d);
try
{
asset = _context.Assets.CreateFromFolder(
folderPath as string,
storageaccount,
assetcreationoption,
(af, p) =>
{
progress[af.Name] = p.Progress;
DoGridTransferUpdateProgress(progress.ToList().Average(l => l.Value), index);
}
);
//SetISMFileAsPrimary(asset); // no need as primary seems to be set by .CreateFromFolder
}
catch (Exception e)
{
Error = true;
DoGridTransferDeclareError(index, e);
TextBoxLogWriteLine("Error when uploading from {0}", folderPath, true);
}
if (!Error)
{
DoGridTransferDeclareCompleted(index, asset.Id);
}
DoRefreshGridAssetV(false);
}
/// <summary>
/// Returns a <see cref="IJob"/> instance with a single <see cref="ITask"/> ready to be submitted.
/// </summary>
/// <param name="jobs">The <see cref="JobBaseCollection"/> instance.</param>
/// <param name="mediaProcessorName">The name of the media processor.</param>
/// <param name="taskConfiguration">The task configuration.</param>
/// <param name="inputAsset">The input <see cref="IAsset"/> instance.</param>
/// <param name="strategy">The <see cref="IAccountSelectionStrategy"/> instance used to pick the output asset storage account.</param>
/// <param name="outputAssetName">The name of the output asset.</param>
/// <param name="outputAssetOptions">The <see cref="AssetCreationOptions"/> of the output asset.</param>
/// <returns>A <see cref="IJob"/> instance with a single <see cref="ITask"/> ready to be submitted.</returns>
public static IJob CreateWithSingleTask(this JobBaseCollection jobs, string mediaProcessorName, string taskConfiguration, IAsset inputAsset, IAccountSelectionStrategy strategy, string outputAssetName, AssetCreationOptions outputAssetOptions)
{
if (strategy == null)
{
throw new ArgumentNullException("strategy");
}
string outputAssetStorageAccount = strategy.SelectAccountForAsset();
return jobs.CreateWithSingleTask(mediaProcessorName, taskConfiguration, inputAsset, outputAssetName, outputAssetStorageAccount, outputAssetOptions);
}
/// <summary>
/// Uploads a single file.
/// </summary>
/// <param name="fileDir">The location of the files.</param>
/// <param name="assetCreationOptions">
/// You can specify the following encryption options for the AssetCreationOptions.
/// None: no encryption.
/// StorageEncrypted: storage encryption. Encrypts a clear input file
/// before it is uploaded to Azure storage.
/// CommonEncryptionProtected: for Common Encryption Protected (CENC) files.
/// For example, a set of files that are already PlayReady encrypted.
/// EnvelopeEncryptionProtected: for HLS with AES encryption files.
/// NOTE: The files must have been encoded and encrypted by Transform Manager.
/// </param>
/// <returns>Returns an asset that contains a single file.</returns>
/// </summary>
/// <returns></returns>
private static IAsset IngestSingleMP4File(string fileDir, AssetCreationOptions assetCreationOptions)
{
// Use the SDK extension method to create a new asset by
// uploading a mezzanine file from a local path.
IAsset asset = _context.Assets.CreateFromFile(
fileDir,
assetCreationOptions,
(af, p) =>
{
Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
});
return asset;
}
/// <summary>
/// Returns a <see cref="IJob"/> instance with a single <see cref="ITask"/> ready to be submitted.
/// </summary>
/// <param name="jobs">The <see cref="JobBaseCollection"/> instance.</param>
/// <param name="mediaProcessorName">The name of the media processor.</param>
/// <param name="taskConfiguration">The task configuration.</param>
/// <param name="inputAsset">The input <see cref="IAsset"/> instance.</param>
/// <param name="outputAssetName">The name of the output asset.</param>
/// <param name="outputAssetOptions">The <see cref="AssetCreationOptions"/> of the output asset.</param>
/// <returns>A <see cref="IJob"/> instance with a single <see cref="ITask"/> ready to be submitted.</returns>
public static IJob CreateWithSingleTask(this JobBaseCollection jobs, string mediaProcessorName, string taskConfiguration, IAsset inputAsset, string outputAssetName, AssetCreationOptions outputAssetOptions)
{
return jobs.CreateWithSingleTask(mediaProcessorName, taskConfiguration, inputAsset, outputAssetName, null, outputAssetOptions);
}
private void DoProcessCreateBulkIngestAndEncryptFiles(string IngestName, string IngestStorage, List<BulkUpload.BulkAsset> assetFiles, string assetStorage, AssetCreationOptions creationoption, string encryptToFolder, bool GenerateAzCopy, bool GenerateSigniant, List<string> SigniantServers, string SigniantAPIKey, bool GenerateAspera)
{
TextBoxLogWriteLine("Creating bulk ingest '{0}'...", IngestName);
IIngestManifest manifest = _context.IngestManifests.Create(IngestName, IngestStorage);
// Create the assets that will be associated with this bulk ingest manifest
foreach (var asset in assetFiles)
{
try
{
IAsset destAsset = _context.Assets.Create(asset.AssetName, assetStorage, creationoption);
IIngestManifestAsset bulkAsset = manifest.IngestManifestAssets.Create(destAsset, asset.AssetFiles);
}
catch (Exception ex)
{
TextBoxLogWriteLine("Bulk: Error when declaring asset '{0}'.", asset.AssetName, true);
TextBoxLogWriteLine(ex);
return;
}
}
TextBoxLogWriteLine("Bulk: {0} asset(s) / {1} file(s) declared for bulk ingest container '{2}'.", assetFiles.Count, manifest.Statistics.PendingFilesCount, manifest.Name);
// Encryption of files
bool Error = false;
if (creationoption == AssetCreationOptions.StorageEncrypted)
{
TextBoxLogWriteLine("Encryption of asset files for bulk upload...");
try
{
manifest.EncryptFilesAsync(encryptToFolder, CancellationToken.None).Wait();
TextBoxLogWriteLine("Encryption of asset files done to folder {0}.", encryptToFolder);
Process.Start(encryptToFolder);
}
catch
{
TextBoxLogWriteLine("Error when encrypting files to folder '{0}'.", encryptToFolder, true);
Error = true;
}
}
if (!Error)
{
TextBoxLogWriteLine("You can upload the file(s) to {0}", manifest.BlobStorageUriForUpload);
if (creationoption == AssetCreationOptions.StorageEncrypted)
{
TextBoxLogWriteLine("Encrypted files are in {0}", encryptToFolder);
}
if (GenerateAspera)
{
string commandline = GenerateAsperaUrl(manifest);
var form = new EditorXMLJSON("Aspera Ingest URL", commandline, false, false, false);
form.Display();
}
if (GenerateSigniant)
{
string commandline = GenerateSigniantCommandLine(manifest, assetFiles, creationoption == AssetCreationOptions.StorageEncrypted, encryptToFolder, SigniantServers, SigniantAPIKey);
var form = new EditorXMLJSON("Signiant Command Line", commandline, false, false, false);
form.Display();
}
if (GenerateAzCopy)
{
string commandline = GenerateAzCopyCommandLine(manifest, assetFiles, creationoption == AssetCreationOptions.StorageEncrypted, encryptToFolder);
var form = new EditorXMLJSON("AzCopy Command Line", commandline, false, false, false);
form.Display();
}
}
DoRefreshGridIngestManifestV(false);
}
public void LaunchJobs_OneJobPerInputAssetWithSpecificConfig(IMediaProcessor processor, List<IAsset> selectedassets, string jobname, int jobpriority, string taskname, string outputassetname, List<string> configuration, AssetCreationOptions myAssetCreationOptions, TaskOptions myTaskOptions, string storageaccountname = "")
{
// a job per asset, one task per job, but each task has a specific config
Task.Factory.StartNew(() =>
{
int index = -1;
foreach (IAsset asset in selectedassets)
{
index++;
string jobnameloc = jobname.Replace(Constants.NameconvInputasset, asset.Name);
IJob myJob = _context.Jobs.Create(jobnameloc, jobpriority);
string config = configuration[index];
string tasknameloc = taskname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config);
ITask myTask = myJob.Tasks.AddNew(
tasknameloc,
processor,
config,
myTaskOptions);
myTask.InputAssets.Add(asset);
// Add an output asset to contain the results of the task
string outputassetnameloc = outputassetname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config);
if (storageaccountname == "")
{
myTask.OutputAssets.AddNew(outputassetnameloc, asset.StorageAccountName, myAssetCreationOptions); // let's use the same storage account than the input asset
}
else
{
myTask.OutputAssets.AddNew(outputassetnameloc, storageaccountname, myAssetCreationOptions);
}
// Submit the job and wait until it is completed.
bool Error = false;
try
{
TextBoxLogWriteLine("Job '{0}' : submitting...", jobnameloc);
myJob.Submit();
}
catch (Exception ex)
{
// Add useful information to the exception
TextBoxLogWriteLine("Job '{0}' : problem", jobnameloc, true);
TextBoxLogWriteLine(ex);
Error = true;
}
if (!Error)
{
TextBoxLogWriteLine("Job '{0}' : submitted.", jobnameloc);
Task.Factory.StartNew(() => dataGridViewJobsV.DoJobProgress(myJob));
}
TextBoxLogWriteLine();
}
DotabControlMainSwitch(Constants.TabJobs);
DoRefreshGridJobV(false);
}
);
}
internal static IAsset CreateSmoothAsset(CloudMediaContext mediaContext, string[] filePaths, AssetCreationOptions options)
{
IAsset asset = mediaContext.Assets.Create(Guid.NewGuid().ToString(), options);
IAccessPolicy policy = mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = mediaContext.Locators.CreateSasLocator(asset, policy);
var blobclient = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
foreach (string filePath in filePaths)
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
file.UploadAsync(filePath, blobclient, locator, CancellationToken.None).Wait();
if (WindowsAzureMediaServicesTestConfiguration.SmallIsm == filePath)
{
file.IsPrimary = true;
file.Update();
}
}
return asset;
}
public void LaunchJobs(IMediaProcessor processor, List<IAsset> selectedassets, string jobname, int jobpriority, string taskname, string outputassetname, List<string> configuration, AssetCreationOptions myAssetCreationOptions, TaskOptions myTaskOptions, string storageaccountname = "")
{
foreach (IAsset asset in selectedassets)
{
string jobnameloc = jobname.Replace(Constants.NameconvInputasset, asset.Name);
IJob myJob = _context.Jobs.Create(jobnameloc, jobpriority);
foreach (string config in configuration)
{
string tasknameloc = taskname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config);
ITask myTask = myJob.Tasks.AddNew(
tasknameloc,
processor,
config,
myTaskOptions);
myTask.InputAssets.Add(asset);
// Add an output asset to contain the results of the task
string outputassetnameloc = outputassetname.Replace(Constants.NameconvInputasset, asset.Name).Replace(Constants.NameconvAMEpreset, config);
if (storageaccountname == "")
{
myTask.OutputAssets.AddNew(outputassetnameloc, asset.StorageAccountName, myAssetCreationOptions); // let's use the same storage account than the input asset
}
else
{
myTask.OutputAssets.AddNew(outputassetnameloc, storageaccountname, myAssetCreationOptions);
}
}
// Submit the job and wait until it is completed.
try
{
myJob.Submit();
}
catch (Exception e)
{
// Add useful information to the exception
if (selectedassets.Count < 5) // only if 4 or less jobs submitted
{
MessageBox.Show(string.Format("There has been a problem when submitting the job '{0}'", jobnameloc) + Constants.endline + Constants.endline + Program.GetErrorMessage(e), "Job Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
// Add useful information to the exception
TextBoxLogWriteLine("There has been a problem when submitting the job {0}.", jobnameloc, true);
TextBoxLogWriteLine(e);
return;
}
TextBoxLogWriteLine("Job '{0}' submitted.", jobnameloc);
Task.Factory.StartNew(() => dataGridViewJobsV.DoJobProgress(myJob));
}
DotabControlMainSwitch(Constants.TabJobs);
DoRefreshGridJobV(false);
}
