CimDSCParser.cs

using Microsoft.Management.Infrastructure;
using Microsoft.Management.Infrastructure.Generic;
using Microsoft.Management.Infrastructure.Serialization;
using Microsoft.PowerShell.Commands;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Management.Automation;
using System.Management.Automation.Language;
using System.Management.Automation.Runspaces;
using System.Management.Automation.Security;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Text;
using System.Security;
using Dbg = System.Management.Automation.Diagnostics;

#if CORECLR

using Environment = System.Management.Automation.Environment;

#endif

namespace Microsoft.PowerShell.DesiredStateConfiguration.Internal
{
    /// <summary>
    /// 
    /// </summary>
    [SuppressMessage("Microsoft.MSInternal", "CA903:InternalNamespaceShouldNotContainPublicTypes",
        Justification = "Needed Internal use only")]
    public static class DscRemoteOperationsClass
    {
        /// <summary>
        /// Convert Cim Instance representing Resource desired state to Powershell Class Object 
        /// </summary>
        public static object ConvertCimInstanceToObject(Type targetType, CimInstance instance, string moduleName)
        {
            var className = instance.CimClass.CimSystemProperties.ClassName;
            object targetObject = null;
            string errorMessage;

            using (System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create(RunspaceMode.CurrentRunspace))
            {
                string script = "param($targetType,$moduleName) & (Microsoft.PowerShell.Core\\Get-Module $moduleName) { New-Object $targetType } ";

                powerShell.AddScript(script);
                powerShell.AddArgument(targetType);
                powerShell.AddArgument(moduleName);

                Collection<PSObject> psExecutionResult = powerShell.Invoke();
                if (psExecutionResult.Count == 1)
                {
                    targetObject = psExecutionResult[0].BaseObject;
                }
                else
                {
                    Exception innerException = null; 
                    if (powerShell.Streams.Error != null && powerShell.Streams.Error.Count > 0)
                    {
                        innerException = powerShell.Streams.Error[0].Exception;
                    }
                    errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.InstantiatePSClassObjectFailed, className);
                    var invalidOperationException = new InvalidOperationException(errorMessage,innerException);
                    throw invalidOperationException;
                }
            }

            foreach (var property in instance.CimInstanceProperties)
            {
                if (property.Value != null)
                {                    
                   
                    MemberInfo[] memberInfo = targetType.GetMember(property.Name, BindingFlags.Public | BindingFlags.Instance);
                    
                    // verify property exists in corresponding class type 
                    if (memberInfo == null ||  memberInfo.Length > 1 || !(memberInfo[0] is PropertyInfo || memberInfo[0] is FieldInfo))
                    {
                        errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.PropertyNotDeclaredInPSClass, new object[] { property.Name, className });
                        var invalidOperationException = new InvalidOperationException(errorMessage);
                        throw invalidOperationException;
                    }

                    var member = memberInfo[0];
                    var memberType = (member is FieldInfo)
                        ? ((FieldInfo)member).FieldType
                        : ((PropertyInfo)member).PropertyType;

                    object targetValue = null;
                    switch (property.CimType)
                    {
                        case CimType.Instance:
                            {
                                var cimPropertyInstance = property.Value as CimInstance;
                                if (cimPropertyInstance != null &&
                                    cimPropertyInstance.CimClass != null &&
                                    cimPropertyInstance.CimClass.CimSystemProperties != null &&                                    
                                    String.Equals(
                                        cimPropertyInstance.CimClass.CimSystemProperties.ClassName,
                                        "MSFT_Credential", StringComparison.OrdinalIgnoreCase))
                                {
                                    targetValue = ConvertCimInstancePsCredential(moduleName, cimPropertyInstance);
                                }
                                else
                                {
                                    targetValue = ConvertCimInstanceToObject(memberType, cimPropertyInstance, moduleName);
                                }
                                if (targetValue == null)
                                {
                                    return null;
                                }
                            }
                            break;
                        case CimType.InstanceArray:
                            {
                                if (memberType == typeof(Hashtable))
                                {
                                    targetValue = ConvertCimInstanceHashtable(moduleName, (CimInstance[])property.Value);
                                }
                                else
                                {
                                    var instanceArray = (CimInstance[])property.Value;
                                    if (!memberType.IsArray)
                                    {
                                        errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.ExpectArrayTypeOfPropertyInPSClass, new object[] { property.Name, className });
                                        var invalidOperationException = new InvalidOperationException(errorMessage);
                                        throw invalidOperationException;
                                    }

                                    var elementType = memberType.GetElementType();
                                    var targetArray = Array.CreateInstance(elementType, instanceArray.Length);
                                    for (int i = 0; i < instanceArray.Length; i++)
                                    {
                                        var obj = ConvertCimInstanceToObject(elementType, instanceArray[i], moduleName);
                                        if (obj == null)
                                        {
                                            return null;
                                        }
                                        targetArray.SetValue(obj, i);
                                    }
                                    targetValue = targetArray;
                                }
                            }
                            break;
                        default:
                            targetValue = LanguagePrimitives.ConvertTo(property.Value, memberType, CultureInfo.InvariantCulture);
                            break;
                    }

                    if (targetValue == null)
                    {
                        errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.ConvertCimPropertyToObjectPropertyFailed, new object[] { property.Name, className });
                        var invalidOperationException = new InvalidOperationException(errorMessage);
                        throw invalidOperationException;
                    }

                    if (member is FieldInfo)
                    {
                        ((FieldInfo)member).SetValue(targetObject, targetValue);
                    }
                    if (member is PropertyInfo)
                    {
                        ((PropertyInfo)member).SetValue(targetObject, targetValue);
                    }
                }
            }
            return targetObject;
        }

        /// <summary>
        /// Convert hashtable from Ciminstance to hashtable primitive type 
        /// </summary>
        /// <param name="providerName"></param>
        /// <param name="arrayInstance"></param>        
        /// <returns></returns>
        private static object ConvertCimInstanceHashtable(string providerName, CimInstance[] arrayInstance)
        {
            var result = new Hashtable();
            string errorMessage;

            try
            {
                foreach (var keyValuePair in arrayInstance)
                {
                    var key = keyValuePair.CimInstanceProperties["Key"];
                    var value = keyValuePair.CimInstanceProperties["Value"];

                    if (key == null || value == null)
                    {
                        errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.InvalidHashtable, providerName);
                        var invalidOperationException = new InvalidOperationException(errorMessage);
                        throw invalidOperationException;
                    }
                    result.Add(LanguagePrimitives.ConvertTo<string>(key.Value), LanguagePrimitives.ConvertTo<string>(value.Value));
                }
            }
            catch (Exception exception)
            {
                errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.InvalidHashtable, providerName);
                var invalidOperationException = new InvalidOperationException(errorMessage, exception);
                throw invalidOperationException;
            }

            return result;
        }
        /// <summary>
        /// Convert CIM instance to PS Credential
        /// </summary>
        /// <param name="providerName"></param>
        /// <param name="propertyInstance"></param>        
        /// <returns></returns>
        private static object ConvertCimInstancePsCredential(string providerName, CimInstance propertyInstance)
        {
            string errorMessage;
            string userName;
            string plainPassWord;

            try
            {
                userName = propertyInstance.CimInstanceProperties["UserName"].Value as string;
                if (string.IsNullOrEmpty(userName))
                {
                    errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.InvalidUserName, providerName);
                    var invalidOperationException = new InvalidOperationException(errorMessage);
                    throw invalidOperationException;
                }
            }
            catch (CimException exception)
            {
                errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.InvalidUserName, providerName);
                var invalidOperationException = new InvalidOperationException(errorMessage, exception);
                throw invalidOperationException;
            }

            try
            {
                plainPassWord = propertyInstance.CimInstanceProperties["PassWord"].Value as string;

                // In future we might receive password in an encrypted format. Make sure we add
                // the decryption login in this method.
                if (string.IsNullOrEmpty(plainPassWord))
                {
                    errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.InvalidPassword, providerName);
                    var invalidOperationException = new InvalidOperationException(errorMessage);
                    throw invalidOperationException;
                }
            }
            catch (CimException exception)
            {
                errorMessage = string.Format(CultureInfo.CurrentCulture, ParserStrings.InvalidPassword, providerName);
                var invalidOperationException = new InvalidOperationException(errorMessage, exception);
                throw invalidOperationException;
            }

            // Extract the password into a SecureString.
            var password = new SecureString();
            foreach (char t in plainPassWord)
            {
                password.AppendChar(t);
            }

            password.MakeReadOnly();
            return new PSCredential(userName, password);
        }
    }
}

namespace Microsoft.PowerShell.DesiredStateConfiguration
{
    /// <summary>
    /// To make it easier to specify -ConfigurationData parameter, we add an ArgumentTransformationAttribute here.
    /// When the input data is of type string and is valid path to a file that can be converted to hashtable, we do
    /// the conversion and return the converted value. Otherwise, we just return the input data.
    /// </summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false)]
    public sealed class ArgumentToConfigurationDataTransformationAttribute : ArgumentTransformationAttribute
    {
        /// <summary>
        /// convert a file of ConfigurationData into a hashtable
        /// </summary>
        /// <param name="engineIntrinsics"></param>
        /// <param name="inputData"></param>
        /// <returns></returns>
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            var configDataPath = inputData as string;
            if (string.IsNullOrEmpty(configDataPath))
            {
                return inputData;
            }

            if (engineIntrinsics == null)
            {
                throw PSTraceSource.NewArgumentNullException("engineIntrinsics");
            }

            return PsUtils.EvaluatePowerShellDataFileAsModuleManifest(
                      "ConfigurationData",
                      configDataPath,
                      engineIntrinsics.SessionState.Internal.ExecutionContext,
                      skipPathValidation: false);
        }
    }

    /// <summary>
    /// <para>
    /// Represents a communication channel to a CIM server.
    /// </para>
    /// <para>
    /// This is the main entry point of the Microsoft.Management.Infrastructure API.
    /// All CIM operations are represented as methods of this class.
    /// </para>
    /// </summary>
    internal class CimDSCParser
    {
        private CimMofDeserializer deserializer;
        private CimMofDeserializer.OnClassNeeded onClassNeeded;
         /// <summary>
        ///
        /// </summary>
        internal CimDSCParser(CimMofDeserializer.OnClassNeeded onClassNeeded)
        {
            deserializer = CimMofDeserializer.Create();
            this.onClassNeeded = onClassNeeded;
        }

        /// <summary>
        ///
        /// </summary>
        internal CimDSCParser(CimMofDeserializer.OnClassNeeded onClassNeeded, Microsoft.Management.Infrastructure.Serialization.MofDeserializerSchemaValidationOption validationOptions)
        {
            deserializer = CimMofDeserializer.Create();
            deserializer.SchemaValidationOption = validationOptions;
            this.onClassNeeded = onClassNeeded;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1045:DoNotPassTypesByReference", MessageId = "3#", Justification = "Have to return 2 things.  Wrapping those 2 things in a class will result in a more, not less complexity")]
        internal List<CimInstance> ParseInstanceMof(string filePath)
        {
            uint offset = 0;
            var buffer = GetFileContent(filePath);
            try
            {
                var result = new List<CimInstance>(deserializer.DeserializeInstances(buffer, ref offset, onClassNeeded, null));
                return result;
            }
            catch (CimException exception)
            {
                PSInvalidOperationException e = PSTraceSource.NewInvalidOperationException(
                    exception, ParserStrings.CimDeserializationError, filePath);

                e.SetErrorId("CimDeserializationError");
                throw e;
            }
        }

        /// <summary>
        /// Read file content to byte array
        /// </summary>
        /// <param name="fullFilePath"></param>
        /// <returns></returns>
        internal static byte[] GetFileContent(string fullFilePath)
        {
            if (string.IsNullOrEmpty(fullFilePath))
            {
                throw PSTraceSource.NewArgumentNullException("fullFilePath");
            }

            if (!File.Exists(fullFilePath))
            {
                throw PSTraceSource.NewArgumentException("fullFilePath");
            }

            using (FileStream fs = File.OpenRead(fullFilePath))
            {
                var bytes = new byte[fs.Length];
                fs.Read(bytes, 0, Convert.ToInt32(fs.Length));
                return bytes;
            }
        }

        internal List<CimClass> ParseSchemaMofFileBuffer(string mof)
        {
            uint offset = 0;
            var buffer = Encoding.Unicode.GetBytes(mof);
            var result = new List<CimClass>(deserializer.DeserializeClasses(buffer, ref offset, null, null, null, onClassNeeded, null));
            return result;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1045:DoNotPassTypesByReference", MessageId = "3#", Justification = "Have to return 2 things.  Wrapping those 2 things in a class will result in a more, not less complexity")]
        internal  List<CimClass> ParseSchemaMof(string filePath)
        {
            uint offset = 0;
            var buffer = GetFileContent(filePath);
            try
            {
                string fileNameDefiningClass = Path.GetFileNameWithoutExtension(filePath);
                int dotIndex = fileNameDefiningClass.IndexOf('.');
                if (dotIndex != -1)
                {
                    fileNameDefiningClass = fileNameDefiningClass.Substring(0, dotIndex);
                }
                var result = new List<CimClass>(deserializer.DeserializeClasses(buffer, ref offset, null, null, null, onClassNeeded, null));
                foreach (CimClass c in result)
                {
                    string superClassName = c.CimSuperClassName;
                    string className = c.CimSystemProperties.ClassName;
                    if ((superClassName != null) && (superClassName.Equals("OMI_BaseResource", StringComparison.OrdinalIgnoreCase)))
                    {
                        //Get the name of the file without schema.mof extension
                        if (!(className.Equals(fileNameDefiningClass, StringComparison.OrdinalIgnoreCase)))
                        {
                            PSInvalidOperationException e = PSTraceSource.NewInvalidOperationException(
                                ParserStrings.ClassNameNotSameAsDefiningFile, className, fileNameDefiningClass);
                            throw e;
                        }
                    }

                }

                return result;
            }
            catch (CimException exception)
            {
                PSInvalidOperationException e = PSTraceSource.NewInvalidOperationException(
                    exception, ParserStrings.CimDeserializationError, filePath);

                e.SetErrorId("CimDeserializationError");
                throw e;
            }
        }

        /// <summary>
        /// Make sure that the instance conforms to the the schema.
        /// </summary>
        /// <param name="classText"></param>
        internal void ValidateInstanceText(string classText)
        {
            uint offset = 0;
            byte[] bytes = System.Text.Encoding.Unicode.GetBytes(classText);
            deserializer.DeserializeInstances(bytes, ref offset, onClassNeeded, null);
        }

    }
}

namespace Microsoft.PowerShell.DesiredStateConfiguration.Internal
{
    /// <summary>
    ///
    /// </summary>
    [SuppressMessage("Microsoft.MSInternal", "CA903:InternalNamespaceShouldNotContainPublicTypes",
        Justification = "Needed Internal use only")]
    public static class DscClassCache
    {
        private const string InboxDscResourceModulePath = "WindowsPowershell\\v1.0\\Modules\\PsDesiredStateConfiguration";
        private const string reservedDynamicKeywords = "^(Synchronization|Certificate|IIS|SQL)$";

        private const string reservedProperties = "^(Require|Trigger|Notify|Before|After|Subscribe)$";

        private static PSTraceSource tracer = PSTraceSource.GetTracer("DSC", "DSC Class Cache");

        // Constants for items in the module qualified name (Module\Version\ClassName)
        const int IndexModuleName = 0;
        const int IndexModuleVersion = 1;
        const int IndexClassName = 2;

        //Create a list of classes which are not actual DSC resources similar to what we do inside PSDesiredStateConfiguration.psm1
        private static readonly string[] hiddenResourceList =
    {
        "MSFT_BaseConfigurationProviderRegistration",
        "MSFT_CimConfigurationProviderRegistration",
        "MSFT_PSConfigurationProviderRegistration",
    };

        //Create a HashSet for fast lookup. According to MSDN, the time complexity of search for an element in a HashSet is O(1)
        private static readonly HashSet<string> hiddenResourceCache = new HashSet<string>(hiddenResourceList,
            StringComparer.OrdinalIgnoreCase);

        //a collection to hold current importing script based resource file
        //this prevent circular importing case when the script resource exising in the same module with resources it import-dscresource
        private static readonly HashSet<string> CurrentImportingScriptFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
               
        /// <summary>
        /// DSC class cache for this runspace.
        /// Cache stores the DSCRunAsBehavior for the class along with actual cim class. 
        /// </summary>
        static Dictionary<string, Tuple<DSCResourceRunAsCredential, Microsoft.Management.Infrastructure.CimClass>> ClassCache
        {
            get
            {
                if (_classCache == null)
                {
                    _classCache = new Dictionary<string, Tuple<DSCResourceRunAsCredential,Microsoft.Management.Infrastructure.CimClass>>(StringComparer.OrdinalIgnoreCase);                    
                }
                return _classCache;
            }
        }

        [ThreadStatic]
        private static Dictionary<string, Tuple<DSCResourceRunAsCredential,Microsoft.Management.Infrastructure.CimClass>> _classCache;        

        /// <summary>
        /// DSC classname to source module mapper
        /// </summary>
        static Dictionary<string, Tuple<string, Version>> ByClassModuleCache
        {
            get
            {
                if (_byClassModuleCache == null)
                {
                    _byClassModuleCache = new Dictionary<string, Tuple<string, Version>>(StringComparer.OrdinalIgnoreCase);
                }
                return _byClassModuleCache;
            }
        }

        [ThreadStatic] private static Dictionary<string, Tuple<string, Version>> _byClassModuleCache;

        /// <summary>
        /// DSC filename to defined class mapper
        /// </summary>
        static Dictionary<string, List<Microsoft.Management.Infrastructure.CimClass>> ByFileClassCache
        {
            get
            {
                if (_byFileClassCache == null)
                {
                    _byFileClassCache = new Dictionary<string, List<Microsoft.Management.Infrastructure.CimClass>>(StringComparer.OrdinalIgnoreCase);
                }
                return _byFileClassCache;
            }
        }

        [ThreadStatic]
        private static Dictionary<string, List<Microsoft.Management.Infrastructure.CimClass>> _byFileClassCache;

        /// <summary>
        /// Filenames from which we have imported script dynamic keywords
        /// </summary>
        static HashSet<string> ScriptKeywordFileCache
        {
            get
            {
                if (_scriptKeywordFileCache == null)
                {
                    _scriptKeywordFileCache = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
                }
                return _scriptKeywordFileCache;
            }
        }

        [ThreadStatic]
        private static HashSet<string> _scriptKeywordFileCache;

        /// <summary>
        /// Default ModuleName and ModuleVersion to use
        /// </summary>
        private static readonly Tuple<string, Version> DefaultModuleInfoForResource = new Tuple<string, Version>("PSDesiredStateConfiguration", new Version("1.1"));

        /// <summary>
        /// Default ModuleName and ModuleVersion to use for meta configuration resources
        /// </summary>
        internal static readonly Tuple<string, Version> DefaultModuleInfoForMetaConfigResource = new Tuple<string, Version>("PSDesiredStateConfigurationEngine", new Version("2.0"));

        /// <summary>
        /// A set of dynamic keywords that can be used in both configuration and meta configuration.
        /// </summary>
        internal static readonly HashSet<string> SystemResourceNames =
            new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Node", "OMI_ConfigurationDocument" };

        /// <summary>
        /// When this property is set to true, DSC Cache will cache multiple versions of a resource.
        /// That means it will cache duplicate resource classes (class names for a resource in two different module versions are same).
        /// NOTE: This property should be set to false for DSC compiler related methods/functionality, such as Import-DscResource,
        ///       because the Mof serializer does not support deserialization of classes with different versions.
        /// </summary>
        [ThreadStatic]
        private static bool _cacheResourcesFromMultipleModuleVersions;
        private static bool CacheResourcesFromMultipleModuleVersions
        {
            get
            {
                return _cacheResourcesFromMultipleModuleVersions;
            }
            set
            {
                _cacheResourcesFromMultipleModuleVersions = value;
            }
        }

        /// <summary>
        /// Initialize the class cache with the default classes in $ENV:SystemDirectory\Configuration.
        /// </summary>
        public static void Initialize()
        {
            Initialize(null, null);
        }

#if CORECLR
        /// <summary>
        /// </summary>
        private static string SystemDirectory
        {
            get { return Environment.GetFolderPath(Environment.SpecialFolder.System); }
        }
#endif

        /// <summary>
        /// Initialize the class cache with the default classes in $ENV:SystemDirectory\Configuration.
        /// </summary>
        /// <param name="errors">Collection of any errors encountered during initialization.</param>
        /// <param name="modulePathList">List of module path from where DSC PS modules will be loaded</param>
        public static void Initialize(Collection<Exception> errors, List<string> modulePathList)
        {
            tracer.WriteLine("Initializing DSC class cache force={0}");
#if CORECLR
            var systemResourceRoot = Path.Combine(SystemDirectory, "Configuration");
#else
            var systemResourceRoot = Path.Combine(Environment.SystemDirectory, "Configuration");
#endif
            var programFilesDirectory = Environment.GetEnvironmentVariable("ProgramFiles");
            Debug.Assert(programFilesDirectory != null, "Program Files environment variable does not exist!");
            var customResourceRoot = Path.Combine(programFilesDirectory, "WindowsPowerShell\\Configuration");
            Debug.Assert(Directory.Exists(customResourceRoot), "%ProgramFiles%\\WindowsPowerShell\\Configuration Directory does not exist");
            var allResourceRoots = new string[] { systemResourceRoot, customResourceRoot };
            //
            // Load the base schema files.
            //
            ClearCache();
            var resourceBaseFile = Path.Combine(systemResourceRoot, "BaseRegistration\\BaseResource.Schema.mof");
            ImportClasses(resourceBaseFile, DefaultModuleInfoForResource, errors);

            var metaConfigFile = Path.Combine(systemResourceRoot, "BaseRegistration\\MSFT_DSCMetaConfiguration.mof");
            ImportClasses(metaConfigFile, DefaultModuleInfoForResource, errors);

            var metaConfigExtensionFile = Path.Combine(systemResourceRoot, "BaseRegistration\\MSFT_MetaConfigurationExtensionClasses.Schema.mof");
            ImportClasses(metaConfigExtensionFile, DefaultModuleInfoForMetaConfigResource, errors);

            //
            // Load all of the system resource schema files, searching
            //
            string resources;
            foreach (var resourceRoot in allResourceRoots)
            {
                resources = Path.Combine(resourceRoot, "Schema");
                if (!Directory.Exists(resources))
                {
                    continue;
                }
                foreach (var schemaFile in Directory.EnumerateDirectories(resources).SelectMany(d => Directory.EnumerateFiles(d, "*.schema.mof")))
                {
                    ImportClasses(schemaFile, DefaultModuleInfoForResource, errors);
                }
            }

            // Load Regular and DSC PS modules
            bool isInboxResource = false;
            List<string> modulePaths = new List<string>();
            if (modulePathList == null || modulePathList.Count == 0)
            {
#if CORECLR
                modulePaths.Add(Path.Combine(SystemDirectory, InboxDscResourceModulePath));
#else
                modulePaths.Add(Path.Combine(Environment.SystemDirectory, InboxDscResourceModulePath));
#endif
                isInboxResource = true;
            }
            else
            {
                foreach (string moduleFolderPath in modulePathList)
                {
                    if (!Directory.Exists(moduleFolderPath))
                    {
                        continue;
                    }

                    foreach (string moduleDir in Directory.EnumerateDirectories(moduleFolderPath))
                    {
                        modulePaths.Add(moduleDir);
                    }
                }
            }

            LoadDSCResourceIntoCache(errors, modulePaths, isInboxResource);
        }

        /// <summary>
        /// Load DSC resources into Cache from moduleFolderPath.
        /// </summary>
        /// <param name="errors">Collection of any errors encountered during initialization.</param>
        /// <param name="modulePathList">Module path from where DSC PS modules will be loaded</param>
        /// <param name="isInboxResource">
        /// if module is inbox.
        /// </param>
        private static void LoadDSCResourceIntoCache(Collection<Exception> errors, List<string> modulePathList, bool isInboxResource)
        {
            foreach (string moduleDir in modulePathList)
            {
                if (!Directory.Exists(moduleDir)) continue;

                var dscResourcesPath = Path.Combine(moduleDir, "DSCResources");
                if (Directory.Exists(dscResourcesPath))
                {
                    foreach (string resourceDir in Directory.EnumerateDirectories(dscResourcesPath))
                    {
                        IEnumerable<string> schemaFiles = Directory.EnumerateFiles(resourceDir, "*.schema.mof");
                        if (!schemaFiles.Any())
                        {
                            continue;
                        }

                        Tuple<string, Version> moduleInfo = GetModuleInfoHelper(moduleDir, isInboxResource, isPsProviderModule: false);
                        if (moduleInfo == null)
                        {
                            continue;
                        }

                        foreach (string schemaFile in schemaFiles)
                        {
                            ImportClasses(schemaFile, moduleInfo, errors);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Get the module name and module version
        /// </summary>
        /// <param name="moduleFolderPath">
        /// Path to the module folder
        /// </param>
        /// <param name="isInboxResource">
        /// if module is inbox.
        /// </param>
        /// <param name="isPsProviderModule">
        /// Indicate a internal DSC module
        /// </param>
        /// <returns></returns>
        static Tuple<string, Version> GetModuleInfoHelper(string moduleFolderPath, bool isInboxResource, bool isPsProviderModule)
        {
            string moduleName = "PsDesiredStateConfiguration";
            if (!isInboxResource)
            {
                moduleName = Path.GetFileName(moduleFolderPath);
            }
            string manifestPath = Path.Combine(moduleFolderPath, moduleName + ".psd1");
            tracer.WriteLine("DSC GetModuleVersion: Try retrieving module version information from file: {0}.", manifestPath);

            if (!File.Exists(manifestPath))
            {
                if (isPsProviderModule)
                {
                    // Some internal PSProviders do not come with a .psd1 file, such
                    // as MSFT_LogResource. We don't report error in this case.
                    return new Tuple<string, Version>(moduleName, new Version("1.0"));
                }
                else
                {
                    tracer.WriteLine("DSC GetModuleVersion: Manifest file '{0}' not exist.", manifestPath);
                    return null;
                }
            }

            try
            {
                Hashtable dataFileSetting =
                    PsUtils.GetModuleManifestProperties(
                        manifestPath,
                        PsUtils.ManifestModuleVersionPropertyName);

                object versionValue = dataFileSetting["ModuleVersion"];
                if (versionValue != null)
                {
                    Version moduleVersion;
                    if (LanguagePrimitives.TryConvertTo(versionValue, out moduleVersion))
                    {
                        return new Tuple<string, Version>(moduleName, moduleVersion);
                    }
                    else
                    {
                        tracer.WriteLine(
                            "DSC GetModuleVersion: ModuleVersion value '{0}' cannot be converted to System.Version. Skip the module '{1}'.",
                            versionValue, moduleName);
                    }
                }
                else
                {
                    tracer.WriteLine(
                        "DSC GetModuleVersion: Manifest file '{0}' does not contain ModuleVersion. Skip the module '{1}'.",
                        manifestPath, moduleName);
                }
            }
            catch (PSInvalidOperationException ex)
            {
                tracer.WriteLine(
                    "DSC GetModuleVersion: Error evaluating module manifest file '{0}', with error '{1}'. Skip the module '{2}'.",
                    manifestPath, ex, moduleName);
            }

            return null;
        }

        //Callback implementation...
        static CimClass MyClassCallback(string serverName, string namespaceName, string className)
        {                        
            foreach (KeyValuePair<string, Tuple<DSCResourceRunAsCredential, Microsoft.Management.Infrastructure.CimClass>> cimClass in ClassCache)
            {                
                string cachedClassName = cimClass.Key.Split(Utils.Separators.Backslash)[IndexClassName];
                if (string.Compare(cachedClassName, className, StringComparison.OrdinalIgnoreCase) == 0)
                {
                    return cimClass.Value.Item2;
                }
            }

            return null;
        }

        /// <summary>
        /// Import CIM classes from the given file
        /// </summary>
        /// <param name="path"></param>
        /// <param name="moduleInfo"></param>
        /// <param name="errors"></param>
        /// <returns></returns>
        public static List<CimClass> ImportClasses(string path, Tuple<string, Version> moduleInfo, Collection<Exception> errors)
        {
            if (string.IsNullOrEmpty(path))
            {
                throw PSTraceSource.NewArgumentNullException("path");
            }

            tracer.WriteLine("DSC ClassCache: importing file: {0}", path);

            var parser = new Microsoft.PowerShell.DesiredStateConfiguration.CimDSCParser(MyClassCallback);

            List<CimClass> classes = null;
            try
            {
                classes = parser.ParseSchemaMof(path);
            }
            catch (PSInvalidOperationException e)
            {
                // Ignore modules with invalid schemas.
                tracer.WriteLine("DSC ClassCache: Error importing file '{0}', with error '{1}'.  Skipping file.", path, e);
                if (errors != null)
                {
                    errors.Add(e);
                }
            }

            if (classes != null)
            {
                foreach (var c in classes)
                {
                    // Only add the class once...
                    var className = c.CimSystemProperties.ClassName;
                    string moduleQualifiedResourceName = GetModuleQualifiedResourceName(moduleInfo.Item1, moduleInfo.Item2.ToString(), className);
                    Tuple <DSCResourceRunAsCredential, Microsoft.Management.Infrastructure.CimClass> cimClassInfo;
                    
                    if (ClassCache.TryGetValue(moduleQualifiedResourceName, out cimClassInfo))
                    {
                        CimClass cimClass = cimClassInfo.Item2;
                        // If this is a nested object and we already have exactly same nested object, we will
                        // allow sharing of nested objects.
                        if (!IsSameNestedObject(cimClass, c))
                        {
                            var files = string.Join(",", GetFileDefiningClass(className));
                            PSInvalidOperationException e = PSTraceSource.NewInvalidOperationException(
                                ParserStrings.DuplicateCimClassDefinition, className, path, files);

                            e.SetErrorId("DuplicateCimClassDefinition");
                            if (errors != null)
                            {
                                errors.Add(e);
                            }
                        }
                    }
                    if (hiddenResourceCache.Contains(className))
                    {
                        continue;
                    }
                    if (!CacheResourcesFromMultipleModuleVersions)
                    {
                        // Find & remove the previous version of the resource.
                        List<KeyValuePair<string, Tuple<DSCResourceRunAsCredential, Microsoft.Management.Infrastructure.CimClass>>> resourceList = FindResourceInCache(moduleInfo.Item1, className);
                        if (resourceList.Count > 0 && !string.IsNullOrEmpty(resourceList[0].Key))
                        {
                            ClassCache.Remove(resourceList[0].Key);
                        }
                    }
                    ClassCache[moduleQualifiedResourceName] = new Tuple<DSCResourceRunAsCredential, Microsoft.Management.Infrastructure.CimClass>(DSCResourceRunAsCredential.Default, c); 
                    ByClassModuleCache[className] = moduleInfo;
                }

                var sb = new System.Text.StringBuilder();
                foreach (var c in classes)
                {
                    sb.Append(c.CimSystemProperties.ClassName);
                    sb.Append(",");
                }

                tracer.WriteLine("DSC ClassCache: loading file '{0}' added the following classes to the cache: {1}", path, sb.ToString());
            }
            else
            {
                tracer.WriteLine("DSC ClassCache: loading file '{0}' added no classes to the cache.");
            }

            ByFileClassCache[path] = classes;
            return classes;
        }

        /// <summary>
        /// get text from SecureString
        /// </summary>
        /// <param name="value">value of SecureString</param>
        /// <returns>decoded string</returns>
        public static string GetStringFromSecureString(SecureString value)
        {
            string passwordValueToAdd = String.Empty;

            if (value != null)
            {
#if CORECLR
                IntPtr ptr = SecureStringMarshal.SecureStringToCoTaskMemUnicode(value);
#else
                IntPtr ptr = Marshal.SecureStringToCoTaskMemUnicode(value);
#endif
                passwordValueToAdd = Marshal.PtrToStringUni(ptr);
                Marshal.ZeroFreeCoTaskMemUnicode(ptr);
            }

            return passwordValueToAdd;
        }

        /// <summary>
        /// Clear out the existing collection of CIM classes and associated keywords.
        /// </summary>
        public static void ClearCache()
        {
            tracer.WriteLine("DSC class: clearing the cache and associated keywords.");
            ClassCache.Clear();            
            ByClassModuleCache.Clear();
            ByFileClassCache.Clear();
            ScriptKeywordFileCache.Clear();
            CacheResourcesFromMultipleModuleVersions = false;
        }

        /// <summary>
        /// Returns module qualified resource name in "Module\Version\Class" format.
        /// </summary>
        /// <param name="moduleName"></param>
        /// <param name="moduleVersion"></param>
        /// <param name="className"></param>
        /// <returns></returns>
        private static string GetModuleQualifiedResourceName(string moduleName, string moduleVersion, string className)
        {
            return String.Format(CultureInfo.InvariantCulture, "{0}\\{1}\\{2}", moduleName, moduleVersion, className);
        }

        /// <summary>
        /// Finds resources in the that which matches the specified class and module name.
        /// </summary>
        /// <param name="moduleName">Module name</param>
        /// <param name="className">Resource type name</param>
        /// <returns>List of found resources in the form of Dictionary{moduleQualifiedName, cimClass}, otherwise empty list.</returns>
        private static List<KeyValuePair<string, Tuple<DSCResourceRunAsCredential, Microsoft.Management.Infrastructure.CimClass>>> FindResourceInCache(string moduleName, string className)
        {
            return (from cacheEntry in ClassCache let splittedName = cacheEntry.Key.Split(Utils.Separators.Backslash)
                    let cachedClassName = splittedName[IndexClassName]
                    let cachedModuleName = splittedName[IndexModuleName]
                    where string.Compare(cachedClassName, className, StringComparison.OrdinalIgnoreCase) == 0
                    && string.Compare(cachedModuleName, moduleName, StringComparison.OrdinalIgnoreCase) == 0 select cacheEntry).ToList();
        }

        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public static List<Tuple<DSCResourceRunAsCredential, Microsoft.Management.Infrastructure.CimClass>> GetCachedClasses()
        {
            return ClassCache.Values.ToList();
        }