/// <summary> /// Prepares the information of the connection /// </summary> /// <param name="websocket"></param> /// <param name="correlationID"></param> /// <param name="session"></param> /// <param name="cancellationToken"></param> /// <param name="logger"></param> /// <returns></returns> public static async Task PrepareConnectionInfoAsync(this ManagedWebSocket websocket, string correlationID = null, Session session = null, CancellationToken cancellationToken = default, Microsoft.Extensions.Logging.ILogger logger = null) { correlationID = correlationID ?? UtilityService.NewUUID; session = session ?? websocket.Get <Session>("Session"); var account = "Visitor"; if (!string.IsNullOrWhiteSpace(session?.User?.ID)) { try { var json = await Router.GetService("Users").ProcessRequestAsync(new RequestInfo(session, "Users", "Profile", "GET") { CorrelationID = correlationID }, cancellationToken).ConfigureAwait(false); account = $"{json?.Get<string>("Name") ?? "Unknown"} ({session.User.ID})"; } catch (Exception ex) { account = $"Unknown ({session.User.ID})"; logger?.LogError($"Error occurred while fetching an account profile => {ex.Message}", ex); } } websocket.Set("AccountInfo", account); websocket.Set("LocationInfo", session != null ? await session.GetLocationAsync(correlationID, cancellationToken).ConfigureAwait(false) : "Unknown"); }
public async Task <IActionResult> ExecuteResilient(Func <Task <IActionResult> > action, IActionResult fallbackResult) { var retryPolicy = Policy .Handle <Exception>((ex) => { _logger.LogWarning($"Error occured during request-execution. Polly will retry. Exception: {ex.Message}"); return(true); }) .RetryAsync(5); var fallbackPolicy = Policy <IActionResult> .Handle <Exception>() .FallbackAsync( fallbackResult, (e, c) => Task.Run(() => _logger.LogError($"Error occured during request-execution. Polly will fallback. Exception: {e.Exception.ToString()}"))); return(await fallbackPolicy .WrapAsync(retryPolicy) .ExecuteAsync(action) .ConfigureAwait(false)); }
public static ProjectDetails LoadProjectDetails(BuildEnvironment environment) { var key = Tuple.Create(environment.ProjectFile, environment.Configuration); ProjectDetails details; if (_allProjects.TryGetValue(key, out details)) { if (!details.HasChanged()) { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.LogDebug($"Using cached project file details for [{environment.ProjectFile}]"); } return(details); } else { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.LogDebug($"Reloading project file details [{environment.ProjectFile}] as one of its imports has been modified."); } } } if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug)) { _log.LogDebug($"Loading project file [{environment.ProjectFile}]"); } details = new ProjectDetails(); var properties = new Dictionary <string, string>(ImmutableDictionary <string, string> .Empty) { ["DesignTimeBuild"] = "true", // this will tell msbuild to not build the dependent projects ["BuildingInsideVisualStudio"] = "true", // this will force CoreCompile task to execute even if all inputs and outputs are up to date ["BuildingInsideUnoSourceGenerator"] = "true", // this will force prevent the task to run recursively ["Configuration"] = environment.Configuration, ["UseHostCompilerIfAvailable"] = "true", ["UseSharedCompilation"] = "true", ["VisualStudioVersion"] = environment.VisualStudioVersion, // Force the intermediate path to be different from the VS default path // so that the generated files don't mess up the file count for incremental builds. ["IntermediateOutputPath"] = Path.Combine(environment.OutputPath, "obj") + Path.DirectorySeparatorChar }; // Target framework is required for the MSBuild 15.0 Cross Compilation. // Loading a project without the target framework results in an empty project, which interatively // sets the TargetFramework property. if (environment.TargetFramework.HasValue()) { properties["TargetFramework"] = environment.TargetFramework; } // TargetFrameworkRootPath is used by VS4Mac to determine the // location of frameworks like Xamarin.iOS. if (environment.TargetFrameworkRootPath.HasValue()) { properties["TargetFrameworkRootPath"] = environment.TargetFrameworkRootPath; } // Platform is intentionally kept as not defined, to avoid having // dependent projects being loaded with a platform they don't support. // properties["Platform"] = _platform; var xmlReader = XmlReader.Create(environment.ProjectFile); var collection = new Microsoft.Build.Evaluation.ProjectCollection(); // Change this logger details to troubleshoot project loading details. collection.RegisterLogger(new Microsoft.Build.Logging.ConsoleLogger() { Verbosity = LoggerVerbosity.Minimal }); // Uncomment this to enable file logging for debugging purposes. // collection.RegisterLogger(new Microsoft.Build.BuildEngine.FileLogger() { Verbosity = LoggerVerbosity.Diagnostic, Parameters = $@"logfile=c:\temp\build\MSBuild.{Guid.NewGuid()}.log" }); collection.OnlyLogCriticalEvents = false; var xml = Microsoft.Build.Construction.ProjectRootElement.Create(xmlReader, collection); // When constructing a project from an XmlReader, MSBuild cannot determine the project file path. Setting the // path explicitly is necessary so that the reserved properties like $(MSBuildProjectDirectory) will work. xml.FullPath = Path.GetFullPath(environment.ProjectFile); var loadedProject = new Microsoft.Build.Evaluation.Project( xml, properties, toolsVersion: null, projectCollection: collection ); var buildTargets = new BuildTargets(loadedProject, "Compile"); // don't execute anything after CoreCompile target, since we've // already done everything we need to compute compiler inputs by then. buildTargets.RemoveAfter("CoreCompile", includeTargetInRemoval: true); details.Configuration = environment.Configuration; details.LoadedProject = loadedProject; // create a project instance to be executed by build engine. // The executed project will hold the final model of the project after execution via msbuild. details.ExecutedProject = loadedProject.CreateProjectInstance(); var hostServices = new Microsoft.Build.Execution.HostServices(); // connect the host "callback" object with the host services, so we get called back with the exact inputs to the compiler task. hostServices.RegisterHostObject(loadedProject.FullPath, "CoreCompile", "Csc", null); var buildParameters = new Microsoft.Build.Execution.BuildParameters(loadedProject.ProjectCollection); // This allows for the loggers to buildParameters.Loggers = collection.Loggers; var buildRequestData = new Microsoft.Build.Execution.BuildRequestData(details.ExecutedProject, buildTargets.Targets, hostServices); var result = BuildAsync(buildParameters, buildRequestData); if (result.Exception == null) { ValidateOutputPath(details.ExecutedProject); var projectFilePath = Path.GetFullPath(Path.GetDirectoryName(environment.ProjectFile)); details.References = details.ExecutedProject.GetItems("ReferencePath").Select(r => r.EvaluatedInclude).ToArray(); if (!details.References.Any()) { if (_log.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Error)) { _log.LogError($"Project has no references."); } LogFailedTargets(environment.ProjectFile, result); details.Generators = new (Type, Func <SourceGenerator>)[0];