Commit 5bc5fa08: First Commit - Migrating from GH repo

First Commit - Migrating from GH repo

5bc5fa08

Varad

committed Jul 7, 2022

Files

Details



	Cache.cs +
	Function1.cs +
	GetLoaderioTestGroupActivity.cs +
	GetLoaderioTestGroupInput.cs +
	Helpers.cs +
	HitProxyUrlActivity.cs +
	host.json +
	LoaderioActivity.cs +
	LoaderioOrchestration.cs +
	LoaderioTest.cs +
	LoaderioTestGroup.cs +
	MasterOrchestration.cs +
	MasterOrchestrationInput.cs +
	RequestType.cs +
	RestartFunctionAppActivity.cs +
	ScaleChangeActivity.cs +
	SKUMatchActivity.cs +
	TableCommands.txt +
	TestScheduler.csproj +
	TestScheduler.sln +
	Webhook.cs +

Cache.cs

+24

/Cache.cs

View

using Newtonsoft.Json.Linq;

using System.Collections.Generic;

public static class Cache

{

public static void Initialize(string clientId, string servicePrincipalPassword, string tenantId, string loaderioKey)

{

FunctionappDomainToDetails = new Dictionary<string, JObject>();

Scenarios = new List<JObject>();

ScenariosSplitByOSAndSKU = new Dictionary<string, List<JObject>>();

ClientId = clientId;

ServicePrincipalPassword = servicePrincipalPassword;

TenantId = tenantId;

LoaderioKey = loaderioKey;

}

public static IDictionary<string, JObject> FunctionappDomainToDetails;

public static List<JObject> Scenarios;

public static IDictionary<string, List<JObject>> ScenariosSplitByOSAndSKU;

public static string ClientId;

public static string ServicePrincipalPassword;

public static string TenantId;

public static string LoaderioKey;

}

Function1.cs

+119

/Function1.cs

View

using System;

using System.Collections.Generic;

using System.IO;

using System.Threading.Tasks;

using Microsoft.Azure.WebJobs;

using Microsoft.Azure.WebJobs.Extensions.DurableTask;

using Microsoft.Extensions.Configuration;

using Microsoft.Extensions.Logging;

using Newtonsoft.Json.Linq;

namespace TestScheduler

{

public class Function1

{

private readonly ILogger _logger;

public Function1(ILoggerFactory loggerFactory)

{

_logger = loggerFactory.CreateLogger("Microsoft.Azure.WebJobs.LoaderioTestScheduler");

}

[FunctionName("Function1")]

public void Run(

Microsoft.Azure.WebJobs.ExecutionContext context,

[TimerTrigger("0 */8 * * *")]TimerInfo timeInfo,

[DurableClient] IDurableOrchestrationClient starter,

ILogger log)

{

_logger.LogInformation($"C# Timer trigger function executing at: {DateTime.UtcNow}");

var config = new ConfigurationBuilder()

.SetBasePath(context.FunctionAppDirectory)

.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)

.AddEnvironmentVariables()

.Build();

string clientId = config["ClientId"];

string servicePrincipalPassword = config["ServicePrincipalPassword"];

string loaderioKey = config["LoaderioAPIKey"];

string loaderioTestURL = config["LoaderioTestsURL"];

string tenantId = config["TenantId"];

var masterOrchestrationsInGroups = new List<Task>();

ClearAndPopulateCache(loaderioTestURL, clientId, servicePrincipalPassword, tenantId, loaderioKey);

// Start Master orchestration for each group

foreach (string key in Cache.ScenariosSplitByOSAndSKU.Keys)

{

try

{

_logger.LogInformation($"Enqueuing master orchestration for group {key}");

// masterOrchestrationsInGroups.Add(starter.StartNewAsync(orchestratorFunctionName: "MasterOrchestration", input: key));

masterOrchestrationsInGroups.Add(starter.StartNewAsync(orchestratorFunctionName: "MasterOrchestration", input: new MasterOrchestrationInput(key, Cache.ScenariosSplitByOSAndSKU[key], clientId, servicePrincipalPassword, tenantId, loaderioKey)));

}

catch (Exception ex)

{

_logger.LogError(ex, $"Error while processing group key {key}");

}

_logger.LogInformation($"C# Timer trigger function completed at: {DateTime.UtcNow}");

}

private void ClearAndPopulateCache(string loaderioTestsUrl, string clientId, string servicePrincipalPassword, string tenantId, string loaderioKey)

{

try

{

using (StreamReader file = new StreamReader(Helpers.GetLoaderioTests(loaderioTestsUrl)))

{

string line = null;

Cache.Initialize(clientId, servicePrincipalPassword, tenantId, loaderioKey);

while ((line = file.ReadLine()) != null)

{

try

{

JObject testGroup = JObject.Parse(line);

string appName = testGroup.Value<string>("AppName");

string domain = $"{appName}.azurewebsites.net";

// Split

string[] SplitAppName = appName.Split('-');

string key = $"{SplitAppName[1].ToLower()}-{SplitAppName[2].ToLower()}"; // {SKU}-{OS}

if(appName.Contains("euap", StringComparison.OrdinalIgnoreCase))

{

key = "euap"; // EUAP apps belong to separate group

}

if(!Cache.ScenariosSplitByOSAndSKU.ContainsKey(key))

{

Cache.ScenariosSplitByOSAndSKU.Add(key, new List<JObject>());

}

Cache.ScenariosSplitByOSAndSKU[key].Add(testGroup);

_logger.LogInformation($"Added {testGroup} to group {key}");

Cache.Scenarios.Add(testGroup);

Cache.FunctionappDomainToDetails.Add(domain, testGroup);

}

catch (Exception ex)

{

_logger.LogError(ex, $"Exception while populating cache for line {line}");

}

// For testing/debugging

foreach(var key in Cache.ScenariosSplitByOSAndSKU.Keys)

{

_logger.LogInformation($"{key} has a value count of {Cache.ScenariosSplitByOSAndSKU[key].Count}");

}

catch (Exception ex)

{

_logger.LogError(ex, $"Exception while clearing/populating cache");

}

GetLoaderioTestGroupActivity.cs

+107

/GetLoaderioTestGroupActivity.cs

View

using System;

using System.Threading.Tasks;

using Microsoft.Azure.WebJobs;

using Microsoft.Azure.WebJobs.Extensions.DurableTask;

using Microsoft.Extensions.Logging;

using Newtonsoft.Json.Linq;

namespace TestScheduler

{

public class GetLoaderioTestGroupActivity

{

private readonly ILogger _logger;

public GetLoaderioTestGroupActivity(ILoggerFactory loggerFactory)

{

_logger = loggerFactory.CreateLogger("Microsoft.Azure.WebJobs.GetLoaderioTestGroupActivity");

}

[FunctionName("GetLoaderioTestGroupActivity")]

public async Task<LoaderioTestGroup> Run(

[ActivityTrigger] IDurableActivityContext context)

{

//JObject testGroup = context.GetInput<JObject>();

GetLoaderioTestGroupInput testGroupInput = context.GetInput<GetLoaderioTestGroupInput>();

JObject testGroup = testGroupInput.TestGroup;

LoaderioTestGroup group = new LoaderioTestGroup();

string appName = testGroup.Value<string>("AppName");

bool shouldWarmUp = !appName.Contains("ep", StringComparison.OrdinalIgnoreCase) && !appName.Contains("cns", StringComparison.OrdinalIgnoreCase);

_logger.LogInformation($"Warmup value is {shouldWarmUp} for {appName}");

group.SubscriptionId = testGroup.Value<string>("SubscriptionId");

group.ResourceGroup = testGroup.Value<string>("ResourceGroup");

group.AppName = appName;

group.ClientId = testGroupInput.ClientId;

group.ServicePrincipalPassword = testGroupInput.ServicePrincipalPassword;

group.TenantId = testGroupInput.TenantId;

string[] testIds = (testGroup.Value<JArray>("LoaderioTestIDs")).ToObject<string[]>();

foreach (string testId in testIds)

{

group.LoaderioTestsWithinGroup.Add(GetTestInvocationDetails(testId, testGroupInput.LoaderioKey, shouldWarmUp));

}

// Wait time between tests

group.WaitTimeBetweenTestsInMinutes = 30;

// Populate current SKU

string token = await Helpers.GetToken(group.ClientId, group.ServicePrincipalPassword, group.TenantId);

group.CurrentSKU = GetCurrentSKUAsync(token, group.SubscriptionId, group.ResourceGroup, appName);

return group;

}

private LoaderioTest GetTestInvocationDetails(string testId, string loaderioKey, bool shouldWarmUp = false)

{

JToken testDetails = Helpers.GetTestDetails(testId, loaderioKey);

JToken testDetail = testDetails.Value<JArray>("urls")[0];

LoaderioTest testParams = new LoaderioTest()

{

Content = testDetail.Value<string>("raw_post_body"),

RequestType = (RequestType)Enum.Parse(typeof(RequestType), testDetail.Value<string>("request_type"), true),

FunctionAppUrlForColdstart = testDetail.Value<string>("url"),

LoaderioTestUrl = $"https://api.loader.io/v2/tests/{testId}/run",

LoaderioStopUrl = $"https://api.loader.io/v2/tests/{testId}/stop",

ContentType = testDetail.Value<JObject>("headers").Value<string>("Content-Type"), // ContentType would be null if not present

LoaderioKey = loaderioKey,

ShouldWarmUp = shouldWarmUp,

};

return testParams;

}

private JObject GetCurrentSKUAsync(string token, string subscriptionId, string resourceGroup, string appName)

{

try

{

string serverFarmId = Helpers.GetServerFarmId(token, subscriptionId, resourceGroup, appName, _logger);

if (string.IsNullOrEmpty(serverFarmId))

{

_logger.LogError($"Server farm id for {appName} is empty");

return null;

}

JObject serverFarmDetails = Helpers.GetServerFarmDetails(token, serverFarmId, _logger);

if (serverFarmDetails == null)

{

_logger.LogError($"Server farm details for {serverFarmId} is null");

return null;

}

return serverFarmDetails.Value<JObject>("sku");

}

catch (Exception ex)

{

_logger.LogError(ex, $"Exception while trying to Get SKU {appName}");

}

return null;

}

GetLoaderioTestGroupInput.cs

/GetLoaderioTestGroupInput.cs

View

Helpers.cs

/Helpers.cs

View

HitProxyUrlActivity.cs

/HitProxyUrlActivity.cs

View

host.json

/host.json

View

LoaderioActivity.cs

/LoaderioActivity.cs

View

LoaderioOrchestration.cs

/LoaderioOrchestration.cs

View

LoaderioTest.cs

/LoaderioTest.cs

View

LoaderioTestGroup.cs

/LoaderioTestGroup.cs

View

MasterOrchestration.cs

/MasterOrchestration.cs

View

MasterOrchestrationInput.cs

/MasterOrchestrationInput.cs

View

RequestType.cs

/RequestType.cs

View

RestartFunctionAppActivity.cs

/RestartFunctionAppActivity.cs

View

ScaleChangeActivity.cs

/ScaleChangeActivity.cs

View

SKUMatchActivity.cs

/SKUMatchActivity.cs

View

TableCommands.txt

/TableCommands.txt

View

TestScheduler.csproj

/TestScheduler.csproj

View

TestScheduler.sln

/TestScheduler.sln

View

Webhook.cs

/Webhook.cs

View