public void ShouldDownloadSameAssetFile2TimesIdenticallyAsStorageSDK()
{
IAsset asset = _mediaContext.Assets.Create("Test", AssetCreationOptions.None);
VerifyAsset(asset);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
UploadFile(locator, asset, _smallWmv, _mediaContext);
UploadFile(locator, asset, WindowsAzureMediaServicesTestConfiguration.SmallWmv2, _mediaContext);
IAssetFile assetFile = asset.AssetFiles.FirstOrDefault();
Assert.IsNotNull(assetFile);
assetFile.IsPrimary = true;
assetFile.Update();
locator.Delete();
policy.Delete();
IAsset refreshedAsset = RefreshedAsset(asset);
Assert.AreEqual(2, refreshedAsset.AssetFiles.Count(), "file count wrong");
for (int i = 0; i < 2; i++)
{
VerifyAndDownloadAsset(refreshedAsset, 2);
}
}
private async Task <WamsLocatorInfo> CreateLocatorAsync(IAsset asset, string accessPolicyName, LocatorType type, TimeSpan duration)
{
IAccessPolicy accessPolicy = null;
ILocator locator = null;
try {
accessPolicy = await Context.AccessPolicies.CreateAsync(accessPolicyName, duration, AccessPermissions.Read | AccessPermissions.List).ConfigureAwait(continueOnCapturedContext: false);
locator = await Context.Locators.CreateLocatorAsync(type, asset, accessPolicy).ConfigureAwait(continueOnCapturedContext: false);
Logger.Information("New {0} locator with duration {1} was created for asset '{2}'", type, duration, asset.Name);
return(new WamsLocatorInfo(locator.Id, locator.Path));
}
catch (Exception ex) {
Logger.Error(ex, "Error while creating locator for asset '{0}'. Cleaning up any created locator and access policy.", asset.Name);
try {
if (locator != null)
{
locator.Delete();
}
if (accessPolicy != null)
{
accessPolicy.Delete();
}
}
catch (Exception iex) {
Logger.Warning(iex, "Error while cleaning up created locator and access policy.");
}
throw;
}
}
public void ShouldCreateEncryptedInitilizedAsset()
{
IAsset asset = _mediaContext.Assets.Create("Test", AssetCreationOptions.StorageEncrypted);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null");
Assert.AreEqual(0, asset.AssetFiles.Count(), "Asset has files");
Assert.AreEqual(AssetState.Initialized, asset.State, "Expecting initilized state");
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
IAssetFile file = asset.AssetFiles.Create(Path.GetFileName(_smallWmv));
Task task = file.UploadAsync(_smallWmv,
_mediaContext.MediaServicesClassFactory.GetBlobTransferClient(),
locator,
CancellationToken.None);
task.Wait();
Assert.IsTrue(task.IsCompleted);
Assert.IsTrue(!task.IsFaulted);
locator.Delete();
policy.Delete();
IAsset refreshedAsset = _mediaContext.Assets.Where(c => c.Id == asset.Id).FirstOrDefault();
Assert.AreEqual(asset.Name, refreshedAsset.Name);
Assert.AreEqual(AssetState.Initialized, refreshedAsset.State);
Assert.AreEqual(1, refreshedAsset.AssetFiles.Count(), "file count wrong");
VerifyAndDownloadAsset(refreshedAsset, 1, false);
ContentKeyTests.VerifyFileAndContentKeyMetadataForStorageEncryption(refreshedAsset, _mediaContext);
}
/// <summary>
/// Downloads the represented file to the specified destination path.
/// </summary>
/// <param name="destinationPath">The path to download the file to.</param>
public void Download(string destinationPath)
{
IAccessPolicy accessPolicy = null;
ILocator locator = null;
try
{
accessPolicy = this.GetMediaContext().AccessPolicies.Create("SdkDownload", TimeSpan.FromHours(12), AccessPermissions.Read);
locator = this.GetMediaContext().Locators.CreateSasLocator(this.Asset, accessPolicy);
BlobTransferClient blobTransfer = this.GetMediaContext().MediaServicesClassFactory.GetBlobTransferClient();
blobTransfer.NumberOfConcurrentTransfers = this.GetMediaContext().NumberOfConcurrentTransfers;
blobTransfer.ParallelTransferThreadCount = this.GetMediaContext().ParallelTransferThreadCount;
this.DownloadAsync(destinationPath, blobTransfer, locator, CancellationToken.None).Wait();
}
catch (AggregateException exception)
{
throw exception.Flatten();
}
finally
{
if (locator != null)
{
locator.Delete();
}
if (accessPolicy != null)
{
accessPolicy.Delete();
}
}
}
public void ShouldCreateEmptyAssetUploadTwoFilesSetPrimaryAndDownloadFile()
{
IAsset asset = _mediaContext.Assets.Create("Test", AssetCreationOptions.None);
VerifyAsset(asset);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
UploadFile(locator, asset, _smallWmv, _mediaContext);
//asset = _dataContext.Assets.Where(c => c.Id == asset.Id).FirstOrDefault();
UploadFile(locator, asset, WindowsAzureMediaServicesTestConfiguration.SmallWmv2, _mediaContext);
Assert.AreEqual(2, asset.AssetFiles.Count());
IAssetFile assetFile = asset.AssetFiles.ToList()[1];
assetFile.IsPrimary = true;
assetFile.Update();
locator.Delete();
policy.Delete();
IAsset refreshedAsset = RefreshedAsset(asset);
Assert.AreEqual(2, refreshedAsset.AssetFiles.Count(), "file count wrong");
VerifyAndDownloadAsset(refreshedAsset, 2);
}
private IAsset CreateMediaAsset(CloudFile model)
{
CloudMediaContext context = new CloudMediaContext(mediaAccountName, mediaAccountKey);
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);
CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer mediaBlobContainer = cloudBlobClient.GetContainerReference(storageContainerReference);
mediaBlobContainer.CreateIfNotExists();
// Create a new asset.
IAsset asset = context.Assets.Create("UploadedVideo-" + Guid.NewGuid(), AssetCreationOptions.None);
IAccessPolicy writePolicy = context.AccessPolicies.Create("writePolicy", TimeSpan.FromMinutes(120), AccessPermissions.Write);
ILocator destinationLocator = context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
// Get the asset container URI and copy blobs from mediaContainer to assetContainer.
Uri uploadUri = new Uri(destinationLocator.Path);
string assetContainerName = uploadUri.Segments[1];
CloudBlobContainer assetContainer = cloudBlobClient.GetContainerReference(assetContainerName);
string fileName = HttpUtility.UrlDecode(Path.GetFileName(model.BlockBlob.Uri.AbsoluteUri));
var sourceCloudBlob = mediaBlobContainer.GetBlockBlobReference(fileName);
sourceCloudBlob.FetchAttributes();
if (sourceCloudBlob.Properties.Length > 0)
{
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
var destinationBlob = assetContainer.GetBlockBlobReference(fileName);
destinationBlob.DeleteIfExists();
destinationBlob.StartCopyFromBlob(sourceCloudBlob);
destinationBlob.FetchAttributes();
if (sourceCloudBlob.Properties.Length != destinationBlob.Properties.Length)
{
model.UploadStatusMessage += "Failed to copy as Media Asset!";
}
}
destinationLocator.Delete();
writePolicy.Delete();
sourceCloudBlob.Delete(); //delete temp blob
// Refresh the asset.
asset = context.Assets.Where(a => a.Id == asset.Id).FirstOrDefault();
var ismAssetFiles = asset.AssetFiles.ToList().Where(f => f.Name.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase)).ToArray();
if (ismAssetFiles.Count() != 1)
{
throw new ArgumentException("The asset should have only one, .ism file");
}
ismAssetFiles.First().IsPrimary = true;
ismAssetFiles.First().Update();
model.UploadStatusMessage += " Media file uploaded successfully by id: " + asset.Id;
model.AssetId = asset.Id;
return(asset);
}
public async Task <IAsset> UploadAssetAsync(string localFilePath, UpdateProgressAction updateProgress, Guid assetProgressMoniker, CancellationToken cancellationToken)
{
Logger.Debug("UploadAssetAsync() invoked with localFilePath value '{0}'.", localFilePath);
IAsset asset = null;
IAccessPolicy uploadAccessPolicy = null;
try {
var assetName = Guid.NewGuid().ToString();
asset = await Context.Assets.CreateAsync(assetName, AssetCreationOptions.None, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
var assetFile = await asset.AssetFiles.CreateAsync(Path.GetFileName(localFilePath), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
assetFile.IsPrimary = true;
uploadAccessPolicy = await Context.AccessPolicies.CreateAsync("Upload Policy", TimeSpan.FromDays(1), AccessPermissions.Write | AccessPermissions.List).ConfigureAwait(continueOnCapturedContext: false);
var uploadLocator = await Context.Locators.CreateLocatorAsync(LocatorType.Sas, asset, uploadAccessPolicy).ConfigureAwait(continueOnCapturedContext: false);
var uploadClient = new BlobTransferClient();
uploadClient.TransferProgressChanged += (sender, e) => updateProgress(new WamsUploadProgressInfo(assetProgressMoniker, e));
await assetFile.UploadAsync(localFilePath, uploadClient, uploadLocator, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
await uploadLocator.DeleteAsync().ConfigureAwait(continueOnCapturedContext: false);
await uploadAccessPolicy.DeleteAsync().ConfigureAwait(continueOnCapturedContext: false);
Logger.Information("New asset with ID '{0}' was uploaded from temp file with name '{1}'.", asset.Id, localFilePath);
return(asset);
}
catch (Exception ex) {
if (ex is OperationCanceledException)
{
Logger.Information("Upload of asset with ID '{0}' from temp file with name '{1}' was canceled.", asset.Id, localFilePath);
}
else
{
Logger.Error(ex, "Error while uploading asset from temp file with name '{0}'. Cleaning up asset and any locators and access policy created for upload.", localFilePath);
}
try {
if (asset != null)
{
asset.Delete(); // Deletes any locators also.
}
if (uploadAccessPolicy != null)
{
uploadAccessPolicy.Delete();
}
}
catch (Exception iex) {
Logger.Warning(iex, "Error while cleaning up asset and any locators and access policy created for upload.");
}
throw;
}
}
public static async Task <IAsset> CreateAsset(CloudBlockBlob blob, string assetName, TraceWriter log)
{
// Create a new asset.
var asset = _mediaServiceContext.Assets.Create(assetName, AssetCreationOptions.None);
log.Info($"Created new asset {asset.Name}");
IAccessPolicy writePolicy = _mediaServiceContext.AccessPolicies.Create("writePolicy", TimeSpan.FromHours(4), AccessPermissions.Write);
ILocator destinationLocator = _mediaServiceContext.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
_storageAccount = CloudStorageAccount.Parse(_connectionString);
CloudBlobClient destBlobStorage = _storageAccount.CreateCloudBlobClient();
// Get the destination asset container reference
string destinationContainerName = (new Uri(destinationLocator.Path)).Segments[1];
CloudBlobContainer assetContainer = destBlobStorage.GetContainerReference(destinationContainerName);
try
{
assetContainer.CreateIfNotExists();
log.Info($"Created new container {destinationContainerName}");
}
catch (Exception ex)
{
log.Error($"!!!ERROR!!!: {ex.Message}");
}
//// Get hold of the destination blob
CloudBlockBlob destinationBlob = assetContainer.GetBlockBlobReference(assetName);
// Copy Blob
try
{
using (var stream = await blob.OpenReadAsync())
{
await destinationBlob.UploadFromStreamAsync(stream);
}
log.Info("Copy Complete.");
var assetFile = asset.AssetFiles.Create(assetName);
assetFile.ContentFileSize = blob.Properties.Length;
assetFile.IsPrimary = true;
assetFile.Update();
asset.Update();
}
catch (Exception ex)
{
log.Error(ex.Message);
log.Info(ex.StackTrace);
log.Info("Copy Failed.");
throw;
}
destinationLocator.Delete();
writePolicy.Delete();
return(asset);
}
/// <summary>
/// Uploads a stream asynchronously
/// </summary>
/// <param name="name">Name for the stream</param>
/// <param name="stream">Stream to be uploaded</param>
/// <param name="cancellationToken">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(Stream stream, CancellationToken cancellationToken)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (this.IsFragmented())
{
throw new NotSupportedException(StringTable.NotSupportedFragblobUpload);
}
IAccessPolicy accessPolicy = null;
ILocator locator = null;
var policyName = "SdkUpload" + Guid.NewGuid().ToString();
return(GetMediaContext().AccessPolicies
.CreateAsync(policyName, TimeSpan.FromHours(12), AccessPermissions.Write)
.ContinueWith <ILocator>(
t =>
{
accessPolicy = t.Result;
t.ThrowIfFaulted(() => this.Cleanup(null, null, locator, accessPolicy));
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, locator, accessPolicy));
locator = this.GetMediaContext().Locators.CreateSasLocator(this.Asset, accessPolicy);
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, locator, accessPolicy));
return locator;
},
cancellationToken).
ContinueWith(
t =>
{
locator = t.Result;
t.ThrowIfFaulted(() => this.Cleanup(null, null, locator, accessPolicy));
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, locator, accessPolicy));
var blobTransfer = GetMediaContext().MediaServicesClassFactory.GetBlobTransferClient();
blobTransfer.NumberOfConcurrentTransfers = this.GetMediaContext().NumberOfConcurrentTransfers;
blobTransfer.ParallelTransferThreadCount = this.GetMediaContext().ParallelTransferThreadCount;
UploadAsync(stream, blobTransfer, locator, cancellationToken).Wait();
locator.Delete();
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, null, accessPolicy));
accessPolicy.Delete();
},
cancellationToken));
}
public void AccessPolicyCRUD()
{
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("AccessPolicyCRUD", TimeSpan.FromDays(1), AccessPermissions.Read);
Assert.AreEqual(AccessPermissions.Read, policy.Permissions);
Assert.AreEqual(TimeSpan.FromDays(1), policy.Duration);
Assert.AreEqual("AccessPolicyCRUD", policy.Name);
policy.Delete();
policy = _mediaContext.AccessPolicies.Create("AccessPolicyCRUD", TimeSpan.FromDays(1), AccessPermissions.Read);
policy.DeleteAsync();
policy = _mediaContext.AccessPolicies.Create("AccessPolicyCRUD", TimeSpan.FromDays(-1), AccessPermissions.Read);
policy.DeleteAsync();
}
static void DeleteAccessPolicy(string existingPolicyId)
{
// To delete a specific access policy, get a reference to the policy.
// based on the policy Id passed to the method.
var policyInstance =
from p in _context.AccessPolicies
where p.Id == existingPolicyId
select p;
IAccessPolicy policy = policyInstance.FirstOrDefault();
Console.WriteLine("Deleting policy {0}", existingPolicyId);
policy.Delete();
}
/// <summary>
/// Creates a new asset and copies blobs from the specifed storage account.
/// </summary>
/// <param name="mediaBlobContainer">The specified blob container.</param>
/// <returns>The new asset.</returns>
static public IAsset CreateAssetFromExistingBlobs(CloudBlobContainer mediaBlobContainer)
{
// Create a new asset.
IAsset asset = _context.Assets.Create("NewAsset_" + Guid.NewGuid(), AssetCreationOptions.None);
IAccessPolicy writePolicy = _context.AccessPolicies.Create("writePolicy",
TimeSpan.FromHours(24), AccessPermissions.Write);
ILocator destinationLocator = _context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
CloudBlobClient destBlobStorage = _destinationStorageAccount.CreateCloudBlobClient();
// Get the asset container URI and Blob copy from mediaContainer to assetContainer.
string destinationContainerName = (new Uri(destinationLocator.Path)).Segments[1];
CloudBlobContainer assetContainer =
destBlobStorage.GetContainerReference(destinationContainerName);
if (assetContainer.CreateIfNotExists())
{
assetContainer.SetPermissions(new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
var blobList = mediaBlobContainer.ListBlobs();
foreach (var sourceBlob in blobList)
{
var assetFile = asset.AssetFiles.Create((sourceBlob as ICloudBlob).Name);
CopyBlob(sourceBlob as ICloudBlob, assetContainer);
assetFile.ContentFileSize = (sourceBlob as ICloudBlob).Properties.Length;
assetFile.Update();
}
asset.Update();
destinationLocator.Delete();
writePolicy.Delete();
// Since we copied a set of Smooth Streaming files,
// set the .ism file to be the primary file.
// If we, for example, copied an .mp4, then the mp4 would be the primary file.
SetISMFileAsPrimary(asset);
return(asset);
}
/// <summary>
/// Uploads the file with given path asynchronously
/// </summary>
/// <param name="path">The path of a file to upload</param>
/// <param name="cancellationToken">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>
internal Task UploadAsync(string path, CancellationToken cancellationToken)
{
ValidateFileName(path);
IAccessPolicy accessPolicy = null;
ILocator locator = null;
var policyName = "SdkUpload" + Guid.NewGuid().ToString();
return(GetMediaContext().AccessPolicies
.CreateAsync(policyName, TimeSpan.FromHours(12), AccessPermissions.Write)
.ContinueWith <ILocator>(
t =>
{
accessPolicy = t.Result;
t.ThrowIfFaulted(() => this.Cleanup(null, null, locator, accessPolicy));
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, locator, accessPolicy));
locator = this.GetMediaContext().Locators.CreateSasLocator(this.Asset, accessPolicy);
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, locator, accessPolicy));
return locator;
},
cancellationToken).
ContinueWith(
t =>
{
locator = t.Result;
t.ThrowIfFaulted(() => this.Cleanup(null, null, locator, accessPolicy));
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, locator, accessPolicy));
var blobTransfer = GetMediaContext().MediaServicesClassFactory.GetBlobTransferClient();
blobTransfer.NumberOfConcurrentTransfers = this.GetMediaContext().NumberOfConcurrentTransfers;
blobTransfer.ParallelTransferThreadCount = this.GetMediaContext().ParallelTransferThreadCount;
UploadAsync(path, blobTransfer, locator, cancellationToken).Wait();
locator.Delete();
cancellationToken.ThrowIfCancellationRequested(() => this.Cleanup(null, null, null, accessPolicy));
accessPolicy.Delete();
},
cancellationToken));
}
//TODO: move to workerEncoder
private IAsset CreateAssetFromBlob(CloudBlobContainer externalMediaBlobContainer, string ExternalBlobName, CloudBlobClient assetBlobClient, string MediaServicesBlobName, string myProcessId)
{
// Create a new asset.
//myProcessId = Guid.NewGuid().ToString();
CloudMediaContext MediaContext = ObtainContext(_accountMediaName, _accountMediaKey);
string assetName = string.Format("{0}_{1}_Butler_{2}", externalMediaBlobContainer.Name, ExternalBlobName, myProcessId);
IAsset asset = MediaContext.Assets.Create(assetName, AssetCreationOptions.None);
IAccessPolicy writePolicy = MediaContext.AccessPolicies.Create("writePolicy_" + assetName, TimeSpan.FromMinutes(120), AccessPermissions.Write);
ILocator destinationLocator = MediaContext.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
string assetContainerName = (new Uri(destinationLocator.Path)).Segments[1];
CloudBlobContainer assetContainer = assetBlobClient.GetContainerReference(assetContainerName);
CloudBlockBlob ExternalBlob = externalMediaBlobContainer.GetBlockBlobReference(ExternalBlobName);
CloudBlockBlob assetBlob = assetContainer.GetBlockBlobReference(MediaServicesBlobName);
var sas = externalMediaBlobContainer.GetSharedAccessSignature(new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTime.UtcNow.AddMinutes(-15),
SharedAccessExpiryTime = DateTime.UtcNow.AddDays(7),
Permissions = SharedAccessBlobPermissions.Read,
});
var srcBlockBlobSasUri = string.Format("{0}{1}", ExternalBlob.Uri, sas);
assetBlob.StartCopyFromBlob(new Uri(srcBlockBlobSasUri));
CloudBlockBlob blobStatusCheck;
blobStatusCheck = (CloudBlockBlob)assetContainer.GetBlobReferenceFromServer(MediaServicesBlobName);
while (blobStatusCheck.CopyState.Status == CopyStatus.Pending)
{
Task.Delay(TimeSpan.FromSeconds(10d)).Wait();
Trace.TraceInformation("Waiting copy of " + blobStatusCheck.Name);
blobStatusCheck = (CloudBlockBlob)assetContainer.GetBlobReferenceFromServer(MediaServicesBlobName);
}
assetBlob.FetchAttributes();
var assetFile = asset.AssetFiles.Create(MediaServicesBlobName);
destinationLocator.Delete();
writePolicy.Delete();
//// Refresh the asset.
asset = MediaContext.Assets.Where(a => a.Id == asset.Id).FirstOrDefault();
return(asset);
}
public void ShouldRemoveAccessPolicyFromCollectionWhenDeleteCalled()
{
// Arrange
string name = "TestPolicy " + Guid.NewGuid().ToString("N");
var duration = new TimeSpan(1, 0, 0);
AccessPermissions permissions = AccessPermissions.List | AccessPermissions.Read;
IAccessPolicy accessPolicy = _mediaContext.AccessPolicies.Create(name, duration, permissions);
// Act
accessPolicy.Delete();
IAccessPolicy actual = _mediaContext.AccessPolicies.Where(x => x.Name == name).FirstOrDefault();
// Assert
Assert.IsNull(actual);
}
private IAsset ProcessUploadFile(string SafeFileName, string FileName, string storageaccount = null)
{
if (storageaccount == null)
{
storageaccount = MyContext.DefaultStorageAccount.Name; // no storage account or null, then let's take the default one
}
IAsset asset = null;
IAccessPolicy policy = null;
ILocator locator = null;
try
{
asset = MyContext.Assets.Create(SafeFileName as string, storageaccount, AssetCreationOptions.None);
IAssetFile file = asset.AssetFiles.Create(SafeFileName);
policy = MyContext.AccessPolicies.Create(
SafeFileName,
TimeSpan.FromDays(30),
AccessPermissions.Write | AccessPermissions.List);
locator = MyContext.Locators.CreateLocator(LocatorType.Sas, asset, policy);
file.UploadProgressChanged += file_UploadProgressChanged;
file.Upload(FileName);
AssetInfo.SetFileAsPrimary(asset, SafeFileName);
}
catch
{
asset = null;
}
finally
{
if (locator != null)
{
locator.Delete();
}
if (policy != null)
{
policy.Delete();
}
}
return(asset);
}
public void ShouldDeleteAccessPolicyWhenDeleteCalled()
{
// Arrange
string name = "TestPolicy " + Guid.NewGuid().ToString("N");
var duration = new TimeSpan(1, 0, 0);
AccessPermissions permissions = AccessPermissions.List | AccessPermissions.Read;
_mediaContext.AccessPolicies.Create(name, duration, permissions);
CloudMediaContext context2 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IAccessPolicy accessPolicy = context2.AccessPolicies.Where(x => x.Name == name).FirstOrDefault();
// Act
accessPolicy.Delete();
CloudMediaContext context3 = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
IAccessPolicy actual = context2.AccessPolicies.Where(x => x.Name == name).FirstOrDefault();
// Assert
Assert.IsNull(actual);
}
public void ShouldCreateEncryptedInitilizedAsset()
{
IAsset asset = _dataContext.Assets.Create("Test", AssetCreationOptions.StorageEncrypted);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null");
Assert.AreEqual(0, asset.AssetFiles.Count(), "Asset has files");
Assert.AreEqual(AssetState.Initialized, asset.State, "Expecting initilized state");
IAccessPolicy policy = _dataContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _dataContext.Locators.CreateSasLocator(asset, policy);
IAssetFile file = asset.AssetFiles.Create(Path.GetFileName(_smallWmv));
Task task = file.UploadAsync(_smallWmv,
new BlobTransferClient
{
NumberOfConcurrentTransfers = 10,
ParallelTransferThreadCount = 10
},
locator,
CancellationToken.None);
task.Wait();
Assert.IsTrue(task.IsCompleted);
Assert.IsTrue(!task.IsFaulted);
locator.Delete();
policy.Delete();
IAsset refreshedAsset = _dataContext.Assets.Where(c => c.Id == asset.Id).FirstOrDefault();
Assert.AreEqual(asset.Name, refreshedAsset.Name);
Assert.AreEqual(AssetState.Initialized, refreshedAsset.State);
Assert.AreEqual(1, refreshedAsset.AssetFiles.Count(), "file count wrong");
// TODO: Task 27827: Design and implement a KeyOracle Role to hold the Private key or keys used to protect content keys
//VerifyAndDownloadAsset(refreshedAsset);
ContentKeyTests.VerifyFileAndContentKeyMetadataForStorageEncryption(refreshedAsset, _dataContext);
}
public static async Task <IAsset> UploadVideo(CloudMediaContext context, string name, string address)
{
IAsset uploadAsset =
await
context.Assets.CreateAsync(Path.GetFileNameWithoutExtension(name), AssetCreationOptions.None,
CancellationToken.None);
IAssetFile assetFile = await uploadAsset.AssetFiles.CreateAsync(name, CancellationToken.None);
IAccessPolicy accessPolicy = context.AccessPolicies.Create(uploadAsset.Name, TimeSpan.FromMinutes(5),
AccessPermissions.Write);
ILocator locator = context.Locators.CreateSasLocator(uploadAsset, accessPolicy);
BlobTransferClient client = new BlobTransferClient()
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
await assetFile.UploadAsync(address, client, locator, CancellationToken.None);
locator.Delete();
accessPolicy.Delete();
return(uploadAsset);
}
private string UploadToAzure(HttpContext context, Stream stream, string fullName, string containerName, int nodeid, string categoryname)
{
//if (ConfigurationManager.AppSettings["AccountName"] == null || ConfigurationManager.AppSettings["AccountKey"] == null)
//{
// return "AccountName or AccountKey are missing";
//}
////BlobStorage blobStorage = DatabaseModel.GetStorageAccountDetail(Convert.ToInt64(context.Session[Const.ConferenceId]));
//BlobStorage blobStorage = new BlobStorage();
//blobStorage.AccountName = ConfigurationManager.AppSettings["AccountName"];
//blobStorage.AccountKey = ConfigurationManager.AppSettings["AccountKey"];
//blobStorage.ContainerName = containerName;
//var configuratorType = ConfigurationManager.AppSettings["ConfiguratorType"];
//var guidFileName = Guid.NewGuid() + Path.GetExtension(fullName);
//var filename = String.Format("{0}/{1}", configuratorType, guidFileName);
//string Result = new DeliverLoad.Models.Comman().UploadDocumentToAzure(stream, filename, blobStorage);
//return Result;
try
{
//ExerciseId = id;
string mediaAccountName = ConfigurationManager.AppSettings["MediaAccountName"];
string mediaAccountKey = ConfigurationManager.AppSettings["MediaAccountKey"];
string storageAccountName = ConfigurationManager.AppSettings["StorageAccountName"];
string storageAccountKey = ConfigurationManager.AppSettings["StorageAccountKey"];
mediaContext = new CloudMediaContext(mediaAccountName, mediaAccountKey);
var storageAccount = new CloudStorageAccount(new StorageCredentials(storageAccountName, storageAccountKey), true);
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
var mediaBlobContainer = cloudBlobClient.GetContainerReference("temporary-media");
mediaBlobContainer.CreateIfNotExists();
// Create a new asset.
asset = mediaContext.Assets.Create("NewAsset_" + Guid.NewGuid(), AssetCreationOptions.None);
IAccessPolicy writePolicy = mediaContext.AccessPolicies.Create("writePolicy",
TimeSpan.FromMinutes(120), AccessPermissions.Write);
ILocator destinationLocator = mediaContext.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
// Get the asset container URI and copy blobs from mediaContainer to assetContainer.
Uri uploadUri = new Uri(destinationLocator.Path);
string assetContainerName = uploadUri.Segments[1];
CloudBlobContainer assetContainer =
cloudBlobClient.GetContainerReference(assetContainerName);
string OriginalFileName = Guid.NewGuid().ToString().ToLower() + Path.GetExtension(fullName);
var sourceCloudBlob = mediaBlobContainer.GetBlockBlobReference(OriginalFileName);
//sourceCloudBlob.UploadFromByteArray(video, 0, video.Length);
BlobRequestOptions bro = new BlobRequestOptions()
{
ServerTimeout = TimeSpan.FromSeconds(5)
};
byte[] Video = ReadToEnd(stream);
sourceCloudBlob.UploadFromByteArray(Video, 0, Video.Length);
sourceCloudBlob.SetProperties();
sourceCloudBlob.FetchAttributes();
if (sourceCloudBlob.Properties.Length > 0)
{
IAssetFile assetFile = asset.AssetFiles.Create(OriginalFileName);
var destinationBlob = assetContainer.GetBlockBlobReference(OriginalFileName);
destinationBlob.DeleteIfExists();
//destinationBlob.StartCopyFromBlob(sourceCloudBlob);
destinationBlob.FetchAttributes();
}
destinationLocator.Delete();
writePolicy.Delete();
// Refresh the asset.
asset = mediaContext.Assets.Where(a => a.Id == asset.Id).FirstOrDefault();
string encodeAssetId = string.Empty;
foreach (var item in asset.AssetFiles)
{
item.IsPrimary = true;
item.ContentFileSize = stream.Length;
item.Update();
encodeAssetId = item.Id;
break;
}
string thumbnailToken = "_min.jpg";
// Preset reference documentation: http://msdn.microsoft.com/en-us/library/windowsazure/jj129582.aspx
var encodingPreset = "H264 Adaptive Bitrate MP4 Set 720p";
var assetToEncode = mediaContext.Assets.Where(a => a.Id == asset.Id).FirstOrDefault();
if (assetToEncode == null)
{
throw new ArgumentException("Could not find assetId: " + encodeAssetId);
}
job = mediaContext.Jobs.Create("Encoding " + assetToEncode.Name + " to " + encodingPreset);
IMediaProcessor latestWameMediaProcessor = (from p in mediaContext.MediaProcessors where p.Name == "Windows Azure Media Encoder" select p).ToList().OrderBy(wame => new Version(wame.Version)).LastOrDefault();
ITask encodeTask = job.Tasks.AddNew("Encoding", latestWameMediaProcessor, encodingPreset, TaskOptions.None);
encodeTask.InputAssets.Add(assetToEncode);
encodeTask.OutputAssets.AddNew(assetToEncode.Name + " as " + encodingPreset, AssetCreationOptions.None);
job.StateChanged += new EventHandler <JobStateChangedEventArgs>((sender, jsc) => Console.WriteLine(string.Format("{0}\n State: {1}\n Time: {2}\n\n", ((IJob)sender).Name, jsc.CurrentState, DateTime.UtcNow.ToString(@"yyyy_M_d_hhmmss"))));
job.Submit();
ThreadStart ts = new ThreadStart(() => EncodeVideoInThread(nodeid, ""));
Thread t1 = new Thread(ts);
t1.IsBackground = true;
t1.Start();
string PrimaryURL = sourceCloudBlob.StorageUri.PrimaryUri.ToString();
int status = service.updateVideoURL(nodeid, PrimaryURL, User.Identity.Name);
return(PrimaryURL);
}
catch (Exception ex)
{
return("-1");
}
}
private void Cleanup(BlobTransferClient blobTransfer, FileEncryption fileEncryption, ILocator locator, IAccessPolicy accessPolicy)
{
lock (this._lock)
{
if (blobTransfer != null)
{
try
{
blobTransfer.TransferProgressChanged -= this.OnDownloadBlobTransferProgressChanged;
}
catch
{
}
finally
{
blobTransfer = null;
}
}
if (fileEncryption != null)
{
try
{
fileEncryption.Dispose();
}
catch
{
}
finally
{
fileEncryption = null;
}
}
if (locator != null)
{
try
{
locator.Delete();
}
catch
{
}
finally
{
locator = null;
}
}
if (accessPolicy != null)
{
try
{
accessPolicy.Delete();
}
catch
{
}
finally
{
accessPolicy = null;
}
}
}
}
static private IAsset CreateAssetFromExistingBlobs(CloudBlobContainer sourceBlobContainer)
{
CloudBlobClient destBlobStorage = _destinationStorageAccount.CreateCloudBlobClient();
// Create a new asset.
IAsset asset = _context.Assets.Create("NewAsset_" + Guid.NewGuid(), AssetCreationOptions.None);
IAccessPolicy writePolicy = _context.AccessPolicies.Create("writePolicy",
TimeSpan.FromHours(24), AccessPermissions.Write);
ILocator destinationLocator =
_context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
// Get the asset container URI and Blob copy from mediaContainer to assetContainer.
CloudBlobContainer destAssetContainer =
destBlobStorage.GetContainerReference((new Uri(destinationLocator.Path)).Segments[1]);
if (destAssetContainer.CreateIfNotExists())
{
destAssetContainer.SetPermissions(new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
var blobList = sourceBlobContainer.ListBlobs();
foreach (var sourceBlob in blobList)
{
var assetFile = asset.AssetFiles.Create((sourceBlob as ICloudBlob).Name);
ICloudBlob destinationBlob = destAssetContainer.GetBlockBlobReference(assetFile.Name);
CopyBlob(sourceBlob as ICloudBlob, destAssetContainer);
assetFile.ContentFileSize = (sourceBlob as ICloudBlob).Properties.Length;
assetFile.Update();
Console.WriteLine("File {0} is of {1} size", assetFile.Name, assetFile.ContentFileSize);
}
asset.Update();
destinationLocator.Delete();
writePolicy.Delete();
// Set the primary asset file.
// If, for example, we copied a set of Smooth Streaming files,
// set the .ism file to be the primary file.
// If we, for example, copied an .mp4, then the mp4 would be the primary file.
var ismAssetFile = asset.AssetFiles.ToList().
Where(f => f.Name.EndsWith(".ism", StringComparison.OrdinalIgnoreCase)).ToArray().FirstOrDefault();
// The following code assigns the first .ism file as the primary file in the asset.
// An asset should have one .ism file.
if (ismAssetFile != null)
{
ismAssetFile.IsPrimary = true;
ismAssetFile.Update();
}
return(asset);
}
/// <summary>
/// Creates a new asset and copies blobs from the specifed storage account.
/// </summary>
/// <param name="blob">The specified blob.</param>
/// <returns>The new asset.</returns>
public static async Task <IAsset> CreateAssetFromBlobAsync(CloudMediaContext context, CloudBlockBlob blob, string assetName, TraceWriter log)
{
//Get a reference to the storage account that is associated with the Media Services account.
StorageCredentials mediaServicesStorageCredentials =
new StorageCredentials(_storageAccountName, _storageAccountKey);
_destinationStorageAccount = new CloudStorageAccount(mediaServicesStorageCredentials, false);
// Create a new asset.
var asset = context.Assets.Create(blob.Name, AssetCreationOptions.None);
log.Info($"Created new asset {asset.Name}");
IAccessPolicy writePolicy = context.AccessPolicies.Create("writePolicy",
TimeSpan.FromHours(4), AccessPermissions.Write);
ILocator destinationLocator = context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
CloudBlobClient destBlobStorage = _destinationStorageAccount.CreateCloudBlobClient();
// Get the destination asset container reference
string destinationContainerName = (new Uri(destinationLocator.Path)).Segments[1];
CloudBlobContainer assetContainer = destBlobStorage.GetContainerReference(destinationContainerName);
try
{
await assetContainer.CreateIfNotExistsAsync();
}
catch (Exception ex)
{
log.Error("ERROR:" + ex.Message);
}
log.Info("Created asset.");
// Get hold of the destination blob
CloudBlockBlob destinationBlob = assetContainer.GetBlockBlobReference(blob.Name);
// Copy Blob
try
{
using (var stream = await blob.OpenReadAsync())
{
await destinationBlob.UploadFromStreamAsync(stream);
}
log.Info("Copy Complete.");
var assetFile = asset.AssetFiles.Create(blob.Name);
assetFile.ContentFileSize = blob.Properties.Length;
//assetFile.MimeType = "video/mp4";
assetFile.IsPrimary = true;
assetFile.Update();
asset.Update();
}
catch (Exception ex)
{
log.Error(ex.Message);
log.Info(ex.StackTrace);
log.Info("Copy Failed.");
throw;
}
destinationLocator.Delete();
writePolicy.Delete();
return(asset);
}
public IAsset CreateMediaAsset()
{
_sourceStorageAccount =
new CloudStorageAccount(new StorageCredentials(_sourceStorageAccountName,
_sourceStorageAccountKey), true);
_destinationStorageAccount =
new CloudStorageAccount(new StorageCredentials(_sourceStorageAccountName,
_sourceStorageAccountKey), true);
CloudBlobClient sourceCloudBlobClient =
_sourceStorageAccount.CreateCloudBlobClient();
CloudBlobContainer sourceContainer =
sourceCloudBlobClient.GetContainerReference(_NameOfBlobContainerYouWantToCopy);
CloudBlobClient destBlobStorage = _destinationStorageAccount.CreateCloudBlobClient();
// Create a new asset.
IAsset asset = context.Assets.Create("NewAsset_" + Guid.NewGuid(), AssetCreationOptions.None);
IAccessPolicy writePolicy = context.AccessPolicies.Create("writePolicy",
TimeSpan.FromHours(24), AccessPermissions.Write);
ILocator destinationLocator =
context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
// Get the asset container URI and Blob copy from mediaContainer to assetContainer.
CloudBlobContainer destAssetContainer =
destBlobStorage.GetContainerReference((new Uri(destinationLocator.Path)).Segments[1]);
if (destAssetContainer.CreateIfNotExists())
{
destAssetContainer.SetPermissions(new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
var blobList = sourceContainer.ListBlobs();
foreach (CloudBlockBlob sourceBlob in blobList)
{
//var assetFile = asset.AssetFiles.Create((sourceBlob as ICloudBlob).Name);
//ICloudBlob destinationBlob = destAssetContainer.GetBlockBlobReference(assetFile.Name);
//CopyBlob(sourceBlob, destAssetContainer);
//sourceBlob.FetchAttributes();
//assetFile.ContentFileSize = (sourceBlob as ICloudBlob).Properties.Length;
//assetFile.Update();
//Console.WriteLine("File {0} is of {1} size", assetFile.Name, assetFile.ContentFileSize);
}
asset.Update();
destinationLocator.Delete();
writePolicy.Delete();
// Set the primary asset file.
// If, for example, we copied a set of Smooth Streaming files,
// set the .ism file to be the primary file.
// If we, for example, copied an .mp4, then the mp4 would be the primary file.
var ismAssetFile = asset.AssetFiles.ToList().
Where(f => f.Name.EndsWith(".ism", StringComparison.OrdinalIgnoreCase)).ToArray().FirstOrDefault();
// The following code assigns the first .ism file as the primary file in the asset.
// An asset should have one .ism file.
if (ismAssetFile != null)
{
ismAssetFile.IsPrimary = true;
ismAssetFile.Update();
}
//CloudStorageAccount storageAccount = CloudStorageAccount.Parse(mediaServiceStorageConnectionString);
//CloudBlobClient cloudBlobClient = storageAccount.CreateCloudBlobClient();
//CloudBlobContainer mediaBlobContainer = cloudBlobClient.GetContainerReference(mediaServiceStorageContainerReference);
//mediaBlobContainer.CreateIfNotExists();
//// Create a new asset.
//IAsset asset = context.Assets.Create("UploadedVideo-" + Guid.NewGuid().ToString().ToLower(), AssetCreationOptions.None);
//IAccessPolicy writePolicy = context.AccessPolicies.Create("writePolicy", TimeSpan.FromMinutes(120), AccessPermissions.Write);
//ILocator destinationLocator = context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
//// Get the asset container URI and copy blobs from mediaContainer to assetContainer.
//Uri uploadUri = new Uri(destinationLocator.Path);
//string assetContainerName = uploadUri.Segments[1];
//CloudBlobContainer assetContainer = cloudBlobClient.GetContainerReference(assetContainerName);
//string fileName = HttpUtility.UrlDecode(Path.GetFileName("https://leadsstorageacc.blob.core.windows.net/sibot/SI_Operations%20%26%20Finance_NWS_Billable%20T%26E%2C%20October%2031%2C%202017.mp4"));
//var sourceCloudBlob = mediaBlobContainer.GetBlockBlobReference(fileName);
//sourceCloudBlob.FetchAttributes();
//if (sourceCloudBlob.Properties.Length > 0)
//{
// IAssetFile assetFile = asset.AssetFiles.Create(fileName);
// var destinationBlob = assetContainer.GetBlockBlobReference(fileName);
// destinationBlob.DeleteIfExists();
// destinationBlob.StartCopyFromBlob(sourceCloudBlob);
// destinationBlob.FetchAttributes();
// if (sourceCloudBlob.Properties.Length != destinationBlob.Properties.Length)
// model.UploadStatusMessage += "Failed to copy as Media Asset!";
//}
//destinationLocator.Delete();
//writePolicy.Delete();
//sourceCloudBlob.Delete(); //delete temp blob
//// Refresh the asset.
//asset = context.Assets.Where(a => a.Id == asset.Id).FirstOrDefault();
//var ismAssetFiles = asset.AssetFiles.FirstOrDefault();
//ismAssetFiles.IsPrimary = true;
//ismAssetFiles.Update();
//model.UploadStatusMessage += " Media file uploaded successfully by id: " + asset.Id;
//model.AssetId = asset.Id;
//IAsset file =RunIndexingJob(asset.Id);
//// Download the job output asset.
//DownloadAsset(file, HttpContext.Server.MapPath("~/Media/Output"));
EncodeToAdaptiveBitrateMP4s(asset.Id);
return(asset);
}
/// <summary>
/// Ingest all Mezzamine files to Asset
/// </summary>
private void IngestAssets()
{
IAccessPolicy writePolicy = MediaContext.AccessPolicies.Create("writePolicy_" + currentAsset.Name, TimeSpan.FromMinutes(120), AccessPermissions.Write);
ILocator destinationLocator = MediaContext.Locators.CreateLocator(LocatorType.Sas, currentAsset, writePolicy);
//Asset Storage
CloudStorageAccount assetStorageCount = CloudStorageAccount.Parse(myRequest.MediaStorageConn);
CloudBlobClient assetClient = assetStorageCount.CreateCloudBlobClient();
CloudBlobContainer assetContainer = assetClient.GetContainerReference(currentAsset.Uri.Segments[1]);
//Mezzamine Storage
CloudStorageAccount MezzamineStorageCount = CloudStorageAccount.Parse(myRequest.ButlerRequest.StorageConnectionString);
CloudBlobClient MezzamineClient = MezzamineStorageCount.CreateCloudBlobClient();
CloudBlobContainer MezzamineContainer = MezzamineClient.GetContainerReference(myRequest.ButlerRequest.WorkflowName);
//Filter Ingest only MP4
foreach (string urlMezzamineFile in myRequest.ButlerRequest.MezzanineFiles.Where(mf => mf.ToLower().EndsWith(".mp4")))
{
Uri xFile = new Uri(urlMezzamineFile);
int segmentIndex = xFile.Segments.Count() - 1;
//Asset BLOB Xfile
string AssetBlobName = Uri.UnescapeDataString(xFile.Segments[segmentIndex]);
CloudBlockBlob assetBlob = assetContainer.GetBlockBlobReference(AssetBlobName);
assetContainer.SetPermissions(new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
}
);
//Mezzamine BLOB Xfile
string MezzamineBlobName = "";
for (int i = 2; i <= segmentIndex; i++)
{
MezzamineBlobName += xFile.Segments[i];
}
MezzamineBlobName = Uri.UnescapeDataString(MezzamineBlobName);
CloudBlockBlob MezzamineBlob = MezzamineContainer.GetBlockBlobReference(MezzamineBlobName);
var sas = MezzamineContainer.GetSharedAccessSignature(new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTime.UtcNow.AddMinutes(-15),
SharedAccessExpiryTime = DateTime.UtcNow.AddDays(7),
Permissions = SharedAccessBlobPermissions.Read,
});
//USE decode URL for spetial characters
var srcBlockBlobSasUri = string.Format("{0}{1}", Uri.UnescapeDataString(MezzamineBlob.Uri.AbsoluteUri), sas);
assetBlob.StartCopy(new Uri(srcBlockBlobSasUri));
Trace.TraceInformation("{0} in process {1} processId {2} Start copy MezzamineFile {3}", this.GetType().FullName, myRequest.ProcessTypeId, myRequest.ProcessInstanceId, MezzamineBlobName);
CloudBlockBlob blobStatusCheck;
blobStatusCheck = (CloudBlockBlob)assetContainer.GetBlobReferenceFromServer(AssetBlobName);
while (blobStatusCheck.CopyState.Status == CopyStatus.Pending)
{
Task.Delay(TimeSpan.FromSeconds(10d)).Wait();
Trace.TraceInformation("{0} in process {1} processId {2} copying MezzamineFile {3} status {4}", this.GetType().FullName, myRequest.ProcessTypeId, myRequest.ProcessInstanceId, MezzamineBlobName, blobStatusCheck.CopyState.Status);
blobStatusCheck = (CloudBlockBlob)assetContainer.GetBlobReferenceFromServer(AssetBlobName);
}
assetBlob.FetchAttributes();
//Add the xFile to Asset
var assetFile = currentAsset.AssetFiles.Create(AssetBlobName);
MezzamineBlob.FetchAttributes();
assetFile.ContentFileSize = MezzamineBlob.Properties.Length;
assetFile.Update();
Trace.TraceInformation("{0} in process {1} processId {2} finish MezzamineFile {3}", this.GetType().FullName, myRequest.ProcessTypeId, myRequest.ProcessInstanceId, MezzamineBlobName);
}
destinationLocator.Delete();
writePolicy.Delete();
currentAsset.Update();
}
public static async Task <IAsset> CreateAssetFromBlobMultipleFilesAsync(CloudMediaContext context, CloudBlockBlob blob, string assetName, TraceWriter log, List <assetfileinJson> assetfilesAsset)
{
//Get a reference to the storage account that is associated with the Media Services account.
StorageCredentials mediaServicesStorageCredentials =
new StorageCredentials(_storageAccountName, _storageAccountKey);
_destinationStorageAccount = new CloudStorageAccount(mediaServicesStorageCredentials, false);
// Create a new asset.
var asset = context.Assets.Create(Path.GetFileNameWithoutExtension(blob.Name), AssetCreationOptions.None);
log.Info($"Created new asset {asset.Name}");
IAccessPolicy writePolicy = context.AccessPolicies.Create("writePolicy",
TimeSpan.FromHours(4), AccessPermissions.Write);
ILocator destinationLocator = context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
CloudBlobClient destBlobStorage = _destinationStorageAccount.CreateCloudBlobClient();
// Get the destination asset container reference
string destinationContainerName = (new Uri(destinationLocator.Path)).Segments[1];
CloudBlobContainer assetContainer = destBlobStorage.GetContainerReference(destinationContainerName);
try
{
await assetContainer.CreateIfNotExistsAsync();
}
catch (Exception ex)
{
log.Error("ERROR:" + ex.Message);
}
log.Info("Created asset.");
var sourceBlobContainer = blob.Container;
foreach (var file in assetfilesAsset)
{
int nbtry = 0;
var sourceBlob = sourceBlobContainer.GetBlobReference(file.fileName);
while (!await sourceBlob.ExistsAsync() && nbtry < 86400) // let's wait 24 hours max
{
log.Info("File " + file.fileName + " does not exist... waiting...");
Thread.Sleep(1000); // let's wait for the blob to be there
nbtry++;
}
if (nbtry == 86440)
{
log.Info("File " + file.fileName + " does not exist... File asset transfer canceled.");
break;
}
log.Info("File " + file.fileName + " found.");
// Copy Blob
try
{
// Get hold of the destination blob
CloudBlockBlob destinationBlob = assetContainer.GetBlockBlobReference(file.fileName);
using (var stream = await sourceBlob.OpenReadAsync())
{
await destinationBlob.UploadFromStreamAsync(stream);
}
log.Info("Copy Complete.");
var assetFile = asset.AssetFiles.Create(sourceBlob.Name);
assetFile.ContentFileSize = sourceBlob.Properties.Length;
//assetFile.MimeType = "video/mp4";
if (file.isPrimary)
{
assetFile.IsPrimary = true;
}
assetFile.Update();
asset.Update();
}
catch (Exception ex)
{
log.Error(ex.Message);
log.Info(ex.StackTrace);
log.Info("Copy Failed.");
throw;
}
}
destinationLocator.Delete();
writePolicy.Delete();
return(asset);
}
public static async Task <object> Run([HttpTrigger(WebHookType = "genericJson")] HttpRequestMessage req, TraceWriter log, Microsoft.Azure.WebJobs.ExecutionContext execContext)
{
log.Info($"Webhook was triggered!");
// Init variables
string jsonContent = await req.Content.ReadAsStringAsync();
dynamic data = JsonConvert.DeserializeObject(jsonContent);
string fileName = null;
var manifestInfo = new ManifestHelpers.ManifestGenerated();
log.Info(jsonContent);
if (data.assetId == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new
{
error = "Please pass asset ID in the input object (assetId)"
}));
}
MediaServicesCredentials amsCredentials = new MediaServicesCredentials();
log.Info($"Using Azure Media Service Rest API Endpoint : {amsCredentials.AmsRestApiEndpoint}");
bool checkStreamingEndpointResponse = false;
bool checkStreamingEndpointResponseSuccess = true;
try
{
fileName = (string)data.fileName;
AzureAdTokenCredentials tokenCredentials = new AzureAdTokenCredentials(amsCredentials.AmsAadTenantDomain,
new AzureAdClientSymmetricKey(amsCredentials.AmsClientId, amsCredentials.AmsClientSecret),
AzureEnvironments.AzureCloudEnvironment);
AzureAdTokenProvider tokenProvider = new AzureAdTokenProvider(tokenCredentials);
_context = new CloudMediaContext(amsCredentials.AmsRestApiEndpoint, tokenProvider);
// Get the asset
string assetid = data.assetId;
var destAsset = _context.Assets.Where(a => a.Id == assetid).FirstOrDefault();
if (destAsset == null)
{
log.Info($"Asset not found {assetid}");
return(req.CreateResponse(HttpStatusCode.BadRequest, new
{
error = "Asset not found"
}));
}
log.Info($"creation of file {fileName}");
// Manifest generate
manifestInfo = ManifestHelpers.LoadAndUpdateManifestTemplate(destAsset, execContext);
// if not file name passed, then we use the one generated based on mp4 files names
if (fileName == null)
{
fileName = manifestInfo.FileName;
}
var filetocreate = destAsset.AssetFiles.Create(fileName);
using (Stream s = ManifestHelpers.GenerateStreamFromString(manifestInfo.Content))
{
filetocreate.Upload(s);
}
log.Info("Manifest file created.");
// let's make the manifest the primary file of the asset
MediaServicesHelper.SetFileAsPrimary(destAsset, fileName);
log.Info("Manifest file set as primary.");
if (data.checkStreamingEndpointResponse != null && (bool)data.checkStreamingEndpointResponse)
{
checkStreamingEndpointResponse = true;
// testing streaming
// publish with a streaming locator (1 hour)
IAccessPolicy readPolicy = _context.AccessPolicies.Create("readPolicy", TimeSpan.FromHours(1), AccessPermissions.Read);
ILocator outputLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, destAsset, readPolicy);
var publishurlsmooth = MediaServicesHelper.GetValidOnDemandURI(_context, destAsset);
try
{
WebRequest request = WebRequest.Create(publishurlsmooth.ToString());
WebResponse response = request.GetResponse();
response.Close();
}
catch (Exception ex)
{
checkStreamingEndpointResponseSuccess = false;
}
outputLocator.Delete();
readPolicy.Delete();
}
}
catch (Exception ex)
{
string message = ex.Message + ((ex.InnerException != null) ? Environment.NewLine + MediaServicesHelper.GetErrorMessage(ex) : "");
log.Info($"ERROR: Exception {message}");
return(req.CreateResponse(HttpStatusCode.InternalServerError, new { error = message }));
}
log.Info($"");
if (checkStreamingEndpointResponse)
{
return(req.CreateResponse(HttpStatusCode.OK, new
{
fileName = fileName,
manifestContent = manifestInfo.Content,
checkStreamingEndpointResponseSuccess = checkStreamingEndpointResponseSuccess
}));
}
else
{
return(req.CreateResponse(HttpStatusCode.OK, new
{
fileName = fileName,
manifestContent = manifestInfo.Content
}));
}
}
private void Cleanup(BlobTransferClient blobTransfer, FileEncryption fileEncryption, ILocator locator, IAccessPolicy accessPolicy)
{
lock (this._lock)
{
if (blobTransfer != null)
{
try
{
blobTransfer.TransferProgressChanged -= this.OnDownloadBlobTransferProgressChanged;
}
catch
{
}
finally
{
blobTransfer = null;
}
}
if (fileEncryption != null)
{
try
{
fileEncryption.Dispose();
}
catch
{
}
finally
{
fileEncryption = null;
}
}
if (locator != null)
{
try
{
locator.Delete();
}
catch
{
}
finally
{
locator = null;
}
}
if (accessPolicy != null)
{
try
{
accessPolicy.Delete();
}
catch
{
}
finally
{
accessPolicy = null;
}
}
}
}
static public void CopyBlobToAssetContainerInTheSameMediaServicesAccount()
{
CloudMediaContext context = new CloudMediaContext(MediaServicesAccountName, MediaServicesAccountKey);
var storageAccount = new CloudStorageAccount(new StorageCredentials(MediaServicesStorageAccountName, MediaServicesStorageAccountKey), true);
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
var mediaBlobContainer = cloudBlobClient.GetContainerReference(cloudBlobClient.BaseUri + "mediafiles001");
mediaBlobContainer.CreateIfNotExists();
string StreamingFilesFolder = Path.GetFullPath(@"../..\SupportFiles\streamingfiles\");
// Upload some files to the blob container (for testing purposes).
DirectoryInfo uploadDirectory = new DirectoryInfo(StreamingFilesFolder);
foreach (var file in uploadDirectory.EnumerateFiles())
{
CloudBlockBlob blob = mediaBlobContainer.GetBlockBlobReference(file.Name);
var name = file.Name;
using (var stream = System.IO.File.OpenRead(StreamingFilesFolder + name))
blob.UploadFromStream(stream);
}
// Create a new asset.
IAsset asset = context.Assets.Create("NewAsset_" + Guid.NewGuid(), AssetCreationOptions.None);
IAccessPolicy writePolicy = context.AccessPolicies.Create("writePolicy",
TimeSpan.FromMinutes(120), AccessPermissions.Write);
ILocator destinationLocator = context.Locators.CreateLocator(LocatorType.Sas, asset, writePolicy);
// Get the asset container URI and copy blobs from mediaContainer to assetContainer.
Uri uploadUri = new Uri(destinationLocator.Path);
string assetContainerName = uploadUri.Segments[1];
CloudBlobContainer assetContainer =
cloudBlobClient.GetContainerReference(assetContainerName);
foreach (var sourceBlob in mediaBlobContainer.ListBlobs())
{
string fileName = HttpUtility.UrlDecode(Path.GetFileName(sourceBlob.Uri.AbsoluteUri));
var sourceCloudBlob = mediaBlobContainer.GetBlockBlobReference(fileName);
sourceCloudBlob.FetchAttributes();
if (sourceCloudBlob.Properties.Length > 0)
{
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
var destinationBlob = assetContainer.GetBlockBlobReference(fileName);
destinationBlob.DeleteIfExists();
destinationBlob.StartCopyFromBlob(sourceCloudBlob);
destinationBlob.FetchAttributes();
if (sourceCloudBlob.Properties.Length != destinationBlob.Properties.Length)
{
Console.WriteLine("Failed to copy");
}
}
}
destinationLocator.Delete();
writePolicy.Delete();
// Refresh the asset.
asset = context.Assets.Where(a => a.Id == asset.Id).FirstOrDefault();
//At this point, you can create a job using your asset.
Console.WriteLine("You are ready to use " + asset.Name);
// Since we copied a set of Smooth Streaming files,
// set the .ism file to be the primary file
var ismAssetFiles = asset.AssetFiles.ToList().
Where(f => f.Name.EndsWith(".ism", StringComparison.OrdinalIgnoreCase))
.ToArray();
if (ismAssetFiles.Count() != 1)
{
throw new ArgumentException("The asset should have only one, .ism file");
}
ismAssetFiles.First().IsPrimary = true;
ismAssetFiles.First().Update();
}
private void ProcessReplica()
{
//1. Create Target Asset
targetAsset = targetMediaContext.Assets.Create(triggerAsset.Name, AssetCreationOptions.None);
IAccessPolicy writePolicy = targetMediaContext.AccessPolicies.Create("writePolicy_" + targetAsset.Name, TimeSpan.FromMinutes(120), AccessPermissions.Write);
ILocator destinationLocator = targetMediaContext.Locators.CreateLocator(LocatorType.Sas, targetAsset, writePolicy);
//2. Copy each File fron Origin to Target
//2.1 Target Asset Storage
CloudBlobClient targetAssetClient = targetStorageAccount.CreateCloudBlobClient();
CloudBlobContainer targetAssetContainer = targetAssetClient.GetContainerReference(targetAsset.Uri.Segments[1]);
//2.2 Trigger (origen) Asset Storage
CloudBlobClient triggerAssetClient = triggerStorageAccount.CreateCloudBlobClient();
CloudBlobContainer triggerAssetContainer = triggerAssetClient.GetContainerReference(triggerAsset.Uri.Segments[1]);
//3. Start Copy all Files
foreach (IAssetFile triggerAssetFile in triggerAsset.AssetFiles)
{
//if (triggerAssetFile.Name.ToLower().EndsWith(".mp4"))
{
string triggerAssetFileUrl = triggerAsset.Uri.AbsoluteUri + "/" + triggerAssetFile.Name;
string targetAssetFileUrl = targetAsset.Uri.AbsoluteUri + "/" + triggerAssetFile.Name;
startCopyBlob(triggerAssetContainer, triggerAssetFileUrl, targetAssetContainer, targetAssetFileUrl);
}
}
//4. Wait all copy process finish
CloudBlockBlob blobStatusCheck;
bool waitLighTrafic = true;
while (waitLighTrafic)
{
waitLighTrafic = false;
foreach (IAssetFile triggerAssetFile in triggerAsset.AssetFiles)
{
// if (triggerAssetFile.Name.ToLower().EndsWith(".mp4"))
{
blobStatusCheck = (CloudBlockBlob)targetAssetContainer.GetBlobReferenceFromServer(triggerAssetFile.Name);
Trace.TraceInformation("{0} copy {1} bytes of {2} Bytes", triggerAssetFile.Name, blobStatusCheck.CopyState.BytesCopied, blobStatusCheck.CopyState.TotalBytes);
waitLighTrafic = (blobStatusCheck.CopyState.Status == CopyStatus.Pending);
}
}
Task.Delay(TimeSpan.FromSeconds(10d)).Wait();
}
foreach (IAssetFile triggerAssetFile in triggerAsset.AssetFiles)
{
//if (triggerAssetFile.Name.ToLower().EndsWith(".mp4"))
{
//Add the xFile to Asset
var assetFile = targetAsset.AssetFiles.Create(triggerAssetFile.Name);
}
}
destinationLocator.Delete();
writePolicy.Delete();
targetAsset.Update();
}
/// <summary>
/// Create Asset and Add blob
/// </summary>
/// <param name="AssetName"></param>
/// <param name="blobUrl"></param>
/// <returns></returns>
public IAsset CreateAsset(string AssetName, string blobUrl, string MediaStorageConn, string StorageConnectionString, string WorkflowName)
{
//Create Empty Asset
Uri MezzamineFileUri = new Uri(blobUrl);
int segmentscount = MezzamineFileUri.Segments.Count() - 1;
IAsset currentAsset = _MediaServicesContext.Assets.Create(AssetName, AssetCreationOptions.None);
//Add the File
IAccessPolicy writePolicy = _MediaServicesContext.AccessPolicies.Create("writePolicy_" + currentAsset.Name, TimeSpan.FromMinutes(120), AccessPermissions.Write);
ILocator destinationLocator = _MediaServicesContext.Locators.CreateLocator(LocatorType.Sas, currentAsset, writePolicy);
//Asset Storage
CloudStorageAccount assetStorageCount = CloudStorageAccount.Parse(MediaStorageConn);
CloudBlobClient assetClient = assetStorageCount.CreateCloudBlobClient();
CloudBlobContainer assetContainer = assetClient.GetContainerReference(currentAsset.Uri.Segments[1]);
//Mezzamine Storage
CloudStorageAccount MezzamineStorageCount = CloudStorageAccount.Parse(StorageConnectionString);
CloudBlobClient MezzamineClient = MezzamineStorageCount.CreateCloudBlobClient();
CloudBlobContainer MezzamineContainer = MezzamineClient.GetContainerReference(WorkflowName);
Uri xFile = new Uri(blobUrl);
int segmentIndex = xFile.Segments.Count() - 1;
//Asset BLOB Xfile
string AssetBlobName = Uri.UnescapeDataString(xFile.Segments[segmentIndex]);
CloudBlockBlob assetBlob = assetContainer.GetBlockBlobReference(AssetBlobName);
assetContainer.SetPermissions(new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
}
);
//Mezzamine BLOB Xfile
string MezzamineBlobName = "";
for (int i = 2; i <= segmentIndex; i++)
{
MezzamineBlobName += xFile.Segments[i];
}
MezzamineBlobName = Uri.UnescapeDataString(MezzamineBlobName);
CloudBlockBlob MezzamineBlob = MezzamineContainer.GetBlockBlobReference(MezzamineBlobName);
var sas = MezzamineContainer.GetSharedAccessSignature(new SharedAccessBlobPolicy()
{
SharedAccessStartTime = DateTime.UtcNow.AddMinutes(-15),
SharedAccessExpiryTime = DateTime.UtcNow.AddDays(7),
Permissions = SharedAccessBlobPermissions.Read,
});
//USE decode URL for spetial characters
var srcBlockBlobSasUri = string.Format("{0}{1}", Uri.UnescapeDataString(MezzamineBlob.Uri.AbsoluteUri), sas);
assetBlob.StartCopyFromBlob(new Uri(srcBlockBlobSasUri));
CloudBlockBlob blobStatusCheck;
blobStatusCheck = (CloudBlockBlob)assetContainer.GetBlobReferenceFromServer(AssetBlobName);
while (blobStatusCheck.CopyState.Status == CopyStatus.Pending)
{
Task.Delay(TimeSpan.FromSeconds(10d)).Wait();
blobStatusCheck = (CloudBlockBlob)assetContainer.GetBlobReferenceFromServer(AssetBlobName);
}
assetBlob.FetchAttributes();
//Add the xFile to Asset
var assetFile = currentAsset.AssetFiles.Create(assetBlob.Name);
MezzamineBlob.FetchAttributes();
assetFile.ContentFileSize = MezzamineBlob.Properties.Length;
assetFile.Update();
destinationLocator.Delete();
writePolicy.Delete();
currentAsset.AssetFiles.FirstOrDefault().IsPrimary = true;
currentAsset.Update();
return(currentAsset);
}
