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)); } }
public bool AfterImportMetadata(ServiceDescriptor serviceDescriptor) { try { // Convert errors to warnings to workaround the issue that many validation errors from XSD compiler // can be ignored. for (int idx = _wsdlImporter.Errors.Count - 1; idx >= _nonWsdlImportErrors; idx--) { var error = _wsdlImporter.Errors[idx]; if (!error.IsWarning) { ToolConsole.ExitCode = ToolExitCode.ValidationErrorTurnedWarning; var warning = new MetadataConversionError(error.Message, isWarning: true); _wsdlImporter.Errors[idx] = warning; } } MarkupTelemetryHelper.SendBindingData(serviceDescriptor.Bindings); Collection <ServiceEndpoint> endpoints = new Collection <ServiceEndpoint>(serviceDescriptor.Endpoints.ToList()); Collection <Binding> bindings = new Collection <Binding>(serviceDescriptor.Bindings.ToList()); Collection <ContractDescription> contracts = new Collection <ContractDescription>(serviceDescriptor.Contracts.ToList()); _codegenExtension.WsdlImported(_wsdlImporter, endpoints, bindings, contracts); } catch (Exception e) { ToolConsole.WriteError(e); } ToolConsole.WriteConversionErrors(_wsdlImporter.Errors); ImportServiceContracts(serviceDescriptor); ToolConsole.WriteConversionErrors(_contractGenerator.Errors); var contractsResolved = true; if (_validateMetadataImport) { _validateMetadataImport = false; contractsResolved = ContractsResolved(serviceDescriptor, this.CodeCompileUnit); if (!contractsResolved) { var importer1 = ServiceDescriptor.DefaultUseMessageFormat ? typeof(DataContractSerializerMessageContractImporter) : typeof(XmlSerializerMessageContractImporter); var importer2 = ServiceDescriptor.DefaultUseMessageFormat ? typeof(XmlSerializerMessageContractImporter) : typeof(DataContractSerializerMessageContractImporter); ToolConsole.WriteWarning(string.Format(CultureInfo.CurrentCulture, SR.WrnCouldNotGenerateContractOperationsFormat, importer1, importer2)); } } // on false, ServiceDescriptor will attempt to use a different contract serializer. return(contractsResolved); }
static public Type[] LoadTypes(Assembly assembly, Verbosity verbosity) { Type[] types; try { types = assembly.GetTypes(); } catch (ReflectionTypeLoadException rtle) { string warning; types = Array.FindAll <Type>(rtle.Types, delegate(Type t) { return(t != null); }); if (verbosity > Verbosity.Normal) { foreach (var ex in rtle.LoaderExceptions) { warning = ex.Message; if (!s_loadTypesWarnings.Contains(warning)) { s_loadTypesWarnings.Add(warning); ToolConsole.WriteWarning(warning); } } if (types.Length == 0) { warning = string.Format(SR.ErrCouldNotLoadTypesFromAssemblyAtFormat, assembly.Location); if (!s_loadTypesWarnings.Contains(warning)) { s_loadTypesWarnings.Add(warning); ToolConsole.WriteWarning(warning); } } else { warning = string.Format(SR.WrnCouldNotLoadTypesFromReferenceAssemblyAtFormat, assembly.Location); if (!s_loadTypesWarnings.Contains(warning)) { s_loadTypesWarnings.Add(warning); ToolConsole.WriteWarning(warning); } } } } return(types); }
static public Assembly LoadAssembly(string path) { string DotDll = ".dll"; string DotExe = ".exe"; if (path.EndsWith(DotDll, StringComparison.OrdinalIgnoreCase) || path.EndsWith(DotExe, StringComparison.OrdinalIgnoreCase)) { path = path.Remove(path.Length - DotDll.Length, DotDll.Length); } try { return(Assembly.Load(new AssemblyName(path))); } catch (Exception ex) { ToolConsole.WriteWarning(string.Format(SR.ErrUnableToLoadReferenceFormat, path, ex.Message)); return(null); } }
private void LogMessage(string message, LogTag logTag, bool logToUI = false) { if (this.EnableTracing || logToUI) { message = message?.Trim(); if (!string.IsNullOrEmpty(message)) { if (logTag == LogTag.Error) { ToolConsole.WriteError(message, isTrace: !logToUI); } else if (logTag == LogTag.Warning) { ToolConsole.WriteWarning(message, isTrace: !logToUI); } else { ToolConsole.WriteLine(message, logToUI ? LogTag.Information : LogTag.LogMessage); } } } }
internal static async Task <int> MainAsync(string[] args, ILogger logger, CancellationToken cancellationToken) { int result = -1; CommandProcessorOptions options = null; WaitForDebugger(); try { options = await CommandProcessorOptions.ParseArgumentsAsync(args, logger, cancellationToken); ValidateUICulture(options); if (options.NoTelemetry == true) { AppInsightsTelemetryClient.IsUserOptedIn = false; } ToolConsole.Init(options); ToolConsole.WriteHeaderIf(options.NoLogo != true); ThrowOnValidationErrors(options); if (options.Help == true) { ToolConsole.WriteHelp(); result = (int)ToolExitCode.Success; } else { // Show early warnings var earlyWarnings = options.Warnings; foreach (string warning in earlyWarnings.Distinct()) { ToolConsole.WriteWarning(warning); } var operationMessage = (options.IsUpdateOperation ? "Update" : "Add") + " web service reference operation started!"; using (var safeLogger = await SafeLogger.WriteStartOperationAsync(options.Logger, operationMessage).ConfigureAwait(false)) { await options.ResolveAsync(cancellationToken).ConfigureAwait(false); ThrowOnValidationErrors(options); options.ProviderId = Tool.ToolName; options.Version = Tool.PackageVersion; foreach (string warning in options.Warnings.Distinct().Except(earlyWarnings)) { ToolConsole.WriteWarning(warning); } if (options.RequiresBoostrapping) { using (var bootstrapper = new SvcutilBootstrapper(options.CloneAs <SvcutilOptions>())) { await options.SetupBootstrappingDirectoryAsync(options.Logger, cancellationToken).ConfigureAwait(false); var bootstrapResult = await bootstrapper.BoostrapSvcutilAsync(options.KeepBootstrapDir, options.Logger, cancellationToken).ConfigureAwait(false); ToolConsole.WriteLine(bootstrapResult.OutputText); result = bootstrapResult.ExitCode; } } else { result = (int) await RunAsync(options, cancellationToken).ConfigureAwait(false); } if (IsSuccess(result)) { if (!File.Exists(options.OutputFile.FullName)) { await safeLogger.WriteMessageAsync("The process completed successfully but no proxy file was found!", logToUI : false); throw new ToolArgumentException(SR.ErrUnexpectedError); } else { await GenerateParamsFileAsync(options, options.Logger, cancellationToken); if (CanAddProjectReferences(options) && !await AddProjectReferencesAsync(options.Project, options, cancellationToken).ConfigureAwait(false)) { result = (int)ToolExitCode.InputError; } } // clean up only on success to allow to troubleshoot any problems on failure. options?.Cleanup(); } } } } catch (Exception e) { result = await ProcessExceptionAsync(e, options); } finally { try { // Don't log telemetry if we're running from bootstrapper or connected service. if (options?.ToolContext <= OperationalContext.Global) { var properties = new Dictionary <string, string>() { { "IsUpdate", (options?.IsUpdateOperation).ToString() }, { "TargetFramework", options?.TargetFramework?.FullName }, { "Parameters", options?.ToTelemetryString() }, { "ExitCode", result.ToString() }, { "RequiresBootstrapping", options?.RequiresBoostrapping.ToString() }, }; var telemetryClient = await AppInsightsTelemetryClient.GetInstanceAsync(cancellationToken).ConfigureAwait(false); telemetryClient.TrackEvent("ToolRun", properties); } } catch { } } return(result); }
public static async Task <AppInsightsTelemetryClient> GetInstanceAsync(CancellationToken cancellationToken) { if (s_instance == null) { try { if (!bool.TryParse(Environment.GetEnvironmentVariable(testModeVariable), out bool testMode)) { testMode = false; } lock (s_lockObj) { if (s_instance == null) { if (!IsUserOptedIn) { // If the user hasn't opted in return now with a null telemetry client to ensure we don't create any telemetry context. return(new AppInsightsTelemetryClient(null)); } TelemetryConfiguration config; try { config = TelemetryConfiguration.Active; } catch (InvalidOperationException) { config = new TelemetryConfiguration(); } config.TelemetryChannel.DeveloperMode = testMode; s_instance = new AppInsightsTelemetryClient(new TelemetryClient(config)); } } var telemetryClient = s_instance._telemetryClient; telemetryClient.InstrumentationKey = instrumentationKey; // Populate context with properties that are common and should be logged for all events. var context = telemetryClient.Context; context.Device.OperatingSystem = GetOperatingSystemString(); #if !NETCORE10 // Set the user id to a stable hash of the user's current username. Users with the same username // or those with hash collisions will show up as the same id. So the user id won't be perfectly unique. // However, it will give us some idea of how many different users are using the tool. context.User.Id = GetStableHashCode(Environment.UserName).ToString(); #endif // DebugLogger tracks telemetry when adding exceptions. We pass null for the logger to avoid the possibility of an endless cyclic call if something goes wrong in GetSdkVersionAsync. var sdkVersion = await ProjectPropertyResolver.GetSdkVersionAsync(System.IO.Directory.GetCurrentDirectory(), null /* logger */, cancellationToken).ConfigureAwait(false); context.Properties["SvcUtil.Version"] = Tool.PackageVersion; context.Properties["Dotnet.Version"] = string.IsNullOrEmpty(sdkVersion) ? "unknown" : sdkVersion; context.Properties["TestMode"] = testMode.ToString(); } catch (Exception ex) { #if DEBUG ToolConsole.WriteWarning(ex.Message); #endif s_isUserOptedIn = false; } } return(s_instance); }