private string GetSasUrl(IAsset asset)
{
// Create an 1-day readonly access policy.
IAccessPolicy streamingPolicy = mediaContext.AccessPolicies.Create("Full Access Policy",
TimeSpan.FromMinutes(20),
AccessPermissions.List | AccessPermissions.Write | AccessPermissions.Read);
// Create the origin locator. Set the start time as 5 minutes
// before the present so that the locator can be accessed immediately
// if there is clock skew between the client and server.
ILocator sasLocator =
(from l in mediaContext.Locators
where l.Type == LocatorType.Sas && l.AssetId == asset.Id
select l).FirstOrDefault();
if (sasLocator != null && sasLocator.ExpirationDateTime < DateTime.UtcNow)
{
sasLocator.Delete();
sasLocator = null;
}
if (sasLocator == null)
{
sasLocator = mediaContext
.Locators.CreateSasLocator(asset,
streamingPolicy,
DateTime.UtcNow.AddMinutes(-5));
}
// Create a full URL to the manifest file. Use this for playback
// in streaming media clients.
string sasUrl = sasLocator.Path;
return(sasUrl);
}
public void ShouldCreateAssetFile()
{
IAsset asset = _mediaContext.Assets.Create("Empty", AssetCreationOptions.StorageEncrypted);
IAssetFile file = asset.AssetFiles.CreateAsync(Path.GetFileName(_smallWmv), CancellationToken.None).Result;
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("temp", TimeSpan.FromMinutes(10), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
BlobTransferClient blobTransferClient = _mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
bool transferCompletedFired = false;
blobTransferClient.TransferCompleted += (sender, args) =>
{
transferCompletedFired = true;
Assert.AreEqual(BlobTransferType.Upload, args.TransferType, "file.UploadAsync Transfer completed expected BlobTransferType is Upload");
};
file.UploadAsync(_smallWmv, blobTransferClient, locator, CancellationToken.None).Wait();
Assert.IsNotNull(asset, "Asset should be non null");
Assert.IsTrue(transferCompletedFired, "TransferCompleted event has not been fired");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID shuold not be null");
Assert.AreEqual(AssetState.Initialized, asset.State, "Asset state wrong");
foreach (IAssetFile ifile in asset.AssetFiles)
{
if (ifile.IsPrimary)
{
Assert.IsTrue(string.Compare(Path.GetFileName(_smallWmv), ifile.Name, StringComparison.InvariantCultureIgnoreCase) == 0, "Main file is wrong");
break;
}
}
}
public void ShouldCreateAssetAsyncWithMultipleFiles()
{
string[] files = Directory.GetFiles("TestFiles");
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.None);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateSasLocator(asset, policy);
var blobclient = _mediaContext.MediaServicesClassFactory.GetBlobTransferClient();
var tasks = new List <Task>();
foreach (string filePath in files)
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
tasks.Add(file.UploadAsync(filePath, blobclient, locator, CancellationToken.None));
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(AssetState.Initialized, asset.State);
Assert.AreEqual(files.Length, asset.AssetFiles.Count());
Assert.AreEqual(1, asset.Locators.Count);
foreach (IAssetFile assetFile in asset.AssetFiles)
{
Assert.IsTrue(files.Any(f => Path.GetFileName(f).Equals(assetFile.Name, StringComparison.OrdinalIgnoreCase)));
}
}
private ILocator AssignSasLocator(IAsset asset)
{
IAccessPolicy myPolicy = azureInstance.context.AccessPolicies.Create("READPOLICYSAS", TimeSpan.FromDays(365 * 20), AccessPermissions.Read);
ILocator destination = azureInstance.context.Locators.CreateSasLocator(asset, myPolicy);
return(destination);
}
private IAccessPolicy GetAccessPolicy(bool readWrite)
{
string policyName = readWrite ? Constant.Media.AccessPolicy.ReadWritePolicyName : Constant.Media.AccessPolicy.ReadOnlyPolicyName;
IAccessPolicy accessPolicy = GetEntityByName(MediaEntity.AccessPolicy, policyName) as IAccessPolicy;
if (accessPolicy == null)
{
TimeSpan policyDuration;
AccessPermissions policyPermissions = AccessPermissions.Read;
if (readWrite)
{
string settingKey = Constant.AppSettingKey.MediaLocatorWriteDurationMinutes;
string durationMinutes = AppSetting.GetValue(settingKey);
policyDuration = new TimeSpan(0, int.Parse(durationMinutes), 0);
policyPermissions = policyPermissions | AccessPermissions.Write;
}
else
{
string settingKey = Constant.AppSettingKey.MediaLocatorReadDurationDays;
string durationDays = AppSetting.GetValue(settingKey);
policyDuration = new TimeSpan(int.Parse(durationDays), 0, 0, 0);
}
accessPolicy = _media.AccessPolicies.Create(policyName, policyDuration, policyPermissions);
}
return(accessPolicy);
}
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);
}
/// <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();
}
}
}
/// <summary>
/// Too complicated. The other method is pretty much simple.
/// </summary>
/// <param name="jobID"></param>
/// <param name="outputFolder"></param>
/// <returns></returns>
static IAsset DownloadAsset(string jobID, string outputFolder)
{
IJob job = GetJob(jobID);
IAsset outputAsset = job.OutputMediaAssets[0];
IAccessPolicy accessPolicy = context.AccessPolicies.Create("File Download Policy", TimeSpan.FromDays(30), AccessPermissions.Read);
ILocator locator = context.Locators.CreateLocator(LocatorType.Sas, outputAsset, accessPolicy);
BlobTransferClient client = new BlobTransferClient()
{
NumberOfConcurrentTransfers = 10,
ParallelTransferThreadCount = 10
};
var downloadTasks = new List <Task>();
foreach (IAssetFile outputFile in outputAsset.AssetFiles)
{
string localDownloadPath = Path.Combine(outputFolder, outputFile.Name);
Console.Write("File download path: " + localDownloadPath);
downloadTasks.Add(
outputFile.DownloadAsync(
Path.GetFullPath(localDownloadPath),
client,
locator,
CancellationToken.None)
);
}
Task.WaitAll(downloadTasks.ToArray());
return(outputAsset);
}
public void ShouldReportProgressForFile()
{
string fileName = _smallWmv;
bool reportedProgress = false;
IAsset asset = _dataContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.StorageEncrypted);
IAccessPolicy policy = _dataContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
ILocator locator = _dataContext.Locators.CreateSasLocator(asset, policy);
var info = new FileInfo(fileName);
IAssetFile file = asset.AssetFiles.Create(info.Name);
var blobclient = new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
};
blobclient.TransferProgressChanged += (s, e) =>
{
Assert.AreEqual(fileName, e.LocalFile);
Assert.IsTrue(e.BytesTransferred <= e.TotalBytesToTransfer);
reportedProgress = true;
};
file.UploadAsync(fileName, blobclient, locator, CancellationToken.None).Wait();
Assert.IsTrue(reportedProgress);
}
static void Main(string[] args)
{
string tenantDomain = args[0];
string RESTendpoint = args[1];
string assetId = args[2];
// Specify your AAD tenant domain, for example "microsoft.onmicrosoft.com"
AzureAdTokenCredentials tokenCredentials = new AzureAdTokenCredentials(tenantDomain, AzureEnvironments.AzureCloudEnvironment);
AzureAdTokenProvider tokenProvider = new AzureAdTokenProvider(tokenCredentials);
// Specify your REST API endpoint, for example "https://accountname.restv2.westcentralus.media.azure.net/API"
_context = new CloudMediaContext(new Uri(RESTendpoint), tokenProvider);
IAsset asset = GetAsset(assetId);
// Always try to reuse access policies. You only need to configure one per type of access (30 day, read for example).
var tempPolicyId = from a in _context.AccessPolicies
where a.Name == "30DayRead"
select a;
IAccessPolicy policy = null;
if (tempPolicyId.Count() < 1)
{
// This will likely only run once ever to create the policy with this specific name.
policy = _context.AccessPolicies.Create("30DayRead",
TimeSpan.FromDays(30),
AccessPermissions.Read);
}
else
{
// The policy exists already and has been found.
policy = tempPolicyId.FirstOrDefault();
}
// Create a locator to the streaming content on an origin.
ILocator originLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset,
policy,
DateTime.UtcNow.AddMinutes(-5));
}
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);
}
// Download the output asset of the specified job to a local folder.
static IAsset DownloadAssetToLocal(IAsset outputAsset, string outputFolder)
{
// Create a SAS locator to download the asset
IAccessPolicy accessPolicy = _context.AccessPolicies.Create("File Download Policy", TimeSpan.FromDays(30), AccessPermissions.Read);
ILocator locator = _context.Locators.CreateLocator(LocatorType.Sas, outputAsset, accessPolicy);
BlobTransferClient blobTransfer = new BlobTransferClient
{
NumberOfConcurrentTransfers = 20,
ParallelTransferThreadCount = 20
};
var downloadTasks = new List <Task>();
foreach (IAssetFile outputFile in outputAsset.AssetFiles)
{
// Use the following event handler to check download progress.
outputFile.DownloadProgressChanged += DownloadProgress;
string localDownloadPath = Path.Combine(outputFolder, outputFile.Name);
Console.WriteLine("File download path: " + localDownloadPath);
downloadTasks.Add(outputFile.DownloadAsync(Path.GetFullPath(localDownloadPath), blobTransfer, locator, CancellationToken.None));
outputFile.DownloadProgressChanged -= DownloadProgress;
}
Task.WaitAll(downloadTasks.ToArray());
return(outputAsset);
}
private void BuildProgressiveDownloadURLs(IAsset asset)
{
// Create a 30-day readonly access policy.
IAccessPolicy policy = _context.AccessPolicies.Create("Streaming policy",
TimeSpan.FromDays(30),
AccessPermissions.Read);
_log.Info("Policy created successfully");
// Create an OnDemandOrigin locator to the asset.
ILocator originLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset,
policy,
DateTime.UtcNow.AddMinutes(-5));
// Display some useful values based on the locator.
_log.Info("Streaming asset base path on origin: ");
_log.Info(originLocator.Path);
// Get MP4 files.
IEnumerable <IAssetFile> mp4AssetFiles = asset
.AssetFiles
.ToList()
.Where(af => af.Name.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase));
// Create a full URL to the MP4 files. Use this to progressively download files.
foreach (var pd in mp4AssetFiles)
{
_log.Info(originLocator.Path + pd.Name);
}
}
/// <summary>
/// PublishAsset - Publishes the asset with global descriptor to enable the asset for streaming.
/// </summary>
/// <param name="asset">asset</param>
/// <returns>Returns list of streaming uri's for all available streaming formats</returns>
public PublishedUrlDetails PublishAsset(IAsset asset)
{
PublishedUrlDetails publishedUrls = new PublishedUrlDetails();
var assetFile = asset.AssetFiles.Where(f => f.Name.ToLower().EndsWith(".ism")).FirstOrDefault();
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Streaming policy", TimeSpan.FromDays(365), AccessPermissions.Read);
ILocator originLocator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset, policy, DateTime.UtcNow.AddMinutes(-5));
Uri smoothStreamingUri = asset.GetSmoothStreamingUri();
Uri hlsUri = asset.GetHlsUri();
Uri mpegDashUri = asset.GetMpegDashUri();
Uri hlsv3Uri = asset.GetHlsv3Uri();
publishedUrls.SmoothUrl = smoothStreamingUri != null?smoothStreamingUri.ToString().Replace("http://", "https://") : " ";
publishedUrls.Hlsv4Uri = hlsUri != null?hlsUri.ToString().Replace("http://", "https://") : " ";
publishedUrls.Hlsv3Uri = hlsv3Uri != null?hlsv3Uri.ToString().Replace("http://", "https://") : " ";
publishedUrls.MpegDashUri = mpegDashUri != null?mpegDashUri.ToString().Replace("http://", "https://") : " ";
if (assetFile != null)
{
publishedUrls.UrlWithOriginLocator = originLocator.Path.Replace("http://", "https://") + assetFile.Name +
"/manifest";
}
return(publishedUrls);
}
public async Task <ICipherText> Encrypt(byte[] data, IPublicKey publicKey, IAccessPolicy accessPolicy)
{
try
{
var publicKeyFile = await LocalHost.WriteFileAsync(publicKey.Value);
var messageFile = await LocalHost.WriteFileAsync(data);
var encodedDataFile = LocalHost.GetRandomFilename();
await LocalHost.RunProcessAsync("cpabe-enc", $"-o {encodedDataFile} {publicKeyFile} {messageFile} \"{accessPolicy.AndGate()}\"");
var encodedDataBytes = await LocalHost.ReadFileAsync(encodedDataFile);
var encodedData = new MockCipherText()
{
Value = encodedDataBytes
};
File.Delete(publicKeyFile);
File.Delete(messageFile);
File.Delete(encodedDataFile);
return(encodedData);
}
catch (Exception exception)
{
throw new ABESchemeException($"Error has occured during encryption: {accessPolicy.AndGate()}", exception);
}
}
public void ShouldCreateAssetFileArrayWithEncryption()
{
var filePaths = new[] { WindowsAzureMediaServicesTestConfiguration.SmallWmv, WindowsAzureMediaServicesTestConfiguration.SmallWmv2 };
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();
}
// Associate an access policy with the asset so we can download the files associated with it
policy = _mediaContext.AccessPolicies.Create("Test", TimeSpan.FromMinutes(10), AccessPermissions.Read);
_mediaContext.Locators.CreateSasLocator(asset, policy);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID should not be null");
Assert.IsTrue(asset.Options == AssetCreationOptions.StorageEncrypted, "AssetCreationOptions did not have the expected value");
VerifyFileAndContentKeyMetadataForStorageEncryption(asset, _mediaContext);
VerifyStorageEncryptionOnFiles(asset, filePaths);
}
private IAsset CreateAssetAndUploadNFilesUsingAsyncCall(int expected)
{
IAsset asset = _dataContext.Assets.Create("TestWithMultipleFiles", AssetCreationOptions.None);
VerifyAsset(asset);
DirectoryInfo info = Directory.CreateDirectory(Guid.NewGuid().ToString());
var files = new List <Task>();
var client = new BlobTransferClient();
IAccessPolicy policy = _dataContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(20), AccessPermissions.Write);
ILocator locator = _dataContext.Locators.CreateSasLocator(asset, policy);
for (int i = 0; i < expected; i++)
{
string fileName;
string fullFilePath = CreateNewFileFromOriginal(info, out fileName);
IAssetFile file = asset.AssetFiles.Create(fileName);
files.Add(file.UploadAsync(fullFilePath, client, locator, CancellationToken.None));
}
Task.WaitAll(files.ToArray());
foreach (Task task in files)
{
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
Assert.IsNull(task.Exception);
}
return(asset);
}
public void TestAccessPolicyCreateRetry()
{
var dataContextMock = new Mock <IMediaDataServiceContext>();
int exceptionCount = 2;
var expected = new AccessPolicyData {
Name = "testData"
};
var fakeResponse = new TestMediaDataServiceResponse {
AsyncState = expected
};
var fakeException = new WebException("testException", WebExceptionStatus.ConnectionClosed);
dataContextMock.Setup((ctxt) => ctxt.AddObject("AccessPolicies", It.IsAny <object>()));
dataContextMock.Setup((ctxt) => ctxt
.SaveChangesAsync(It.IsAny <object>()))
.Returns(() => Task.Factory.StartNew <IMediaDataServiceResponse>(() =>
{
if (--exceptionCount > 0)
{
throw fakeException;
}
return(fakeResponse);
}));
_mediaContext.MediaServicesClassFactory = new TestMediaServicesClassFactory(dataContextMock.Object);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Empty", TimeSpan.FromSeconds(1), AccessPermissions.None);
Assert.AreEqual(expected.Name, policy.Name);
Assert.AreEqual(0, exceptionCount);
}
public void ShouldThrowArgumentExceptionWhenUploadAsyncFileNameNotEqualToAssetFileName()
{
IAsset asset = _mediaContext.Assets.Create("test", AssetCreationOptions.None);
string fileUploaded = _smallWmv;
IAssetFile fileInfo = asset.AssetFiles.Create("test.txt");
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(1),
AccessPermissions.Write);
ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.Sas, asset, policy);
try
{
fileInfo.UploadAsync(fileUploaded,
new BlobTransferClient
{
NumberOfConcurrentTransfers = 5,
ParallelTransferThreadCount = 5
},
locator,
CancellationToken.None);
}
catch (ArgumentException ex)
{
AssertFileMismatchException(fileUploaded, ex);
throw;
}
}
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 override void Fill(NumericTextBoxPropertyBag propertyBag, FillerParams fillerParams)
{
if (fillerParams.SkipSecurityFill == false)
{
IModelPropertyConfiguration propertyConfig = ReadPropertyConfiguration(fillerParams.ModelName, fillerParams.PropertyName, fillerParams.ConfigKey);
if (propertyConfig != null && propertyConfig.PropertyConfiguration != null)
{
IAccessPolicy accessSecurity = GetAccess(propertyConfig.PropertyConfiguration.Security);
if (accessSecurity != null)
{
propertyBag.Enabled = accessSecurity.Enabled;
propertyBag.ReadOnly = accessSecurity.ReadOnly;
propertyBag.Masking = accessSecurity.Masking;
propertyBag.Visibility = accessSecurity.Visibility;
}
}
else
{
setDefalutSecurity(propertyBag);
}
}
else
{
setDefalutSecurity(propertyBag);
}
}
private IAsset CreateAndConfigureAsset(ZetronMstIncidents zetronMstIncidents, out ILocator originLocator)
{
//Create asset
IAsset asset = null;
try
{
asset = _mediaContext.Assets.Create("Asset_" + zetronMstIncidents.IncidentId.ToString(), AssetCreationOptions.None);
// Create a 30 - day readonly access policy.
IAccessPolicy accessPolicy = _mediaContext.AccessPolicies.Create("Streaming policy",
TimeSpan.FromDays(30),
AccessPermissions.Read);
// Create a locator to the streaming content on an origin.
originLocator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset,
accessPolicy,
DateTime.UtcNow.AddMinutes(-5));
}
catch (Exception ex)
{
Log(ex.Message);
throw;
}
return(asset);
}
public void ShouldVerifyParametersInLocatorCreate()
{
IAsset asset = _mediaContext.Assets.Create("Test", AssetCreationOptions.None);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Test", TimeSpan.FromDays(1), AccessPermissions.Read);
bool assetNullverified = false;
try
{
_mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, null, policy);
}
catch (ArgumentNullException)
{
assetNullverified = true;
}
bool policyNullverified = false;
try
{
_mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset, null);
}
catch (ArgumentNullException)
{
policyNullverified = true;
}
Assert.IsTrue(assetNullverified, "Expecting ArgumentNullException passing asset as null");
Assert.IsTrue(policyNullverified, "Expecting ArgumentNullException passing policy as null");
}
public String GetSasUrl(IAsset asset, TimeSpan accessPolicyTimeout)
{
// Create a policy for the asset.
IAccessPolicy readPolicy = mediaContext.AccessPolicies.Create("My Test Policy", accessPolicyTimeout, AccessPermissions.Read);
ILocator locator = mediaContext.Locators.CreateSasLocator(asset,
readPolicy,
DateTime.UtcNow.AddMinutes(-5));
// Print the path for the locator you created.
Console.WriteLine("Locator path: ");
Console.WriteLine(locator.Path);
Console.WriteLine();
var theOutputFile =
from f in asset.Files
where f.Name.EndsWith(".mp4")
select f;
// Cast the IQueryable variable back to an IFileInfo.
IFileInfo theFile = theOutputFile.FirstOrDefault();
string fileName = theFile.Name;
// Now take the locator path, add the file name, and build a complete SAS URL to browse to the asset.
var uriBuilder = new UriBuilder(locator.Path);
uriBuilder.Path += "/" + fileName;
// Print the full SAS URL
Console.WriteLine("Full URL to file: ");
Console.WriteLine(uriBuilder.Uri.AbsoluteUri);
Console.WriteLine();
//writeToFile(uriBuilder.Uri.AbsoluteUri, output);
// Return the SAS URL.
return(uriBuilder.Uri.AbsoluteUri);
}
public void LocatorCRUD()
{
ILocator stubed = _mediaContext.Locators.FirstOrDefault();
Assert.IsNotNull(stubed);
Assert.IsNotNull(stubed.Asset);
Assert.IsNotNull(stubed.AccessPolicy);
IAsset asset = _mediaContext.Assets.Create("Test", AssetCreationOptions.None);
IAccessPolicy policy = _mediaContext.AccessPolicies.Create("Test", TimeSpan.FromDays(1), AccessPermissions.Read);
ILocator locator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset, policy);
Assert.IsNotNull(locator.AccessPolicy);
Assert.IsNotNull(locator.Asset);
locator.Update(DateTime.UtcNow.AddDays(5));
locator.Update(DateTime.UtcNow.AddDays(1), DateTime.UtcNow.AddDays(5));
locator.UpdateAsync(DateTime.UtcNow.AddDays(5));
locator.Delete();
Assert.IsNull(_mediaContext.Locators.Where(c => c.Id == locator.Id).FirstOrDefault());
ILocator sas = _mediaContext.Locators.CreateSasLocator(asset, policy);
sas.Delete();
sas = _mediaContext.Locators.CreateSasLocatorAsync(asset, policy).Result;
sas.Delete();
ILocator sasAsync = _mediaContext.Locators.CreateSasLocatorAsync(asset, policy, DateTime.UtcNow, "Name").Result;
sasAsync.DeleteAsync().Wait();
}
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);
}
public static string PublishAndBuildStreamingURLs(String jobID, CloudMediaContext _context)
{
string urlForClientStreaming;
try
{
IJob job = _context.Jobs.Where(j => j.Id == jobID).FirstOrDefault();
IAsset asset = job.OutputMediaAssets.FirstOrDefault();
// Create a 30-day readonly access policy.
// You cannot create a streaming locator using an AccessPolicy that includes write or delete permissions.
IAccessPolicy policy = _context.AccessPolicies.Create($"{asset.Name}_Streaming_Policy", TimeSpan.FromDays(30), AccessPermissions.Read);
// Create a locator to the streaming content on an origin.
ILocator originLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset, policy, DateTime.UtcNow.AddMinutes(-5));
// Get a reference to the streaming manifest file from the
// collection of files in the asset.
var manifestFile = asset.AssetFiles.ToList().Where(f => f.Name.ToLower().EndsWith(".ism")).FirstOrDefault();
// Create a full URL to the manifest file. Use this for playback
// in streaming media clients.
//urlForClientStreaming = originLocator.Path + manifestFile.Name + "/manifest";
urlForClientStreaming = originLocator.Path + manifestFile.Name + "/manifest" + "(format=m3u8-aapl)?video.m3u8";
}
catch (Exception)
{
return(null);
}
return(urlForClientStreaming);
}
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 ShouldCreateAssetFileArrayWithPlayReadyEncryption()
{
// Note that these files are not really PlayReady encrypted. For the purposes of this test that is okay.
IAsset asset = _mediaContext.Assets.Create(Guid.NewGuid().ToString(), AssetCreationOptions.CommonEncryptionProtected);
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 new[] { WindowsAzureMediaServicesTestConfiguration.SmallWmv, WindowsAzureMediaServicesTestConfiguration.SmallWmv2 })
{
var info = new FileInfo(filePath);
IAssetFile file = asset.AssetFiles.Create(info.Name);
file.UploadAsync(filePath, blobclient, locator, CancellationToken.None).Wait();
}
Guid keyId = Guid.NewGuid();
byte[] contentKey = GetRandomBuffer(16);
IContentKey key = _mediaContext.ContentKeys.Create(keyId, contentKey);
asset.ContentKeys.Add(key);
Assert.IsNotNull(asset, "Asset should be non null");
Assert.AreNotEqual(Guid.Empty, asset.Id, "Asset ID should not be null");
Assert.IsTrue(asset.Options == AssetCreationOptions.CommonEncryptionProtected, "AssetCreationOptions did not have the expected value");
VerifyFileAndContentKeyMetadataForCommonEncryption(asset);
VerifyContentKeyVersusExpectedValue2(asset, contentKey, keyId);
}
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;
}
}
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;
}
}
}
}
