private static void AddLogArgument(PipDataBuilder pipDataBuilder, int loggerNumber, AbsolutePath logFile, string verbosity) { using (pipDataBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, string.Empty)) { pipDataBuilder.Add(PipDataAtom.FromString(I($"/flp{loggerNumber}:logfile="))); pipDataBuilder.Add((PipDataAtom.FromAbsolutePath(logFile))); pipDataBuilder.Add(PipDataAtom.FromString(I($";{verbosity}"))); } }
private bool TryAddMsBuildArguments(ProjectWithPredictions project, PipDataBuilder pipDataBuilder, AbsolutePath logDirectory, AbsolutePath outputResultCacheFile, out string failureDetail) { // Common arguments to all MsBuildExe invocations pipDataBuilder.AddRange(s_commonArgumentsToMsBuildExe.Select(argument => PipDataAtom.FromString(argument))); // Log verbosity if (!TryGetLogVerbosity(m_resolverSettings.LogVerbosity, out string logVerbosity)) { failureDetail = $"Cannot set the MSBuild log verbosity. '{m_resolverSettings.LogVerbosity}' is not a valid option."; return(false); } AddLogArgument(pipDataBuilder, 1, logDirectory.Combine(PathTable, "msbuild.log"), $"Verbosity={logVerbosity}"); AddLogArgument(pipDataBuilder, 2, logDirectory.Combine(PathTable, "msbuild.wrn"), "Verbosity=Quiet;warningsonly"); AddLogArgument(pipDataBuilder, 3, logDirectory.Combine(PathTable, "msbuild.err"), "Verbosity=Quiet;errorsonly"); AddLogArgument(pipDataBuilder, 4, logDirectory.Combine(PathTable, "msbuild.prf"), "PerformanceSummary"); // Global properties on the project are turned into build parameters foreach (var kvp in project.GlobalProperties) { AddMsBuildProperty(pipDataBuilder, kvp.Key, kvp.Value); } // Configure binary logger if specified if (m_resolverSettings.EnableBinLogTracing == true) { using (pipDataBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, string.Empty)) { pipDataBuilder.Add(PipDataAtom.FromString("/binaryLogger:")); pipDataBuilder.Add(PipDataAtom.FromAbsolutePath(logDirectory.Combine(PathTable, "msbuild.binlog"))); } } // Targets to execute. var targets = project.PredictedTargetsToExecute.Targets; Contract.Assert(targets.Count > 0); foreach (string target in targets) { pipDataBuilder.Add(PipDataAtom.FromString($"/t:{target}")); } // Pass the output result cache file if present if (outputResultCacheFile != AbsolutePath.Invalid) { using (pipDataBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, string.Empty)) { // Flag /orc is the short form of /outputResultsCache, and part of MSBuild 'build in isolation' mode. // By specifying this flag, MSBuild will write the build result at the end of this invocation into the cache file pipDataBuilder.Add(PipDataAtom.FromString("/orc:")); pipDataBuilder.Add(PipDataAtom.FromAbsolutePath(outputResultCacheFile)); } } else { // In legacy (non-isolated) mode, we still have to rely on SDKs honoring this flag pipDataBuilder.Add(PipDataAtom.FromString("/p:buildprojectreferences=false")); } failureDetail = string.Empty; return(true); }
private bool TryConfigureProcessBuilder( ProcessBuilder processBuilder, PipConstructionHelper pipConstructionHelper, ProjectWithPredictions project, QualifierId qualifierId, out AbsolutePath outputResultCacheFile, out string failureDetail) { outputResultCacheFile = AbsolutePath.Invalid; if (!TrySetBuildToolExecutor(pipConstructionHelper, processBuilder, project)) { failureDetail = "Failed to construct tooldefinition"; return(false); } // Working directory - the directory where the project file lives. processBuilder.WorkingDirectory = DirectoryArtifact.CreateWithZeroPartialSealId(project.FullPath.GetParent(PathTable)); // We allow undeclared inputs to be read processBuilder.Options |= Process.Options.AllowUndeclaredSourceReads; // Run in a container if specified if (m_resolverSettings.RunInContainer) { processBuilder.Options |= Process.Options.NeedsToRunInContainer; processBuilder.ContainerIsolationLevel = ContainerIsolationLevel.IsolateAllOutputs; } // By default the double write policy is to allow same content double writes. processBuilder.DoubleWritePolicy |= m_resolverSettings.DoubleWritePolicy ?? DoubleWritePolicy.AllowSameContentDoubleWrites; SetUntrackedFilesAndDirectories(processBuilder); // Add the log directory and its corresponding files var qualifier = m_context.QualifierTable.GetQualifier(qualifierId); AbsolutePath logDirectory = GetLogDirectory(project, qualifier); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.log"), FileExistence.Optional); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.wrn"), FileExistence.Optional); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.err"), FileExistence.Optional); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.prf"), FileExistence.Optional); if (m_resolverSettings.EnableBinLogTracing == true) { processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.binlog"), FileExistence.Optional); } // Unless the legacy non-isolated mode is explicitly specified, the project builds in isolation, and therefore // it produces an output cache file. This file is placed on the (unique) object directory for this project if (m_resolverSettings.UseLegacyProjectIsolation != true) { var objectDirectory = pipConstructionHelper.GetUniqueObjectDirectory(project.FullPath.GetName(PathTable)); outputResultCacheFile = objectDirectory.Path.Combine(PathTable, PathAtom.Create(PathTable.StringTable, OutputCacheFileName)); processBuilder.AddOutputFile(outputResultCacheFile, FileExistence.Required); } // Path to the project processBuilder.ArgumentsBuilder.Add(PipDataAtom.FromAbsolutePath(project.FullPath)); // Response file with the rest of the arguments var rspFileSpec = ResponseFileSpecification.Builder() .AllowForRemainingArguments(processBuilder.ArgumentsBuilder.CreateCursor()) .ForceCreation(true) .Prefix("@") .Build(); processBuilder.SetResponseFileSpecification(rspFileSpec); if (!TryAddMsBuildArguments(project, processBuilder.ArgumentsBuilder, logDirectory, outputResultCacheFile, out failureDetail)) { return(false); } // Q_SESSION_GUID is used to provide a unique build GUID to build tools and scripts. // It'll cause full cache misses if we try to hash it as an input, however, so exclude. processBuilder.SetPassthroughEnvironmentVariable(StringId.Create(m_context.StringTable, BuildEnvironmentConstants.QSessionGuidEnvVar)); // GlobalUnsafePassthroughEnvironmentVariables processBuilder.SetGlobalPassthroughEnvironmentVariable(m_frontEndHost.Configuration.FrontEnd.GlobalUnsafePassthroughEnvironmentVariables, m_context.StringTable); // mspdbsrv: _MSPDBSRV_ENDPOINT_ sets up one mspdbsrv.exe instance per build target execution. // However this process will live beyond the build.cmd or msbuild.exe call. // Allow the pip job object to clean the process without complaint. // // vctip.exe: On any compile error this telemetry upload exe will be run as a detached process. // Just let it be killed. // TODO: Can we stop it running? https://stackoverflow.microsoft.com/questions/74425/how-to-disable-vctip-exe-in-vc14 // // conhost.exe: This process needs a little bit more time to finish after the main process, but killing it right away // is inconsequential. // // All child processes: Don't wait to kill the processes. // CODESYNC: CloudBuild repo TrackerExecutor.cs "info.NestedProcessTerminationTimeout = TimeSpan.Zero" processBuilder.AllowedSurvivingChildProcessNames = ReadOnlyArray <PathAtom> .FromWithoutCopy( PathAtom.Create(m_context.StringTable, "mspdbsrv.exe"), PathAtom.Create(m_context.StringTable, "vctip.exe"), PathAtom.Create(m_context.StringTable, "conhost.exe"), PathAtom.Create(m_context.StringTable, "VBCSCompiler.exe")); // There are some cases (e.g. a 64-bit MSBuild launched as a child process from a 32-bit MSBuild instance) where // processes need a little bit more time to finish. Increasing the timeout does not affect job objects where no child // processes survive, or job object where the only surviving processes are the ones explicitly allowed to survive (which // are killed immediately). So overall, this non-zero timeout will only make some pips that would have failed to take a little // bit longer (and hopefully succeed) processBuilder.NestedProcessTerminationTimeout = TimeSpan.FromMilliseconds(500); SetProcessEnvironmentVariables(CreateEnvironment(logDirectory, project), processBuilder); failureDetail = string.Empty; return(true); }
/// <summary> /// Adds all predicted dependencies as inputs, plus all individual inputs predicted for the project /// </summary> /// <remarks> /// Adding all predicted dependencies is key to get the right scheduling. On the other hand, all predicted inputs /// are not really needed since we are running in undeclared read mode. However, they contribute to make the weak fingerprint stronger (that /// otherwise will likely be just a shared opaque output at the root). /// </remarks> private void ProcessInputs( ProjectWithPredictions project, ProcessBuilder processBuilder) { // Predicted output directories for all direct dependencies, plus the output directories for the given project itself var knownOutputDirectories = project.ProjectReferences.SelectMany(reference => reference.PredictedOutputFolders).Union(project.PredictedOutputFolders); // Add all predicted inputs that are recognized as true source files // This is done to make the weak fingerprint stronger. Pips are scheduled so undeclared source reads are allowed. This means // we don't actually need accurate (or in fact any) input predictions to run successfully. But we are trying to avoid the degenerate case // of a very small weak fingerprint with too many candidates, that can slow down two-phase cache look-up. foreach (AbsolutePath buildInput in project.PredictedInputFiles) { // If any of the predicted inputs is under the predicted output folder of a dependency, then there is a very good chance the predicted input is actually an intermediate file // In that case, don't add the input as a source file to stay on the safe side. Otherwise we will have a file that is both declared as a source file and contained in a directory // dependency. if (knownOutputDirectories.Any(outputFolder => buildInput.IsWithin(PathTable, outputFolder))) { continue; } // If any of the predicted inputs is under an untracked directory scope, don't add it as an input if (processBuilder.GetUntrackedDirectoryScopesSoFar().Any(untrackedDirectory => buildInput.IsWithin(PathTable, untrackedDirectory))) { continue; } processBuilder.AddInputFile(FileArtifact.CreateSourceFile(buildInput)); } IEnumerable <ProjectWithPredictions> references; // The default for EnableTransitiveProjectReferences is false, so it has to be true explicitly to kick in if (m_resolverSettings.EnableTransitiveProjectReferences == true) { // In this case all the transitive closure is automatically exposed to the project as direct references var transitiveReferences = new HashSet <ProjectWithPredictions>(); ComputeTransitiveDependenciesFor(project, transitiveReferences); references = transitiveReferences; } else { // Only direct dependencies are declared. // Add all known explicit inputs from project references. But rule out // projects that have a known empty list of targets: those projects are not scheduled, so // there is nothing to consume from them. references = project.ProjectReferences.Where(projectReference => projectReference.PredictedTargetsToExecute.Targets.Count != 0); } var argumentsBuilder = processBuilder.ArgumentsBuilder; foreach (ProjectWithPredictions projectReference in references) { bool outputsPresent = m_processOutputsPerProject.TryGetValue(projectReference, out MSBuildProjectOutputs projectOutputs); if (!outputsPresent) { Contract.Assert(false, $"Pips must have been presented in dependency order: {projectReference.FullPath.ToString(PathTable)} missing, dependency of {project.FullPath.ToString(PathTable)}"); } // Add all known output directories foreach (StaticDirectory output in projectOutputs.OutputDirectories) { processBuilder.AddInputDirectory(output.Root); } // If the dependency was built in isolation, this project needs to access the generated cache files if (projectOutputs.BuildsInIsolation) { var outputCache = projectOutputs.OutputCacheFile; processBuilder.AddInputFile(outputCache); // Instruct MSBuild to use the cache file from the associated dependency as an input. // Flag /irc is the short form of /inputResultsCaches, and part of MSBuild 'build in isolation' mode. using (argumentsBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, string.Empty)) { argumentsBuilder.Add(PipDataAtom.FromString("/irc:")); argumentsBuilder.Add(PipDataAtom.FromAbsolutePath(outputCache)); } } } }
private bool TryAddMsBuildArguments(ProjectWithPredictions project, PipDataBuilder pipDataBuilder, AbsolutePath logDirectory, AbsolutePath outputResultCacheFile, out string failureDetail) { // Common arguments to all MsBuildExe invocations pipDataBuilder.AddRange(s_commonArgumentsToMsBuildExe.Select(argument => PipDataAtom.FromString(argument))); // Log verbosity if (!TryGetLogVerbosity(m_resolverSettings.LogVerbosity, out string logVerbosity)) { failureDetail = $"Cannot set the MSBuild log verbosity. '{m_resolverSettings.LogVerbosity}' is not a valid option."; return(false); } AddLogArgument(pipDataBuilder, 1, logDirectory.Combine(PathTable, "msbuild.log"), $"Verbosity={logVerbosity}"); AddLogArgument(pipDataBuilder, 2, logDirectory.Combine(PathTable, "msbuild.wrn"), "Verbosity=Quiet;warningsonly"); AddLogArgument(pipDataBuilder, 3, logDirectory.Combine(PathTable, "msbuild.err"), "Verbosity=Quiet;errorsonly"); AddLogArgument(pipDataBuilder, 4, logDirectory.Combine(PathTable, "msbuild.prf"), "PerformanceSummary"); // Global properties on the project are turned into build parameters foreach (var kvp in project.GlobalProperties) { AddMsBuildProperty(pipDataBuilder, kvp.Key, kvp.Value); } // Configure binary logger if specified if (m_resolverSettings.EnableBinLogTracing == true) { using (pipDataBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, string.Empty)) { pipDataBuilder.Add(PipDataAtom.FromString("/binaryLogger:")); pipDataBuilder.Add(PipDataAtom.FromAbsolutePath(logDirectory.Combine(PathTable, "msbuild.binlog"))); } } // Targets to execute. // If the prediction is available, there should be at least one target (otherwise it makes no sense to schedule the project, and we should have caught this earlier) // If the prediction is not available, we fallback to call default targets (which means not passing any specific /t:). A more strict policy would be to bail out // here saying that the project is not complying to the target protocol specification. We leave it relaxed for now, but we log it. // https://github.com/Microsoft/msbuild/blob/master/documentation/specs/static-graph.md if (project.PredictedTargetsToExecute.IsPredictionAvailable) { var targets = project.PredictedTargetsToExecute.Targets; Contract.Assert(targets.Count > 0); foreach (string target in targets) { pipDataBuilder.Add(PipDataAtom.FromString($"/t:{target}")); } } else { // The prediction for the targets to execute is not available. Just log this as a warning for now, defaults targets will be used. Tracing.Logger.Log.ProjectIsNotSpecifyingTheProjectReferenceProtocol( m_context.LoggingContext, Location.FromFile(project.FullPath.ToString(PathTable)), project.FullPath.GetName(m_context.PathTable).ToString(m_context.StringTable)); } // Pass the output result cache file if present if (outputResultCacheFile != AbsolutePath.Invalid) { using (pipDataBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, string.Empty)) { // Flag /orc is the short form of /outputResultsCache, and part of MSBuild 'build in isolation' mode. // By specifying this flag, MSBuild will write the build result at the end of this invocation into the cache file pipDataBuilder.Add(PipDataAtom.FromString("/orc:")); pipDataBuilder.Add(PipDataAtom.FromAbsolutePath(outputResultCacheFile)); } } else { // In legacy (non-isolated) mode, we still have to rely on SDKs honoring this flag pipDataBuilder.Add(PipDataAtom.FromString("/p:buildprojectreferences=false")); } failureDetail = string.Empty; return(true); }
private bool TryConfigureProcessBuilder( ProcessBuilder processBuilder, PipConstructionHelper pipConstructionHelper, ProjectWithPredictions project, QualifierId qualifierId, out AbsolutePath outputResultCacheFile, out string failureDetail) { outputResultCacheFile = AbsolutePath.Invalid; if (!TrySetBuildToolExecutor(pipConstructionHelper, processBuilder, project)) { failureDetail = "Failed to construct tooldefinition"; return(false); } // Working directory - the directory where the project file lives. processBuilder.WorkingDirectory = DirectoryArtifact.CreateWithZeroPartialSealId(project.FullPath.GetParent(PathTable)); // We allow undeclared inputs to be read processBuilder.Options |= Process.Options.AllowUndeclaredSourceReads; // Run in a container if specified if (m_resolverSettings.RunInContainer) { processBuilder.Options |= Process.Options.NeedsToRunInContainer; processBuilder.ContainerIsolationLevel = ContainerIsolationLevel.IsolateAllOutputs; } // Until we can deal with double writes in a better way, this unsafe option allows the build to progress and // prints warnings processBuilder.DoubleWritePolicy |= DoubleWritePolicy.UnsafeFirstDoubleWriteWins; SetUntrackedFilesAndDirectories(processBuilder); // Add the log directory and its corresponding files var qualifier = m_context.QualifierTable.GetQualifier(qualifierId); AbsolutePath logDirectory = GetLogDirectory(project, qualifier); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.log"), FileExistence.Optional); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.wrn"), FileExistence.Optional); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.err"), FileExistence.Optional); processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.prf"), FileExistence.Optional); if (m_resolverSettings.EnableBinLogTracing == true) { processBuilder.AddOutputFile(logDirectory.Combine(PathTable, "msbuild.binlog"), FileExistence.Optional); } // Unless the legacy non-isolated mode is explicitly specified, the project builds in isolation, and therefore // it produces an output cache file. This file is placed on the (unique) object directory for this project if (m_resolverSettings.UseLegacyProjectIsolation != true) { var objectDirectory = pipConstructionHelper.GetUniqueObjectDirectory(project.FullPath.GetName(PathTable)); outputResultCacheFile = objectDirectory.Path.Combine(PathTable, PathAtom.Create(PathTable.StringTable, OutputCacheFileName)); processBuilder.AddOutputFile(outputResultCacheFile, FileExistence.Required); } // Path to the project processBuilder.ArgumentsBuilder.Add(PipDataAtom.FromAbsolutePath(project.FullPath)); // Response file with the rest of the arguments var rspFileSpec = ResponseFileSpecification.Builder() .AllowForRemainingArguments(processBuilder.ArgumentsBuilder.CreateCursor()) .ForceCreation(true) .Prefix("@") .Build(); processBuilder.SetResponseFileSpecification(rspFileSpec); if (!TryAddMsBuildArguments(project, qualifier, processBuilder.ArgumentsBuilder, logDirectory, outputResultCacheFile, out failureDetail)) { return(false); } // Q_SESSION_GUID is used to provide a unique build GUID to build tools and scripts. // It'll cause full cache misses if we try to hash it as an input, however, so exclude. processBuilder.SetPassthroughEnvironmentVariable(StringId.Create(m_context.StringTable, BuildEnvironmentConstants.QSessionGuidEnvVar)); // mspdbsrv: _MSPDBSRV_ENDPOINT_ sets up one mspdbsrv.exe instance per build target execution. // However this process will live beyond the build.cmd or msbuild.exe call. // Allow the pip job object to clean the process without complaint. // // vctip.exe: On any compile error this telemetry upload exe will be run as a detached process. // Just let it be killed. // TODO: Can we stop it running? https://stackoverflow.microsoft.com/questions/74425/how-to-disable-vctip-exe-in-vc14 // // conhost.exe: This process needs a little bit more time to finish after the main process. We shouldn't be allowing // this one to survive, we just need the timeout to be slightly more than zero. This will also be beneficial to other // arbitrary processeses that need a little bit more time. But, apparently, setting a timeout has a perf impact that is // being investigated. TODO: revisit this once this is fixed. // // All child processes: Don't wait to kill the processes. // CODESYNC: CloudBuild repo TrackerExecutor.cs "info.NestedProcessTerminationTimeout = TimeSpan.Zero" processBuilder.AllowedSurvivingChildProcessNames = ReadOnlyArray <PathAtom> .FromWithoutCopy( PathAtom.Create(m_context.StringTable, "mspdbsrv.exe"), PathAtom.Create(m_context.StringTable, "vctip.exe"), PathAtom.Create(m_context.StringTable, "conhost.exe")); processBuilder.NestedProcessTerminationTimeout = TimeSpan.Zero; SetProcessEnvironmentVariables(CreateEnvironment(logDirectory, project), processBuilder); failureDetail = string.Empty; return(true); }
private bool TryAddMsBuildArguments(ProjectWithPredictions <AbsolutePath> project, Qualifier qualifier, PipDataBuilder pipDataBuilder, AbsolutePath logDirectory, out string failureDetail) { // Common arguments to all MsBuildExe invocations pipDataBuilder.AddRange(s_commonArgumentsToMsBuildExe.Select(argument => PipDataAtom.FromString(argument))); // Log verbosity if (!TryGetLogVerbosity(m_resolverSettings.LogVerbosity, out string logVerbosity)) { failureDetail = $"Cannot set the MSBuild log verbosity. '{m_resolverSettings.LogVerbosity}' is not a valid option."; return(false); } AddLogArgument(pipDataBuilder, 1, logDirectory.Combine(PathTable, "msbuild.log"), $"Verbosity={logVerbosity}"); AddLogArgument(pipDataBuilder, 2, logDirectory.Combine(PathTable, "msbuild.wrn"), "Verbosity=Quiet;warningsonly"); AddLogArgument(pipDataBuilder, 3, logDirectory.Combine(PathTable, "msbuild.err"), "Verbosity=Quiet;errorsonly"); AddLogArgument(pipDataBuilder, 4, logDirectory.Combine(PathTable, "msbuild.prf"), "PerformanceSummary"); // Global properties on the project are turned into build parameters foreach (var kvp in project.GlobalProperties) { AddMsBuildProperty(pipDataBuilder, kvp.Key, kvp.Value); } // The specified qualifier, unless overridden by a global property, is turned into a property as well // This means that: // 1) if the project is not being referenced with a specific property that matters to the qualifier, the requested qualifier is used // 2) if a particular property (e.g. platform) is set when referencing the project, that is honored foreach (StringId key in qualifier.Keys) { string keyAsString = key.ToString(m_context.StringTable); if (!project.GlobalProperties.ContainsKey(keyAsString)) { var success = qualifier.TryGetValue(m_context.StringTable, keyAsString, out string value); Contract.Assert(success); AddMsBuildProperty(pipDataBuilder, keyAsString, value); } } // Configure binary logger if specified if (m_resolverSettings?.EnableBinLogTracing == true) { using (pipDataBuilder.StartFragment(PipDataFragmentEscaping.NoEscaping, string.Empty)) { pipDataBuilder.Add(PipDataAtom.FromString("/binaryLogger:")); pipDataBuilder.Add(PipDataAtom.FromAbsolutePath(logDirectory.Combine(PathTable, "msbuild.binlog"))); } } // Targets to execute. // If the prediction is available, there should be at least one target (otherwise it makes no sense to schedule the project, and we should have caught this earlier) // If the prediction is not available, we fallback to call default targets (which means not passing any specific /t:). A more strict policy would be to bail out // here saying that the project is not complying to the target protocol specification. We leave it relaxed for now, but we log it. // https://github.com/Microsoft/msbuild/blob/master/documentation/specs/static-graph.md if (project.PredictedTargetsToExecute.IsPredictionAvailable) { var targets = project.PredictedTargetsToExecute.Targets; Contract.Assert(targets.Count > 0); foreach (string target in targets) { pipDataBuilder.Add(PipDataAtom.FromString($"/t:{target}")); } } else { // The prediction for the targets to execute is not available. Just log this as a warning for now, defaults targets will be used. Tracing.Logger.Log.ProjectIsNotSpecifyingTheProjectReferenceProtocol( m_context.LoggingContext, Location.FromFile(project.FullPath.ToString(PathTable)), project.FullPath.GetName(m_context.PathTable).ToString(m_context.StringTable)); } failureDetail = string.Empty; return(true); }