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); }