private static void AddAllAssembliesFromAppDomainBinDirectory( CompilationConfiguration result, XmlNode child) { // Get the path to the bin directory string binPath = HttpRuntime.BinDirectoryInternal; FileInfo[] binDlls; if (!FileUtil.DirectoryExists(binPath)) { // This is expected to fail if there is no 'bin' dir Debug.Trace("Template", "Failed to access bin dir \"" + binPath + "\""); } else { DirectoryInfo binPathDirectory = new DirectoryInfo(binPath); // Get a list of all the DLL's in the bin directory binDlls = binPathDirectory.GetFiles("*.dll"); string configFile = ConfigurationException.GetXmlNodeFilename(child); for (int i = 0; i < binDlls.Length; i++) { string assemblyName = Util.GetAssemblyNameFromFileName(binDlls[i].Name); // Remember the config file location info, in case an error // occurs later when we try to load the assembly (ASURT 72183) int configFileLine = ConfigurationException.GetXmlNodeLineNumber(child); result._assemblies[assemblyName] = new object[] { configFile, configFileLine, true /*starDirective*/ }; } } }
private CompilationConfiguration(CompilationConfiguration original) { if (original._compilerLanguages != null) { _compilerLanguages = (Hashtable)original._compilerLanguages.Clone(); } if (original._compilerExtensions != null) { _compilerExtensions = (Hashtable)original._compilerExtensions.Clone(); } if (original._assemblies != null) { _assemblies = (Hashtable)original._assemblies.Clone(); } _defaultLanguage = original._defaultLanguage; _tempDirectory = original._tempDirectory; _debug = original._debug; _strict = original._strict; _explicit = original._explicit; _batch = original._batch; _batchTimeout = original._batchTimeout; _maxBatchGeneratedFileSize = original._maxBatchGeneratedFileSize; _maxBatchSize = original._maxBatchSize; _recompilationsBeforeAppRestarts = original._recompilationsBeforeAppRestarts; }
internal /*public*/ static int GetRecompilationsBeforeAppRestarts(HttpContext context) { CompilationConfiguration compConfig = (UI.CompilationConfiguration)context.GetConfig(sectionName); if (compConfig == null) { return(recompilationsBeforeAppRestartsDefault); } return(compConfig.RecompilationsBeforeAppRestarts); }
internal /*public*/ static int GetMaxBatchSize(HttpContext context) { CompilationConfiguration compConfig = (UI.CompilationConfiguration)context.GetConfig(sectionName); if (compConfig == null) { return(maxBatchSizeDefault); } return(compConfig.MaxBatchSize); }
internal /*public*/ static int GetBatchTimeout(HttpContext context) { CompilationConfiguration compConfig = (UI.CompilationConfiguration)context.GetConfig(sectionName); if (compConfig == null) { return(batchTimeoutDefault); } return(compConfig.BatchTimeout); }
internal /*public*/ static bool IsBatchingEnabled(HttpContext context) { CompilationConfiguration compConfig = (UI.CompilationConfiguration)context.GetConfig(sectionName); if (compConfig == null) { return(true); } return(compConfig.Batch); }
internal /*public*/ static bool IsDebuggingEnabled(HttpContext context) { CompilationConfiguration compConfig = (UI.CompilationConfiguration)context.GetConfig(sectionName); if (compConfig == null) { return(false); } return(compConfig.DebuggingEnabled); }
/* * Return a CompilerInfo that a extension maps to. */ internal static CompilerInfo GetCompilerInfoFromExtension(HttpContext context, string extension) { // Get the <compilation> config object CompilationConfiguration config = (CompilationConfiguration)context.GetConfig(sectionName); if (config == null) { // Unsupported extension: throw an exception throw new HttpException(HttpRuntime.FormatResourceString(SR.Invalid_lang_extension, extension)); } return(config.GetCompilerInfoFromExtension(extension)); }
/* * Simple wrapper to get the Assemblies for a context */ internal static IDictionary GetAssembliesFromContext(HttpContext context) { // Get the CompilationConfiguration object for the passed in context CompilationConfiguration compilationConfiguration = (CompilationConfiguration)context.GetConfig(sectionName); if (compilationConfiguration == null) { return(null); } return(compilationConfiguration.Assemblies); }
internal /*public*/ static CompilerInfo GetDefaultLanguageCompilerInfo(HttpContext context) { CompilationConfiguration config = null; // Get the <compilation> config object if (context != null) { config = (CompilationConfiguration)context.GetConfig(sectionName); } // If no default language was specified in config, use VB if (config == null || config._defaultLanguage == null) { return(new CompilerInfo(typeof(Microsoft.VisualBasic.VBCodeProvider))); } return(config.GetCompilerInfoFromLanguage(config._defaultLanguage)); }
/* * Add all the assemblies specified in the config files */ private void AppendConfigAssemblies() { // Always add dependencies to System.Web.dll and System.dll (ASURT 78531) AddAssemblyDependency(typeof(Page).Assembly); AddAssemblyDependency(typeof(Uri).Assembly); // Get the set of config assemblies for our context IDictionary configAssemblies = CompilationConfiguration.GetAssembliesFromContext(_context); if (configAssemblies == null) { return; } // Add dependencies to all the config assemblies foreach (Assembly a in configAssemblies.Values) { AddAssemblyDependency(a); } // Also, link in the global.asax assembly AddAssemblyDependency(HttpApplicationFactory.ApplicationType.Assembly); }
/* * Compile a source file into an assembly, and import it */ private void ImportSourceFile(string virtualPath) { // Get a full path to the source file string baseVirtualDir = UrlPath.GetDirectory(_virtualPath); string fullVirtualPath = UrlPath.Combine(baseVirtualDir, virtualPath); string physicalPath = _context.Request.MapPath(fullVirtualPath, null, false /*allowCrossAppMapping*/); // Add the source file to the list of files we depend on AddSourceDependency(physicalPath); CompilerInfo compilerInfo = CompilationConfiguration.GetCompilerInfoFromFileName( _context, physicalPath); CompilerParameters compilParams = compilerInfo.CompilParams; // Compile it into an assembly Assembly a = SourceCompiler.GetAssemblyFromSourceFile(_context, fullVirtualPath, null /*assemblies*/, compilerInfo.CompilerType, compilParams); // Add a dependency to the assembly AddAssemblyDependency(a); }
/* * Process a <%@ %> block */ private void ProcessDirective(string directiveName, IDictionary directive) { // Empty means default if (directiveName == "") { directiveName = DefaultDirectiveName; } // Check for the main directive if (string.Compare(directiveName, DefaultDirectiveName, true, CultureInfo.InvariantCulture) == 0) { // Make sure the main directive was not already specified if (_fFoundMainDirective) { throw new HttpException( HttpRuntime.FormatResourceString(SR.Only_one_directive_allowed, DefaultDirectiveName)); } _fFoundMainDirective = true; // Since description is a no op, just remove it if it's there directive.Remove("description"); // Similarily, ignore 'codebehind' attribute (ASURT 4591) directive.Remove("codebehind"); string language = Util.GetAndRemoveNonEmptyAttribute(directive, "language"); CompilerInfo compilerInfo; // Get the compiler for the specified language (if any) if (language != null) { compilerInfo = CompilationConfiguration.GetCompilerInfoFromLanguage( _context, language); } else { // Get a default from config compilerInfo = CompilationConfiguration.GetDefaultLanguageCompilerInfo(_context); } _compilerType = compilerInfo.CompilerType; _compilParams = compilerInfo.CompilParams; _className = Util.GetAndRemoveRequiredAttribute(directive, "class"); if (_compilParams != null) { ProcessCompilationParams(directive, _compilParams); } } else if (string.Compare(directiveName, "assembly", true) == 0) { // Assembly directive // Remove the attributes as we get them from the dictionary string assemblyName = Util.GetAndRemoveNonEmptyAttribute(directive, "name"); string src = Util.GetAndRemoveNonEmptyAttribute(directive, "src"); if (assemblyName != null && src != null) { throw new HttpException( HttpRuntime.FormatResourceString(SR.Attributes_mutually_exclusive, "Name", "Src")); } if (assemblyName != null) { AddAssemblyDependency(assemblyName); } // Is it a source file that needs to be compiled on the fly else if (src != null) { ImportSourceFile(src); } else { throw new HttpException(HttpRuntime.FormatResourceString(SR.Missing_attr, "name")); } } else { throw new HttpException( HttpRuntime.FormatResourceString(SR.Unknown_directive, directiveName)); } // If there are some attributes left, fail Util.CheckUnknownDirectiveAttributes(directiveName, directive); }
private static void ProcessCompilersElement(CompilationConfiguration result, XmlNode node) { // reject attributes HandlerBase.CheckForUnrecognizedAttributes(node); string configFile = ConfigurationException.GetXmlNodeFilename(node); foreach (XmlNode child in node.ChildNodes) { // skip whitespace and comments // reject nonelements if (HandlerBase.IsIgnorableAlsoCheckForNonElement(child)) { continue; } if (child.Name != "compiler") { HandlerBase.ThrowUnrecognizedElement(child); } string languages = String.Empty; HandlerBase.GetAndRemoveStringAttribute(child, "language", ref languages); string extensions = String.Empty; HandlerBase.GetAndRemoveStringAttribute(child, "extension", ref extensions); string compilerTypeName = null; HandlerBase.GetAndRemoveRequiredNonEmptyStringAttribute(child, "type", ref compilerTypeName); // Create a CompilerParameters for this compiler. CompilerParameters compilParams = new CompilerParameters(); int warningLevel = 0; if (HandlerBase.GetAndRemoveNonNegativeIntegerAttribute(child, "warningLevel", ref warningLevel) != null) { compilParams.WarningLevel = warningLevel; // Need to be false if the warning level is 0 compilParams.TreatWarningsAsErrors = (warningLevel > 0); } string compilerOptions = null; if (HandlerBase.GetAndRemoveStringAttribute(child, "compilerOptions", ref compilerOptions) != null) { compilParams.CompilerOptions = compilerOptions; } HandlerBase.CheckForUnrecognizedAttributes(child); HandlerBase.CheckForChildNodes(child); // Create a CompilerInfo structure for this compiler int configFileLine = ConfigurationException.GetXmlNodeLineNumber(child); CompilerInfo compilInfo = new CompilerInfo(compilParams, compilerTypeName, configFile, configFileLine); if (result._compilerLanguages == null) { result._compilerLanguages = new Hashtable(SymbolHashCodeProvider.Default, SymbolEqualComparer.Default); result._compilerExtensions = new Hashtable(SymbolHashCodeProvider.Default, SymbolEqualComparer.Default); } // Parse the semicolon separated lists string[] languageList = languages.Split(s_fieldSeparators); string[] extensionList = extensions.Split(s_fieldSeparators); foreach (string language in languageList) { result._compilerLanguages[language] = compilInfo; } foreach (string extension in extensionList) { result._compilerExtensions[extension] = compilInfo; } } }
private static void ProcessAssembliesElement(CompilationConfiguration result, XmlNode node) { // reject attributes HandlerBase.CheckForUnrecognizedAttributes(node); string configFile = ConfigurationException.GetXmlNodeFilename(node); Hashtable addEntries = null; Hashtable removeEntries = null; bool hasClear = false; foreach (XmlNode child in node.ChildNodes) { // skip whitespace and comments // reject nonelements if (HandlerBase.IsIgnorableAlsoCheckForNonElement(child)) { continue; } // handle <add>, <remove>, <clear> tags if (child.Name == "add") { string assemblyName = GetAssembly(child); // Check for duplicate lines (ASURT 93151) if (addEntries == null) { addEntries = new Hashtable(new CaseInsensitiveHashCodeProvider(CultureInfo.InvariantCulture), new CaseInsensitiveComparer(CultureInfo.InvariantCulture)); } if (addEntries.ContainsKey(assemblyName)) { HandlerBase.ThrowDuplicateLineException(child); } addEntries[assemblyName] = null; if (result._assemblies == null) { result._assemblies = new Hashtable(new CaseInsensitiveHashCodeProvider(CultureInfo.InvariantCulture), new CaseInsensitiveComparer(CultureInfo.InvariantCulture)); } // if key already exists then we might have already loaded it if (result._assemblies.ContainsKey(assemblyName) == false) { if (assemblyName == "*") { AddAllAssembliesFromAppDomainBinDirectory(result, child); } else { // Remember the config file location info, in case an error // occurs later when we try to load the assembly (ASURT 72183) int configFileLine = ConfigurationException.GetXmlNodeLineNumber(child); result._assemblies[assemblyName] = new object[] { configFile, configFileLine, false /*starDirective*/ }; } } } else if (child.Name == "remove") { string assemblyName = GetAssembly(child); // Check for duplicate lines (ASURT 93151) if (removeEntries == null) { removeEntries = new Hashtable(new CaseInsensitiveHashCodeProvider(CultureInfo.InvariantCulture), new CaseInsensitiveComparer(CultureInfo.InvariantCulture)); } if (removeEntries.ContainsKey(assemblyName)) { HandlerBase.ThrowDuplicateLineException(child); } removeEntries[assemblyName] = null; if (result._assemblies != null) { // If it's a '*' remove everything if (assemblyName == "*") { result._assemblies.Clear(); } else { // Otherwise, just remove the one assembly (if present) result._assemblies.Remove(assemblyName); } } } else if (child.Name == "clear") { // Check for duplicate lines (ASURT 93151) if (hasClear) { HandlerBase.ThrowDuplicateLineException(child); } hasClear = true; HandlerBase.CheckForUnrecognizedAttributes(child); HandlerBase.CheckForChildNodes(child); if (result._assemblies != null) { result._assemblies.Clear(); } } else { HandlerBase.ThrowUnrecognizedElement(child); } } }
internal static object CreateStatic(object inheritedObject, XmlNode node) { CompilationConfiguration inherited = (CompilationConfiguration)inheritedObject; CompilationConfiguration result; if (inherited == null) { result = new CompilationConfiguration(); } else { result = new CompilationConfiguration(inherited); } // // Handle attributes (if they exist) // - tempDirectory - "[directory]" // - debug="true/false" // - strict="true/false" // - explicit="true/false" // - batch="true/false" // - batchtimeout="[time in seconds]" // - maxBatchGeneratedFileSize="[max combined size (in KB) of the generated source files per batched compilation]" // - maxBatchSize="[max number of classes per batched compilation]" // - numRecompilesBeforeAppRestart="[max number of recompilations before appdomain is cycled]" // - defaultLanguage - must be in the list of languages // XmlNode a = HandlerBase.GetAndRemoveNonEmptyStringAttribute( node, "tempDirectory", ref result._tempDirectory); if (a != null) { if (!Path.IsPathRooted(result._tempDirectory)) { throw new ConfigurationException( HttpRuntime.FormatResourceString(SR.Invalid_temp_directory), a); } } HandlerBase.GetAndRemoveBooleanAttribute(node, "debug", ref result._debug); HandlerBase.GetAndRemoveBooleanAttribute(node, "strict", ref result._strict); HandlerBase.GetAndRemoveBooleanAttribute(node, "explicit", ref result._explicit); HandlerBase.GetAndRemoveBooleanAttribute(node, "batch", ref result._batch); HandlerBase.GetAndRemovePositiveIntegerAttribute(node, "batchTimeout", ref result._batchTimeout); HandlerBase.GetAndRemovePositiveIntegerAttribute(node, "maxBatchGeneratedFileSize", ref result._maxBatchGeneratedFileSize); HandlerBase.GetAndRemovePositiveIntegerAttribute(node, "maxBatchSize", ref result._maxBatchSize); HandlerBase.GetAndRemovePositiveIntegerAttribute(node, "numRecompilesBeforeAppRestart", ref result._recompilationsBeforeAppRestarts); HandlerBase.GetAndRemoveStringAttribute(node, "defaultLanguage", ref result._defaultLanguage); HandlerBase.CheckForUnrecognizedAttributes(node); // // Handle child elements (if they exist) // - compilers // - assemblies // foreach (XmlNode child in node.ChildNodes) { // skip whitespace and comments // reject nonelements if (HandlerBase.IsIgnorableAlsoCheckForNonElement(child)) { continue; } // handle <compilers> and <assemblies> if (child.Name == "compilers") { ProcessCompilersElement(result, child); } else if (child.Name == "assemblies") { ProcessAssembliesElement(result, child); } else { HandlerBase.ThrowUnrecognizedElement(child); } } return(result); }