private void AddTestAssetFiles(IAsset asset, AssetType assetType)
{
IAssetFile assetFile = null;
switch (assetType)
{
case AssetType.MP4:
assetFile = asset.AssetFiles.Create("test.mp4");
assetFile.IsPrimary = true;
assetFile.Update();
break;
case AssetType.MediaServicesHLS:
assetFile = asset.AssetFiles.Create("test-m3u8-aapl.ism");
assetFile.IsPrimary = true;
assetFile.Update();
asset.AssetFiles.Create("test-m3u8-aapl.m3u8");
asset.AssetFiles.Create("test-m3u8-aapl-952962.ts");
asset.AssetFiles.Create("test-m3u8-aapl-952962.m3u8");
asset.AssetFiles.Create("test-m3u8-aapl-952962.ismx");
break;
case AssetType.MultiBitrateMP4:
assetFile = asset.AssetFiles.Create("test.ism");
assetFile.IsPrimary = true;
assetFile.Update();
asset.AssetFiles.Create("test.mp4");
break;
case AssetType.SmoothStreaming:
assetFile = asset.AssetFiles.Create("test.ism");
assetFile.IsPrimary = true;
assetFile.Update();
asset.AssetFiles.Create("test.ismc");
asset.AssetFiles.Create("test.ismv");
break;
case AssetType.Unknown:
assetFile = asset.AssetFiles.Create("test.wmv");
assetFile.IsPrimary = true;
assetFile.Update();
break;
}
}
private void CopyAssetFiles(IAsset myAssetTo, List <IAssetFile> files)
{
foreach (var assetFile in files)
{
string magicName = assetFile.Name;
assetFile.Download(magicName);
try
{
Trace.TraceInformation("Copying {0}", magicName);
IAssetFile newFile = myAssetTo.AssetFiles.Create(assetFile.Name);
newFile.Upload(magicName);
newFile.Update();
}
catch (Exception X)
{
Trace.TraceError("Error CopyAssetFiles " + X.Message);
if (File.Exists(magicName))
{
System.IO.File.Delete(magicName);
}
throw X;
}
System.IO.File.Delete(magicName);
}
myAssetTo.Update();
}
private IAsset CreateSmoothAsset(string[] filePaths)
{
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
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);
}
private void SetVideoPrimary()
{
IAssetFile video = myAssetOriginal.AssetFiles.Where(f => !(f.Name.EndsWith(".workflow"))).FirstOrDefault();
video.IsPrimary = true;
video.Update();
}
public static CloudBlockBlob WriteContentToBlob(IAsset asset, CloudBlobContainer dstContainer, string dstBlobName, string blobContent)
{
string uri = null;
CloudBlockBlob blob = null;
try
{
//dstContainer.CreateIfNotExists();
blob = dstContainer.GetBlockBlobReference(dstBlobName);
blob.DeleteIfExists();
var options = new BlobRequestOptions()
{
ServerTimeout = TimeSpan.FromMinutes(10)
};
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(blobContent), false))
{
blob.UploadFromStream(stream, null, options);
}
IAssetFile assetFile = asset.AssetFiles.Create(dstBlobName);
blob.FetchAttributes();
assetFile.ContentFileSize = blob.Properties.Length;
//assetFile.IsPrimary = false;
assetFile.Update();
}
catch (Exception e)
{
throw e;
}
return(blob);
}
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);
}
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);
}
}
public void ShouldNotThrowWhenSavingFileInfoIfTheAssetIsInPublishedState()
{
IAsset asset = AssetTests.CreateAsset(_mediaContext, _smallWmv, AssetCreationOptions.None);
IAssetFile assetFile = asset.AssetFiles.First();
assetFile.IsPrimary = false;
assetFile.MimeType = String.Empty;
assetFile.Update();
}
public string CopyFile(IAsset sourceAsset, IAsset destinationAsset, string sourceFileName, string destinationFileName, bool primaryFile)
{
string sourceContainerName = sourceAsset.Uri.Segments[1];
CloudBlockBlob sourceBlob = GetBlob(sourceContainerName, string.Empty, sourceFileName, true);
string destinationContainerName = destinationAsset.Uri.Segments[1];
CloudBlockBlob destinationBlob = GetBlob(destinationContainerName, string.Empty, destinationFileName, false);
string operationId = CopyBlob(sourceBlob, destinationBlob, false);
IAssetFile assetFile = destinationAsset.AssetFiles.Create(destinationFileName);
assetFile.ContentFileSize = sourceBlob.Properties.Length;
assetFile.MimeType = sourceBlob.Properties.ContentType;
assetFile.IsPrimary = primaryFile;
assetFile.Update();
return(operationId);
}
private void CopyCaptions(IAsset myAssetFrom, IAsset myAssetTo)
{
foreach (var assetFile in myAssetFrom.AssetFiles)
{
if (assetFile.Name.EndsWith(".ttml") || assetFile.Name.EndsWith(".vtt"))
{
string magicName = assetFile.Name;
assetFile.Download(magicName);
IAssetFile newFile = myAssetTo.AssetFiles.Create(assetFile.Name);
newFile.Upload(magicName);
System.IO.File.Delete(magicName);
newFile.Update();
}
}
myAssetTo.Update();
}
/// <summary>
/// This method will upload the video to azure storage account and associate with azure media service instance
/// </summary>
/// <param name="fileName">Name of the video file</param>
/// <param name="videoBytes">Video bytes</param>
/// <returns>Azure asset id to track the uploaded asset</returns>
public string Upload(string fileName, byte[] videoBytes)
{
IAsset asset = azureInstance.context.Assets.Create(fileName, AssetCreationOptions.None);
//ILocator destination = AssignSasLocator(asset);
CloudBlobContainer destContainer = blobClient.GetContainerReference(new Uri(asset.Uri.ToString()).Segments[1]);
CloudBlockBlob destBlob = destContainer.GetBlockBlobReference(fileName);
destBlob.UploadFromByteArray(videoBytes, 0, videoBytes.Length);
destBlob.SetProperties();
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
assetFile.Update();
//destination.Delete();
return(asset.Id);
}
public void AssetCRUDWithEmptyFile()
{
IAsset asset = _mediaContext.Assets.Create("Test", AssetCreationOptions.None);
IAssetFile file = asset.AssetFiles.Create("test");
Assert.IsNotNull(asset);
Assert.IsNotNull(asset.AssetFiles);
Assert.AreEqual(1, asset.AssetFiles.Count());
file.ContentFileSize = 100;
file.Update();
file.Delete();
Assert.IsNotNull(asset.AssetFiles);
Assert.AreEqual(0, asset.AssetFiles.Count());
asset.Delete();
Assert.IsNull(_mediaContext.Assets.Where(c => c.Id == asset.Id).FirstOrDefault());
}
public void ShouldGetClearConfigurationFromTask()
{
var filePaths = new[] { WindowsAzureMediaServicesTestConfiguration.SmallIsm, WindowsAzureMediaServicesTestConfiguration.SmallIsmc, WindowsAzureMediaServicesTestConfiguration.SmallIsmv };
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
foreach (string filePath in filePaths)
{
string filename = Path.GetFileName(filePath);
IAssetFile file = asset.AssetFiles.Create(filename);
file.Upload(filePath);
if (WindowsAzureMediaServicesTestConfiguration.SmallIsm == filePath)
{
file.IsPrimary = true;
file.Update();
}
}
string originalConfiguration = File.ReadAllText(WindowsAzureMediaServicesTestConfiguration.PlayReadyConfig);
IMediaProcessor processor = JobTests.GetMediaProcessor(_mediaContext, WindowsAzureMediaServicesTestConfiguration.MpEncryptorName);
IJob job = _mediaContext.Jobs.Create("PlayReady protect a smooth streaming asset for GetClearConfigurationFromTask");
ITask task = job.Tasks.AddNew("SmoothProtectTask", processor, originalConfiguration, TaskOptions.ProtectedConfiguration);
task.InputAssets.Add(asset);
task.OutputAssets.AddNew("Job OutPut", AssetCreationOptions.None);
// Verify that we can get the configuration back before we create a job template. Note that is the point that things actually get encrypted
Assert.AreEqual(String.CompareOrdinal(task.GetClearConfiguration(), originalConfiguration), 0);
job.Submit();
Assert.AreEqual(job.Tasks.Count, 1);
Assert.AreEqual(TaskOptions.ProtectedConfiguration, job.Tasks[0].Options);
Assert.IsNotNull(job.Tasks[0].InitializationVector);
Assert.IsFalse(String.IsNullOrEmpty(job.Tasks[0].EncryptionKeyId));
Assert.AreEqual(ConfigurationEncryption.SchemeName, job.Tasks[0].EncryptionScheme);
Assert.AreEqual(ConfigurationEncryption.SchemeVersion, job.Tasks[0].EncryptionVersion);
JobTests.WaitForJob(job.Id, JobState.Finished, JobTests.VerifyAllTasksFinished);
// Verify that the configuration isn't clear
Assert.AreNotEqual(String.CompareOrdinal(job.Tasks[0].Configuration, originalConfiguration), 0);
// Verify that we can decrypt the configuration and get the correct clear value
string decryptedConfiguration = job.Tasks[0].GetClearConfiguration();
Assert.AreEqual(String.CompareOrdinal(decryptedConfiguration, originalConfiguration), 0);
}
private static void CallUpdateUploadDownloadAndDelete(IAssetFile file, string name)
{
file.Update();
file.UpdateAsync();
var uploadFile = Path.Combine(Path.GetTempPath(), name);
try
{
File.CreateText(uploadFile).Close();
file.Upload(uploadFile);
}
finally
{
File.Delete(uploadFile);
}
file.Download(Path.GetTempFileName());
file.Delete();
}
private void CopyCaptions(IAsset myAssetFrom, IAsset myAssetTo)
{
var captionFileList = (from f in myAssetFrom.AssetFiles select f).Where(f =>
f.Name.EndsWith(".ttml") ||
f.Name.EndsWith(".vtt") ||
f.Name.EndsWith(".kw.xml")
);
foreach (var assetFile in captionFileList)
{
string magicName = assetFile.Name;
assetFile.Download(magicName);
IAssetFile newFile = myAssetTo.AssetFiles.Create(assetFile.Name);
newFile.Upload(magicName);
System.IO.File.Delete(magicName);
newFile.Update();
}
myAssetTo.Update();
}
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);
}
private static void SetPrimaryFile(IAsset asset)
{
if (asset.AssetFiles.Count() == 1)
{
IAssetFile assetFile = asset.AssetFiles.Single();
assetFile.IsPrimary = true;
assetFile.Update();
}
else
{
foreach (IAssetFile assetFile in asset.AssetFiles)
{
if (assetFile.Name.EndsWith(Constants.Media.FileExtension.Manifest, StringComparison.InvariantCultureIgnoreCase))
{
assetFile.IsPrimary = true;
assetFile.Update();
}
}
}
}
private void SetPrimaryFile(IAsset asset)
{
if (asset.AssetFiles.Count() == 1)
{
IAssetFile assetFile = asset.AssetFiles.Single();
assetFile.IsPrimary = true;
assetFile.Update();
}
else
{
foreach (IAssetFile assetFile in asset.AssetFiles)
{
if (IsManifestFile(assetFile.Name))
{
assetFile.IsPrimary = true;
assetFile.Update();
}
}
}
}
public void ShouldSetContentFileSizeOnAssetFileWithoutUpload()
{
IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None);
IAssetFile fileInfo = asset.AssetFiles.Create("test.txt");
int expected = 0;
Assert.AreEqual(expected, fileInfo.ContentFileSize, "Unexpected ContentFileSize value");
expected = 100;
fileInfo.ContentFileSize = expected;
fileInfo.Update();
IAssetFile refreshedFile = _mediaContext.Files.Where(c => c.Id == fileInfo.Id).FirstOrDefault();
Assert.IsNotNull(refreshedFile);
Assert.AreEqual(expected, refreshedFile.ContentFileSize, "ContentFileSize Mismatch after Update");
//Double check with new context
_mediaContext = WindowsAzureMediaServicesTestConfiguration.CreateCloudMediaContext();
refreshedFile = _mediaContext.Files.Where(c => c.Id == fileInfo.Id).FirstOrDefault();
Assert.IsNotNull(refreshedFile);
Assert.AreEqual(expected, refreshedFile.ContentFileSize, "ContentFileSize Mismatch after Update");
}
public IAsset CreateAsset(string authToken, string assetName, string storageAccount, bool storageEncryption, string[] fileNames)
{
AssetCreationOptions creationOptions = storageEncryption ? AssetCreationOptions.StorageEncrypted : AssetCreationOptions.None;
IAsset asset = _media.Assets.Create(assetName, storageAccount, creationOptions);
BlobClient blobClient = new BlobClient(authToken, storageAccount);
string sourceContainerName = Constants.Storage.Blob.Container.Upload;
if (storageEncryption)
{
foreach (string fileName in fileNames)
{
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainerName, null, fileName, false);
Stream sourceStream = sourceBlob.OpenRead();
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
assetFile.Upload(sourceStream);
}
}
else
{
string destinationContainerName = asset.Uri.Segments[1];
foreach (string fileName in fileNames)
{
CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainerName, null, fileName, true);
CloudBlockBlob destinationBlob = blobClient.GetBlob(destinationContainerName, null, fileName, false);
blobClient.CopyBlob(sourceBlob, destinationBlob, false);
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
assetFile.ContentFileSize = sourceBlob.Properties.Length;
assetFile.Update();
}
}
SetPrimaryFile(asset);
asset.Update();
return(asset);
}
// Update the Media Services asset with the current contents of the Storage container.
private static void UpdateContainer(CloudBlobContainer targetContainer, IAsset assetDestination, string primaryFileName)
{
foreach (IListBlobItem blob in targetContainer.ListBlobs(blobListingDetails: BlobListingDetails.Metadata))
{
CloudBlockBlob targetCloudBlob = (CloudBlockBlob)blob;
string fileName = targetCloudBlob.Name;
targetCloudBlob.FetchAttributes();
if (targetCloudBlob.Properties.Length > 0)
{
IAssetFile assetFile = assetDestination.AssetFiles.Create(fileName);
assetFile.ContentFileSize = targetCloudBlob.Properties.Length;
if (fileName.ToLower().EndsWith(".ism"))
{
assetFile.IsPrimary = true;
}
else if (fileName.ToLower() == primaryFileName.ToLower())
{
assetFile.IsPrimary = true;
}
assetFile.Update(); // If using the async version of this method make sure you add an await.
}
}
}
private static void CallUpdateUploadDownloadAndDelete(IAssetFile file, string name)
{
file.Update();
file.UpdateAsync();
var uploadFile = Path.Combine(Path.GetTempPath(), name);
try
{
File.CreateText(uploadFile).Close();
file.Upload(uploadFile);
}
finally
{
File.Delete(uploadFile);
}
file.Download(Path.GetTempFileName());
file.Delete();
}
public void SetPrimaryFile(IAsset MyAsset, IAssetFile theAssetFile)
{
MyAsset.AssetFiles.ToList().ForEach(af => { af.IsPrimary = false; af.Update(); });
theAssetFile.IsPrimary = true;
theAssetFile.Update();
}
public static async Task <object> Run([HttpTrigger(WebHookType = "genericJson")] HttpRequestMessage req, TraceWriter log)
{
log.Info($"AMS v2 Function - AddAssetFiles was triggered!");
string jsonContent = await req.Content.ReadAsStringAsync();
dynamic data = JsonConvert.DeserializeObject(jsonContent);
// Validate input objects
if (data.assetId == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new { error = "Please pass assetId in the input object" }));
}
if (data.primaryFileName == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new { error = "Please pass primaryFileName in the input object" }));
}
string assetId = data.assetId;
string primaryFileName = data.primaryFileName;
List <string> fileNames = null;
if (data.fileNames != null)
{
fileNames = ((JArray)data.fileNames).ToObject <List <string> >();
}
MediaServicesCredentials amsCredentials = new MediaServicesCredentials();
IAsset asset = null;
try
{
// Load AMS account context
log.Info($"Using AMS v2 REST API Endpoint : {amsCredentials.AmsRestApiEndpoint.ToString()}");
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
asset = _context.Assets.Where(a => a.Id == assetId).FirstOrDefault();
if (asset == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, new { error = "Asset not found" }));
}
string destinationContainerName = asset.Uri.Segments[1];
/*
* // Azure AD Storage API access
* string[] uri = asset.Uri.Host.Split('.');
* string storageAccountName = uri[0];
*
* string accessToken = BlobStorageHelper.GetUserOAuthToken(amsCredentials.AmsAadTenantDomain, amsCredentials.AmsClientId, amsCredentials.AmsClientSecret);
* TokenCredential tokenCredential = new TokenCredential(accessToken);
* StorageCredentials storageCredentials = new StorageCredentials(tokenCredential);
* CloudBlobContainer destinationBlobContainer = BlobStorageHelper.GetCloudBlobContainer(storageCredentials, storageAccountName, destinationContainerName);
*/
CloudBlobContainer destinationBlobContainer = BlobStorageHelper.GetCloudBlobContainer(BlobStorageHelper.AmsStorageAccountName, BlobStorageHelper.AmsStorageAccountKey, destinationContainerName);
foreach (var fileName in fileNames)
{
IAssetFile assetFile = asset.AssetFiles.Create(fileName);
CloudBlockBlob blob = destinationBlobContainer.GetBlockBlobReference(fileName);
blob.FetchAttributes();
assetFile.ContentFileSize = blob.Properties.Length;
assetFile.IsPrimary = false;
if (fileName == primaryFileName)
{
assetFile.IsPrimary = true;
}
assetFile.Update();
}
}
catch (Exception e)
{
log.Info($"ERROR: Exception {e}");
return(req.CreateResponse(HttpStatusCode.BadRequest));
}
return(req.CreateResponse(HttpStatusCode.OK, new
{
assetId = assetId
}));
}
public static void Migrate()
{
try
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.CreateLogger();
Log.Information("Starting up");
CloudMediaContext sourceContext = CloudMediaContextCreator.Create("Source");
CloudMediaContext destinationContext = CloudMediaContextCreator.Create("Destination");
StorageCredentials destinationStorageCredentials = StorageCredentialsCreator.Create("Destination");
StorageCredentials sourceStorageCredentials = StorageCredentialsCreator.Create("Source");
List <string> done = new List <string>();
if (File.Exists(doneFileName))
{
done = File.ReadAllLines(doneFileName).ToList();
}
done.Add($"Started at {DateTime.Now}");
// Get a reference to the source asset in the source context.
var allSourceAssets = GetAllAssets(sourceContext);
var allDestinationAssets = GetAllAssets(destinationContext);
Log.Information("Source {0}, Destination {1}", allSourceAssets.Count, allDestinationAssets.Count);
List <string> mapping = new List <string>();
if (File.Exists(mappingFileName))
{
mapping = File.ReadAllLines(mappingFileName).ToList();
}
mapping.Add($"Started at {DateTime.Now}");
int totalNumberOfAssets = allSourceAssets.Count;
int currentAsset = 1;
foreach (IAsset sourceAsset in allSourceAssets)
{
Log.Information("Handling {0} of {1}, {2}", currentAsset, totalNumberOfAssets, sourceAsset.Name);
currentAsset++;
if (done.Contains(sourceAsset.Id))
{
Log.Information("asset: {0} with id: {1} was already done, skipping asset", sourceAsset.Name, sourceAsset.Id);
continue;
}
// Create an empty destination asset in the destination context.
IAsset destinationAsset = destinationContext.Assets.Create(sourceAsset.Name, AssetCreationOptions.None);
mapping.Add($"asset: source: {sourceAsset.Id}, {sourceAsset.Name} / destination: {destinationAsset.Id.ToString()}, {destinationAsset.Name}");
StoreMapping(mapping);
// Copy all the files in the source asset to the destination asset using azcopy (copy containers)
StorageContainerCopy.CopySourceToDestinationContainer(destinationStorageCredentials, sourceStorageCredentials, sourceAsset, destinationAsset);
Log.Information("Copy finished, creating files");
foreach (var sourceAssetFile in sourceAsset.AssetFiles)
{
Log.Information($"Creating {sourceAssetFile.Name}");
IAssetFile destinationFile = destinationAsset.AssetFiles.Create(sourceAssetFile.Name);
destinationFile.IsPrimary = sourceAssetFile.IsPrimary;
destinationFile.MimeType = sourceAssetFile.MimeType;
destinationFile.ContentFileSize = sourceAssetFile.ContentFileSize;
destinationFile.Update();
}
// TODO: Handle dynamic encryption, create locators
destinationAsset.Update();
done.Add($"{sourceAsset.Id}");
StoreDone(done);
}
Log.Information("Handled {0} assets", allSourceAssets.Count);
Log.Information("Shutting down");
}
catch (Exception error)
{
Log.Error(error, "An error occurred during migration");
throw;
}
}
private void CreateMediaAsset(CloudFile model)
{
string mediaAccountName = ConfigurationManager.AppSettings["MediaAccountName"];
string mediaAccountKey = ConfigurationManager.AppSettings["MediaAccountKey"];
string storageAccountName = ConfigurationManager.AppSettings["StorageAccountName"];
string storageAccountKey = ConfigurationManager.AppSettings["StorageAccountKey"];
CloudMediaContext context = new CloudMediaContext(mediaAccountName, mediaAccountKey);
var storageAccount = new CloudStorageAccount(new StorageCredentials(storageAccountName, storageAccountKey), true);
var cloudBlobClient = storageAccount.CreateCloudBlobClient();
var mediaBlobContainer = cloudBlobClient.GetContainerReference("mediaservicesdemo");
mediaBlobContainer.CreateIfNotExists();
// 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);
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.StartCopy(sourceCloudBlob);
destinationBlob.FetchAttributes();
if (sourceCloudBlob.Properties.Length != destinationBlob.Properties.Length)
{
model.UploadStatusMessage += "Failed to copy as Media Asset!";
}
assetFile.ContentFileSize = (sourceCloudBlob as ICloudBlob).Properties.Length;
assetFile.Update();
}
//destinationLocator.Delete();
//writePolicy.Delete();
//// 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();
//Changed
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();
}
// End changed
model.UploadStatusMessage += " Created Media Asset '" + asset.Name + "' successfully.";
model.AssetId = asset.Id;
}
