public void Init(DragKeyDelegate dragKeyDownHandler, DragKeyDelegate dragKeyUpHandler, LogErrorDelegate logErrorHandler, int dragAreaLayerMask) { DragKeyDownHandler = dragKeyDownHandler; DragKeyUpHandler = dragKeyUpHandler; LogErrorHandler = logErrorHandler; DragAreaLayerMask = dragAreaLayerMask; }
// save this instance of telemetrycollection to a file // this method first saves the data in a tmp file // and then replaces the existing one (if it exists) to reduce the chances of corrupting the file. public void SaveToFile(string filePath, LogErrorDelegate logErrorDelegate) { try { string filePathTemp = string.Format("{0}.tmp", filePath); // saving current collection in a json serialization format on temporary file using (StreamWriter file = File.CreateText(filePathTemp)) { // using converter to properly serialize dictionary keys JsonSerializerSettings settings = new JsonSerializerSettings(); settings.ContractResolver = new DictionaryAsArrayResolver(); string json = JsonConvert.SerializeObject(this, settings); // writing json to file file.Write(json); } // create or replace file File.Copy(filePathTemp, filePath, true); // remove temporary file File.Delete(filePathTemp); } catch (Exception e) { logErrorDelegate(LogSourceId, "Error when trying to save telemetry aggregation to file: {0} - Exception: {1}", filePath, e); } }
public static TelemetryCollection LoadTelemetryCollection(string filePath, LogErrorDelegate logErrorDelegate) { TelemetryCollection telemetryCollection = null; if (File.Exists(filePath)) { try { using (StreamReader file = File.OpenText(filePath)) { // using converter to properly serialize dictionary keys string serializedObject = file.ReadToEnd(); JsonSerializerSettings settings = new JsonSerializerSettings() { ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor }; settings.ContractResolver = new DictionaryAsArrayResolver(); telemetryCollection = JsonConvert.DeserializeObject <TelemetryCollection>(serializedObject, settings); } } catch (JsonException e) { logErrorDelegate(LogSourceId, "Error deserializing file :{0} - Exception {1}", filePath, e); } catch (Exception e) { logErrorDelegate(LogSourceId, "Error loading persisted telemetry from file: {0} - Exception {1}", filePath, e); } } return(telemetryCollection); }
// Returns the next line in the file being parsed private string ReadNextLine(LogErrorDelegate logErrorDelegate) { string configLine = null; try { configLine = this.fileStream.ReadLine(); } catch (Exception e) { logErrorDelegate(LogSourceId, "Exception while reading line from config file: {0}", e.Message); } return(configLine); }
public Transform UI3DRoot = null; //3D UI组件的根节点 public void Init(LoadUIPanelDelegate loadUIPanelHandler, LogErrorDelegate logErrorHandler, ButtonDownDelegate mouseLeftButtonDownHandler, ButtonDownDelegate mouseRightButtonDownHandler, ButtonDownDelegate closeUIFormKeyDownHandler, ButtonDownDelegate confirmKeyDownHandler, ButtonDownDelegate inputNavigateKeyDownHandler) { LoadUIPanelHandler = loadUIPanelHandler; LogErrorHandler = logErrorHandler; MouseLeftButtonDownHandler = mouseLeftButtonDownHandler; MouseRightButtonDownHandler = mouseRightButtonDownHandler; CloseUIFormKeyDownHandler = closeUIFormKeyDownHandler; ConfirmKeyDownHandler = confirmKeyDownHandler; InputNavigateKeyDownHandler = inputNavigateKeyDownHandler; }
public ManifestEventFieldsLookup(IEnumerable <string> manifestFilePaths, LogErrorDelegate logErrorDelegate, bool verbose) { int taskEventNamesCollisionCount = 0; // constructing the lookup dictionary this.events = new Dictionary <Tuple <string, string>, Dictionary <string, FieldDefinition> >(); // iterating over all manifest files foreach (var manifestFile in manifestFilePaths) { ManifestLoader manifestLoader = new ManifestLoader(); ManifestDefinitionDescription manifestDefinitionDescription = manifestLoader.LoadManifest(manifestFile); // iterating over all providers in the manifest file foreach (var provider in manifestDefinitionDescription.Providers) { // including all events from the provider to the dictionary foreach (var ev in provider.Events.Values) { try { Dictionary <string, FieldDefinition> fieldDictionary = new Dictionary <string, FieldDefinition>(); this.events.Add(Tuple.Create(ev.TaskName, ev.EventName), fieldDictionary); // including all fields from the event foreach (var field in ev.Fields) { fieldDictionary.Add(field.Name, field); } } catch (Exception) { if (verbose) { logErrorDelegate(LogSourceId, "(TaskName: {0}, EventName: {1}) collision for UnparsedEventName: {2}", ev.TaskName, ev.EventName, ev.UnparsedEventName); } taskEventNamesCollisionCount++; } } } if (taskEventNamesCollisionCount > 0) { logErrorDelegate(LogSourceId, "Warning - Found {0} collisions on pairs (TaskName, EventName). Parser is using first occurence. For more details use verbose mode.", taskEventNamesCollisionCount); } } }
public static async Task <(bool Success, Stack Stack)> GetStackAsync(this IAmazonCloudFormation cfnClient, string stackName, LogErrorDelegate logError) { Stack stack = null; try { var describe = await cfnClient.DescribeStacksAsync(new DescribeStacksRequest { StackName = stackName }); // make sure the stack is in a stable state (not updating and not failed) stack = describe.Stacks.FirstOrDefault(); switch (stack?.StackStatus) { case null: case "CREATE_COMPLETE": case "ROLLBACK_COMPLETE": case "UPDATE_COMPLETE": case "UPDATE_ROLLBACK_COMPLETE": // we're good to go break; default: logError?.Invoke($"{stackName} is not in a valid state; module deployment must be complete and successful (status: {stack?.StackStatus})", null); return(false, null); } } catch (AmazonCloudFormationException) { // stack not found; nothing to do } return(true, stack); }
public static async Task <(Stack Stack, bool Success)> TrackStackUpdateAsync( this IAmazonCloudFormation cfnClient, string stackName, string stackId, string mostRecentStackEventId, ModuleNameMappings nameMappings = null, LogErrorDelegate logError = null ) { var seenEventIds = new HashSet <string>(); var foundMostRecentStackEvent = (mostRecentStackEventId == null); var request = new DescribeStackEventsRequest { StackName = stackId ?? stackName }; var eventList = new List <StackEvent>(); var ansiLinesPrinted = 0; // iterate as long as the stack is being created/updated var active = true; var success = false; while (active) { await Task.Delay(TimeSpan.FromSeconds(3)); // fetch as many events as possible for the current stack var events = new List <StackEvent>(); try { var response = await cfnClient.DescribeStackEventsAsync(request); events.AddRange(response.StackEvents); } catch (System.Net.Http.HttpRequestException e) when((e.InnerException is System.Net.Sockets.SocketException) && (e.InnerException.Message == "No such host is known")) { // ignore network issues and just try again continue; } events.Reverse(); // skip any events that preceded the most recent event before the stack update operation while (!foundMostRecentStackEvent && events.Any()) { var evt = events.First(); if (evt.EventId == mostRecentStackEventId) { foundMostRecentStackEvent = true; } seenEventIds.Add(evt.EventId); events.RemoveAt(0); } if (!foundMostRecentStackEvent) { throw new ApplicationException($"unable to find starting event for stack: {stackName}"); } // report only on new events foreach (var evt in events.Where(evt => !seenEventIds.Contains(evt.EventId))) { UpdateEvent(evt); if (!seenEventIds.Add(evt.EventId)) { // we found an event we already saw in the past, no point in looking at more events break; } if (IsFinalStackEvent(evt) && (evt.LogicalResourceId == stackName)) { // event signals stack creation/update completion; time to stop active = false; success = IsSuccessfulFinalStackEvent(evt); break; } } RenderEvents(); } if (!success) { return(Stack : null, Success : false); } // describe stack and report any output values var description = await cfnClient.DescribeStacksAsync(new DescribeStacksRequest { StackName = stackName }); return(Stack : description.Stacks.FirstOrDefault(), Success : success); // local function string TranslateLogicalIdToFullName(string logicalId) { var fullName = logicalId; nameMappings?.ResourceNameMappings?.TryGetValue(logicalId, out fullName); return(fullName ?? logicalId); } string TranslateResourceTypeToFullName(string awsType) { var fullName = awsType; nameMappings?.TypeNameMappings?.TryGetValue(awsType, out fullName); return(fullName ?? awsType); } void RenderEvents() { if (Settings.UseAnsiConsole) { if (ansiLinesPrinted > 0) { Console.Write(AnsiTerminal.MoveLineUp(ansiLinesPrinted)); } var maxResourceStatusLength = eventList.Any() ? eventList.Max(evt => evt.ResourceStatus.ToString().Length) : 0; var maxResourceTypeNameLength = eventList.Any() ? eventList.Max(evt => TranslateResourceTypeToFullName(evt.ResourceType).Length) : 0; foreach (var evt in eventList) { var resourceStatus = evt.ResourceStatus.ToString(); var resourceType = TranslateResourceTypeToFullName(evt.ResourceType); if (_ansiStatusColorCodes.TryGetValue(evt.ResourceStatus, out var ansiColor)) { // print resource status Console.Write(ansiColor); Console.Write(resourceStatus); Console.Write(AnsiTerminal.Reset); Console.Write("".PadRight(maxResourceStatusLength - resourceStatus.Length + 4)); // print resource type Console.Write(resourceType); Console.Write("".PadRight(maxResourceTypeNameLength - resourceType.Length + 4)); // print resource name Console.Write(TranslateLogicalIdToFullName(evt.LogicalResourceId)); // print status reason if ((logError == null) && (evt.ResourceStatusReason != null)) { Console.Write($" ({evt.ResourceStatusReason})"); } } else { Console.Write($"{resourceStatus} {resourceType} {TranslateLogicalIdToFullName(evt.LogicalResourceId)}{(evt.ResourceStatusReason != null ? $" ({evt.ResourceStatusReason})" : "")}"); } Console.Write(AnsiTerminal.ClearEndOfLine); Console.WriteLine(); } ansiLinesPrinted = eventList.Count; } } void UpdateEvent(StackEvent evt) { if (Settings.UseAnsiConsole) { var index = eventList.FindIndex(e => e.LogicalResourceId == evt.LogicalResourceId); if (index < 0) { eventList.Add(evt); } else { eventList[index] = evt; } } else { Console.WriteLine($"{evt.ResourceStatus,-35} {TranslateResourceTypeToFullName(evt.ResourceType),-55} {TranslateLogicalIdToFullName(evt.LogicalResourceId)}{(evt.ResourceStatusReason != null ? $" ({evt.ResourceStatusReason})" : "")}"); } // capture failed operation as an error switch (evt.ResourceStatus) { case "CREATE_FAILED": case "ROLLBACK_FAILED": case "UPDATE_FAILED": case "DELETE_FAILED": case "UPDATE_ROLLBACK_FAILED": case "UPDATE_ROLLBACK_IN_PROGRESS": if (evt.ResourceStatusReason != "Resource creation cancelled") { logError?.Invoke($"{evt.ResourceStatus} {TranslateLogicalIdToFullName(evt.LogicalResourceId)} [{TranslateResourceTypeToFullName(evt.ResourceType)}]: {evt.ResourceStatusReason}", /*Exception*/ null); } break; } } }
public Log() { logger = new Logger(); logError += logger.LogToConsole; logError += logger.LogToFile; }
public static async Task <(bool Success, Stack Stack)> GetStackAsync(this IAmazonCloudFormation cfnClient, string stackName, LogErrorDelegate logError) { Stack stack = null; var attempts = 0; try { var describe = await cfnClient.DescribeStacksAsync(new DescribeStacksRequest { StackName = stackName }); // make sure the stack is in a stable state (not updating and not failed) stack = describe.Stacks.FirstOrDefault(); switch (stack?.StackStatus) { case null: case "CREATE_COMPLETE": case "ROLLBACK_COMPLETE": case "UPDATE_COMPLETE": case "UPDATE_ROLLBACK_COMPLETE": // we're good to go break; default: logError?.Invoke($"{stackName} is not in a valid state; CloudFormation stack must be complete and successful (status: {stack?.StackStatus})", null); return(false, null); } } catch (AmazonCloudFormationException) { // stack not found; nothing to do } catch (HttpRequestException e) when(e.Message == "The requested name is valid, but no data of the requested type was found") { // NOTE (2020-03-31, bjorg): avoid sporadic DNS issues by waiting an trying again if (++attempts < 3) { await Task.Delay(TimeSpan.FromSeconds(attempts)); } } return(true, stack); }
public static extern bool UWK_Initialize(LogCallbackDelegate logcb, LogErrorDelegate errorcb, ProcessUWKEventDelegate processcb, UWKBetaDelegate betacb, IntPtr initJson);
//--- Constructors --- public ParameterStoreFunctionNodeDeserializer(string workingDirectory, LogErrorDelegate logError, Settings settings) { _workingDirectory = workingDirectory ?? throw new ArgumentNullException(nameof(workingDirectory)); LogError = logError ?? throw new ArgumentNullException(nameof(logError)); Settings = settings ?? throw new ArgumentNullException(nameof(settings)); }
public static extern int UWK_Initialize(LogCallbackDelegate logcb, LogErrorDelegate errorcb, ProcessMessageDelegate processcb, IntPtr initJson);
// private constructor // the only public exposed method is the static method Parse private SyntaxAnalyzer(StreamReader fileStream, IEnumerable <string> manifestFilesPaths, LogErrorDelegate logErrorDelegate, bool verbose) { this.fileStream = fileStream; this.lexAnalyzer = null; this.semanticsAnalyzer = new SemanticsAnalyzer(manifestFilesPaths, manifestFilesPaths.Any(), logErrorDelegate, verbose); }
// Static method which returns a list with the white-listed traces and // respective aggregation configurations parsed from the config file provided public static List <ParseResult> Parse( string filePath, IEnumerable <string> manifestFilesPaths, LogErrorDelegate logErrorDelegate, bool verbose, out List <TraceAggregationConfig> telemetryConfigEntryList) { telemetryConfigEntryList = new List <TraceAggregationConfig>(); List <ParseResult> parseResultsList = new List <ParseResult>(); try { using (StreamReader fileStream = File.OpenText(filePath)) { SyntaxAnalyzer telemetryParser = new SyntaxAnalyzer(fileStream, manifestFilesPaths, logErrorDelegate, verbose); // parse line by line using the grammar and stores the parsed trace configurations int currentLine = 0; while (true) { TraceAggregationConfig traceConfigEntry; currentLine++; string configLine = telemetryParser.ReadNextLine(logErrorDelegate); if (configLine == null) { // EOL break; } telemetryParser.lexAnalyzer = new LexicalAnalyzer(configLine); var parseResult = telemetryParser.L(out traceConfigEntry); parseResult.LineNumber = currentLine; if (parseResult.ParseCode != ParseCode.EmptyLine && parseResult.ParseCode != ParseCode.Comment) { // checking if something went wrong during parsing and a null object was created if (traceConfigEntry == null && parseResult.ParseCode == ParseCode.Success) { logErrorDelegate(LogSourceId, "Unexpected null entry generated on parsing of file - {0} - ParseResult: {1}", filePath, parseResult); parseResult = new ParseResult(ParseCode.ParserError, string.Format("Previous ParseResult Value: {0}", parseResult), 0, currentLine); } parseResultsList.Add(parseResult); if (parseResult.ParseCode == ParseCode.Success) { telemetryConfigEntryList.Add(traceConfigEntry); } } } } } catch (Exception e) { parseResultsList.Add(new ParseResult(ParseCode.ParserError, string.Format("Exception while opening or parsing config file - {0} - Exception: {1}", filePath, e))); } return(parseResultsList); }
// tries to read the persisted serialization. If fails returns a new instance (empty) public static TelemetryCollection LoadOrCreateTelemetryCollection(string filePath, TelemetryIdentifiers telemetryIdentifier, int dailyNumberOfTelemetryPushes, out bool telCollectionloadedFromDisk, LogErrorDelegate logErrorDelegate) { TelemetryCollection telemetryCollection = TelemetryCollection.LoadTelemetryCollection(filePath, logErrorDelegate); // if loaded from file and configuration on the push rate not changed add telemetryIdentifier, otherwise create a new one if (telemetryCollection != null && telemetryCollection.DailyNumberOfTelemetryPushes == dailyNumberOfTelemetryPushes) { telemetryCollection.TelemetryIds = telemetryIdentifier; telCollectionloadedFromDisk = true; } else { telemetryCollection = new TelemetryCollection(telemetryIdentifier, dailyNumberOfTelemetryPushes); telCollectionloadedFromDisk = false; } return(telemetryCollection); }
public SemanticsAnalyzer(IEnumerable <string> manifestFilePaths, bool enableManifestSemanticsCheck, LogErrorDelegate logErrorDelegate, bool verbose) { this.manifestSemanticsCheckEnabled = enableManifestSemanticsCheck; this.manifestLookup = new ManifestEventFieldsLookup(manifestFilePaths, logErrorDelegate, verbose); }
private void LogError(string msg) { LogErrorDelegate?.BeginInvoke($"ImageProcessor Error: {msg}", (r) => { }, null); }