wrap launch darkly in CLI to avoid bringing in new deps

src/Dynamo.All.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.32106.194
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32228.430
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DynamoCore", "DynamoCore\DynamoCore.csproj", "{7858FA8C-475F-4B8E-B468-1F8200778CF8}"
 	ProjectSection(ProjectDependencies) = postProject
@@ -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}

src/DynamoCore/Logging/AnalyticsService.cs

@@ -13,7 +13,7 @@ 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;
-
+        private static IAnalyticsClient dynamoAnalyticsClient;
         /// <summary>
         /// Starts the client when DynamoModel is created. This method initializes
         /// the Analytics service and application life cycle start is tracked.
@@ -41,8 +41,9 @@ internal static void Start(DynamoModel model, bool isHeadless, bool isTestMode)
             // This will also load the Analytics.Net.ADP assembly
             // We must initialize the ADPAnalyticsUI instance before the Analytics.Start call.
             adpAnalyticsUI = new ADPAnalyticsUI();
+            dynamoAnalyticsClient = new DynamoAnalyticsClient(model);
 
-            Analytics.Start(new DynamoAnalyticsClient(model));
+            Analytics.Start(dynamoAnalyticsClient);
             model.WorkspaceAdded += OnWorkspaceAdded;
         }
 
@@ -107,5 +108,13 @@ internal static void ShowADPConsetDialog(IntPtr? host)
                 adpAnalyticsUI.ShowOptInDialog(System.Threading.Thread.CurrentThread.CurrentUICulture.Name, false, host);
             }
         }
+        internal static string GetUserIDForSession()
+        {
+            if (dynamoAnalyticsClient is DynamoAnalyticsClient dac)
+            {
+                return dac.Session.UserId;
+            }
+            return null;
+        }
     }
 }

src/DynamoCore/Models/DynamoModel.cs

@@ -129,7 +129,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 +376,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
@@ -647,6 +649,14 @@ protected DynamoModel(IStartConfiguration config)
             if (!areAnalyticsDisabledFromConfig && !Dynamo.Logging.Analytics.DisableAnalytics)
             {
                 AnalyticsService.Start(this, IsHeadless, IsTestMode);
+                //only start feature flags if analytics is not disabled.
+                try
+                {
+                    //TODO consider CLI lifetime, should this be reset for each flag check, or okay to leave running for Dynamo lifetime?
+                    FeatureFlags = new DynamoUtilities.DynamoFeatureFlagsManager(AnalyticsService.GetUserIDForSession());
+                    FeatureFlags.MessageLogged += LogMessageWrapper;
+                }
+                catch (Exception e) { Logger.LogError($"could not start feature flags manager {e}"); };
             }
 
             if (!IsTestMode && PreferenceSettings.IsFirstRun)
@@ -1199,7 +1209,8 @@ public void Dispose()
             CustomNodeManager.MessageLogged -= LogMessage;
             CustomNodeManager.Dispose();
             MigrationManager.MessageLogged -= LogMessage;
-
+            FeatureFlags.MessageLogged -= LogMessageWrapper;
+            FeatureFlags.Dispose();
         }
 
         private void InitializeCustomNodeManager()
@@ -2744,6 +2755,11 @@ 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)
@@ -2770,7 +2786,7 @@ select string.IsNullOrEmpty(function.Namespace)
         }
 #endif
 
-        private void AddNodeTypeToSearch(TypeLoadData typeLoadData)
+    private void AddNodeTypeToSearch(TypeLoadData typeLoadData)
         {
             if (!typeLoadData.IsDSCompatible || typeLoadData.IsDeprecated || typeLoadData.IsHidden
                 || typeLoadData.IsMetaNode)

src/DynamoCoreWpf/Views/Core/DynamoView.xaml.cs

@@ -1008,6 +1008,18 @@ private void DynamoView_Loaded(object sender, EventArgs e)
                 this.Deactivated += (s, args) => { HidePopupWhenWindowDeactivated(null); };
             }
             loaded = true;
+
+            //feature flag test.
+            if (DynamoModel.FeatureFlags.CheckFeatureFlag<bool>("EasterEggIcon1", false))
+            {
+                dynamoViewModel.Model.Logger.Log("EasterEggIcon1 is true");
+                MessageBoxService.Show(this,"EasterEggIcon1 was true", "eastereggicon1", MessageBoxButton.OK, MessageBoxImage.Asterisk);
+            }
+            else
+            {
+                dynamoViewModel.Model.Logger.Log("EasterEggIcon1 is false");
+            }
+
         }
 
         /// <summary>

src/DynamoUtilities/DynamoFeatureFlagsManager.cs

@@ -0,0 +1,102 @@
+using Dynamo.Utilities;
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+
+
+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 const string checkFeatureFlagCommandToken = @"<<<<<CheckFeatureFlag>>>>>";
+        private string relativePath = Path.Combine("DynamoFeatureFlags", "DynamoFeatureFlags.exe");
+        internal event Action<string> MessageLogged;
+        public override void Dispose()
+        {
+            KillProcess();
+        }
+        /// <summary>
+        /// Constructor
+        /// Start the CLI tool and keep it around...
+        /// TODO we need to better handle if Dynamo crashes/is terminated - this process needs to be cleaned up.
+        /// </summary>
+        internal DynamoFeatureFlagsManager(string userkey)
+        {
+            ProcessStartInfo startInfo = new ProcessStartInfo
+            {
+                CreateNoWindow = true,
+                RedirectStandardOutput = true,
+                RedirectStandardInput = true,
+
+                UseShellExecute = false,
+                Arguments = $"-u {userkey}",
+                FileName = GetToolPath(relativePath)
+            };
+
+            process.StartInfo = startInfo;
+            try
+            {
+                process.Start();
+                started = true;
+            }
+            catch (Win32Exception)
+            {
+                // Do nothing
+            }
+        }
+
+        internal T CheckFeatureFlag<T>(string featureFlagKey, T defaultval)
+        {
+            if(!(defaultval is bool || defaultval is string)){
+                MessageLogged?.Invoke("unsupported flag type");
+                return defaultval;
+            }
+            if (!started)
+            {
+                 MessageLogged?.Invoke(GetCantStartErrorMessage());
+                 return defaultval;
+            }
+            try
+            {
+                process.StandardInput.WriteLine(checkFeatureFlagCommandToken);
+                process.StandardInput.WriteLine(featureFlagKey);
+                process.StandardInput.WriteLine(defaultval);
+                process.StandardInput.WriteLine(typeof(T).FullName);
+                process.StandardInput.WriteLine(endOfDataToken);
+            }
+            catch (Exception e) when (e is IOException || e is ObjectDisposedException)
+            {
+                KillProcess();
+                MessageLogged?.Invoke(GetCantCommunicateErrorMessage());
+                return defaultval;
+            }
+            //TODO if we start moving more complex types than bool/string we should use
+            //JSON (either newtonsoft or system.runtime.serializer which we already reference in this csproj).
+            var dataFromCLI = GetData();
+            //convert from string to string or bool.
+            var output = Convert.ChangeType(dataFromCLI, typeof(T));
+
+            return (T)output;
+        }
+
+
+        protected override string GetCantStartErrorMessage()
+        {
+            return $"$can't start { GetToolPath(relativePath)}";
+        }
+
+        protected override string GetCantCommunicateErrorMessage()
+        {
+            return $"$can't communicate with { GetToolPath(relativePath)}";
+        }
+    }
+}