Merge pull request #6 from avkaur/dev

update the powershell model for dsc node report

src/ResourceManager/Automation/Commands.Automation/Cmdlet/ImportAzureAutomationDscNodeConfiguration.cs

@@ -0,0 +1,78 @@
+// ----------------------------------------------------------------------------------
+//
+// Copyright Microsoft Corporation
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ----------------------------------------------------------------------------------
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Management.Automation;
+using System.Security.Permissions;
+using Microsoft.Azure.Commands.Automation.Common;
+using Microsoft.Azure.Commands.Automation.Model;
+using Microsoft.WindowsAzure.Commands.Utilities.Common;
+
+namespace Microsoft.Azure.Commands.Automation.Cmdlet
+{
+    /// <summary>
+    /// Imports dsc node configuration script
+    /// </summary>
+    [Cmdlet(VerbsData.Import, "AzureAutomationDscNodeConfiguration")]
+    [OutputType(typeof(NodeConfiguration))]
+    public class ImportAzureAutomationDscNodeConfiguration : AzureAutomationBaseCmdlet
+    {
+        /// <summary>
+        /// True to overwrite the existing configuration; false otherwise.
+        /// </summary>        
+        private bool overwriteExistingConfiguration;
+
+        /// <summary>
+        /// Gets or sets the source path.
+        /// </summary>
+        [Parameter(Mandatory = true, ValueFromPipelineByPropertyName = true, HelpMessage = "Path to the node configuration .mof to import.")]        
+        [ValidateNotNullOrEmpty]
+        public string Path { get; set; }
+
+        /// <summary>
+        /// Gets or sets the configuration name for the node configuration.
+        /// </summary>
+        [Parameter(Mandatory = true, ValueFromPipelineByPropertyName = true, HelpMessage = "The name of the DSC Configuration to import the Node Configuration under. All Node Configurations in Azure Automation must exist under a Configuration. The name of the Configuration will become the namespace of the imported Node Configuration, in the form of 'ConfigurationName.MofFileName'")]        
+        public string ConfigurationName { get; set; }
+
+
+        /// <summary>
+        /// Gets or sets switch parameter to confirm overwriting of existing configurations.
+        /// </summary>
+        [Parameter(Mandatory = false, HelpMessage = "Forces the command to overwrite an existing Node Configuration.")]
+        public SwitchParameter Force
+        {
+            get { return this.overwriteExistingConfiguration; }
+            set { this.overwriteExistingConfiguration = value; }
+        }
+
+        /// <summary>
+        /// Execute this cmdlet.
+        /// </summary>
+        [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
+        public override void ExecuteCmdlet()
+        {
+            var nodeConfiguration = this.AutomationClient.CreateNodeConfiguration(
+                    this.ResourceGroupName,
+                    this.AutomationAccountName,
+                    this.Path,
+                    this.ConfigurationName,
+                    this.Force);
+
+            this.WriteObject(nodeConfiguration);
+        }
+    }
+}

src/ResourceManager/Automation/Commands.Automation/Cmdlet/StartAzureAutomationDscCompilationJob.cs

@@ -42,6 +42,12 @@ public class StartAzureAutomationDscCompilationJob : AzureAutomationBaseCmdlet
         [Parameter(Mandatory = false, HelpMessage = "The compilation job parameters.")]
         public IDictionary Parameters { get; set; }
 
+        /// <summary>
+        /// Gets or sets the configuration data.
+        /// </summary>
+        [Parameter(Mandatory = false, HelpMessage = "The compilation job configuration data.")]
+        public IDictionary ConfigurationData { get; set; }
+
         /// <summary>
         /// Execute this cmdlet.
         /// </summary>
@@ -50,6 +56,10 @@ protected override void AutomationExecuteCmdlet()
         {
             CompilationJob job = null;
 
+            if (this.ConfigurationData != null)
+            {
+                Parameters.Add("ConfigurationData", this.ConfigurationData);
+            }
             job = this.AutomationClient.StartCompilationJob(this.ResourceGroupName, this.AutomationAccountName, this.ConfigurationName, this.Parameters);
 
             this.WriteObject(job);

src/ResourceManager/Automation/Commands.Automation/Commands.ResourceManagement.Automation.csproj

@@ -117,6 +117,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Cmdlet\AzureAutomationBaseCmdlet.cs" />
+    <Compile Include="Cmdlet\ImportAzureAutomationDscNodeConfiguration.cs" />
     <Compile Include="Cmdlet\ExportAzureAutomationDscConfiguration.cs" />
     <Compile Include="Cmdlet\ExportAzureAutomationDscNodeReportContent.cs" />
     <Compile Include="Cmdlet\GetAzureAutomationCertificate.cs" />

src/ResourceManager/Automation/Commands.Automation/Common/AutomationClientDSC.cs

@@ -257,6 +257,48 @@ private Model.DscConfiguration TryGetConfigurationModel(string resourceGroupName
             return configuration;
         }
 
+        public Model.DscConfiguration CreateConfiguration(
+           string resourceGroupName,
+           string automationAccountName,
+           string configrationName,
+           string nodeName)
+        {
+            string configurationContent = "Configuration {0} { Node {1} { } } ";
+            configurationContent = string.Format(configurationContent,configrationName,nodeName);
+
+            using (var request = new RequestSettings(this.automationManagementClient))
+            {
+
+                // location of the configuration is set to same as that of automation account
+                string location = this.GetAutomationAccount(resourceGroupName, automationAccountName).Location;
+
+                var configurationCreateParameters = new DscConfigurationCreateOrUpdateParameters()
+                {
+                    Name = configrationName,
+                    Location = location,                
+                    Properties = new DscConfigurationCreateOrUpdateProperties()
+                    {
+                        Description = String.Empty,
+                        LogVerbose = false,
+                        Source = new Microsoft.Azure.Management.Automation.Models.ContentSource()
+                        {
+                            // only embeddedContent supported for now
+                            ContentType = Model.ContentSourceType.embeddedContent.ToString(),
+                            Value = configurationContent
+                        }
+                    }
+                };
+
+                var configuration =
+                    this.automationManagementClient.Configurations.CreateOrUpdate(
+                        resourceGroupName,
+                        automationAccountName,
+                        configurationCreateParameters).Configuration;
+
+                return new Model.DscConfiguration(resourceGroupName, automationAccountName, configuration);
+            }
+        }
+
     #endregion
 
         #region DscMetaConfig Operations
@@ -1023,6 +1065,21 @@ public Model.CompilationJob StartCompilationJob(string resourceGroupName, string
         #endregion
 
         #region node configuration
+        public Model.NodeConfiguration TryGetNodeConfiguration(string resourceGroupName, string automationAccountName, string nodeConfigurationName, string rollupStatus)
+        {
+            using (var request = new RequestSettings(this.automationManagementClient))
+            {
+                try
+                {
+                    return GetNodeConfiguration(resourceGroupName, automationAccountName, nodeConfigurationName, rollupStatus);
+                }
+                catch (ResourceNotFoundException)
+                {
+                    return null;
+                }                
+            }
+        }
+
         public Model.NodeConfiguration GetNodeConfiguration(string resourceGroupName, string automationAccountName, string nodeConfigurationName, string rollupStatus)
         {
             using (var request = new RequestSettings(this.automationManagementClient))
@@ -1118,6 +1175,90 @@ public Model.NodeConfiguration GetNodeConfiguration(string resourceGroupName, st
             }
         }
 
+        public Model.NodeConfiguration CreateNodeConfiguration(
+            string resourceGroupName,
+            string automationAccountName,
+            string sourcePath,
+            string configurationName,
+            bool overWrite)
+        {
+            using (var request = new RequestSettings(this.automationManagementClient))
+            {
+                Requires.Argument("ResourceGroupName", resourceGroupName).NotNullOrEmpty();
+                Requires.Argument("AutomationAccountName", automationAccountName).NotNullOrEmpty();
+                Requires.Argument("SourcePath", sourcePath).NotNullOrEmpty();
+                Requires.Argument("configurationName", configurationName).NotNullOrEmpty();
+
+                string fileContent = null;
+                string nodeConfigurationName = null;
+                string nodeName = null;
+
+                if (File.Exists(Path.GetFullPath(sourcePath)))
+                {
+                    fileContent = System.IO.File.ReadAllText(sourcePath);
+                    nodeConfigurationName = configurationName + "." + System.IO.Path.GetFileNameWithoutExtension(sourcePath);
+                }
+                else
+                {
+                    // file path not valid.
+                    throw new FileNotFoundException(
+                                        string.Format(
+                                            CultureInfo.CurrentCulture,
+                                            Resources.ConfigurationSourcePathInvalid));
+                }
+
+                 // if node configuration already exists, ensure overwrite flag is specified
+                var nodeConfigurationModel = this.TryGetNodeConfiguration(
+                    resourceGroupName,
+                    automationAccountName,
+                    nodeConfigurationName,
+                    null);
+                if (nodeConfigurationModel != null)
+                {
+                    if (!overWrite)
+                    {
+                        throw new ResourceCommonException(typeof(Model.NodeConfiguration),
+                            string.Format(CultureInfo.CurrentCulture, Resources.NodeConfigurationAlreadyExists, nodeConfigurationName));
+                    }
+                }
+
+                // if configuration already exists, ensure overwrite flag is specified
+                var configurationModel = this.TryGetConfigurationModel(
+                    resourceGroupName,
+                    automationAccountName,
+                    configurationName);
+                if (configurationModel == null)
+                {
+                    //create empty configuration if its empty
+                    this.CreateConfiguration(resourceGroupName, automationAccountName, configurationName, nodeName);
+                }
+
+                var nodeConfigurationCreateParameters = new DscNodeConfigurationCreateOrUpdateParameters()
+                {
+                    Name = nodeConfigurationName,
+                    Source = new Microsoft.Azure.Management.Automation.Models.ContentSource()
+                    {
+                        // only embeddedContent supported for now
+                        ContentType = Model.ContentSourceType.embeddedContent.ToString(),
+                        Value = fileContent
+                    },
+                    Configuration = new DscConfigurationAssociationProperty() 
+                    {
+                        Name = configurationName
+                    }
+                };
+
+                var nodeConfiguration =
+                    this.automationManagementClient.NodeConfigurations.CreateOrUpdate(
+                        resourceGroupName,
+                        automationAccountName,
+                        nodeConfigurationCreateParameters).NodeConfiguration;
+
+
+                return new Model.NodeConfiguration(resourceGroupName, automationAccountName, nodeConfiguration, null);
+            }
+        }
+
         #endregion
 
         #region dsc reports
@@ -1339,39 +1480,19 @@ private string FormatDateTime(DateTimeOffset dateTime)
         private IDictionary<string, string> ProcessConfigurationParameters(string resourceGroupName, string automationAccountName, string configurationName, IDictionary parameters)
         {
             parameters = parameters ?? new Dictionary<string, string>();
-            IEnumerable<KeyValuePair<string, DscConfigurationParameter>> configurationParameters = this.ListConfigurationParameters(resourceGroupName, automationAccountName, configurationName);
-            var filteredParameters = new Dictionary<string, string>();
-
-            foreach (var configParameter in configurationParameters)
-            {
-                if (parameters.Contains(configParameter.Key))
+            var filteredParameters = new Dictionary<string,string>();
+            foreach (var key in parameters.Keys)
+            {                
+                try
                 {
-                    object paramValue = parameters[configParameter.Key];
-                    try
-                    {
-                        filteredParameters.Add(configParameter.Key, paramValue.ToString());
-                    }
-                    catch (JsonSerializationException)
-                    {
-                        throw new ArgumentException(
-                        string.Format(
-                            CultureInfo.CurrentCulture, Resources.ConfigurationParameterCannotBeSerializedToJson, configParameter.Key));
-                    }
+                    filteredParameters.Add(key.ToString(), Newtonsoft.Json.JsonConvert.SerializeObject(parameters[key]));
                 }
-                else if (configParameter.Value.IsMandatory)
+                catch (JsonSerializationException)
                 {
-                    throw new ArgumentException(
-                        string.Format(
-                            CultureInfo.CurrentCulture, Resources.ConfigurationParameterValueRequired, configParameter.Key));
-                }
-            }
-
-            if (filteredParameters.Count != parameters.Count)
-            {
-                throw new ArgumentException(
-                    string.Format(CultureInfo.CurrentCulture, Resources.InvalidConfigurationParameters));
+                    throw new ArgumentException(string.Format(
+                        CultureInfo.CurrentCulture, Resources.ConfigurationParameterCannotBeSerializedToJson, key.ToString()));
+                }             
             }
-
             return filteredParameters;
         }
 

src/ResourceManager/Automation/Commands.Automation/Common/IAutomationClient.cs

@@ -59,6 +59,8 @@ public interface IAutomationClient
         IEnumerable<NodeConfiguration> ListNodeConfigurationsByConfigurationName(string resourceGroupName, string automationAccountName, string configurationName, string rollupStatus);
 
         IEnumerable<NodeConfiguration> ListNodeConfigurations(string resourceGroupName, string automationAccountName, string rollupStatus);
+
+        NodeConfiguration CreateNodeConfiguration(string resourceGroupName, string automationAccountName, string sourcePath, string nodeConfiguraionName, bool overWrite);
         #endregion
 
         #region Configurations

src/ResourceManager/Automation/Commands.Automation/Common/Requires.cs

@@ -73,6 +73,24 @@ public ArgumentRequirements<T> NotNull()
 
                 return this;
             }
+
+            /// <summary>
+            /// Checks argument value for not null or empty
+            /// </summary>
+            /// <returns>The not null requirement</returns>
+            public ArgumentRequirements<T> NotNullOrEmpty()
+            {
+                if (this.Value == null)
+                {
+                    throw new ArgumentNullException(this.Name);
+                }
+                else if (string.IsNullOrEmpty(this.Value.ToString()))
+                {
+                    throw new ArgumentNullException(this.Name);
+                }
+
+                return this;
+            }
         }
     }
 }