private static async Task <MetricStatus> MakeRequestAsync(ScenarioInput scenario, int subScenarioStep, int subScenario)
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(scenario.CurrentSystemLanguage);
var methodEnum = new HttpMethod(scenario.UrlFetch.Method);
httpClient.Timeout = TimeSpan.FromHours(10d);
var httpRequestMessage = new HttpRequestMessage(methodEnum, scenario.UrlFetch.ActionUrl)
{
Content = new StringContent(JsonConvert.SerializeObject(scenario.Parameters), Encoding.UTF8, "application/json")
};
return(await httpClient.SendAsync(httpRequestMessage)
.ContinueWith(x =>
{
var httpResponseMessage = x.GetAwaiter().GetResult();
if (httpResponseMessage.IsSuccessStatusCode)
{
Console.ForegroundColor = ConsoleColor.Green;
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
}
Console.WriteLine($"[{subScenarioStep.ToString().PadLeft(3)}/{subScenario.ToString().PadLeft(3)}][{httpResponseMessage.StatusCode}]: {httpResponseMessage.Content.ReadAsStringAsync().GetAwaiter().GetResult()}");
Console.ForegroundColor = ConsoleColor.White;
return JsonConvert.DeserializeObject <MetricStatus>(httpResponseMessage.Content.ReadAsStringAsync().GetAwaiter().GetResult());
})
.ConfigureAwait(false));
}
}
private static void WriteEachClientResultJson(ScenarioInput scenario)
{
if (Directory.Exists($"{scenario.Directory}\\{scenario.CurrentSystemName}"))
{
Directory.Delete($"{scenario.Directory}\\{scenario.CurrentSystemName}", true);
}
else
{
Directory.CreateDirectory($"{scenario.Directory}\\{scenario.CurrentSystemName}");
}
foreach (var scenarioResult in scenario.Bateries)
{
if (!Directory.Exists($"{scenario.Directory}\\{scenario.CurrentSystemName}\\{scenarioResult.Count}"))
{
Directory.CreateDirectory($"{scenario.Directory}\\{scenario.CurrentSystemName}\\{scenarioResult.Count}");
}
foreach (var scenarioResultClientResult in scenarioResult.ClientResults)
{
using (var streamWriter =
new StreamWriter(scenario.ResultPath(scenarioResult.Count, scenarioResultClientResult.Count)))
{
var contentJsonUnPrettyfied =
JsonConvert.SerializeObject(scenarioResultClientResult.Result, Formatting.Indented);
streamWriter.WriteLine(contentJsonUnPrettyfied);
}
}
}
}
public static void WriteCompiledResultJson(ScenarioInput scenario)
{
var baterias = scenario.Bateries.SelectMany(x => x.ClientResults).GroupBy(x => x.Count).ToList();
foreach (var bateriaGrouped in baterias)
{
var results = bateriaGrouped.Select(y => new MetricStatusCompiled
{
ClientToModuleTotalTime = y.Result.Select(x => (double)x.ClientToModule.TotalTime).GetMedian(),
ClientToModulePercentualError = y.Result
.Select(x => ((double)x.ClientToModule.Error) / ((double)x.ClientToModule.Total)).GetMedian(),
ResilienceModuleToExternalTotalSuccessTime = y.Result
.Select(x => (double)x.ResilienceModuleToExternalService.TotalSuccessTime).GetMedian(),
ResilienceModuleToExternalTotalErrorTime = y.Result
.Select(x => (double)x.ResilienceModuleToExternalService.TotalErrorTime).GetMedian(),
ResilienceModuleToExternalTotalTime =
y.Result.Select(x => (double)x.ResilienceModuleToExternalService.TotalSuccessTime + (double)x.ResilienceModuleToExternalService.TotalErrorTime).GetMedian(),
ResilienceModuleToExternalAverageTimePerRequest = y.Result
.Select(x => x.ResilienceModuleToExternalService.AverageSuccessTimePerRequest).GetMedian(),
}).ToList();
if (!Directory.Exists($"{scenario.Directory}\\{scenario.CurrentSystemName}"))
{
Directory.CreateDirectory($"{scenario.Directory}\\{scenario.CurrentSystemName}");
}
var resultCompiledPath = scenario.ResultCompiledPath(bateriaGrouped.Key);
using (var streamWriter =
new StreamWriter(resultCompiledPath))
{
var contentJsonUnPrettyfied = JsonConvert.SerializeObject(results, Formatting.Indented);
streamWriter.WriteLine(contentJsonUnPrettyfied);
}
}
}
public double ScenarioCheck([FromUri] bool scenarioCheck, [FromBody] ScenarioInput scenarioInput)
{
var applicableBudget = _db.Budgets.Where(i => i.Date >= scenarioInput.startMonth && i.Date <= scenarioInput.endMonth).ToList();
double amountPlannedToSpend = 0.00;
foreach (var budg in applicableBudget)
{
amountPlannedToSpend += (double)budg.Amount;
}
var income = _db.IncomeSources.Where(i => i.ActiveJob == true && i.EstimatedIncome != null).ToList();
double amountPlannedToEarn = 0.00;
foreach (var inc in income)
{
int multiplyNumber = 1;
//Check if the income is biweekly or monthly
// If the income is monthly, multiply the estimated income by the number of months
if (inc.PayFrequency.Contains(PaymentFrequency.Monthly))
{
multiplyNumber = Convert.ToInt32((scenarioInput.endMonth.AddMonths(1) - scenarioInput.startMonth).TotalDays / 30);
}
// If the income is biweekly, multiply the estimated income by the number of weeks divided by two
else if (inc.PayFrequency.Contains(PaymentFrequency.Biweekly))
{
multiplyNumber = Convert.ToInt32((scenarioInput.endMonth.AddMonths(1) - scenarioInput.startMonth).TotalDays / 14);
}
else if (inc.PayFrequency.Contains(PaymentFrequency.TwiceAMonth))
{
multiplyNumber = Convert.ToInt32((scenarioInput.endMonth.AddMonths(1) - scenarioInput.startMonth));
}
amountPlannedToEarn += (double)(inc.EstimatedIncome * multiplyNumber);
}
return(scenarioInput.initialAmount + amountPlannedToEarn - amountPlannedToSpend);
}
private static void ConfigProxy(ScenarioInput scenario)
{
Console.WriteLine($"Config Proxy to {scenario.ProxyConfiguration.Behavior}");
var vaurienConfigLines = File.ReadAllLines(scenario.ProxyConfiguration.VaurienConfigPath);
vaurienConfigLines[4] = $"behavior = {scenario.ProxyConfiguration.Behavior}";
using (var streamWriter = new StreamWriter(scenario.ProxyConfiguration.VaurienConfigPath))
{
foreach (var vaurienConfigLine in vaurienConfigLines)
{
streamWriter.WriteLine(vaurienConfigLine);
}
}
var p = new Process
{
StartInfo =
{
FileName = "cmd.exe",
WorkingDirectory = scenario.ProxyConfiguration.DockerComposePath,
WindowStyle = ProcessWindowStyle.Normal,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardInput = true
}
};
p.Start();
p.StandardInput.WriteLine(scenario.ProxyConfiguration.RestartVaurienContainerCommand);
Console.ForegroundColor = ConsoleColor.White;
Thread.Sleep(10000);
}
protected async Task ApplicationInsights_SucceedsTest()
{
string functionName = "Scenarios";
TestHelpers.ClearFunctionLogs(functionName);
string functionTrace = $"Function trace: {Guid.NewGuid().ToString()}";
ScenarioInput input = new ScenarioInput
{
Scenario = "appInsights",
Container = "scenarios-output",
Value = functionTrace
};
Dictionary <string, object> arguments = new Dictionary <string, object>
{
{ "input", JsonConvert.SerializeObject(input) }
};
await Fixture.Host.CallAsync(functionName, arguments);
// make sure file logs have the info
IList <string> logs = null;
await TestHelpers.Await(() =>
{
logs = TestHelpers.GetFunctionLogsAsync(functionName, throwOnNoLogs: false).Result;
return(logs.Count > 0);
});
// No need for assert; this will throw if there's not one and only one
logs.Single(p => p.EndsWith(functionTrace));
// Validate the traces. Order by message string as the requests may come in
// slightly out-of-order or on different threads
TelemetryPayload[] telemetries = _fixture.TelemetryItems
.Where(t => t.Data.BaseType == "MessageData")
.Where(t => !t.Data.BaseData.Message.Contains("Loaded custom extension"))
.OrderBy(t => t.Data.BaseData.Message)
.ToArray();
ValidateTrace(telemetries[0], "Found the following functions:\r\n", LogCategories.Startup);
ValidateTrace(telemetries[1], "Function completed (Success, Id=", LogCategories.Executor);
ValidateTrace(telemetries[2], "Function started (Id=", LogCategories.Executor);
ValidateTrace(telemetries[3], functionTrace, LogCategories.Function);
ValidateTrace(telemetries[4], "Generating 1 job function(s)", LogCategories.Startup);
ValidateTrace(telemetries[5], "Host configuration file read:", LogCategories.Startup);
ValidateTrace(telemetries[6], "Host lock lease acquired by instance ID", ScriptConstants.LogCategoryHostGeneral);
ValidateTrace(telemetries[7], "Job host started", LogCategories.Startup);
ValidateTrace(telemetries[8], "Reading host configuration file", LogCategories.Startup);
// Finally, validate the request
TelemetryPayload request = _fixture.TelemetryItems
.Where(t => t.Data.BaseType == "RequestData")
.Single();
ValidateRequest(request);
}
private static void WriteJson(ScenarioInput scenario)
{
lock (scenario)
{
WriteEachClientResultJson(scenario);
WriteCompiledResultJson(scenario);
WriteScenario(scenario);
}
}
private static void WriteTxt(ScenarioInput scenario)
{
var count = 1;
foreach (var result in scenario.Bateries)
{
using var streamWriter = new StreamWriter($"{scenario.Directory}\\{scenario.FileNameWithoutExtension}[{count}].result");
streamWriter.Write(JsonConvert.SerializeObject(result, Formatting.Indented));
count++;
}
}
public async Task Scenario_BindingData()
{
var input = new ScenarioInput
{
Scenario = "bindingData",
Value = Guid.NewGuid().ToString()
};
await Fixture.Host.BeginFunctionAsync("Scenarios", JObject.FromObject(input));
// Change assert to watch for a log
await WaitForTraceAsync("Scenarios", log => log.FormattedMessage.Contains(input.Value));
}
private void ProcessScenario(ScenarioInput scenario)
{
Console.WriteLine($"Scenario: {scenario.Directory}\\{scenario.FileName}");
Console.WriteLine(JsonConvert.SerializeObject(scenario));
ConfigProxy(scenario);
for (var currentSystemLanguage = 0; currentSystemLanguage < scenario.UrlFetch.BaseUrl.Length; currentSystemLanguage++)
{
scenario.CurrentSystem = currentSystemLanguage;
for (var count = 1; count <= scenario.Count; count++)
{
foreach (var subScenario in scenario.Clients)
{
Console.WriteLine($"Scenario: {scenario.Directory}\\{scenario.FileName}");
Console.WriteLine($"System Language: {scenario.CurrentSystemName}");
Console.WriteLine($" Bateria de Teste: {count}/{scenario.Count}");
Console.WriteLine($" SubScenario: {subScenario}");
Console.WriteLine(" Start sending");
if (File.Exists(scenario.ResultPath(count, subScenario)))
{
File.Delete(scenario.ResultPath(count, subScenario));
}
if (scenario.AsyncClients)
{
var tasks = new List <Task <MetricStatus> >();
for (var i = 1; i <= subScenario; i++)
{
tasks.Add(MakeRequestAsync(scenario, i, subScenario));
}
var results = Task.WhenAll(tasks).GetAwaiter().GetResult();
foreach (var result in results)
{
scenario.AddResult(count, subScenario, result);
}
}
else
{
for (var i = 1; i <= subScenario; i++)
{
scenario.AddResult(count, subScenario, MakeRequest(scenario, i, subScenario));
}
}
}
}
_resultWriterService.Write(scenario);
}
}
public async Task Scenario_RandGuidBinding_GeneratesRandomIDs()
{
var container = Fixture.BlobClient.GetContainerReference("scenarios-output");
if (await container.ExistsAsync())
{
BlobResultSegment blobSegment = await container.ListBlobsSegmentedAsync(null);
foreach (CloudBlockBlob blob in blobSegment.Results)
{
await blob.DeleteAsync();
}
}
// Call 3 times - expect 3 separate output blobs
for (int i = 0; i < 3; i++)
{
ScenarioInput input = new ScenarioInput
{
Scenario = "randGuid",
Container = "scenarios-output",
Value = i.ToString()
};
Dictionary <string, object> arguments = new Dictionary <string, object>
{
{ "input", JsonConvert.SerializeObject(input) }
};
await Fixture.Host.CallAsync("Scenarios", arguments);
}
var blobSegments = await container.ListBlobsSegmentedAsync(null);
var blobs = blobSegments.Results.Cast <CloudBlockBlob>().ToArray();
Assert.Equal(3, blobs.Length);
foreach (var blob in blobs)
{
string content = await blob.DownloadTextAsync();
int blobInt = int.Parse(content.Trim(new char[] { '\uFEFF', '\u200B' }));
Assert.True(blobInt >= 0 && blobInt <= 3);
}
}
private static void WriteCsv(ScenarioInput scenario)
{
// lock (scenario)
// {
// foreach (var scenarioResult in scenario.Results)
// {
// if (File.Exists(scenario.ResultPath(scenarioResult.Key)))
// return;
//
// using (var streamWriter =
// new StreamWriter(scenario.ResultPath(scenarioResult.Key)))
// {
// WriteHeaderCsv(streamWriter);
// foreach (var httpResponseMessage in scenarioResult.Value)
// streamWriter.WriteLine(httpResponseMessage.GetCsvLine());
// }
// }
// }
}
private static void WriteScenario(ScenarioInput scenario)
{
scenario.Run = false;
try
{
using (var streamWriter =
new StreamWriter($"{scenario.Directory}\\{scenario.FileName}"))
{
var contentJsonUnPrettyfied =
JsonConvert.SerializeObject(scenario.ToScenario(), Formatting.Indented);
streamWriter.WriteLine(contentJsonUnPrettyfied);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task FileLogging_SucceedsTest()
{
string functionName = "Scenarios";
TestHelpers.ClearFunctionLogs(functionName);
string guid1 = Guid.NewGuid().ToString();
string guid2 = Guid.NewGuid().ToString();
ScenarioInput input = new ScenarioInput
{
Scenario = "fileLogging",
Container = "scenarios-output",
Value = $"{guid1};{guid2}"
};
Dictionary <string, object> arguments = new Dictionary <string, object>
{
{ "input", JsonConvert.SerializeObject(input) }
};
await Fixture.Host.CallAsync(functionName, arguments);
// wait for logs to flush
await Task.Delay(FileTraceWriter.LogFlushIntervalMs);
IList <string> logs = null;
await TestHelpers.Await(() =>
{
logs = TestHelpers.GetFunctionLogsAsync(functionName, throwOnNoLogs: false).Result;
return(logs.Count > 0);
});
Assert.True(logs.Count == 4, string.Join(Environment.NewLine, logs));
// No need for assert; this will throw if there's not one and only one
logs.Single(p => p.EndsWith($"From TraceWriter: {guid1}"));
logs.Single(p => p.EndsWith($"From ILogger: {guid2}"));
}
private MetricStatus MakeRequest(ScenarioInput scenario, int subScenarioStep, int subScenario) => MakeRequestAsync(scenario, subScenarioStep, subScenario).GetAwaiter().GetResult();
protected async Task ApplicationInsights_SucceedsTest()
{
string functionName = "Scenarios";
TestHelpers.ClearFunctionLogs(functionName);
string guid = Guid.NewGuid().ToString();
ScenarioInput input = new ScenarioInput
{
Scenario = "appInsights",
Container = "scenarios-output",
Value = guid
};
Dictionary <string, object> arguments = new Dictionary <string, object>
{
{ "input", JsonConvert.SerializeObject(input) }
};
await Fixture.Host.CallAsync(functionName, arguments);
// make sure file logs have the info
IList <string> logs = null;
await TestHelpers.Await(() =>
{
logs = TestHelpers.GetFunctionLogsAsync(functionName, throwOnNoLogs: false).Result;
return(logs.Count > 0);
});
// No need for assert; this will throw if there's not one and only one
logs.Single(p => p.EndsWith(guid));
Assert.Equal(10, _fixture.TelemetryItems.Count);
// Pull out the function log and verify; it's timestamp may make the following ordering
// tough to verify.
TelemetryPayload telemetryItem = _fixture.TelemetryItems.Single(t => t.Data.BaseData.Message == guid);
ValidateTrace(telemetryItem, guid, LogCategories.Function);
_fixture.TelemetryItems.Remove(telemetryItem);
// The Host lock message is on another thread and may fire out of order.
// https://github.com/Azure/azure-webjobs-sdk-script/issues/1674
telemetryItem = _fixture.TelemetryItems.Single(t => t.Data.BaseData.Message?.StartsWith("Host lock lease acquired by instance ID") ?? false);
ValidateTrace(telemetryItem, "Host lock lease acquired by instance ID", ScriptConstants.LogCategoryHostGeneral);
_fixture.TelemetryItems.Remove(telemetryItem);
// Enqueue by time as the requests may come in slightly out-of-order
Queue <TelemetryPayload> telemetryQueue = new Queue <TelemetryPayload>();
_fixture.TelemetryItems.OrderBy(t => t.Time).ToList().ForEach(t => telemetryQueue.Enqueue(t));
telemetryItem = telemetryQueue.Dequeue();
ValidateTrace(telemetryItem, "Reading host configuration file", LogCategories.Startup);
telemetryItem = telemetryQueue.Dequeue();
ValidateTrace(telemetryItem, "Host configuration file read:", LogCategories.Startup);
telemetryItem = telemetryQueue.Dequeue();
ValidateTrace(telemetryItem, "Generating 26 job function(s)", LogCategories.Startup);
telemetryItem = telemetryQueue.Dequeue();
ValidateTrace(telemetryItem, "Found the following functions:\r\n", LogCategories.Startup);
telemetryItem = telemetryQueue.Dequeue();
ValidateTrace(telemetryItem, "Job host started", LogCategories.Startup);
// Even though the RequestTelemetry comes last, the timestamp is at the beginning of the invocation
telemetryItem = telemetryQueue.Dequeue();
ValidateRequest(telemetryItem);
telemetryItem = telemetryQueue.Dequeue();
ValidateTrace(telemetryItem, "Function started (Id=", LogCategories.Executor);
telemetryItem = telemetryQueue.Dequeue();
ValidateTrace(telemetryItem, "Function completed (Success, Id=", LogCategories.Executor);
}
public void Write(ScenarioInput scenario) => resultTypeHandler[scenario.ResultType](scenario);
