DYN-6052 Add node info event and API under DynamoServices package for ProtoCore (#14234)

QilongTang · web-flow · commit c15e2153f21f · 2023-08-15T00:45:08.000-04:00
* Add node info event and API

* Update

* Update

* clean up

* remove line and column from InfoEntry

* comments

* clean up

* clean up
diff --git a/src/DynamoCore/Engine/EngineController.cs b/src/DynamoCore/Engine/EngineController.cs
@@ -17,6 +17,7 @@
 using ProtoScript.Runners;
 using BuildWarning = ProtoCore.BuildData.WarningEntry;
 using RuntimeWarning = ProtoCore.Runtime.WarningEntry;
+using RuntimeInfo = ProtoCore.Runtime.InfoEntry;
 
 namespace Dynamo.Engine
 {
@@ -500,6 +501,11 @@ internal IDictionary<Guid, List<RuntimeWarning>> GetRuntimeWarnings()
             return liveRunnerServices.GetRuntimeWarnings();
         }
 
+        internal IDictionary<Guid, List<RuntimeInfo>> GetRuntimeInfos()
+        {
+            return liveRunnerServices.GetRuntimeInfos();
+        }
+
         internal IEnumerable<Guid> GetExecutedAstGuids(Guid sessionID)
         {
             return liveRunnerServices.GetExecutedAstGuids(sessionID);
diff --git a/src/DynamoCore/Engine/LiveRunnerServices.cs b/src/DynamoCore/Engine/LiveRunnerServices.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Collections.Generic;
 using Dynamo.Logging;
 using ProtoCore.Mirror;
@@ -119,6 +119,15 @@ internal List<Guid> PreviewGraph(GraphSyncData graphData, bool verboseLogging)
             return liveRunner.GetRuntimeWarnings();
         }
 
+        /// <summary>
+        /// Returns runtime infos for this run.
+        /// </summary>
+        /// <returns></returns>
+        internal IDictionary<Guid, List<ProtoCore.Runtime.InfoEntry>> GetRuntimeInfos()
+        {
+            return liveRunner.GetRuntimeInfos();
+        }
+
         /// <summary>
         /// Returns build warnings for this run.
         /// </summary>
diff --git a/src/DynamoCore/Graph/Nodes/NodeModel.cs b/src/DynamoCore/Graph/Nodes/NodeModel.cs
@@ -8,7 +8,6 @@
 using System.Runtime.Serialization;
 using System.Xml;
 using Autodesk.DesignScript.Runtime;
-using DesignScript.Builtin;
 using Dynamo.Configuration;
 using Dynamo.Engine;
 using Dynamo.Engine.CodeGeneration;
diff --git a/src/DynamoCore/Graph/Workspaces/HomeWorkspaceModel.cs b/src/DynamoCore/Graph/Workspaces/HomeWorkspaceModel.cs
@@ -732,13 +732,13 @@ internal void MarkNodesAsModifiedAndRequestRun(IEnumerable<NodeModel> nodes, boo
         private void OnUpdateGraphCompleted(AsyncTask task)
         {
             var updateTask = (UpdateGraphAsyncTask)task;
-            var messages = new Dictionary<Guid, string>();
+            var warnings = new Dictionary<Guid, string>();
 
             // Runtime warnings take precedence over build warnings.
             foreach (var warning in updateTask.RuntimeWarnings)
             {
                 var message = string.Join(Environment.NewLine, warning.Value.Select(w => w.Message));
-                messages.Add(warning.Key, message);
+                warnings.Add(warning.Key, message);
             }
 
             foreach (var warning in updateTask.BuildWarnings)
@@ -748,12 +748,12 @@ private void OnUpdateGraphCompleted(AsyncTask task)
                 // But for cyclic dependency warnings, it is
                 // easier to understand to report a build warning.
                 string message = string.Empty;
-                if (messages.ContainsKey(warning.Key))
+                if (warnings.ContainsKey(warning.Key))
                 {
                     if (!warning.Value.Any(w => w.ID == ProtoCore.BuildData.WarningID.InvalidStaticCyclicDependency))
                         continue;
 
-                    messages.Remove(warning.Key);
+                    warnings.Remove(warning.Key);
                     message = string.Join("\n", warning.Value.
                         Where(w => w.ID == ProtoCore.BuildData.WarningID.InvalidStaticCyclicDependency).
                         Select(w => w.Message));
@@ -765,20 +765,33 @@ private void OnUpdateGraphCompleted(AsyncTask task)
 
                 if (!string.IsNullOrEmpty(message))
                 {
-                    messages.Add(warning.Key, message);
+                    warnings.Add(warning.Key, message);
                 }
             }
 
             var workspace = updateTask.TargetedWorkspace;
-            foreach (var message in messages)
+            foreach (var warning in warnings)
             {
-                var guid = message.Key;
+                var guid = warning.Key;
                 var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid);
                 if (node == null)
                     continue;
                 using (node.PropertyChangeManager.SetPropsToSuppress(nameof(NodeModel.ToolTipText), nameof(NodeModel.Infos), nameof(NodeModel.State)))
                 {
-                    node.Warning(message.Value); // Update node warning message.
+                    node.Warning(warning.Value); // Update node warning message.
+                }
+            }
+
+            // Update node info message.
+            foreach (var info in updateTask.RuntimeInfos)
+            {
+                var guid = info.Key;
+                var node = workspace.Nodes.FirstOrDefault(n => n.GUID == guid);
+                if (node == null)
+                    continue;
+                using (node.PropertyChangeManager.SetPropsToSuppress(nameof(NodeModel.ToolTipText), nameof(NodeModel.Infos), nameof(NodeModel.State)))
+                {
+                    node.Info(string.Join(Environment.NewLine, info.Value.Select(w => w.Message)));
                 }
             }
 
@@ -792,8 +805,8 @@ private void OnUpdateGraphCompleted(AsyncTask task)
             // Dispatch the failure message display for execution on UI thread.
             // 
             EvaluationCompletedEventArgs e = task.Exception == null || IsTestMode
-                ? new EvaluationCompletedEventArgs(true,messages.Keys,null)
-                : new EvaluationCompletedEventArgs(true, messages.Keys, task.Exception);
+                ? new EvaluationCompletedEventArgs(true,warnings.Keys,null)
+                : new EvaluationCompletedEventArgs(true, warnings.Keys, task.Exception);
 
             EvaluationCount ++;
 
diff --git a/src/DynamoCore/Models/DynamoModel.cs b/src/DynamoCore/Models/DynamoModel.cs
@@ -1008,7 +1008,7 @@ protected DynamoModel(IStartConfiguration config)
 #endif
 
             LogWarningMessageEvents.LogWarningMessage += LogWarningMessage;
-
+            LogWarningMessageEvents.LogInfoMessage += LogInfoMessage;
             StartBackupFilesTimer();
 
             TraceReconciliationProcessor = this;
@@ -1459,6 +1459,7 @@ public void Dispose()
 #endif
 
             LogWarningMessageEvents.LogWarningMessage -= LogWarningMessage;
+            LogWarningMessageEvents.LogInfoMessage -= LogInfoMessage;
             foreach (var ws in _workspaces)
             {
                 ws.Dispose();
@@ -1849,6 +1850,16 @@ private void LogWarningMessage(LogWarningMessageEventArgs args)
             EngineController.LiveRunnerRuntimeCore.RuntimeStatus.LogWarning(WarningID.Default, args.message);
         }
 
+        /// <summary>
+        /// This info message is displayed on the node associated with the FFI dll
+        /// </summary>
+        /// <param name="args"></param>
+        private void LogInfoMessage(LogWarningMessageEventArgs args)
+        {
+            Validity.Assert(EngineController.LiveRunnerRuntimeCore != null);
+            EngineController.LiveRunnerRuntimeCore.RuntimeStatus.LogInfo(InfoID.Default, args.message);
+        }
+
         #endregion
 
         #region engine management
diff --git a/src/DynamoCore/Scheduler/UpdateGraphAsyncTask.cs b/src/DynamoCore/Scheduler/UpdateGraphAsyncTask.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Dynamo.Engine;
@@ -112,12 +112,14 @@ protected override void HandleTaskCompletionCore()
             {
                 BuildWarnings = new Dictionary<Guid, List<WarningEntry>>();
                 RuntimeWarnings = new Dictionary<Guid, List<ProtoCore.Runtime.WarningEntry>>();
+                RuntimeInfos = new Dictionary<Guid, List<ProtoCore.Runtime.InfoEntry>>();
             }
             else
             {
                 // Retrieve warnings in the context of ISchedulerThread.
                 BuildWarnings = engineController.GetBuildWarnings();
                 RuntimeWarnings = engineController.GetRuntimeWarnings();
+                RuntimeInfos = engineController.GetRuntimeInfos();
 
                 // Mark all modified nodes as being updated (if the task has been 
                 // successfully scheduled, executed and completed, it is expected 
@@ -220,6 +222,7 @@ protected override TaskMergeInstruction CanMergeWithCore(AsyncTask otherTask)
         internal WorkspaceModel TargetedWorkspace { get; private set; }
         internal IDictionary<Guid, List<WarningEntry>> BuildWarnings { get; private set; }
         internal IDictionary<Guid, List<ProtoCore.Runtime.WarningEntry>> RuntimeWarnings { get; private set; }
+        internal IDictionary<Guid, List<ProtoCore.Runtime.InfoEntry>> RuntimeInfos { get; private set; }
 
         #endregion
 
diff --git a/src/Engine/ProtoCore/BuildStatus.cs b/src/Engine/ProtoCore/BuildStatus.cs
@@ -73,6 +73,9 @@ public struct WarningEntry
         }
     }
 
+    /// <summary>
+    /// VM print out message
+    /// </summary>
     public class OutputMessage
     {
         public enum MessageType { Info, Warning, Error }
@@ -97,6 +100,16 @@ public OutputMessage(MessageType type, string message,
             Column = column;
         }
 
+        // A constructor for info messages without line and colume.
+        internal OutputMessage(MessageType type, string message, string filePath)
+        {
+            Type = type;
+            Message = message;
+            FilePath = filePath;
+            Line = -1;
+            Column = -1;
+        }
+
         public MessageType Type { get; private set; }
         public string FilePath { get; private set; }
         public int Line { get; private set; }
diff --git a/src/Engine/ProtoCore/RuntimeStatus.cs b/src/Engine/ProtoCore/RuntimeStatus.cs
@@ -52,13 +52,29 @@ public struct WarningEntry
             public int AstID;
             public string Filename;
         }
+
+        internal enum InfoID
+        {
+            Default
+        }
+
+        public struct InfoEntry
+        {
+            internal Runtime.InfoID ID;
+            internal string Message;
+            internal int ExpressionID;
+            internal Guid GraphNodeGuid;
+            internal int AstID;
+            internal string Filename;
+        }
     }
 
     public class RuntimeStatus
     {
         private readonly DynamoLock rwl = new DynamoLock();
         private ProtoCore.RuntimeCore runtimeCore;
         private List<Runtime.WarningEntry> warnings;
+        private List<Runtime.InfoEntry> infos;
 
         public IOutputStream MessageHandler
         {
@@ -83,6 +99,28 @@ public List<Runtime.WarningEntry> Warnings
             }
         }
 
+        internal List<Runtime.InfoEntry> Infos
+        {
+            get
+            {
+                using (rwl.CreateReadLock())
+                {
+                    return infos.ToList();
+                }
+            }
+        }
+
+        internal int InfosCount
+        {
+            get
+            {
+                using (rwl.CreateReadLock())
+                {
+                    return infos.Count;
+                }
+            }
+        }
+
         public int WarningCount
         {
             get
@@ -99,6 +137,7 @@ public void ClearWarningForExpression(int expressionID)
             using (rwl.CreateWriteLock())
             {
                 warnings.RemoveAll(w => w.ExpressionID == expressionID);
+                infos.RemoveAll(w => w.ExpressionID == expressionID);
             }
         }
 
@@ -107,6 +146,7 @@ public void ClearWarningsForGraph(Guid guid)
             using (rwl.CreateWriteLock())
             {
                 warnings.RemoveAll(w => w.GraphNodeGuid.Equals(guid));
+                infos.RemoveAll(w => w.GraphNodeGuid.Equals(guid));
             }
         }
 
@@ -115,6 +155,7 @@ public void ClearWarningsForAst(int astID)
             using (rwl.CreateWriteLock())
             {
                 warnings.RemoveAll(w => w.AstID.Equals(astID));
+                infos.RemoveAll(w => w.AstID.Equals(astID));
             }
         }
 
@@ -123,6 +164,7 @@ public RuntimeStatus(RuntimeCore runtimeCore,
                              System.IO.TextWriter writer = null)
         {
             warnings = new List<Runtime.WarningEntry>();
+            infos = new List<Runtime.InfoEntry>();
             this.runtimeCore = runtimeCore;
 
             if (writer != null)
@@ -196,11 +238,56 @@ public void LogWarning(Runtime.WarningID ID, string message, string filename, in
             }
         }
 
+        internal void LogInfo(Runtime.InfoID ID, string message, string filename)
+        {
+            filename ??= string.Empty;
+
+            if (MessageHandler != null)
+            {
+                var outputMessage = new OutputMessage(OutputMessage.MessageType.Info,
+                                                      message.Trim(), filename);
+                MessageHandler.Write(outputMessage);
+            }
+
+            AssociativeGraph.GraphNode executingGraphNode = null;
+            var executive = runtimeCore.CurrentExecutive.CurrentDSASMExec;
+            if (executive != null)
+            {
+                executingGraphNode = executive.Properties.executingGraphNode;
+                // In delta execution mode, it means the info is from some
+                // internal graph node. 
+                if (executingGraphNode != null && executingGraphNode.guid.Equals(System.Guid.Empty))
+                {
+                    executingGraphNode = runtimeCore.DSExecutable.ExecutingGraphnode;
+                }
+            }
+
+            var entry = new InfoEntry
+            {
+                ID = ID,
+                Message = message,
+                ExpressionID = runtimeCore.RuntimeExpressionUID,
+                GraphNodeGuid = executingGraphNode == null ? Guid.Empty : executingGraphNode.guid,
+                AstID = executingGraphNode == null ? Constants.kInvalidIndex : executingGraphNode.OriginalAstID,
+                Filename = filename
+            };
+
+            using (rwl.CreateWriteLock())
+            {
+                infos.Add(entry);
+            }
+        }
+
         public void LogWarning(Runtime.WarningID ID, string message)
         {
             LogWarning(ID, message, string.Empty, Constants.kInvalidIndex, Constants.kInvalidIndex);
         }
 
+        internal void LogInfo(Runtime.InfoID ID, string message)
+        {
+            LogInfo(ID, message, string.Empty);
+        }
+
         private void AuditCodeLocation(ref string filePath, ref int line, ref int column)
         {
             // We don't attempt to change line and column numbers if 
diff --git a/src/Engine/ProtoScript/Runners/LiveRunner.cs b/src/Engine/ProtoScript/Runners/LiveRunner.cs
diff --git a/src/NodeServices/MessageEvents.cs b/src/NodeServices/MessageEvents.cs

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@`
`17`	`17`	`using ProtoScript.Runners;`
`18`	`18`	`using BuildWarning = ProtoCore.BuildData.WarningEntry;`
`19`	`19`	`using RuntimeWarning = ProtoCore.Runtime.WarningEntry;`
	`20`	`+using RuntimeInfo = ProtoCore.Runtime.InfoEntry;`
`20`	`21`
`21`	`22`	`namespace Dynamo.Engine`
`22`	`23`	`{`
`@@ -500,6 +501,11 @@ internal IDictionary<Guid, List<RuntimeWarning>> GetRuntimeWarnings()`
`500`	`501`	`return liveRunnerServices.GetRuntimeWarnings();`
`501`	`502`	`}`
`502`	`503`
	`504`	`+ internal IDictionary<Guid, List<RuntimeInfo>> GetRuntimeInfos()`
	`505`	`+ {`
	`506`	`+ return liveRunnerServices.GetRuntimeInfos();`
	`507`	`+ }`
	`508`	`+`
`503`	`509`	`internal IEnumerable<Guid> GetExecutedAstGuids(Guid sessionID)`
`504`	`510`	`{`
`505`	`511`	`return liveRunnerServices.GetExecutedAstGuids(sessionID);`
Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,9 @@ public struct WarningEntry`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
	`76`	`+ /// <summary>`
	`77`	`+ /// VM print out message`
	`78`	`+ /// </summary>`
`76`	`79`	`public class OutputMessage`
`77`	`80`	`{`
`78`	`81`	`public enum MessageType { Info, Warning, Error }`
`@@ -97,6 +100,16 @@ public OutputMessage(MessageType type, string message,`
`97`	`100`	`Column = column;`
`98`	`101`	`}`
`99`	`102`
	`103`	`+ // A constructor for info messages without line and colume.`
	`104`	`+ internal OutputMessage(MessageType type, string message, string filePath)`
	`105`	`+ {`
	`106`	`+ Type = type;`
	`107`	`+ Message = message;`
	`108`	`+ FilePath = filePath;`
	`109`	`+ Line = -1;`
	`110`	`+ Column = -1;`
	`111`	`+ }`
	`112`	`+`
`100`	`113`	`public MessageType Type { get; private set; }`
`101`	`114`	`public string FilePath { get; private set; }`
`102`	`115`	`public int Line { get; private set; }`