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