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);