public void ShouldCreateOutputAssetWithAccountSelectionStrategy() { CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, true); string inputAssetFilePath = Path.Combine(Directory.GetCurrentDirectory(), smallWmv); string inputAssetFileName = Path.GetFileName(inputAssetFilePath); this.inputAsset = context.Assets.Create("InputAsset", strategy, AssetCreationOptions.StorageEncrypted); IAssetFile file = this.inputAsset.AssetFiles.Create(inputAssetFileName); file.Upload(inputAssetFilePath); IJob job = context.Jobs.Create("Job to test using an account selection strategy for an output asset"); ITask task = job.Tasks.AddNew( "Task to test using an account selection strategy for an output asset", context.MediaProcessors.GetLatestMediaProcessorByName(MediaProcessorNames.MediaEncoderStandard), MediaEncoderStandardTaskPresetStrings.H264SingleBitrate4x3SD, TaskOptions.None); task.InputAssets.Add(this.inputAsset); task.OutputAssets.AddNew("OutputAsset", strategy, AssetCreationOptions.None); job.Submit(); job.GetExecutionProgressTask(CancellationToken.None).Wait(); Assert.IsNotNull(job); Assert.AreEqual(1, job.Tasks.Count, "Unexpected number of tasks in job"); Assert.AreEqual(1, job.OutputMediaAssets.Count, "Unexpected number of output assets in the job"); this.outputAsset = job.OutputMediaAssets[0]; Assert.IsNotNull(outputAsset.StorageAccountName, "Storage account name in output assset is null"); }
/// <summary> /// Upload an Asset /// </summary> /// <param name="filePath">Path of the video</param> /// <param name="uploadHandler">Handler to retrieve the progress</param> /// <returns></returns> public async Task <IAsset> UploadAsset(string filePath, EventHandler <UploadProgressChangedEventArgs> uploadHandler = null) { Task <IAsset> uploadTask = Task.Run(() => { // Retrieve filename string assetName = Path.GetFileName(filePath); // Create a new asset in the context IAsset asset = _mediaContext.Assets.Create(assetName, AssetCreationOptions.None); // Create a new asset file IAssetFile file = asset.AssetFiles.Create(assetName); // Hook-up the event if handler is specified if (uploadHandler != null) { file.UploadProgressChanged += uploadHandler; } // Upload the video file.Upload(filePath); return(asset); }); await uploadTask; return(uploadTask.Result); // Snippet when you want to use the Microsoft Azure Media Services extensions //return await _mediaContext.Assets.CreateFromFileAsync(filePath, AssetCreationOptions.None, cancellationToken); }
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 void CreateAssetAndUploadNFilesSync(int expected) { IAsset asset = _mediaContext.Assets.Create("TestWithMultipleFiles", AssetCreationOptions.None); VerifyAsset(asset); DirectoryInfo info = null; try { info = Directory.CreateDirectory(Guid.NewGuid().ToString()); for (int i = 0; i < expected; i++) { string fullFilePath = null; string fileName; fullFilePath = CreateNewFileFromOriginal(info, out fileName); IAssetFile file = asset.AssetFiles.Create(fileName); file.Upload(fullFilePath); } Assert.AreEqual(expected, _mediaContext.Files.Where(c => c.ParentAssetId == asset.Id).Count()); } finally { if (info != null) { info.Delete(recursive: true); } } }
public void ShouldCreateOutputAssetWithAccountSelectionStrategy() { CapacityBasedAccountSelectionStrategy strategy = CapacityBasedAccountSelectionStrategy.FromAccounts(context, true); string inputAssetFilePath = Path.Combine(TestContext.TestDeploymentDir, smallWmv); string inputAssetFileName = Path.GetFileName(inputAssetFilePath); IAsset inputAsset = context.Assets.Create("", strategy, AssetCreationOptions.StorageEncrypted); IAssetFile file = inputAsset.AssetFiles.Create(inputAssetFileName); file.Upload(inputAssetFilePath); IJob job = context.Jobs.Create("Job to test using an account selection strategy for an output asset"); ITask task = job.Tasks.AddNew("Task to test using an account selection strategy for an output asset", GetMediaProcessor(Encoder), Preset, TaskOptions.None); task.InputAssets.Add(inputAsset); task.OutputAssets.AddNew("OutputAsset", strategy, AssetCreationOptions.None); job.Submit(); // Note that we don't want for the job to finish. We just need the submit to succeed. IJob refreshedJob = context.Jobs.Where(c => c.Id == job.Id).FirstOrDefault(); Assert.IsNotNull(refreshedJob); Assert.AreEqual(1, refreshedJob.Tasks.Count, "Unexpected number of tasks in job"); Assert.AreEqual(1, refreshedJob.Tasks[0].OutputAssets.Count, "Unexpected number of output assets in the job"); Assert.IsNotNull(refreshedJob.Tasks[0].OutputAssets[0].StorageAccountName, "Storage account name in output assset is null"); }
public void ShouldDownloadEnvelopeEncryptionProtectedAssetFile() { IAsset asset = _mediaContext.Assets.Create(_smallWmv, AssetCreationOptions.EnvelopeEncryptionProtected); string name = Path.GetFileName(_smallWmv); IAssetFile file = asset.AssetFiles.Create(name); file.Upload(_smallWmv); VerifyAndDownloadAsset(asset, 1); }
/// <summary> /// Creates the asset. Note, there is a breaking change in the new SDK! /// You have to first create the Asset, which is always empty. /// Then create a file within that asset, then upload a content the newly created file /// </summary> /// <param name="pathToFile">The path to file.</param> public void CreateAsset(string pathToFile) { IAsset newAsset = this.MediaService.MediaContext.Assets.Create(System.IO.Path.GetFileName(pathToFile), AssetCreationOptions.None); // note, the file to be uploaded must match (case insensitive) // to the Name property of the IAssetFile instance we are uploading to IAssetFile file = newAsset.AssetFiles.Create(System.IO.Path.GetFileName(pathToFile)); file.Upload(pathToFile); }
public void ShouldCreateSingleFileAssetWithNoLocatorUsingOveloadSync() { IAsset asset = _mediaContext.Assets.Create("Empty", AssetCreationOptions.StorageEncrypted); IAssetFile file = asset.AssetFiles.Create(Path.GetFileName(_smallWmv)); file.Upload(_smallWmv); Assert.IsNotNull(asset, "Asset should be non null"); Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null"); Assert.AreEqual(AssetState.Initialized, asset.State, "Asset state wrong"); }
private void ProcessUploadFileToAsset(string SafeFileName, string FileName, IAsset MyAsset) { try { IAssetFile UploadedAssetFile = MyAsset.AssetFiles.Create(SafeFileName); UploadedAssetFile.UploadProgressChanged += MyUploadProgressChanged; UploadedAssetFile.Upload(FileName as string); } catch { MessageBox.Show("Error when uploading the file"); } }
public void ShouldThrowArgumentExceptionWhenUploadSyncFileNameNotEqualToAssetFileName() { IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None); string fileUploaded = _smallWmv; IAssetFile fileInfo = asset.AssetFiles.Create("test.txt"); try { fileInfo.Upload(fileUploaded); } catch (ArgumentException ex) { AssertFileMismatchException(fileUploaded, ex); throw; } }
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(); }
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(); }
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); }
private static void PublishTextTracks(BlobClient blobClient, ITask jobTask, IAsset encoderOutput) { if (encoderOutput != null) { IAsset speechOutput = jobTask.OutputAssets[0]; IAssetFile[] webVttFiles = GetAssetFiles(speechOutput, Constant.Media.FileExtension.WebVtt); foreach (IAssetFile webVttFile in webVttFiles) { JObject processorConfig = JObject.Parse(jobTask.Configuration); string languageId = Language.GetLanguageId(processorConfig); string fileName = string.Concat(languageId, Constant.Media.FileExtension.WebVtt); string sourceContainer = webVttFile.Asset.Uri.Segments[1]; CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainer, null, webVttFile.Name); using (Stream sourceStream = sourceBlob.OpenRead()) { IAssetFile destinationFile = encoderOutput.AssetFiles.Create(fileName); destinationFile.Upload(sourceStream); } } } }
public IAsset CreateAsset(string authToken, string assetName, string storageAccount, bool storageEncryption, string[] fileNames) { AssetCreationOptions assetEncryption = storageEncryption ? AssetCreationOptions.StorageEncrypted : AssetCreationOptions.None; IAsset asset = _media.Assets.Create(assetName, storageAccount, assetEncryption); BlobClient blobClient = new BlobClient(authToken, storageAccount); string sourceContainer = Constant.Storage.Blob.Container.FileUpload; if (fileNames.Length == 1) { string fileName = fileNames[0]; IAssetFile assetFile = asset.AssetFiles.Create(fileName); CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainer, null, fileName, true); Stream sourceStream = sourceBlob.OpenRead(); assetFile.Upload(sourceStream); foreach (ILocator locator in asset.Locators) { locator.Delete(); } } else { BlobTransferClient transferClient = new BlobTransferClient(); ILocator sasLocator = CreateLocator(LocatorType.Sas, asset, true); List <Task> uploadTasks = new List <Task>(); foreach (string fileName in fileNames) { IAssetFile assetFile = asset.AssetFiles.Create(fileName); CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainer, null, fileName, true); Stream sourceStream = sourceBlob.OpenRead(); Task uploadTask = assetFile.UploadAsync(sourceStream, transferClient, sasLocator, CancellationToken.None); uploadTasks.Add(uploadTask); } Task.WaitAll(uploadTasks.ToArray()); sasLocator.Delete(); } SetPrimaryFile(asset); return(asset); }
private static void PublishAnalytics(BlobClient blobClient, DocumentClient documentClient, MediaPublish contentPublish, ITask jobTask, IAsset encoderOutput) { foreach (IAsset outputAsset in jobTask.OutputAssets) { string[] fileNames = GetFileNames(outputAsset, Constant.Media.FileExtension.Json); foreach (string fileName in fileNames) { string documentData = string.Empty; string sourceContainerName = outputAsset.Uri.Segments[1]; CloudBlockBlob sourceBlob = blobClient.GetBlob(sourceContainerName, null, fileName); using (Stream sourceStream = sourceBlob.OpenRead()) { StreamReader streamReader = new StreamReader(sourceStream); documentData = streamReader.ReadToEnd(); } JObject document = JObject.Parse(documentData); document = DocumentClient.SetContext(document, contentPublish.MediaAccount, outputAsset.Id); MediaProcessor?mediaProcessor = Processor.GetMediaProcessor(jobTask.MediaProcessorId); string documentId = UpsertDocument(documentClient, document, mediaProcessor.Value, outputAsset, fileName); if (encoderOutput != null) { string assetFileName = mediaProcessor.Value.ToString(); if (!string.IsNullOrEmpty(documentId)) { assetFileName = string.Concat(assetFileName, Constant.TextDelimiter.Identifier, documentId); } assetFileName = string.Concat(assetFileName, Constant.Media.FileExtension.Json); IAssetFile assetFile = encoderOutput.AssetFiles.Create(assetFileName); using (Stream sourceStream = sourceBlob.OpenRead()) { StreamReader streamReader = new StreamReader(sourceStream); assetFile.Upload(sourceStream); } } } } }
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); }
static IAsset CreateAssetAndProtectedStreamingLocatorInV2(CloudMediaContext v2Client, ConfigWrapper config, string assetNameOrDescription) { // Create the input Asset IAsset originalAsset = v2Client.Assets.Create("input asset", AssetCreationOptions.None); string filename = Path.GetFileName(config.FilePathToUpload); IAssetFile assetFile = originalAsset.AssetFiles.Create(filename); assetFile.Upload(config.FilePathToUpload); // Submit a job to encode the single input file into an adaptive streaming set IJob job = v2Client.Jobs.Create("Media Encoder Standard Job"); IMediaProcessor processor = GetMediaEncoderStandardProcessor(v2Client); ITask task = job.Tasks.AddNew("Adaptive Streaming encode", processor, "Adaptive Streaming", TaskOptions.None); task.InputAssets.Add(originalAsset); task.OutputAssets.AddNew(assetNameOrDescription, AssetCreationOptions.None); job.Submit(); job.GetExecutionProgressTask(CancellationToken.None).Wait(); // Get the output asset to publish job.Refresh(); IAsset assetToPublish = v2Client.Assets.Where(a => a.Id == job.Tasks[0].OutputAssets[0].Id).First(); // Create the content key Guid keyId = Guid.NewGuid(); byte[] contentKey = GetRandomBuffer(16); IContentKey key = v2Client.ContentKeys.Create(keyId, contentKey, "ContentKey", ContentKeyType.EnvelopeEncryption); // Create ContentKeyAuthorizationPolicy with Open restriction and create authorization policy IContentKeyAuthorizationPolicy policy = v2Client.ContentKeyAuthorizationPolicies.CreateAsync("Open Authorization Policy").Result; ContentKeyAuthorizationPolicyRestriction restriction = new ContentKeyAuthorizationPolicyRestriction { Name = "Open Authorization Policy", KeyRestrictionType = (int)ContentKeyRestrictionType.Open, Requirements = null }; List <ContentKeyAuthorizationPolicyRestriction> restrictions = new List <ContentKeyAuthorizationPolicyRestriction>(); restrictions.Add(restriction); var policyOption = v2Client.ContentKeyAuthorizationPolicyOptions.Create("policy", ContentKeyDeliveryType.BaselineHttp, restrictions, ""); policy.Options.Add(policyOption); // Add ContentKeyAuthorizationPolicy to ContentKey key.AuthorizationPolicyId = policy.Id; key.Update(); assetToPublish.ContentKeys.Add(key); Uri keyAcquisitionUri = key.GetKeyDeliveryUrl(ContentKeyDeliveryType.BaselineHttp); UriBuilder uriBuilder = new UriBuilder(keyAcquisitionUri); uriBuilder.Query = String.Empty; keyAcquisitionUri = uriBuilder.Uri; // The following policy configuration specifies: // key url that will have KID=<Guid> appended to the envelope and // the Initialization Vector (IV) to use for the envelope encryption. var assetDeliveryPolicyConfiguration = new Dictionary <AssetDeliveryPolicyConfigurationKey, string> { { AssetDeliveryPolicyConfigurationKey.EnvelopeBaseKeyAcquisitionUrl, keyAcquisitionUri.ToString() }, }; var assetDeliveryPolicy = v2Client.AssetDeliveryPolicies.Create("AssetDeliveryPolicy", AssetDeliveryPolicyType.DynamicEnvelopeEncryption, AssetDeliveryProtocol.SmoothStreaming | AssetDeliveryProtocol.HLS | AssetDeliveryProtocol.Dash, assetDeliveryPolicyConfiguration); // Add AssetDelivery Policy to the asset assetToPublish.DeliveryPolicies.Add(assetDeliveryPolicy); // Create a 30-day readonly access policy. // You cannot create a streaming locator using an AccessPolicy that includes write or delete permissions. IAccessPolicy accessPolicy = v2Client.AccessPolicies.Create("Streaming Access Policy", TimeSpan.FromDays(365 * 100), AccessPermissions.Read); // Create a locator to the streaming content on an origin. ILocator originLocator = v2Client.Locators.CreateLocator(LocatorType.OnDemandOrigin, assetToPublish, accessPolicy, DateTime.UtcNow.AddMinutes(-5)); // remove the original input asset as we don't need it for demonstration purposes originalAsset.Delete(); return(assetToPublish); }