DynamoDS
diff --git a/‎src/DynamoCore/Models/DynamoModel.cs
Copy file name to clipboard
+15-22Lines changed: 15 additions & 22 deletions b/‎src/DynamoCore/Models/DynamoModel.cs
Copy file name to clipboard
+15-22Lines changed: 15 additions & 22 deletions
diff --git a/‎src/DynamoCore/Search/NodeSearchModel.cs
Copy file name to clipboard
+32-9Lines changed: 32 additions & 9 deletions b/‎src/DynamoCore/Search/NodeSearchModel.cs
Copy file name to clipboard
+32-9Lines changed: 32 additions & 9 deletions
diff --git a/‎src/DynamoCore/Utilities/LuceneSearchUtility.cs
Copy file name to clipboard
+39-12Lines changed: 39 additions & 12 deletions b/‎src/DynamoCore/Utilities/LuceneSearchUtility.cs
Copy file name to clipboard
+39-12Lines changed: 39 additions & 12 deletions
diff --git a/‎src/DynamoCoreWpf/ViewModels/Search/NodeAutoCompleteSearchViewModel.cs
Copy file name to clipboard
+3-5Lines changed: 3 additions & 5 deletions b/‎src/DynamoCoreWpf/ViewModels/Search/NodeAutoCompleteSearchViewModel.cs
Copy file name to clipboard
+3-5Lines changed: 3 additions & 5 deletions
@@ -1592,7 +1592,6 @@ private void InitializeIncludedNodes()
 
             var cnbNode = new CodeBlockNodeSearchElement(cbnData, LibraryServices);
             SearchModel?.Add(cnbNode);
-            LuceneUtility.AddNodeTypeToSearchIndex(cnbNode, iDoc);
 
             var symbolSearchElement = new NodeModelSearchElement(symbolData)
             {
@@ -1611,10 +1610,8 @@ private void InitializeIncludedNodes()
             };
 
             SearchModel?.Add(symbolSearchElement);
-            LuceneUtility.AddNodeTypeToSearchIndex(symbolSearchElement, iDoc);
-
             SearchModel?.Add(outputSearchElement);
-            LuceneUtility.AddNodeTypeToSearchIndex(outputSearchElement, iDoc);
+            LuceneUtility.AddNodeTypeToSearchIndexBulk([cnbNode, symbolSearchElement, outputSearchElement], iDoc);
 
         }
 
@@ -1755,6 +1752,7 @@ internal void LoadNodeLibrary(Assembly assem, bool suppressZeroTouchLibraryLoad
         private void LoadNodeModels(List<TypeLoadData> nodes, bool isPackageMember)
         {
             var iDoc = LuceneUtility.InitializeIndexDocumentForNodes();
+            List<NodeSearchElement> nodeSearchElements = [];
             foreach (var type in nodes)
             {
                 // Protect ourselves from exceptions thrown by malformed third party nodes.
@@ -1769,14 +1767,15 @@ private void LoadNodeModels(List<TypeLoadData> nodes, bool isPackageMember)
                     // TODO: get search element some other way
                     if (ele != null)
                     {
-                        LuceneUtility.AddNodeTypeToSearchIndex(ele, iDoc);
+                        nodeSearchElements.Add(ele);
                     }
                 }
                 catch (Exception e)
                 {
                     Logger.Log(e);
                 }
             }
+            LuceneUtility.AddNodeTypeToSearchIndexBulk(nodeSearchElements, iDoc);
         }
 
         private void InitializePreferences()
@@ -3478,26 +3477,20 @@ internal void HideUnhideNamespace(bool hide, string library, string namespc)
         internal void AddZeroTouchNodesToSearch(IEnumerable<FunctionGroup> functionGroups)
         {
             var iDoc = LuceneUtility.InitializeIndexDocumentForNodes();
+            List<NodeSearchElement> nodes = new();
             foreach (var funcGroup in functionGroups)
-                AddZeroTouchNodeToSearch(funcGroup, iDoc);
-        }
-
-        private void AddZeroTouchNodeToSearch(FunctionGroup funcGroup, Document iDoc)
-        {
-            foreach (var functionDescriptor in funcGroup.Functions)
             {
-                AddZeroTouchNodeToSearch(functionDescriptor, iDoc);
-            }
-        }
-
-        private void AddZeroTouchNodeToSearch(FunctionDescriptor functionDescriptor, Document iDoc)
-        {
-            if (functionDescriptor.IsVisibleInLibrary)
-            {
-                var ele = new ZeroTouchSearchElement(functionDescriptor);
-                SearchModel?.Add(ele);
-                LuceneUtility.AddNodeTypeToSearchIndex(ele, iDoc);
+                foreach (var functionDescriptor in funcGroup.Functions)
+                {
+                    if (functionDescriptor.IsVisibleInLibrary)
+                    {
+                        var ele = new ZeroTouchSearchElement(functionDescriptor);
+                        SearchModel?.Add(ele);
+                        nodes.Add(ele);
+                    }
+                }
             }
+            LuceneUtility.AddNodeTypeToSearchIndexBulk(nodes, iDoc);
         }
 
         /// <summary>
 
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Xml;
 using Dynamo.Configuration;
 using Dynamo.Graph.Nodes;
@@ -10,7 +11,6 @@
 using Dynamo.Utilities;
 using DynamoUtilities;
 using Lucene.Net.Documents;
-using Lucene.Net.Index;
 using Lucene.Net.QueryParsers.Classic;
 using Lucene.Net.Search;
 
@@ -231,29 +231,42 @@ internal string ProcessNodeCategory(string category, ref SearchElementGroup grou
             return category.Substring(0, index);
         }
 
-        internal IEnumerable<NodeSearchElement> Search(string search, LuceneSearchUtility luceneSearchUtility)
+        /// <summary>
+        /// Search for nodes by using a search key.
+        /// </summary>
+        /// <param name="search"></param>
+        /// <param name="luceneSearchUtility"></param>
+        /// <param name="ctk">Cancellation token to short circuit the search.</param>
+        /// <returns></returns>
+        /// <exception cref="Exception"></exception>
+        internal IEnumerable<NodeSearchElement> Search(string search, LuceneSearchUtility luceneSearchUtility, CancellationToken ctk = default)
         {
-            
+            ctk.ThrowIfCancellationRequested();
+
             if (luceneSearchUtility != null)
             {
-                //The DirectoryReader and IndexSearcher have to be assigned after commiting indexing changes and before executing the Searcher.Search() method, otherwise new indexed info won't be reflected
-                luceneSearchUtility.dirReader = luceneSearchUtility.writer != null ? luceneSearchUtility.writer.GetReader(applyAllDeletes: true) : DirectoryReader.Open(luceneSearchUtility.indexDir);
-                luceneSearchUtility.Searcher = new IndexSearcher(luceneSearchUtility.dirReader);
+                if (luceneSearchUtility.Searcher == null)
+                {
+                    throw new Exception("Invalid IndexSearcher found");
+                }
 
                 string searchTerm = search.Trim();
                 var candidates = new List<NodeSearchElement>();
+
                 var parser = new MultiFieldQueryParser(LuceneConfig.LuceneNetVersion, LuceneConfig.NodeIndexFields, luceneSearchUtility.Analyzer)
                 {
                     AllowLeadingWildcard = true,
                     DefaultOperator = LuceneConfig.DefaultOperator,
                     FuzzyMinSim = LuceneConfig.MinimumSimilarity
                 };
 
-                Query query = parser.Parse(luceneSearchUtility.CreateSearchQuery(LuceneConfig.NodeIndexFields, searchTerm));
+                Query query = parser.Parse(luceneSearchUtility.CreateSearchQuery(LuceneConfig.NodeIndexFields, searchTerm, false, ctk));
                 TopDocs topDocs = luceneSearchUtility.Searcher.Search(query, n: LuceneConfig.DefaultResultsCount);
 
                 for (int i = 0; i < topDocs.ScoreDocs.Length; i++)
                 {
+                    ctk.ThrowIfCancellationRequested();
+
                     // read back a Lucene doc from results
                     Document resultDoc = luceneSearchUtility.Searcher.Doc(topDocs.ScoreDocs[i].Doc);
 
@@ -268,7 +281,7 @@ internal IEnumerable<NodeSearchElement> Search(string search, LuceneSearchUtilit
                     }
                     else
                     {
-                        var foundNode = FindModelForNodeNameAndCategory(name, cat, parameters);
+                        var foundNode = FindModelForNodeNameAndCategory(name, cat, parameters, ctk);
                         if (foundNode != null)
                         {
                             candidates.Add(foundNode);
@@ -280,8 +293,18 @@ internal IEnumerable<NodeSearchElement> Search(string search, LuceneSearchUtilit
             return null;
         }
 
-        internal NodeSearchElement FindModelForNodeNameAndCategory(string nodeName, string nodeCategory, string parameters)
+        /// <summary>
+        /// Finds the node model that corresponds to the input nodeName, nodeCategory and parameters.
+        /// </summary>
+        /// <param name="nodeName"></param>
+        /// <param name="nodeCategory"></param>
+        /// <param name="parameters"></param>
+        /// <param name="ctk">Cancellation token to short circuit the operation.</param>
+        /// <returns></returns>
+        internal NodeSearchElement FindModelForNodeNameAndCategory(string nodeName, string nodeCategory, string parameters, CancellationToken ctk = default)
         {
+            ctk.ThrowIfCancellationRequested();
+
             var result = Entries.Where(e => {
                 if (e.Name.Replace(" ", string.Empty).Equals(nodeName) && e.FullCategoryName.Equals(nodeCategory))
                 {
 
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using Dynamo.Configuration;
 using Dynamo.Models;
 using Dynamo.Search.SearchElements;
@@ -23,7 +24,6 @@
 using Lucene.Net.Search;
 using Lucene.Net.Store;
 using Lucene.Net.Util;
-using Newtonsoft.Json;
 
 namespace Dynamo.Utilities
 {
@@ -50,7 +50,7 @@ internal class LuceneSearchUtility
         internal Lucene.Net.Store.Directory indexDir;
 
         /// <summary>
-        /// Lucene Index write
+        /// Lucene Index write. Make sure to call InitializeIndexSearcher after every index change.
         /// </summary>
         internal IndexWriter writer;
 
@@ -190,6 +190,16 @@ internal void CreateLuceneIndexWriter(OpenMode mode = OpenMode.CREATE)
             }
         }
 
+        /// <summary>
+        /// InitializeIndexSearcher initializes the dirReader and Searcher of this class.
+        /// This method should be called after every index change. 
+        /// </summary>
+        private void InitializeIndexSearcher()
+        {
+            dirReader = writer != null ? writer.GetReader(applyAllDeletes: true) : DirectoryReader.Open(indexDir);
+            Searcher = new(dirReader);
+        }
+
         /// <summary>
         /// Initialize Lucene index document object for reuse
         /// </summary>
@@ -252,11 +262,8 @@ internal void UpdateIndexedNodesInfo(List<NodeSearchElement> nodeList)
             if(nodeList.Any())
             {
                 writer.DeleteAll();
-                foreach(var node in nodeList)
-                {
-                    var iDoc = InitializeIndexDocumentForNodes();
-                    AddNodeTypeToSearchIndex(node, iDoc);
-                }             
+                var iDoc = InitializeIndexDocumentForNodes();
+                AddNodeTypeToSearchIndexBulk(nodeList, iDoc);
             }         
         }
 
@@ -321,8 +328,9 @@ internal void SetDocumentFieldValue(Document doc, string field, string value, bo
         /// <param name="fields">All fields to be searched in.</param>
         /// <param name="SearchTerm">Search key to be searched for.</param>
         /// <param name="IsPackageContext">Set this to true if the search context is packages instead of nodes.</param>
+        /// <param name="ctk">Cancellation token to short circuit the search.</param>
         /// <returns></returns>
-        internal string CreateSearchQuery(string[] fields, string SearchTerm, bool IsPackageContext = false)
+        internal string CreateSearchQuery(string[] fields, string SearchTerm, bool IsPackageContext = false, CancellationToken ctk = default)
         {
             //By Default the search will be normal
             SearchType searchType = SearchType.Normal;
@@ -353,6 +361,7 @@ internal string CreateSearchQuery(string[] fields, string SearchTerm, bool IsPac
             foreach (string f in fields)
             {
                 Occur occurQuery = Occur.SHOULD;
+                ctk.ThrowIfCancellationRequested();
 
                 searchTerm = QueryParser.Escape(SearchTerm);
                 if (searchType == SearchType.ByDotCategory)
@@ -383,7 +392,7 @@ internal string CreateSearchQuery(string[] fields, string SearchTerm, bool IsPac
                     continue;
 
                 //Adds the FuzzyQuery and 4 WildcardQueries (3 of them contain regular expressions), with the normal weights
-                AddQueries(searchTerm, f, searchType, booleanQuery, occurQuery, fuzzyLogicMaxEdits);
+                AddQueries(searchTerm, f, searchType, booleanQuery, occurQuery, fuzzyLogicMaxEdits, ctk);
 
                 if (searchType == SearchType.ByEmptySpace)
                 {
@@ -396,7 +405,7 @@ internal string CreateSearchQuery(string[] fields, string SearchTerm, bool IsPac
                         if (string.IsNullOrEmpty(s)) continue;
 
                         //Adds the FuzzyQuery and 4 WildcardQueries (3 of them contain regular expressions), with the weights for Queries with RegularExpressions
-                        AddQueries(s, f, searchType, booleanQuery, occurQuery, LuceneConfig.FuzzySearchMinEdits, true);
+                        AddQueries(s, f, searchType, booleanQuery, occurQuery, LuceneConfig.FuzzySearchMinEdits, ctk, true);
                     }
                 }
             }
@@ -412,9 +421,12 @@ internal string CreateSearchQuery(string[] fields, string SearchTerm, bool IsPac
         /// <param name="booleanQuery">The Boolean query in which the Wildcard queries will be added</param>
         /// <param name="occurQuery">Occur type can be Should or Must</param>
         /// <param name="fuzzyLogicMaxEdits">Max edit lenght for Fuzzy queries</param>
+        /// <param name="ctk">Cancellation token to short circuit the operation.</param>
         /// <param name="termSplit">Indicates if the SearchTerm has been split by empty space or not</param>
-        private void AddQueries(string searchTerm, string field, SearchType searchType, BooleanQuery booleanQuery, Occur occurQuery, int fuzzyLogicMaxEdits, bool termSplit = false)
+        private void AddQueries(string searchTerm, string field, SearchType searchType, BooleanQuery booleanQuery, Occur occurQuery, int fuzzyLogicMaxEdits, CancellationToken ctk = default, bool termSplit = false)
         {
+            ctk.ThrowIfCancellationRequested();
+
             string querySearchTerm = searchTerm.Replace(" ", string.Empty);
 
             FuzzyQuery fuzzyQuery;
@@ -582,14 +594,16 @@ internal void CommitWriterChanges()
         {
             //Commit the info indexed if index writer exists
             writer?.Commit();
+
+            InitializeIndexSearcher();
         }
 
         /// <summary>
         /// Add node information to existing Lucene index
         /// </summary>
         /// <param name="node">node info that will be indexed</param>
         /// <param name="doc">Lucene document in which the node info will be indexed</param>
-        internal void AddNodeTypeToSearchIndex(NodeSearchElement node, Document doc)
+        internal void AddNodeTypeToSearchIndex_uninitialized(NodeSearchElement node, Document doc)
         {
             if (addedFields == null) return;
             // During DynamoModel initialization, the index writer should still be valid here
@@ -628,6 +642,19 @@ internal void AddNodeTypeToSearchIndex(NodeSearchElement node, Document doc)
 
             writer?.AddDocument(doc);
         }
+        internal void AddNodeTypeToSearchIndex(NodeSearchElement node, Document doc)
+        {
+            AddNodeTypeToSearchIndex_uninitialized(node,doc);
+            InitializeIndexSearcher();
+        }
+        internal void AddNodeTypeToSearchIndexBulk(List<NodeSearchElement> nodes, Document doc)
+        {
+            foreach(var node in nodes)
+            {
+                AddNodeTypeToSearchIndex_uninitialized(node, doc);
+            }
+            InitializeIndexSearcher();
+        }
     }
 
     /// <summary>
 
@@ -733,11 +733,9 @@ internal void SearchAutoCompleteCandidates(string input)
                     LuceneSearch.LuceneUtilityNodeAutocomplete = new LuceneSearchUtility(dynamoViewModel.Model, LuceneSearchUtility.DefaultStartConfig);
 
                     //Memory indexing process for Node Autocomplete (indexing just the nodes returned by the NodeAutocomplete service so we limit the scope of the query search)
-                    foreach (var node in searchElementsCache.Select(x => x.Model))
-                    {
-                        var doc = LuceneUtility.InitializeIndexDocumentForNodes();
-                        LuceneUtility.AddNodeTypeToSearchIndex(node, doc);
-                    }
+                    var doc = LuceneUtility.InitializeIndexDocumentForNodes();
+                    List<NodeSearchElement> nodeSearchElements = [.. searchElementsCache.Select(x => x.Model)];
+                    LuceneUtility.AddNodeTypeToSearchIndexBulk(nodeSearchElements, doc);
 
                     //Write the Lucene documents to memory
                     LuceneUtility.CommitWriterChanges();
Original file line number	Diff line number	Diff line change
`@@ -1592,7 +1592,6 @@ private void InitializeIncludedNodes()`
`1592`	`1592`
`1593`	`1593`	`var cnbNode = new CodeBlockNodeSearchElement(cbnData, LibraryServices);`
`1594`	`1594`	`SearchModel?.Add(cnbNode);`
`1595`		`- LuceneUtility.AddNodeTypeToSearchIndex(cnbNode, iDoc);`
`1596`	`1595`
`1597`	`1596`	`var symbolSearchElement = new NodeModelSearchElement(symbolData)`
`1598`	`1597`	`{`
`@@ -1611,10 +1610,8 @@ private void InitializeIncludedNodes()`
`1611`	`1610`	`};`
`1612`	`1611`
`1613`	`1612`	`SearchModel?.Add(symbolSearchElement);`
`1614`		`- LuceneUtility.AddNodeTypeToSearchIndex(symbolSearchElement, iDoc);`
`1615`		`-`
`1616`	`1613`	`SearchModel?.Add(outputSearchElement);`
`1617`		`- LuceneUtility.AddNodeTypeToSearchIndex(outputSearchElement, iDoc);`
	`1614`	`+ LuceneUtility.AddNodeTypeToSearchIndexBulk([cnbNode, symbolSearchElement, outputSearchElement], iDoc);`
`1618`	`1615`
`1619`	`1616`	`}`
`1620`	`1617`
`@@ -1755,6 +1752,7 @@ internal void LoadNodeLibrary(Assembly assem, bool suppressZeroTouchLibraryLoad`
`1755`	`1752`	`private void LoadNodeModels(List<TypeLoadData> nodes, bool isPackageMember)`
`1756`	`1753`	`{`
`1757`	`1754`	`var iDoc = LuceneUtility.InitializeIndexDocumentForNodes();`
	`1755`	`+ List<NodeSearchElement> nodeSearchElements = [];`
`1758`	`1756`	`foreach (var type in nodes)`
`1759`	`1757`	`{`
`1760`	`1758`	`// Protect ourselves from exceptions thrown by malformed third party nodes.`
`@@ -1769,14 +1767,15 @@ private void LoadNodeModels(List<TypeLoadData> nodes, bool isPackageMember)`
`1769`	`1767`	`// TODO: get search element some other way`
`1770`	`1768`	`if (ele != null)`
`1771`	`1769`	`{`
`1772`		`- LuceneUtility.AddNodeTypeToSearchIndex(ele, iDoc);`
	`1770`	`+ nodeSearchElements.Add(ele);`
`1773`	`1771`	`}`
`1774`	`1772`	`}`
`1775`	`1773`	`catch (Exception e)`
`1776`	`1774`	`{`
`1777`	`1775`	`Logger.Log(e);`
`1778`	`1776`	`}`
`1779`	`1777`	`}`
	`1778`	`+ LuceneUtility.AddNodeTypeToSearchIndexBulk(nodeSearchElements, iDoc);`
`1780`	`1779`	`}`
`1781`	`1780`
`1782`	`1781`	`private void InitializePreferences()`
`@@ -3478,26 +3477,20 @@ internal void HideUnhideNamespace(bool hide, string library, string namespc)`
`3478`	`3477`	`internal void AddZeroTouchNodesToSearch(IEnumerable<FunctionGroup> functionGroups)`
`3479`	`3478`	`{`
`3480`	`3479`	`var iDoc = LuceneUtility.InitializeIndexDocumentForNodes();`
	`3480`	`+ List<NodeSearchElement> nodes = new();`
`3481`	`3481`	`foreach (var funcGroup in functionGroups)`
`3482`		`- AddZeroTouchNodeToSearch(funcGroup, iDoc);`
`3483`		`- }`
`3484`		`-`
`3485`		`- private void AddZeroTouchNodeToSearch(FunctionGroup funcGroup, Document iDoc)`
`3486`		`- {`
`3487`		`- foreach (var functionDescriptor in funcGroup.Functions)`
`3488`	`3482`	`{`
`3489`		`- AddZeroTouchNodeToSearch(functionDescriptor, iDoc);`
`3490`		`- }`
`3491`		`- }`
`3492`		`-`
`3493`		`- private void AddZeroTouchNodeToSearch(FunctionDescriptor functionDescriptor, Document iDoc)`
`3494`		`- {`
`3495`		`- if (functionDescriptor.IsVisibleInLibrary)`
`3496`		`- {`
`3497`		`- var ele = new ZeroTouchSearchElement(functionDescriptor);`
`3498`		`- SearchModel?.Add(ele);`
`3499`		`- LuceneUtility.AddNodeTypeToSearchIndex(ele, iDoc);`
	`3483`	`+ foreach (var functionDescriptor in funcGroup.Functions)`
	`3484`	`+ {`
	`3485`	`+ if (functionDescriptor.IsVisibleInLibrary)`
	`3486`	`+ {`
	`3487`	`+ var ele = new ZeroTouchSearchElement(functionDescriptor);`
	`3488`	`+ SearchModel?.Add(ele);`
	`3489`	`+ nodes.Add(ele);`
	`3490`	`+ }`
	`3491`	`+ }`
`3500`	`3492`	`}`
	`3493`	`+ LuceneUtility.AddNodeTypeToSearchIndexBulk(nodes, iDoc);`
`3501`	`3494`	`}`
`3502`	`3495`
`3503`	`3496`	`/// <summary>`