public JsonLogger getJsonLogger()
{
if (this.logger == null)
{
this.logger = new JsonLogger(serverURL, UseDotNetHTTP());
}
return this.logger;
}
private void getALogger()
{
if (logger == null)
{
logger = (GetComponent("JsonHelper") as JsonHelper).getJsonLogger();
if (logger == null) Debug.Log("logger is null!!");
}
}
private void resetJsonLogger()
{
disposeLogger();
var fileName = string.Format("log-{0}.json", DateTime.Now.ToString("yyyy-MM-dd[hh-mm-ss]"));
var path = Path.Combine(ThisGuiModelData.DumperSettings.DumperDirectory, fileName);
_jsonLogger = new JsonLogger(path);
}
public double GetNumber(string key)
{
var value = GetValue(key);
if (value == null)
{
JsonLogger.Error(key + " == null");
return(double.NaN);
}
return(value.Number);
}
public JsonObject GetObject(string key)
{
var value = GetValue(key);
if (value == null)
{
JsonLogger.Error(key + " == null");
return(null);
}
return(value.Obj);
}
public bool GetBoolean(string key)
{
var value = GetValue(key);
if (value == null)
{
JsonLogger.Error(key + " == null");
return(false);
}
return(value.Boolean);
}
public JsonArray GetArray(string key)
{
var value = GetValue(key);
if (value == null)
{
JsonLogger.Error(key + " == null");
return(null);
}
return(value.Array);
}
public string GetString(string key)
{
var value = GetValue(key);
if (value == null)
{
JsonLogger.Error(key + "(string) == null");
return(string.Empty);
}
return(value.Str);
}
/// <summary>
/// Remove the value at the given index, if it exists.
/// </summary>
/// <param name="index"></param>
public void Remove(int index)
{
if (index >= 0 && index < values.Count)
{
values.RemoveAt(index);
}
else
{
JsonLogger.Error("index out of range: " + index + " (Expected 0 <= index < " + values.Count + ")");
}
}
public void _OnAreaEntered(Area2D area)
{
var baton = area.GetOwner <Baton>();
if (JsonLogger.GetInstance().Recording)
{
if (baton.Speed > 0)
{
JsonLogger.GetInstance().LogLap(baton.batonId);
}
}
}
public async Task Execute()
{
try
{
await ExecuteInternal();
}
finally
{
JsonLogger.WriteScenario(this);
TestMap.StoppedEarly.TryRemove(_testDetails.GetGuid(), out _);
}
}
public TestApp()
{
JsonLogger logger = new JsonLogger();
logger.LogError("Test error 1");
logger.LogDebug("Test debug 1");
logger.LogError(new LogObject("test 2"));
logger.LogDebug(new LogObject("test debug 2"));
logger.LogError();
logger.LogDebug();
}
public override void _Pressed()
{
base._Pressed();
if (!JsonLogger.GetInstance().Recording)
{
JsonLogger.GetInstance().Start();
recordIcon.Visible = true;
}
else
{
JsonLogger.GetInstance().Stop();
recordIcon.Visible = false;
}
}
private void disposeLogger()
{
if (_jsonLogger != null)
{
_jsonLogger.Dispose();
_jsonLogger = null;
}
if (_directoryMonitor != null)
{
_directoryMonitor.Dispose();
_directoryMonitor = null;
}
}
public static void TestConnection()
{
try
{
using (SqlConnection con = new SqlConnection(CONNECTIONSTRING))
{
}
}
catch (Exception e)
{
JsonLogger _logger = new JsonLogger();
LogObject lo = new LogObject(e);
_logger.LogError(lo);
}
}
public void SimpleWrite()
{
var logProcessor = new TestLogProcessor();
ILogger logger = new JsonLogger("Test logger", new LoggerExternalScopeProvider(), logProcessor);
logger.LogInformation("Sample message");
var firstLogEntry = logProcessor.Log.FirstOrDefault();
Assert.IsNotNull(firstLogEntry, "Log not passed to ILogProcessor");
JObject jsonObject = JsonConvert.DeserializeObject <JObject>(firstLogEntry.First().String);
Assert.AreEqual(jsonObject["message"].ToString(), "Sample message");
Assert.AreEqual(jsonObject["log_name"]?.ToString(), "Test logger");
Assert.AreEqual(jsonObject["level"].ToString(), 2.ToString());
Assert.AreEqual(jsonObject["level_string"]?.ToString(), "INFO");
}
static void Main(string[] args)
{
var tempFile = Path.GetTempFileName();
Console.WriteLine(tempFile);
using (var logger = new JsonLogger(tempFile, false, "test"))
{
logger.Info(1234);
logger.Info(new double[] { 1.2, 3.4, 5.6 });
logger.Info(new Dictionary <int, string>()
{
{ 1, "one" }, { 2, "two" }
});
logger.Fatal("something\nwrong\nhappened", "Fatal message");
try
{
throw new ApplicationException("application exception");
}
catch (Exception e)
{
logger.Debug(e);
}
var dir = new DirectoryInfo("C:\\Windows");
logger.Debug(dir);
}
using (var reader = new StreamReader(tempFile))
{
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
Console.WriteLine(line);
}
}
Console.Write("Push Enter to exit.");
Console.ReadLine();
}
internal Scenario(List <Step> steps, TestDetails testDetails)
{
TestMap.NotRun.TryRemove(testDetails.GetGuid(), out _);
TestMap.StoppedEarly.TryAdd(testDetails.GetGuid(), this);
StoryText = testDetails.StoryText;
ScenarioText = testDetails.ScenarioText;
_reporters = new Reporters.Reporters();
Steps = steps;
try
{
Execute();
}
finally
{
JsonLogger.WriteScenario(this);
TestMap.StoppedEarly.TryRemove(testDetails.GetGuid(), out _);
}
}
private static void Main()
{
_consoleManager = new ConsoleManager();
_excelLogger = new ExcelLogger();
_filePerVehicleLogger = new FilePerVehicleLogger(_consoleManager);
_htmlLogger = new HtmlLogger(_filePerVehicleLogger, _consoleManager);
_jsonLogger = new JsonLogger(_filePerVehicleLogger, _consoleManager);
_webCrawler = new WebCrawler(_consoleManager);
_stringHelper = new StringHelper();
_logger = new Logger(_jsonLogger, _htmlLogger, _stringHelper, _consoleManager);
_dataProcessor = new DataProcessor(_consoleManager, _stringHelper, _webCrawler, _excelLogger, _logger);
_groundForcesScraper = new GroundForcesScraper(_webCrawler);
try
{
OverallStopwatch.Start();
_consoleManager.WriteProgramTitleVersionAndInitialBlurb();
_consoleManager.WriteInputInstructionsAndAwaitUserInput(ConsoleColor.Yellow, ConsoleKey.Enter, "Press ENTER to begin.");
// Load Wiki Home page
HtmlDocument groundForcesWikiHomePage = _groundForcesScraper.GetGroundForcesWikiHomePage();
// Crawl ground forces
// TODO: Some of these parameters can be moved into DataProcessor as they aren't used again
_dataProcessor.CrawlWikiSectionPagesForData(groundForcesWikiHomePage);
OverallStopwatch.Stop();
TimeSpan elapsedTime = OverallStopwatch.Elapsed;
// TODO: Add console manage method for this
_consoleManager.WriteTextLine($"Completed in {elapsedTime.Hours:00}:{elapsedTime.Minutes:00}:{elapsedTime.Seconds:00}");
_consoleManager.WriteExitInstructions();
}
catch (Exception ex)
{
_consoleManager.WriteException($"The following exception was encounted: {ex.Message}\r\nException details: {ex.StackTrace}");
}
}
public override void _ExitTree()
{
base._ExitTree();
JsonLogger.GetInstance().Stop();
}
public ApiLogginMiddleware(Encoding encoding, JsonLogger logger)
{
this.encoding = encoding;
this.logger = logger;
}
private static JsonObject Fail(string expected, int position)
{
JsonLogger.Error("Invalid json string, expecting " + expected + " at " + position);
return(null);
}
/// <summary>
/// Attempt to parse a string into a JSONObject.
/// </summary>
/// <param name="jsonString"></param>
/// <returns>A new JSONObject or null if parsing fails.</returns>
public static JsonObject Parse(string jsonString)
{
if (string.IsNullOrEmpty(jsonString))
{
return(null);
}
JsonValue currentValue = null;
var keyList = new List <string>();
var state = JsonParsingState.Object;
for (var startPosition = 0; startPosition < jsonString.Length; ++startPosition)
{
startPosition = SkipWhitespace(jsonString, startPosition);
switch (state)
{
case JsonParsingState.Object:
if (jsonString[startPosition] != '{')
{
return(Fail('{', startPosition));
}
JsonValue newObj = new JsonObject();
if (currentValue != null)
{
newObj.Parent = currentValue;
}
currentValue = newObj;
state = JsonParsingState.Key;
break;
case JsonParsingState.EndObject:
if (jsonString[startPosition] != '}')
{
return(Fail('}', startPosition));
}
if (currentValue.Parent == null)
{
return(currentValue.Obj);
}
switch (currentValue.Parent.Type)
{
case JsonValueType.Object:
currentValue.Parent.Obj.values[keyList.Pop()] = new JsonValue(currentValue.Obj);
break;
case JsonValueType.Array:
currentValue.Parent.Array.Add(new JsonValue(currentValue.Obj));
break;
default:
return(Fail("valid object", startPosition));
}
currentValue = currentValue.Parent;
state = JsonParsingState.ValueSeparator;
break;
case JsonParsingState.Key:
if (jsonString[startPosition] == '}')
{
--startPosition;
state = JsonParsingState.EndObject;
break;
}
var key = ParseString(jsonString, ref startPosition);
if (key == null)
{
return(Fail("key string", startPosition));
}
keyList.Add(key);
state = JsonParsingState.KeyValueSeparator;
break;
case JsonParsingState.KeyValueSeparator:
if (jsonString[startPosition] != ':')
{
return(Fail(':', startPosition));
}
state = JsonParsingState.Value;
break;
case JsonParsingState.ValueSeparator:
switch (jsonString[startPosition])
{
case ',':
state = currentValue.Type == JsonValueType.Object ? JsonParsingState.Key : JsonParsingState.Value;
break;
case '}':
state = JsonParsingState.EndObject;
--startPosition;
break;
case ']':
state = JsonParsingState.EndArray;
--startPosition;
break;
default:
return(Fail(", } ]", startPosition));
}
break;
case JsonParsingState.Value:
{
var c = jsonString[startPosition];
if (c == '"')
{
state = JsonParsingState.String;
}
else if (char.IsDigit(c) || c == '-')
{
state = JsonParsingState.Number;
}
else
{
switch (c)
{
case '{':
state = JsonParsingState.Object;
break;
case '[':
state = JsonParsingState.Array;
break;
case ']':
if (currentValue.Type == JsonValueType.Array)
{
state = JsonParsingState.EndArray;
}
else
{
return(Fail("valid array", startPosition));
}
break;
case 'f':
case 't':
state = JsonParsingState.Boolean;
break;
case 'n':
state = JsonParsingState.Null;
break;
default:
return(Fail("beginning of value", startPosition));
}
}
--startPosition; //To re-evaluate this char in the newly selected state
break;
}
case JsonParsingState.String:
var str = ParseString(jsonString, ref startPosition);
if (str == null)
{
return(Fail("string value", startPosition));
}
switch (currentValue.Type)
{
case JsonValueType.Object:
currentValue.Obj.values[keyList.Pop()] = new JsonValue(str);
break;
case JsonValueType.Array:
currentValue.Array.Add(str);
break;
default:
JsonLogger.Error("Fatal error, current JSON value not valid");
return(null);
}
state = JsonParsingState.ValueSeparator;
break;
case JsonParsingState.Number:
var number = ParseNumber(jsonString, ref startPosition);
if (double.IsNaN(number))
{
return(Fail("valid number", startPosition));
}
switch (currentValue.Type)
{
case JsonValueType.Object:
currentValue.Obj.values[keyList.Pop()] = new JsonValue(number);
break;
case JsonValueType.Array:
currentValue.Array.Add(number);
break;
default:
JsonLogger.Error("Fatal error, current JSON value not valid");
return(null);
}
state = JsonParsingState.ValueSeparator;
break;
case JsonParsingState.Boolean:
if (jsonString[startPosition] == 't')
{
if (jsonString.Length < startPosition + 4 ||
jsonString[startPosition + 1] != 'r' ||
jsonString[startPosition + 2] != 'u' ||
jsonString[startPosition + 3] != 'e')
{
return(Fail("true", startPosition));
}
switch (currentValue.Type)
{
case JsonValueType.Object:
currentValue.Obj.values[keyList.Pop()] = new JsonValue(true);
break;
case JsonValueType.Array:
currentValue.Array.Add(new JsonValue(true));
break;
default:
JsonLogger.Error("Fatal error, current JSON value not valid");
return(null);
}
startPosition += 3;
}
else
{
if (jsonString.Length < startPosition + 5 ||
jsonString[startPosition + 1] != 'a' ||
jsonString[startPosition + 2] != 'l' ||
jsonString[startPosition + 3] != 's' ||
jsonString[startPosition + 4] != 'e')
{
return(Fail("false", startPosition));
}
switch (currentValue.Type)
{
case JsonValueType.Object:
currentValue.Obj.values[keyList.Pop()] = new JsonValue(false);
break;
case JsonValueType.Array:
currentValue.Array.Add(new JsonValue(false));
break;
default:
JsonLogger.Error("Fatal error, current JSON value not valid");
return(null);
}
startPosition += 4;
}
state = JsonParsingState.ValueSeparator;
break;
case JsonParsingState.Array:
if (jsonString[startPosition] != '[')
{
return(Fail('[', startPosition));
}
JsonValue newArray = new JsonArray();
if (currentValue != null)
{
newArray.Parent = currentValue;
}
currentValue = newArray;
state = JsonParsingState.Value;
break;
case JsonParsingState.EndArray:
if (jsonString[startPosition] != ']')
{
return(Fail(']', startPosition));
}
if (currentValue.Parent == null)
{
return(currentValue.Obj);
}
switch (currentValue.Parent.Type)
{
case JsonValueType.Object:
currentValue.Parent.Obj.values[keyList.Pop()] = new JsonValue(currentValue.Array);
break;
case JsonValueType.Array:
currentValue.Parent.Array.Add(new JsonValue(currentValue.Array));
break;
default:
return(Fail("valid object", startPosition));
}
currentValue = currentValue.Parent;
state = JsonParsingState.ValueSeparator;
break;
case JsonParsingState.Null:
if (jsonString[startPosition] == 'n')
{
if (jsonString.Length < startPosition + 4 ||
jsonString[startPosition + 1] != 'u' ||
jsonString[startPosition + 2] != 'l' ||
jsonString[startPosition + 3] != 'l')
{
return(Fail("null", startPosition));
}
switch (currentValue.Type)
{
case JsonValueType.Object:
currentValue.Obj.values[keyList.Pop()] = new JsonValue(JsonValueType.Null);
break;
case JsonValueType.Array:
currentValue.Array.Add(new JsonValue(JsonValueType.Null));
break;
default:
JsonLogger.Error("Fatal error, current JSON value not valid");
return(null);
}
startPosition += 3;
}
state = JsonParsingState.ValueSeparator;
break;
}
}
JsonLogger.Error("Unexpected end of string");
return(null);
}
public TryCatchMiddleware(JsonLogger logger)
{
this.logger = logger;
}
public ValuesController(JsonLogger logger)
{
logger.Write(LogLevel.Debug, "values controller created", new { });
}
