internal async Task BuildBootstrapProjectAsync(ILogger logger, CancellationToken cancellationToken)
{
string outputText;
string errorMessage = null;
try
{
ToolConsole.WriteLineIf(ToolConsole.Verbosity >= Verbosity.Verbose, Resource.RestoringNuGetPackagesMsg);
var restoreResult = await this.MSBuildProj.RestoreAsync(logger, cancellationToken).ConfigureAwait(false);
MarkupTelemetryHelper.TelemetryPostOperation(restoreResult.ExitCode == 0, "Restore bootstrapper");
if (restoreResult.ExitCode != 0)
{
ToolConsole.WriteWarning(restoreResult.OutputText);
}
ToolConsole.WriteLineIf(ToolConsole.Verbosity >= Verbosity.Verbose, Resource.BuildingProjectMsg);
var buildResult = await this.MSBuildProj.BuildAsync(logger, cancellationToken).ConfigureAwait(false);
MarkupTelemetryHelper.TelemetryPostOperation(buildResult.ExitCode == 0, "Build bootstrapper");
}
catch (ProcessRunner.ProcessException exception)
{
throw new BootstrapException(string.Format(CultureInfo.CurrentCulture, "{0}{1}{2}", exception.Message, Environment.NewLine, Resource.BootstrapErrorDisableReferences));
}
}
private async Task GenerateProjectAsync(bool keepBootstrapperDir, ILogger logger, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var projectFullPath = Path.Combine(this.Options.BootstrapPath.FullName, nameof(SvcutilBootstrapper), SvcutilBootstrapper.ProjectName);
if (keepBootstrapperDir)
{
// creating the directory prevents the bootstrapper project from deleting it as it doesn't own it, files will not be deleted either.
Directory.CreateDirectory(Path.GetDirectoryName(projectFullPath));
}
// If the target framework was provided, it was validated already when processing params.
// Bootstrapping is enabled only for netcoreapp or netstandard TFM, let's check.
bool isSupportedTFM = TargetFrameworkHelper.IsSupportedFramework(this.Options.TargetFramework.FullName, out var frameworkInfo);
Debug.Assert(frameworkInfo.IsDnx, "The bootstrapper has been enabled for a non-DNX platform!");
ToolConsole.WriteLineIf(ToolConsole.Verbosity >= Verbosity.Verbose, Resource.CreatingProjectMsg);
using (await SafeLogger.WriteStartOperationAsync(logger, $"Creating project file: \"{projectFullPath}\"").ConfigureAwait(false))
{
var svcutilPkgRef = ProjectDependency.FromAssembly(Path.Combine(Path.GetDirectoryName(Tool.FullPath), Tool.AssemblyName + ".dll"));
this.MSBuildProj = await MSBuildProj.DotNetNewAsync(projectFullPath, logger, cancellationToken).ConfigureAwait(false);
this.MSBuildProj.AddDependency(svcutilPkgRef);
// NOTE: If post v2.0 NetStandard ships a different version from NetCore the table below needs to be updated!
var targetFramework = frameworkInfo.FullName;
if (isSupportedTFM && frameworkInfo.IsKnownDnx)
{
if (frameworkInfo.Name == FrameworkInfo.Netstandard)
{
targetFramework = FrameworkInfo.Netcoreapp + TargetFrameworkHelper.NetStandardToNetCoreVersionMap[frameworkInfo.Version];
}
this.MSBuildProj.TargetFramework = targetFramework;
}
// else
// The TFM is unknown: either, it was not provided or it is a version not yet known to the tool,
// we will use the default TF from the generated project.
}
foreach (ProjectDependency dependency in this.Options.References)
{
this.MSBuildProj.AddDependency(dependency);
}
if (!string.IsNullOrEmpty(this.Options.RuntimeIdentifier))
{
this.MSBuildProj.RuntimeIdentifier = this.Options.RuntimeIdentifier;
}
// Don't treat warnings as errors so the bootstrapper will succeed as often as possible.
this.MSBuildProj.ClearWarningsAsErrors();
await this.MSBuildProj.SaveAsync(logger, cancellationToken).ConfigureAwait(false);
}
internal async Task <ProcessRunner.ProcessResult> BoostrapSvcutilAsync(bool keepBootstrapperDir, ILogger logger, CancellationToken cancellationToken)
{
bool redirectOutput = false;
if (this.Options.ToolContext == OperationalContext.Infrastructure)
{
redirectOutput = true;
}
ProcessRunner.ProcessResult result = null;
using (await SafeLogger.WriteStartOperationAsync(logger, "Bootstrapping svcutil ...").ConfigureAwait(false))
{
// guard against bootstrapping recursion.
if (this.Options.NoBootstrapping != true)
{
Debug.Fail($"The NoBootstrapping property is not set, this would cause infinite bootstrapping recursion!");
return(null);
}
if (this.Options.Project != null && StringComparer.OrdinalIgnoreCase.Compare(this.Options.Project.FileName, SvcutilBootstrapper.ProjectName) == 0)
{
Debug.Fail("Bootstrapping is enabled for the bootstrapper! This would cause an infinite bootstrapping recursion!");
return(null);
}
// When in Infrastructure mode (WCF CS) it is assumed the initial progress message is to be presented by the calling tool.
ToolConsole.WriteLineIf(ToolConsole.ToolModeLevel != OperationalContext.Infrastructure, Resource.BootstrappingApplicationMsg);
await GenerateProjectAsync(keepBootstrapperDir, logger, cancellationToken).ConfigureAwait(false);
await GenerateProgramFileAsync(logger, cancellationToken).ConfigureAwait(false);
var paramsFilePath = await GenerateParamsFileAsync(logger, cancellationToken).ConfigureAwait(false);
await BuildBootstrapProjectAsync(logger, cancellationToken).ConfigureAwait(false);
ToolConsole.WriteLineIf(ToolConsole.Verbosity >= Verbosity.Verbose, Resource.InvokingProjectMsg);
result = await ProcessRunner.RunAsync("dotnet", $"run \"{paramsFilePath}\"", this.MSBuildProj.DirectoryPath, redirectOutput, logger, cancellationToken).ConfigureAwait(false);
MarkupTelemetryHelper.TelemetryPostOperation(result.ExitCode == 0, "Invoke svcutil bootstrapper");
}
return(result);
}
internal static async Task <ToolExitCode> RunAsync(CommandProcessorOptions options, CancellationToken cancellationToken)
{
ImportModule importModule = null;
var credsProvicer = new CmdCredentialsProvider();
ServiceDescriptor serviceDescriptor = options.Inputs.Count == 1 ?
new ServiceDescriptor(options.Inputs[0].ToString(), credsProvicer, credsProvicer, credsProvicer) :
new ServiceDescriptor(options.Inputs.Select(i => i.ToString()).ToList(), credsProvicer, credsProvicer, credsProvicer);
// When in Infrastructure mode (WCF CS) it is assumed the metadata docs have been downloaded and passed in as wsdl files.
if (options.ToolContext != OperationalContext.Infrastructure)
{
if (serviceDescriptor.MetadataUrl != null)
{
ToolConsole.WriteLine(string.Format(SR.RetreivingMetadataMsgFormat, serviceDescriptor.MetadataUrl.AbsoluteUri));
}
else
{
var displayUri = serviceDescriptor.MetadataFiles.Count() == 1 ? serviceDescriptor.MetadataFiles.First().LocalPath : SR.WsdlOrSchemaFilesMsg;
ToolConsole.WriteLine(string.Format(SR.ReadingMetadataMessageFormat, displayUri));
}
}
using (await SafeLogger.WriteStartOperationAsync(options.Logger, "Importing metadata ...").ConfigureAwait(false))
{
try
{
await serviceDescriptor.ImportMetadataAsync(
(wi) => importModule = new ImportModule(options, serviceDescriptor, wi),
(sd) => importModule.BeforeImportMetadata(sd),
(sd) => importModule.AfterImportMetadata(sd),
cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
if (Utils.IsFatalOrUnexpected(ex))
{
throw;
}
var exception = new ToolInputException(Utils.GetExceptionMessage(ex), ex);
if (serviceDescriptor.MetadataUrl != null)
{
exception = new ToolMexException(exception, serviceDescriptor.MetadataUrl);
}
throw exception;
}
}
using (await SafeLogger.WriteStartOperationAsync(options.Logger, "Processing Code DOM ...").ConfigureAwait(false))
{
ToolConsole.WriteLine(SR.GeneratingFiles);
CodeSerializer codeSerializer = new CodeSerializer(options, serviceDescriptor.MetadataDocuments);
var filePath = codeSerializer.Save(importModule.CodeCompileUnit);
// When in Infrastructure mode (WCF CS) it is assumed the output file path have been provided so no need to display it.
ToolConsole.WriteLineIf(options.ToolContext != OperationalContext.Infrastructure, filePath, LogTag.Important);
}
return(ToolConsole.ExitCode);
}
