public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
HttpRequest req, ILogger log, Microsoft.Azure.WebJobs.ExecutionContext execContext)
{
MediaServicesHelpers.LogInformation(log, "C# HTTP trigger function processed a request.");
dynamic data;
try
{
data = JsonConvert.DeserializeObject(new StreamReader(req.Body).ReadToEnd());
}
catch (Exception ex)
{
return(IrdetoHelpers.ReturnErrorException(log, ex));
}
var generalOutputInfos = new List <GeneralOutputInfo>();
var assetName = (string)data.assetName;
if (assetName == null)
{
return(IrdetoHelpers.ReturnErrorException(log, "Error - please pass assetName in the JSON"));
}
var fileName = (string)data.fileName;
ManifestGenerated smildata = null;
VodSemaphore semaphore = null;
if (data.semaphore != null)
{
semaphore = VodSemaphore.FromJson((string)data.semaphore);
}
// Azure region management
var azureRegions = new List <string>();
if ((string)data.azureRegion != null)
{
azureRegions = ((string)data.azureRegion).Split(',').ToList();
}
else
{
azureRegions.Add((string)null);
}
foreach (var region in azureRegions)
{
ConfigWrapper config = new ConfigWrapper(new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddEnvironmentVariables()
.Build(),
region
);
MediaServicesHelpers.LogInformation(log, "config loaded.", region);
MediaServicesHelpers.LogInformation(log, "connecting to AMS account : " + config.AccountName, region);
var client = await MediaServicesHelpers.CreateMediaServicesClientAsync(config);
// Set the polling interval for long running operations to 2 seconds.
// The default value is 30 seconds for the .NET client SDK
client.LongRunningOperationRetryTimeout = 2;
MediaServicesHelpers.LogInformation(log, "asset name : " + assetName, region);
var asset = client.Assets.Get(config.ResourceGroup, config.AccountName, assetName);
if (asset == null)
{
throw new Exception($"Asset {asset} does not exist.");
}
// Access to container
ListContainerSasInput input = new ListContainerSasInput()
{
Permissions = AssetContainerPermission.ReadWriteDelete,
ExpiryTime = DateTime.Now.AddHours(2).ToUniversalTime()
};
var responseListSas = await client.Assets.ListContainerSasAsync(config.ResourceGroup, config.AccountName, asset.Name, input.Permissions, input.ExpiryTime);
string uploadSasUrl = responseListSas.AssetContainerSasUrls.First();
var sasUri = new Uri(uploadSasUrl);
var container = new CloudBlobContainer(sasUri);
// Manifest generate
smildata = (semaphore == null) ? await ManifestHelpers.LoadAndUpdateManifestTemplate(asset, container, execContext, fileName)
: await ManifestHelpers.LoadAndUpdateManifestTemplateUsingSemaphore(semaphore, execContext, fileName);
// if not file name passed, then we use the one generated based on mp4 files names
if (fileName == null)
{
fileName = smildata.FileName;
}
var blob = container.GetBlockBlobReference(fileName);
using (Stream s = ManifestHelpers.GenerateStreamFromString(smildata.Content))
{
await blob.UploadFromStreamAsync(s);
}
}
var response = new JObject
{
{ "success", true },
{ "fileName", fileName },
{ "manifestContent", smildata.Content },
{
"operationsVersion",
AssemblyName.GetAssemblyName(Assembly.GetExecutingAssembly().Location).Version.ToString()
}
};
return(new OkObjectResult(
response
));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
HttpRequest req, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
dynamic data;
try
{
data = JsonConvert.DeserializeObject(new StreamReader(req.Body).ReadToEnd());
}
catch (Exception ex)
{
return(IrdetoHelpers.ReturnErrorException(log, ex));
}
var assetName = (string)data.assetName;
if (assetName == null)
{
return(IrdetoHelpers.ReturnErrorException(log, "Error - please pass assetName in the JSON"));
}
// Azure region management
var azureRegions = new List <string>();
if ((string)data.azureRegion != null)
{
azureRegions = ((string)data.azureRegion).Split(',').ToList();
}
else
{
azureRegions.Add((string)null);
}
// semaphore file (json structure)
VodSemaphore semaphore = null;
if (data.semaphore != null)
{
semaphore = VodSemaphore.FromJson((string)data.semaphore);
}
// init default
var streamingLocatorGuid = Guid.NewGuid(); // same locator for the two ouputs if 2 live event namle created
var uniquenessLocator = streamingLocatorGuid.ToString().Substring(0, 13);
var streamingLocatorName = "locator-" + uniquenessLocator;
string locatorPath = string.Empty;
string uniquenessPolicyName = Guid.NewGuid().ToString().Substring(0, 13);
// Default content id and semaphare value
string irdetoContentId = null;
if (semaphore != null && semaphore.DrmContentId != null) // semaphore data has higher priority
{
irdetoContentId = semaphore.DrmContentId;
}
else if (data.defaultIrdetoContentId != null)
{
irdetoContentId = (string)data.defaultIrdetoContentId;
}
var clientTasks = new List <Task <AssetEntry> >();
foreach (var region in azureRegions)
{
var task = Task <AssetEntry> .Run(async() =>
{
Asset asset = null;
ConfigWrapper config = new ConfigWrapper(new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddEnvironmentVariables()
.Build(),
region
);
MediaServicesHelpers.LogInformation(log, "config loaded.", region);
MediaServicesHelpers.LogInformation(log, "connecting to AMS account : " + config.AccountName, region);
var client = await MediaServicesHelpers.CreateMediaServicesClientAsync(config);
// Set the polling interval for long running operations to 2 seconds.
// The default value is 30 seconds for the .NET client SDK
client.LongRunningOperationRetryTimeout = 2;
// let's get the asset
try
{
MediaServicesHelpers.LogInformation(log, "Getting asset.", region);
asset = await client.Assets.GetAsync(config.ResourceGroup, config.AccountName, assetName);
}
catch (Exception ex)
{
throw new Exception("Error when retreving asset by name", ex);
}
// Locator creation
try
{
StreamingLocator locator = null;
locator = await IrdetoHelpers.CreateClearLocator(config, streamingLocatorName, client, asset, streamingLocatorGuid);
MediaServicesHelpers.LogInformation(log, "locator : " + locator.Name, region);
}
catch (Exception ex)
{
throw new Exception("Error when creating the locator", ex);
}
// let's build info for the live event and output
AssetEntry assetEntry = await GenerateInfoHelpers.GenerateAssetInformation(config, client, asset, semaphore, irdetoContentId, region);
var locatorPath2 = assetEntry.StreamingLocators.Where(l => l.StreamingLocatorName == streamingLocatorName).First().Urls.Where(u => u.Protocol == OutputProtocol.SmoothStreaming.ToString()).First().Url;
var uriloc = new Uri(locatorPath2);
locatorPath = uriloc.Scheme + "://" + uriloc.Host + "/" + uriloc.Segments[1];
if (!await CosmosHelpers.CreateOrUpdateAssetDocument(assetEntry))
{
log.LogWarning("Cosmos access not configured.");
}
return(assetEntry);
});
clientTasks.Add(task);
}
try
{
Task.WaitAll(clientTasks.ToArray());
}
catch (Exception ex)
{
return(IrdetoHelpers.ReturnErrorException(log, ex));
}
return(new OkObjectResult(
JsonConvert.SerializeObject(new VodAssetInfoSimple {
CreatedLocatorName = streamingLocatorName, CreatedLocatorPath = locatorPath, Success = true, Asset = clientTasks.Select(i => i.Result).First()
}, Formatting.Indented)
));
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]
HttpRequest req, ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
dynamic data;
try
{
data = JsonConvert.DeserializeObject(new StreamReader(req.Body).ReadToEnd());
}
catch (Exception ex)
{
return(IrdetoHelpers.ReturnErrorException(log, ex));
}
var assetName = (string)data.assetName;
if (assetName == null)
{
return(IrdetoHelpers.ReturnErrorException(log, "Error - please pass assetName in the JSON"));
}
// Azure region management
var azureRegions = new List <string>();
if ((string)data.azureRegion != null)
{
azureRegions = ((string)data.azureRegion).Split(',').ToList();
}
else
{
azureRegions.Add((string)null);
}
// semaphore file (json structure)
VodSemaphore semaphore = null;
if (data.semaphore != null)
{
semaphore = VodSemaphore.FromJson((string)data.semaphore);
}
// init default
var streamingLocatorGuid = Guid.NewGuid(); // same locator for the two ouputs if 2 live event namle created
var uniquenessLocator = streamingLocatorGuid.ToString().Substring(0, 13);
var streamingLocatorName = "locator-" + uniquenessLocator;
string uniquenessPolicyName = Guid.NewGuid().ToString().Substring(0, 13);
// useDRM init
var useDRM = true;
if (data.useDRM != null)
{
useDRM = (bool)data.useDRM;
}
else if (semaphore != null & semaphore.ClearStream != null)
{
useDRM = !(bool)semaphore.ClearStream;
}
// Default content id and semaphare value
string irdetoContentId = null;
if (semaphore != null && semaphore.DrmContentId != null) // semaphore data has higher priority
{
irdetoContentId = semaphore.DrmContentId;
}
else if (data.defaultIrdetoContentId != null)
{
irdetoContentId = (string)data.defaultIrdetoContentId;
}
DateTime?startTime = null;
DateTime?endTime = null;
try
{
if (semaphore != null && semaphore.StartTime != null)
{
startTime = DateTime.ParseExact(semaphore.StartTime, AssetEntry.DateFormat, System.Globalization.CultureInfo.InvariantCulture);
}
if (semaphore != null && semaphore.EndTime != null)
{
endTime = DateTime.ParseExact(semaphore.EndTime, AssetEntry.DateFormat, System.Globalization.CultureInfo.InvariantCulture);
}
}
catch (Exception ex)
{
return(IrdetoHelpers.ReturnErrorException(log, ex));
}
var cencKey = new StreamingLocatorContentKey();
var cbcsKey = new StreamingLocatorContentKey();
if (useDRM)
{
try
{
ConfigWrapper config = new ConfigWrapper(new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddEnvironmentVariables()
.Build(),
null);
MediaServicesHelpers.LogInformation(log, "Irdeto call...");
cencKey = await IrdetoHelpers.GenerateAndRegisterCENCKeyToIrdeto(irdetoContentId, config);
cbcsKey = await IrdetoHelpers.GenerateAndRegisterCBCSKeyToIrdeto(irdetoContentId, config);
MediaServicesHelpers.LogInformation(log, "Irdeto call done.");
}
catch (Exception ex)
{
return(IrdetoHelpers.ReturnErrorException(log, ex, "Irdeto response error"));
}
}
var clientTasks = new List <Task <AssetEntry> >();
foreach (var region in azureRegions)
{
var task = Task <AssetEntry> .Run(async() =>
{
Asset asset = null;
StreamingPolicy streamingPolicy = null;
ConfigWrapper config = new ConfigWrapper(new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddEnvironmentVariables()
.Build(),
region
);
MediaServicesHelpers.LogInformation(log, "config loaded.", region);
MediaServicesHelpers.LogInformation(log, "connecting to AMS account : " + config.AccountName, region);
var client = await MediaServicesHelpers.CreateMediaServicesClientAsync(config);
// Set the polling interval for long running operations to 2 seconds.
// The default value is 30 seconds for the .NET client SDK
client.LongRunningOperationRetryTimeout = 2;
if (useDRM)
{
MediaServicesHelpers.LogInformation(log, "Trying to read streaming policy from Cosmos.", region);
string streamingPolicyName = null;
// Load streaming policy info from Cosmos
try
{
var info = await CosmosHelpers.ReadStreamingPolicyDocument(new StreamingPolicyInfo(true)
{
AMSAccountName = config.AccountName
});
if (info == null)
{
log.LogWarning("Streaming policy not read from Cosmos.");
}
else
{
streamingPolicyName = info.StreamingPolicyName;
}
}
catch (Exception ex)
{
throw new Exception("Error reading Cosmos DB", ex);
}
// STREAMING POLICY CREATION
if (streamingPolicyName == null) // not found in Cosmos let's create a new one
{
MediaServicesHelpers.LogInformation(log, "Creating streaming policy.", region);
try
{
streamingPolicy = await IrdetoHelpers.CreateStreamingPolicyIrdeto(config, client, uniquenessPolicyName);
}
catch (Exception ex)
{
throw new Exception("Streaming policy creation error", ex);
}
try
{
if (!await CosmosHelpers.CreateOrUpdatePolicyDocument(new StreamingPolicyInfo(true)
{
AMSAccountName = config.AccountName,
StreamingPolicyName = streamingPolicy.Name
}))
{
log.LogWarning("Cosmos access not configured or error.");
}
}
catch (Exception ex)
{
throw new Exception("Streaming policy write error to Cosmos", ex);
}
}
else
{
MediaServicesHelpers.LogInformation(log, "Getting streaming policy in AMS.", region);
try
{
streamingPolicy = await client.StreamingPolicies.GetAsync(config.ResourceGroup, config.AccountName, streamingPolicyName);
}
catch (Exception ex)
{
throw new Exception("Error when getting streaming policy " + streamingPolicy, ex);
}
}
}
// let's get the asset
try
{
MediaServicesHelpers.LogInformation(log, "Getting asset.", region);
asset = await client.Assets.GetAsync(config.ResourceGroup, config.AccountName, assetName);
}
catch (Exception ex)
{
throw new Exception("Error when retreving asset by name", ex);
}
// Locator creation
try
{
StreamingLocator locator = null;
if (useDRM)
{
locator = await IrdetoHelpers.SetupDRMAndCreateLocatorWithNewKeys(config, streamingPolicy.Name,
streamingLocatorName, client, asset, cencKey, cbcsKey, streamingLocatorGuid, irdetoContentId, startTime, endTime);
}
else // no DRM
{
locator = await IrdetoHelpers.CreateClearLocator(config, streamingLocatorName, client, asset, streamingLocatorGuid, startTime, endTime);
}
MediaServicesHelpers.LogInformation(log, "locator : " + locator.Name, region);
}
catch (Exception ex)
{
throw new Exception("Error when creating the locator", ex);
}
// let's build info for the live event and output
AssetEntry assetEntry = await GenerateInfoHelpers.GenerateAssetInformation(config, client, asset, semaphore, irdetoContentId, region);
if (!await CosmosHelpers.CreateOrUpdateAssetDocument(assetEntry))
{
log.LogWarning("Cosmos access not configured.");
}
return(assetEntry);
});
clientTasks.Add(task);
}
try
{
Task.WaitAll(clientTasks.ToArray());
}
catch (Exception ex)
{
return(IrdetoHelpers.ReturnErrorException(log, ex));
}
return(new OkObjectResult(
JsonConvert.SerializeObject(new VodAssetInfo {
Success = true, Assets = clientTasks.Select(i => i.Result).ToList()
}, Formatting.Indented)
));
}
