DynamoDS
diff --git a/‎src/Dynamo.All.sln
Copy file name to clipboard
+11Lines changed: 11 additions & 0 deletions b/‎src/Dynamo.All.sln
Copy file name to clipboard
+11Lines changed: 11 additions & 0 deletions
diff --git a/‎src/DynamoCore/Logging/AnalyticsService.cs
Copy file name to clipboard
+8-1Lines changed: 8 additions & 1 deletion b/‎src/DynamoCore/Logging/AnalyticsService.cs
Copy file name to clipboard
+8-1Lines changed: 8 additions & 1 deletion
diff --git a/‎src/DynamoCore/Models/DynamoModel.cs
Copy file name to clipboard
+61-2Lines changed: 61 additions & 2 deletions b/‎src/DynamoCore/Models/DynamoModel.cs
Copy file name to clipboard
+61-2Lines changed: 61 additions & 2 deletions
diff --git a/‎src/DynamoCoreWpf/Views/Core/DynamoView.xaml.cs
Copy file name to clipboard
+43-2Lines changed: 43 additions & 2 deletions b/‎src/DynamoCoreWpf/Views/Core/DynamoView.xaml.cs
Copy file name to clipboard
+43-2Lines changed: 43 additions & 2 deletions
diff --git a/‎src/DynamoUtilities/DynamoFeatureFlagsManager.cs
Copy file name to clipboard
+113Lines changed: 113 additions & 0 deletions b/‎src/DynamoUtilities/DynamoFeatureFlagsManager.cs
Copy file name to clipboard
+113Lines changed: 113 additions & 0 deletions
@@ -241,6 +241,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AssemblyRenamerCLI", "Tools
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AssemblyInfoGenerator", "AssemblySharedInfoGenerator\AssemblyInfoGenerator.csproj", "{133FC760-5699-46D9-BEA6-E816B5F01016}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DynamoFeatureFlags", "Tools\DynamoFeatureFlags\DynamoFeatureFlags.csproj", "{94CF053D-BB66-4FC7-883B-48F072701BA9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -905,6 +907,14 @@ Global
 		{133FC760-5699-46D9-BEA6-E816B5F01016}.Release|Any CPU.Build.0 = Release|Any CPU
 		{133FC760-5699-46D9-BEA6-E816B5F01016}.Release|x64.ActiveCfg = Release|Any CPU
 		{133FC760-5699-46D9-BEA6-E816B5F01016}.Release|x64.Build.0 = Release|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Debug|x64.Build.0 = Debug|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Release|x64.ActiveCfg = Release|Any CPU
+		{94CF053D-BB66-4FC7-883B-48F072701BA9}.Release|x64.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -990,6 +1000,7 @@ Global
 		{E6DF2FBD-7D4D-4465-94DC-D576D737E985} = {0E492D35-2310-4849-9694-A2A53C09F21B}
 		{12FB4DA4-7E9C-4C2E-91CD-1D0B523A9535} = {88D45B00-E564-41DB-B57C-9509646CAA49}
 		{F382C3F8-C55C-4350-800A-3D13A94F8E13} = {D114C59C-CF66-4CC2-980F-9301FB4EA4E1}
+		{94CF053D-BB66-4FC7-883B-48F072701BA9} = {D114C59C-CF66-4CC2-980F-9301FB4EA4E1}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {89CB19C6-BF0A-4E6A-BFDA-79D143EAB59D}
 
@@ -13,7 +13,6 @@ class AnalyticsService
     {
         // Use the Analytics.Core interface so that we do not have to load the ADP assembly at this time.
         private static IAnalyticsUI adpAnalyticsUI;
-
         /// <summary>
         /// Starts the client when DynamoModel is created. This method initializes
         /// the Analytics service and application life cycle start is tracked.
@@ -107,5 +106,13 @@ internal static void ShowADPConsetDialog(IntPtr? host)
                 adpAnalyticsUI.ShowOptInDialog(System.Threading.Thread.CurrentThread.CurrentUICulture.Name, false, host);
             }
         }
+        internal static string GetUserIDForSession()
+        {
+            if (Analytics.client is DynamoAnalyticsClient dac)
+            {
+                return dac.Session?.UserId;
+            }
+            return null;
+        }
     }
 }
@@ -10,6 +10,7 @@
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Threading;
+using System.Threading.Tasks;
 using System.Xml;
 using Dynamo.Configuration;
 using Dynamo.Core;
@@ -129,7 +130,7 @@ public partial class DynamoModel : IDynamoModel, IDisposable, IEngineControllerM
         private Timer backupFilesTimer;
         private Dictionary<Guid, string> backupFilesDict = new Dictionary<Guid, string>();
         internal readonly Stopwatch stopwatch = Stopwatch.StartNew();
-
+    
         #endregion
 
         #region static properties
@@ -376,6 +377,8 @@ public IEnumerable<WorkspaceModel> Workspaces
         public AuthenticationManager AuthenticationManager { get; set; }
 
         internal static string DefaultPythonEngine { get; private set; }
+
+        internal static DynamoUtilities.DynamoFeatureFlagsManager FeatureFlags { get; private set; }
         #endregion
 
         #region initialization and disposal
@@ -656,9 +659,38 @@ protected DynamoModel(IStartConfiguration config)
             }
 
             // If user skipped analytics from assembly config, do not try to launch the analytics client
+            // or the feature flags client.
             if (!areAnalyticsDisabledFromConfig && !Dynamo.Logging.Analytics.DisableAnalytics)
             {
                 AnalyticsService.Start(this, IsHeadless, IsTestMode);
+
+
+                //run process startup/reading on another thread so we don't block dynamo startup.
+                //if we end up needing to control aspects of dynamo model or view startup that we can't make
+                //event based/async then just run this on main thread - ie get rid of the Task.Run()
+                var mainThreadSyncContext = new SynchronizationContext();
+                Task.Run(() =>
+                {
+                    try
+                    {
+                        //this will kill the CLI process after cacheing the flags in Dynamo process.
+                        using (FeatureFlags =
+                                new DynamoUtilities.DynamoFeatureFlagsManager(
+                                AnalyticsService.GetUserIDForSession(),
+                                mainThreadSyncContext,
+                                IsTestMode))
+                        {
+                            FeatureFlags.MessageLogged += LogMessageWrapper;
+                            //this will block task thread as it waits for data from feature flags process.
+                            FeatureFlags.CacheAllFlags();
+                        }
+                    }
+                    catch (Exception e) { Logger.LogError($"could not start feature flags manager {e}"); };
+                });
+
+                //TODO just a test of feature flag event, safe to remove at any time.
+                DynamoUtilities.DynamoFeatureFlagsManager.FlagsRetrieved += CheckFeatureFlagTest;
+
             }
 
             if (!IsTestMode && PreferenceSettings.IsFirstRun)
@@ -885,6 +917,28 @@ protected DynamoModel(IStartConfiguration config)
             DynamoReady(new ReadyParams(this));
         }
 
+        private void CheckFeatureFlagTest()
+        {
+            if (DynamoModel.FeatureFlags.CheckFeatureFlag<bool>("EasterEggIcon1", false))
+            {
+                this.Logger.Log("EasterEggIcon1 is true FROM MODEL");
+
+            }
+            else
+            {
+                this.Logger.Log("EasterEggIcon1 is false FROM MODEL");
+            }
+
+            if (DynamoModel.FeatureFlags.CheckFeatureFlag<string>("EasterEggMessage1", "NA") is var s && s != "NA")
+            {
+                this.Logger.Log("EasterEggMessage1 is enabled FROM MODEL");
+            }
+            else
+            {
+                this.Logger.Log("EasterEggMessage1 is disabled FROM MODEL");
+            }
+        }
+
         private void SetDefaultPythonTemplate()
         {
             // First check if the default python template is overridden by a PythonTemplate.py file in AppData
@@ -1211,7 +1265,8 @@ public void Dispose()
             CustomNodeManager.MessageLogged -= LogMessage;
             CustomNodeManager.Dispose();
             MigrationManager.MessageLogged -= LogMessage;
-
+            FeatureFlags.MessageLogged -= LogMessageWrapper;
+            DynamoUtilities.DynamoFeatureFlagsManager.FlagsRetrieved -= CheckFeatureFlagTest;
         }
 
         private void InitializeCustomNodeManager()
@@ -2769,6 +2824,10 @@ private void LogMessage(ILogMessage obj)
         {
             Logger.Log(obj);
         }
+        private void LogMessageWrapper(string m)
+        {
+            LogMessage(Dynamo.Logging.LogMessage.Info(m));
+        }
 
 #if DEBUG_LIBRARY
         private void DumpLibrarySnapshot(IEnumerable<Engine.FunctionGroup> functionGroups)
 
@@ -120,7 +120,7 @@ public DynamoView(DynamoViewModel dynamoViewModel)
             tabSlidingWindowStart = tabSlidingWindowEnd = 0;
 
             //Initialize the ViewExtensionManager with the CommonDataDirectory so that view extensions found here are checked first for dll's with signed certificates
-            viewExtensionManager = new ViewExtensionManager(new[] {dynamoViewModel.Model.PathManager.CommonDataDirectory });
+            viewExtensionManager = new ViewExtensionManager(new[] { dynamoViewModel.Model.PathManager.CommonDataDirectory });
 
             _timer = new Stopwatch();
             _timer.Start();
@@ -220,7 +220,6 @@ public DynamoView(DynamoViewModel dynamoViewModel)
             this.dynamoViewModel.Model.WorkspaceOpened += OnWorkspaceOpened;
             FocusableGrid.InputBindings.Clear();
         }
-
         private void OnWorkspaceOpened(WorkspaceModel workspace)
         {
             if (!(workspace is HomeWorkspaceModel hws))
@@ -1009,6 +1008,20 @@ private void DynamoView_Loaded(object sender, EventArgs e)
                 this.Deactivated += (s, args) => { HidePopupWhenWindowDeactivated(null); };
             }
             loaded = true;
+
+            
+            //The following code illustrates use of FeatureFlagsManager.
+            //safe to remove.
+            if (DynamoModel.FeatureFlags != null)
+            {
+                CheckTestFlags();
+            }
+            //if feature flags is not yet initalized, subscribe to the event and wait.
+            else
+            {
+                DynamoUtilities.DynamoFeatureFlagsManager.FlagsRetrieved += CheckTestFlags;
+            }
+           
         }
 
         /// <summary>
@@ -1021,6 +1034,33 @@ private void HidePopupWhenWindowDeactivated(object obj)
             if (workspace != null)
                 workspace.HideAllPopUp(obj);
         }
+        /// <summary>
+        /// check some test flags from launch darkly.
+        /// code is safe to remove at any time.
+        /// </summary>
+        private void CheckTestFlags()
+        {
+
+            //feature flag test.
+            if (DynamoModel.FeatureFlags?.CheckFeatureFlag<bool>("EasterEggIcon1", false) == true)
+            {
+                dynamoViewModel.Model.Logger.Log("EasterEggIcon1 is true from view");
+            }
+            else
+            {
+                dynamoViewModel.Model.Logger.Log("EasterEggIcon1 is false from view");
+            }
+
+            if (DynamoModel.FeatureFlags?.CheckFeatureFlag<string>("EasterEggMessage1", "NA") is string ffs && ffs != "NA")
+            {
+                dynamoViewModel.Model.Logger.Log("EasterEggMessage1 is enabled from view");
+                MessageBoxService.Show(this, ffs, "EasterEggMessage1", MessageBoxButton.OK, MessageBoxImage.Asterisk);
+            }
+            else
+            {
+                dynamoViewModel.Model.Logger.Log("EasterEggMessage1 is disabled from view");
+            }
+        }
 
         private void TrackStartupAnalytics()
         {
@@ -1574,6 +1614,7 @@ private void WindowClosed(object sender, EventArgs e)
             this.dynamoViewModel.RequestReturnFocusToView -= OnRequestReturnFocusToView;
             this.dynamoViewModel.Model.WorkspaceSaving -= OnWorkspaceSaving;
             this.dynamoViewModel.Model.WorkspaceOpened -= OnWorkspaceOpened;
+            DynamoUtilities.DynamoFeatureFlagsManager.FlagsRetrieved -= CheckTestFlags;
 
             this.Dispose();
             sharedViewExtensionLoadedParams?.Dispose();
 
@@ -0,0 +1,113 @@
+using Dynamo.Utilities;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace DynamoUtilities
+{
+
+
+    /// <summary>
+    /// A wrapper around the DynamoFeatureFlags CLI tool.
+    /// Which is itself a wrapper around LaunchDarkly.
+    /// Not thread safe.
+    /// </summary>
+    internal class DynamoFeatureFlagsManager : CLIWrapper
+    {
+        private string relativePath = Path.Combine("DynamoFeatureFlags", "DynamoFeatureFlags.exe");
+        private Dictionary<string, object> AllFlagsCache { get; set; }//TODO lock is likely overkill.
+        private SynchronizationContext syncContext;
+        internal static event Action FlagsRetrieved;
+
+        /// <summary>
+        /// Constructor
+        /// Start the CLI tool and keep it around...
+        /// </summary>
+        /// <param name="userkey">non PII key to identify this user.</param>
+        /// <param name="syncContext">context used for raising FlagRetrieved event.</param>
+        /// <param name="testmode">will not contact feature flag service in testmode, will respond with defaults.</param>
+        internal DynamoFeatureFlagsManager(string userkey, SynchronizationContext syncContext, bool testmode=false)
+        {  
+            this.syncContext = syncContext;
+            //dont pass userkey arg if null/empty
+            var userkeyarg = $"-u {userkey}";
+            var testmodearg = string.Empty;
+            if (string.IsNullOrEmpty(userkey))
+            {
+                userkeyarg = String.Empty;
+            }
+            if (testmode == true)
+            {
+                testmodearg = "-t";
+            }
+            var args = $"{userkeyarg} -p {Process.GetCurrentProcess().Id} {testmodearg}";
+            StartProcess(relativePath, args);
+        }
+
+        internal void CacheAllFlags()
+        {
+
+            //wait for response
+            var dataFromCLI = GetData();
+            //convert from json string to dictionary.
+            try
+            {  
+                AllFlagsCache = JsonConvert.DeserializeObject<Dictionary<string, object>>(dataFromCLI);
+                //invoke the flags retrieved event on the sync context which should be the main ui thread.
+                syncContext?.Send((_) =>
+                {   
+                    FlagsRetrieved?.Invoke();
+
+                },null);
+                
+            }
+            catch (Exception e)
+            {
+                RaiseMessageLogged($"{e?.Message}");
+            }
+        }
+
+        internal T CheckFeatureFlag<T>(string featureFlagKey, T defaultval)
+        {
+            if(!(defaultval is bool || defaultval is string)){
+                RaiseMessageLogged("unsupported flag type");
+                return defaultval;
+            }
+            // if we have not retrieved flags from the cli return empty
+            // and log.
+           
+            if(AllFlagsCache == null)
+            {
+                RaiseMessageLogged("the flags cache is null, something went wrong retrieving feature flags," +
+                  " or you need to wait longer for the cache to populate, you can use the static FlagsRetrieved event for this purpose. ");
+                return defaultval;
+            }
+            if (AllFlagsCache.ContainsKey(featureFlagKey))
+            {
+                return (T)AllFlagsCache[featureFlagKey];
+            }
+            else
+            {
+                RaiseMessageLogged($"failed to get value for feature flag key ex: {featureFlagKey},{System.Environment.NewLine} returning default value: {defaultval}");
+                return defaultval;
+            }
+        }
+
+
+        protected override string GetCantStartErrorMessage()
+        {
+            return $"can't start { GetToolPath(relativePath)}";
+        }
+
+        protected override string GetCantCommunicateErrorMessage()
+        {
+            return $"can't communicate with { GetToolPath(relativePath)}";
+        }
+    }
+}
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,6 @@ class AnalyticsService`
`13`	`13`	`{`
`14`	`14`	`// Use the Analytics.Core interface so that we do not have to load the ADP assembly at this time.`
`15`	`15`	`private static IAnalyticsUI adpAnalyticsUI;`
`16`		`-`
`17`	`16`	`/// <summary>`
`18`	`17`	`/// Starts the client when DynamoModel is created. This method initializes`
`19`	`18`	`/// the Analytics service and application life cycle start is tracked.`
`@@ -107,5 +106,13 @@ internal static void ShowADPConsetDialog(IntPtr? host)`
`107`	`106`	`adpAnalyticsUI.ShowOptInDialog(System.Threading.Thread.CurrentThread.CurrentUICulture.Name, false, host);`
`108`	`107`	`}`
`109`	`108`	`}`
	`109`	`+ internal static string GetUserIDForSession()`
	`110`	`+ {`
	`111`	`+ if (Analytics.client is DynamoAnalyticsClient dac)`
	`112`	`+ {`
	`113`	`+ return dac.Session?.UserId;`
	`114`	`+ }`
	`115`	`+ return null;`
	`116`	`+ }`
`110`	`117`	`}`
`111`	`118`	`}`