config persistence part1 - much more to come

README.md

@@ -44,6 +44,10 @@ From src:
 `layout` (`l`): Creates a full layout in {root}/_layout  
    Does a clean, restore, build, publish and copy
 
+`update` (`u`) {dirname}: Builds and publishes just one dir.  Patches the layout
+   update {dirname}
+   Use if you change code in an assembly and don't want to wait for the full layout.
+
 `validate` (`v`): Precheckin validation.  Runs git clean, layout and test.
 
 ### Editors

src/Agent.Listener/Configuration/AgentCredential.cs

@@ -4,50 +4,82 @@
 
 namespace Microsoft.VisualStudio.Services.Agent.Configuration
 {
-    public abstract class AgentCredential
+    public class CredentialData
     {
-        public abstract void ReadCredential(IHostContext context, Dictionary<string, string> args, Boolean isUnattended);
-
-        protected virtual String ReadCredentialConfig(
-            IHostContext context,
-            string parameterName,
-            bool isSecret,
-            Dictionary<String, ArgumentMetaData> metaData,
-            Dictionary<String, String> args,
-            Boolean isUnattended)
-        {
-            TraceSource m_trace = context.Trace["AgentCrendialManager"];
-            m_trace.Info("Reading credential configuration {0}", parameterName);
-            return context.GetService<IConsoleWizard>()
-                .GetConfigurationValue(context, parameterName, metaData, args, isUnattended);
-        }
+        public string Scheme { get; set; }
+        public Dictionary<string, string> Data { get; set; }
     }
 
-    public sealed class TokenCredential : AgentCredential
+    public interface ICredentialProvider
     {
-        private Dictionary<String, ArgumentMetaData> CredentialMetaData = new Dictionary<String, ArgumentMetaData>
-                                                                               {
-                                                                                   {
-                                                                                       "Token",
-                                                                                       new ArgumentMetaData
-                                                                                           {
-                                                                                               Description = "Personal Access Token",
-                                                                                               IsSercret = true,
-                                                                                               Validator = Validators.NonEmptyValidator
-                                                                                           }
-                                                                                   }
-                                                                               };
-        public String Token { get; private set; }
-
-        public override void ReadCredential(IHostContext context, Dictionary<String, String> args, Boolean isUnattended)
+        CredentialData CredentialData { get; set; }
+        // TODO: (bryanmac) abstract GetVSSCredential which knows how to instantiate based off data
+        void ReadCredential(IHostContext context, Dictionary<string, string> args, bool enforceSupplied);
+    }
+
+    public abstract class CredentialProvider : ICredentialProvider
+    {
+        public CredentialProvider(string scheme)
         {
-            this.Token = this.ReadCredentialConfig(context, "Token", true, this.CredentialMetaData, args, isUnattended);
+            CredentialData = new CredentialData();
+            CredentialData.Scheme = scheme;
+            CredentialData.Data = new Dictionary<string, string>();
         }
+
+        public CredentialData CredentialData { get; set; }
+
+        // TODO: (bryanmac) abstract GetVSSCredential which knows how to instantiate based off data
+
+        public abstract void ReadCredential(IHostContext context, Dictionary<string, string> args, bool enforceSupplied);
     }
 
-    public enum AuthScheme
+    public sealed class PersonalAccessToken : CredentialProvider
     {
-        Unknown,
-        Pat
+        public PersonalAccessToken(): base("PAT") {}
+
+        public override void ReadCredential(IHostContext context, Dictionary<string, string> args, bool enforceSupplied)
+        {
+            TraceSource trace = context.GetTrace("PersonalAccessToken");
+            trace.Info("ReadCredentials()");
+
+            var wizard = context.GetService<IConsoleWizard>();
+            trace.Verbose("reading token");
+            string tokenVal = wizard.ReadValue("token", 
+                                            "PersonalAccessToken", 
+                                            true, 
+                                            String.Empty, 
+                                            // can do better
+                                            Validators.NonEmptyValidator,
+                                            args, 
+                                            enforceSupplied);
+            CredentialData.Data["token"] = tokenVal;
+        }        
     }
+
+    public sealed class AlternateCredential : CredentialProvider
+    {
+        public AlternateCredential(): base("ALT") {}
+
+        public override void ReadCredential(IHostContext context, Dictionary<string, string> args, bool enforceSupplied)
+        {
+            var wizard = context.GetService<IConsoleWizard>();
+            CredentialData.Data["Username"] = wizard.ReadValue("username", 
+                                            "Username", 
+                                            false,
+                                            String.Empty,
+                                            // can do better
+                                            Validators.NonEmptyValidator, 
+                                            args, 
+                                            enforceSupplied);
+
+            CredentialData.Data["Password"] = wizard.ReadValue("password", 
+                                            "Password", 
+                                            true,
+                                            String.Empty,
+                                            // can do better
+                                            Validators.NonEmptyValidator,
+                                            args, 
+                                            enforceSupplied);            
+        }        
+    }    
 }