/// <summary> /// Instantiates and composes the composers. /// </summary> public void Compose() { // make sure it is there _composition.WithCollectionBuilder <ComponentCollectionBuilder>(); IEnumerable <Type> orderedComposerTypes; using (_logger.DebugDuration <Composers>("Preparing composer types.", "Prepared composer types.")) { orderedComposerTypes = PrepareComposerTypes(); } var composers = InstantiateComposers(orderedComposerTypes); using (_logger.DebugDuration <Composers>($"Composing composers. (log when >{LogThresholdMilliseconds}ms)", "Composed composers.")) { foreach (var composer in composers) { var componentType = composer.GetType(); using (_logger.DebugDuration <Composers>($"Composing {componentType.FullName}.", $"Composed {componentType.FullName}.", thresholdMilliseconds: LogThresholdMilliseconds)) { composer.Compose(_composition); } } } }
private MacroContent Render(MacroModel macro, IPublishedContent content, IDictionary pageElements) { if (content == null) { throw new ArgumentNullException(nameof(content)); } var macroInfo = $"Render Macro: {macro.Name}, type: {macro.MacroType}, cache: {macro.CacheDuration}"; using (_plogger.DebugDuration <MacroRenderer>(macroInfo, "Rendered Macro.")) { // parse macro parameters ie replace the special [#key], [$key], etc. syntaxes foreach (var prop in macro.Properties) { prop.Value = ParseAttribute(pageElements, prop.Value); } var cultureName = System.Threading.Thread.CurrentThread.CurrentUICulture.Name; macro.CacheIdentifier = GetContentCacheIdentifier(macro, content.Id, cultureName); // get the macro from cache if it is there var macroContent = GetMacroContentFromCache(macro); // macroContent.IsEmpty may be true, meaning the macro produces no output, // but still can be cached because its execution did not trigger any error. // so we need to actually render, only if macroContent is null if (macroContent != null) { return(macroContent); } // this will take care of errors // it may throw, if we actually want to throw, so better not // catch anything here and let the exception be thrown var attempt = ExecuteMacroOfType(macro, content); // by convention ExecuteMacroByType must either throw or return a result // just check to avoid internal errors macroContent = attempt.Result; if (macroContent == null) { throw new Exception("Internal error, ExecuteMacroOfType returned no content."); } // add to cache if render is successful // content may be empty but that's not an issue if (attempt.Success) { // write to cache (if appropriate) AddMacroContentToCache(macro, macroContent); } return(macroContent); } }
private void AcquireMainDom() { using DisposableTimer? timer = _profilingLogger.DebugDuration <CoreRuntime>("Acquiring MainDom.", "Acquired."); try { _mainDom.Acquire(_applicationShutdownRegistry); } catch { timer?.Fail(); throw; } }
public void Initialize() { using (_profilingLogger.DebugDuration <ComponentCollection>($"Initializing. (log components when >{LogThresholdMilliseconds}ms)", "Initialized.")) { foreach (var component in this) { var componentType = component.GetType(); using (_profilingLogger.DebugDuration <ComponentCollection>($"Initializing {componentType.FullName}.", $"Initialized {componentType.FullName}.", thresholdMilliseconds: LogThresholdMilliseconds)) { component.Initialize(); } } } }
public void Can_Deep_Clone_Perf_Test() { // Arrange ContentType contentType = ContentTypeBuilder.CreateTextPageContentType(); contentType.Id = 99; Content content = ContentBuilder.CreateTextpageContent(contentType, "Textpage", -1); int i = 200; foreach (IProperty property in content.Properties) { property.Id = ++i; } content.Id = 10; content.CreateDate = DateTime.Now; content.CreatorId = 22; content.Key = Guid.NewGuid(); content.Level = 3; content.Path = "-1,4,10"; content.ContentSchedule.Add(DateTime.Now, DateTime.Now.AddDays(1)); //// content.ChangePublishedState(PublishedState.Published); content.SortOrder = 5; content.TemplateId = 88; content.Trashed = false; content.UpdateDate = DateTime.Now; content.WriterId = 23; var runtimeCache = new ObjectCacheAppCache(); runtimeCache.Insert(content.Id.ToString(CultureInfo.InvariantCulture), () => content); IProfilingLogger proflog = GetTestProfilingLogger(); using (proflog.DebugDuration <ContentTests>("STARTING PERF TEST WITH RUNTIME CACHE")) { for (int j = 0; j < 1000; j++) { object clone = runtimeCache.Get(content.Id.ToString(CultureInfo.InvariantCulture)); } } using (proflog.DebugDuration <ContentTests>("STARTING PERF TEST WITHOUT RUNTIME CACHE")) { for (int j = 0; j < 1000; j++) { var clone = (ContentType)contentType.DeepClone(); } } }
/// <inheritdoc /> public override object ConvertIntermediateToObject(IPublishedElement owner, PublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview) { using (_proflog.DebugDuration <PublishedPropertyType>($"ConvertPropertyToNestedContent ({propertyType.DataType.Id})")) { var configuration = propertyType.DataType.ConfigurationAs <NestedContentConfiguration>(); var contentTypes = configuration.ContentTypes; var elements = contentTypes.Length == 1 ? PublishedModelFactory.CreateModelList(contentTypes[0].Alias) : new List <IPublishedElement>(); var value = (string)inter; if (string.IsNullOrWhiteSpace(value)) { return(elements); } var objects = JsonConvert.DeserializeObject <List <JObject> >(value); if (objects.Count == 0) { return(elements); } foreach (var sourceObject in objects) { var element = ConvertToElement(sourceObject, referenceCacheLevel, preview); if (element != null) { elements.Add(element); } } return(elements); } }
protected override IComponent CreateItem(IFactory factory, Type itemType) { using (_logger.DebugDuration <ComponentCollectionBuilder>($"Creating {itemType.FullName}.", $"Created {itemType.FullName}.", thresholdMilliseconds: LogThresholdMilliseconds)) { return(base.CreateItem(factory, itemType)); } }
/// <summary> /// Tries to find the document matching the request, by running the IPublishedContentFinder instances. /// </summary> /// <exception cref="InvalidOperationException">There is no finder collection.</exception> internal void FindPublishedContent(PublishedRequest request) { const string tracePrefix = "FindPublishedContent: "; // look for the document // the first successful finder, if any, will set this.PublishedContent, and may also set this.Template // some finders may implement caching using (_profilingLogger.DebugDuration <PublishedRouter>( $"{tracePrefix}Executing finders...", $"{tracePrefix}Completed executing finders")) { //iterate but return on first one that finds it var found = _contentFinders.Any(finder => { _logger.Debug <PublishedRouter>("Finder {ContentFinderType}", finder.GetType().FullName); return(finder.TryFindContent(request)); }); _profilingLogger.Debug <PublishedRouter>( "Found? {Found} Content: {PublishedContentId}, Template: {TemplateAlias}, Domain: {Domain}, Culture: {Culture}, Is404: {Is404}, StatusCode: {StatusCode}", found, request.HasPublishedContent ? request.PublishedContent.Id : "NULL", request.HasTemplate ? request.TemplateAlias : "NULL", request.HasDomain ? request.Domain.ToString() : "NULL", request.Culture?.Name ?? "NULL", request.Is404, request.ResponseStatusCode); } // indicate that the published content (if any) we have at the moment is the // one that was found by the standard finders before anything else took place. request.SetIsInitialPublishedContent(); }
/// <summary> /// Tries to find the document matching the request, by running the IPublishedContentFinder instances. /// </summary> /// <exception cref="InvalidOperationException">There is no finder collection.</exception> internal bool FindPublishedContent(IPublishedRequestBuilder request) { const string tracePrefix = "FindPublishedContent: "; // look for the document // the first successful finder, if any, will set this.PublishedContent, and may also set this.Template // some finders may implement caching using (_profilingLogger.DebugDuration <PublishedRouter>( $"{tracePrefix}Begin finders", $"{tracePrefix}End finders")) { // iterate but return on first one that finds it var found = _contentFinders.Any(finder => { _logger.LogDebug("Finder {ContentFinderType}", finder.GetType().FullName); return(finder.TryFindContent(request)); }); _logger.LogDebug( "Found? {Found}, Content: {PublishedContentId}, Template: {TemplateAlias}, Domain: {Domain}, Culture: {Culture}, StatusCode: {StatusCode}", found, request.HasPublishedContent() ? request.PublishedContent.Id : "NULL", request.HasTemplate() ? request.Template?.Alias : "NULL", request.HasDomain() ? request.Domain.ToString() : "NULL", request.Culture ?? "NULL", request.ResponseStatusCode); return(found); } }
public override bool PerformRun() { switch (_runtime.ServerRole) { case ServerRole.Replica: _logger.Debug <LogScrubber>("Does not run on replica servers."); return(true); // DO repeat, server role can change case ServerRole.Unknown: _logger.Debug <LogScrubber>("Does not run on servers with unknown role."); return(true); // DO repeat, server role can change } // ensure we do not run if not main domain, but do NOT lock it if (_runtime.IsMainDom == false) { _logger.Debug <LogScrubber>("Does not run if not MainDom."); return(false); // do NOT repeat, going down } // Ensure we use an explicit scope since we are running on a background thread. using (var scope = _scopeProvider.CreateScope()) using (_logger.DebugDuration <LogScrubber>("Log scrubbing executing", "Log scrubbing complete")) { _auditService.CleanLogs(GetLogScrubbingMaximumAge(_settings)); scope.Complete(); } return(true); // repeat }
// internal/virtual for tests (i.e. hack, do not port to netcore) internal virtual void DetermineRuntimeLevel(IUmbracoDatabaseFactory databaseFactory, IProfilingLogger profilingLogger) { using (var timer = profilingLogger.DebugDuration <CoreRuntime>("Determining runtime level.", "Determined.")) { try { _state.DetermineRuntimeLevel(databaseFactory); profilingLogger.Debug <CoreRuntime, RuntimeLevel, RuntimeLevelReason>("Runtime level: {RuntimeLevel} - {RuntimeLevelReason}", _state.Level, _state.Reason); if (_state.Level == RuntimeLevel.Upgrade) { profilingLogger.Debug <CoreRuntime>("Configure database factory for upgrades."); databaseFactory.ConfigureForUpgrade(); } } catch { _state.Level = RuntimeLevel.BootFailed; _state.Reason = RuntimeLevelReason.BootFailedOnException; timer?.Fail(); throw; } } }
/// <summary> /// The RegEx matches any HTML attribute values that start with a tilde (~), those that match are passed to ResolveUrl to replace the tilde with the application path. /// </summary> /// <param name="text"></param> /// <returns></returns> /// <remarks> /// When used with a Virtual-Directory set-up, this would resolve all URLs correctly. /// The recommendation is that the "ResolveUrlsFromTextString" option (in umbracoSettings.config) is set to false for non-Virtual-Directory installs. /// </remarks> public string EnsureUrls(string text) { if (_contentSection.ResolveUrlsFromTextString == false) { return(text); } using (var timer = _logger.DebugDuration(typeof(IOHelper), "ResolveUrlsFromTextString starting", "ResolveUrlsFromTextString complete")) { // find all relative URLs (ie. URLs that contain ~) var tags = ResolveUrlPattern.Matches(text); _logger.Debug <long, int>(typeof(IOHelper), "After regex: {Duration} matched: {TagsCount}", timer.Stopwatch.ElapsedMilliseconds, tags.Count); foreach (Match tag in tags) { var url = ""; if (tag.Groups[1].Success) { url = tag.Groups[1].Value; } // The richtext editor inserts a slash in front of the URL. That's why we need this little fix // if (url.StartsWith("/")) // text = text.Replace(url, ResolveUrl(url.Substring(1))); // else if (string.IsNullOrEmpty(url) == false) { var resolvedUrl = (url.Substring(0, 1) == "/") ? IOHelper.ResolveUrl(url.Substring(1)) : IOHelper.ResolveUrl(url); text = text.Replace(url, resolvedUrl); } } } return(text); }
public override bool PerformRun() { switch (_runtime.ServerRole) { case ServerRole.Replica: _logger.Debug <LogScrubber>("Does not run on replica servers."); return(true); // DO repeat, server role can change case ServerRole.Unknown: _logger.Debug <LogScrubber>("Does not run on servers with unknown role."); return(true); // DO repeat, server role can change } // ensure we do not run if not main domain, but do NOT lock it if (_runtime.IsMainDom == false) { _logger.Debug <LogScrubber>("Does not run if not MainDom."); return(false); // do NOT repeat, going down } // running on a background task, and Log.CleanLogs uses the old SqlHelper, // better wrap in a scope and ensure it's all cleaned up and nothing leaks using (var scope = _scopeProvider.CreateScope()) using (_logger.DebugDuration <LogScrubber>("Log scrubbing executing", "Log scrubbing complete")) { _auditService.CleanLogs(GetLogScrubbingMaximumAge(_settings)); scope.Complete(); } return(true); // repeat }
/// <summary> /// add the given section to the given user group /// </summary> /// <remarks> /// if umbraco throws an exception here, we capture it /// because if we don't umbraco won't startup and that /// might be a bad thing :( /// </remarks> /// <param name="groupAlias"></param> /// <param name="sectionAlias"></param> private void AddSection(string groupAlias, string sectionAlias) { using (logger.DebugDuration <CustomSectionComponent>($"Adding Section {sectionAlias} to {groupAlias}")) { var group = userService.GetUserGroupByAlias(groupAlias); if (group != null) { if (!group.AllowedSections.Contains(sectionAlias)) { group.AddAllowedSection(sectionAlias); try { userService.Save(group); logger.Info <CustomSectionComponent>($"Section {sectionAlias} added to {groupAlias} group"); } catch (Exception ex) { logger.Warn <CustomSectionComponent>("Error adding section {0} to group {1} [{2}]", sectionAlias, groupAlias, ex.Message); } } } } }
public override async Task <bool> PerformRunAsync(CancellationToken token) { switch (_runtime.ServerRole) { case ServerRole.Replica: _logger.Debug <ScheduledTasks>("Does not run on replica servers."); return(true); // DO repeat, server role can change case ServerRole.Unknown: _logger.Debug <ScheduledTasks>("Does not run on servers with unknown role."); return(true); // DO repeat, server role can change } // ensure we do not run if not main domain, but do NOT lock it if (_runtime.IsMainDom == false) { _logger.Debug <ScheduledTasks>("Does not run if not MainDom."); return(false); // do NOT repeat, going down } using (_logger.DebugDuration <ScheduledTasks>("Scheduled tasks executing", "Scheduled tasks complete")) { try { await ProcessTasksAsync(token); } catch (Exception ex) { _logger.Error <ScheduledTasks>(ex, "Error executing scheduled task"); } } return(true); // repeat }
public override Task PerformExecuteAsync(object?state) { switch (_serverRegistrar.CurrentServerRole) { case ServerRole.Subscriber: _logger.LogDebug("Does not run on subscriber servers."); return(Task.CompletedTask); case ServerRole.Unknown: _logger.LogDebug("Does not run on servers with unknown role."); return(Task.CompletedTask); } // Ensure we do not run if not main domain, but do NOT lock it if (_mainDom.IsMainDom == false) { _logger.LogDebug("Does not run if not MainDom."); return(Task.CompletedTask); } // Ensure we use an explicit scope since we are running on a background thread. using (ICoreScope scope = _scopeProvider.CreateCoreScope()) using (_profilingLogger.DebugDuration <LogScrubber>("Log scrubbing executing", "Log scrubbing complete")) { _auditService.CleanLogs((int)_settings.MaxLogAge.TotalMinutes); _ = scope.Complete(); } return(Task.CompletedTask); }
public override object ConvertIntermediateToObject(IPublishedElement owner, IPublishedPropertyType propertyType, PropertyCacheLevel referenceCacheLevel, object inter, bool preview) { using (_proflog.DebugDuration <MultiUrlPickerValueConverter>($"ConvertPropertyToLinks ({propertyType.DataType.Id})")) { var maxNumber = propertyType.DataType.ConfigurationAs <MultiUrlPickerConfiguration>().MaxNumber; if (inter == null) { return(maxNumber == 1 ? null : Enumerable.Empty <Link>()); } var links = new List <Link>(); var dtos = _jsonSerializer.Deserialize <IEnumerable <MultiUrlPickerValueEditor.LinkDto> >(inter.ToString()); var publishedSnapshot = _publishedSnapshotAccessor.GetRequiredPublishedSnapshot(); foreach (var dto in dtos) { var type = LinkType.External; var url = dto.Url; if (dto.Udi != null) { type = dto.Udi.EntityType == Constants.UdiEntityType.Media ? LinkType.Media : LinkType.Content; var content = type == LinkType.Media ? publishedSnapshot.Media.GetById(preview, dto.Udi.Guid) : publishedSnapshot.Content.GetById(preview, dto.Udi.Guid); if (content == null || content.ContentType.ItemType == PublishedItemType.Element) { continue; } url = content.Url(_publishedUrlProvider); } links.Add( new Link { Name = dto.Name, Target = dto.Target, Type = type, Udi = dto.Udi, Url = url + dto.QueryString, } ); } if (maxNumber == 1) { return(links.FirstOrDefault()); } if (maxNumber > 0) { return(links.Take(maxNumber)); } return(links); } }
public override async Task PerformExecuteAsync(object?state) { if (_healthChecksSettings.Notification.Enabled == false) { return; } if (_runtimeState.Level != RuntimeLevel.Run) { return; } switch (_serverRegistrar.CurrentServerRole) { case ServerRole.Subscriber: _logger.LogDebug("Does not run on subscriber servers."); return; case ServerRole.Unknown: _logger.LogDebug("Does not run on servers with unknown role."); return; } // Ensure we do not run if not main domain, but do NOT lock it if (_mainDom.IsMainDom == false) { _logger.LogDebug("Does not run if not MainDom."); return; } // Ensure we use an explicit scope since we are running on a background thread and plugin health // checks can be making service/database calls so we want to ensure the CallContext/Ambient scope // isn't used since that can be problematic. using (ICoreScope scope = _scopeProvider.CreateCoreScope()) using (_profilingLogger.DebugDuration <HealthCheckNotifier>("Health checks executing", "Health checks complete")) { // Don't notify for any checks that are disabled, nor for any disabled just for notifications. Guid[] disabledCheckIds = _healthChecksSettings.Notification.DisabledChecks .Select(x => x.Id) .Union(_healthChecksSettings.DisabledChecks .Select(x => x.Id)) .Distinct() .ToArray(); IEnumerable <HealthCheck> checks = _healthChecks .Where(x => disabledCheckIds.Contains(x.Id) == false); var results = await HealthCheckResults.Create(checks); results.LogResults(); // Send using registered notification methods that are enabled. foreach (IHealthCheckNotificationMethod notificationMethod in _notifications.Where(x => x.Enabled)) { await notificationMethod.SendAsync(results); } } }
public bool GetHtmlByUrl(string url, out string fullHtml) { using (_profilingLogger.DebugDuration <HtmlService>("GetHtmlByUrl(" + url + ")", "GetHtmlByUrl(" + url + ") done")) { if (!Uri.TryCreate(url, UriKind.Absolute, out Uri uri)) { fullHtml = ""; return(false); } try { var httpTimeout = _fullTextConfig.GetHttpTimeout(); var cookieDictionary = GetQueryStringCollection(); var webRequest = (HttpWebRequest)WebRequest.Create(uri); httpTimeout *= 1000; webRequest.Timeout = httpTimeout; webRequest.UserAgent = "FullTextIndexer"; if (cookieDictionary != null && cookieDictionary.Count > 0) { var container = new CookieContainer(); var domain = webRequest.Address.DnsSafeHost; foreach (var cookie in cookieDictionary) { container.Add(new Cookie(cookie.Key, cookie.Value, "/", domain)); } webRequest.CookieContainer = container; } var webResponse = (HttpWebResponse)webRequest.GetResponse(); using (var sr = new StreamReader(webResponse.GetResponseStream())) { fullHtml = sr.ReadToEnd(); } return(true); } catch (WebException ex) { _logger.Error <HtmlService>(ex, "Error in FullTextSearch retrieval."); fullHtml = string.Empty; } return(false); } }
protected override IEnumerable <IComponent> CreateItems(IFactory factory) { _logger = factory.GetInstance <IProfilingLogger>(); using (_logger.DebugDuration <ComponentCollectionBuilder>($"Creating components. (log when >{LogThresholdMilliseconds}ms)", "Created.")) { return(base.CreateItems(factory)); } }
public override async Task <bool> PerformRunAsync(CancellationToken token) { if (_runtimeState.Level != RuntimeLevel.Run) { return(true); // repeat... } switch (_runtimeState.ServerRole) { case ServerRole.Replica: _logger.Debug <HealthCheckNotifier>("Does not run on replica servers."); return(true); // DO repeat, server role can change case ServerRole.Unknown: _logger.Debug <HealthCheckNotifier>("Does not run on servers with unknown role."); return(true); // DO repeat, server role can change } // ensure we do not run if not main domain, but do NOT lock it if (_runtimeState.IsMainDom == false) { _logger.Debug <HealthCheckNotifier>("Does not run if not MainDom."); return(false); // do NOT repeat, going down } // Ensure we use an explicit scope since we are running on a background thread and plugin health // checks can be making service/database calls so we want to ensure the CallContext/Ambient scope // isn't used since that can be problematic. using (var scope = _scopeProvider.CreateScope()) using (_logger.DebugDuration <HealthCheckNotifier>("Health checks executing", "Health checks complete")) { var healthCheckConfig = Current.Configs.HealthChecks(); // Don't notify for any checks that are disabled, nor for any disabled // just for notifications var disabledCheckIds = healthCheckConfig.NotificationSettings.DisabledChecks .Select(x => x.Id) .Union(healthCheckConfig.DisabledChecks .Select(x => x.Id)) .Distinct() .ToArray(); var checks = _healthChecks .Where(x => disabledCheckIds.Contains(x.Id) == false); var results = new HealthCheckResults(checks); results.LogResults(); // Send using registered notification methods that are enabled foreach (var notificationMethod in _notifications.Where(x => x.Enabled)) { await notificationMethod.SendAsync(results, token); } } return(true); // repeat }
/// <summary> /// Tries to find the document matching the request, by running the IPublishedContentFinder instances. /// </summary> /// <exception cref="InvalidOperationException">There is no finder collection.</exception> internal async Task <bool> FindPublishedContent(IPublishedRequestBuilder request) { const string tracePrefix = "FindPublishedContent: "; // look for the document // the first successful finder, if any, will set this.PublishedContent, and may also set this.Template // some finders may implement caching DisposableTimer?profilingScope = null; try { if (_logger.IsEnabled(LogLevel.Debug)) { profilingScope = _profilingLogger.DebugDuration <PublishedRouter>( $"{tracePrefix}Begin finders", $"{tracePrefix}End finders"); } // iterate but return on first one that finds it var found = false; foreach (IContentFinder contentFinder in _contentFinders) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug("Finder {ContentFinderType}", contentFinder.GetType().FullName); } found = await contentFinder.TryFindContent(request); if (found) { break; } } if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug( "Found? {Found}, Content: {PublishedContentId}, Template: {TemplateAlias}, Domain: {Domain}, Culture: {Culture}, StatusCode: {StatusCode}", found, request.HasPublishedContent() ? request.PublishedContent?.Id : "NULL", request.HasTemplate() ? request.Template?.Alias : "NULL", request.HasDomain() ? request.Domain?.ToString() : "NULL", request.Culture ?? "NULL", request.ResponseStatusCode); } return(found); } finally { profilingScope?.Dispose(); } }
protected override IComponent CreateItem(IServiceProvider factory, Type itemType) { IProfilingLogger logger = factory.GetRequiredService <IProfilingLogger>(); using (logger.DebugDuration <ComponentCollectionBuilder>( $"Creating {itemType.FullName}.", $"Created {itemType.FullName}.", thresholdMilliseconds: LogThresholdMilliseconds)) { return(base.CreateItem(factory, itemType)); } }
public override async Task <bool> PerformRunAsync(CancellationToken token) { if (_runtimeState.Level != RuntimeLevel.Run) { return(true); // repeat... } switch (_runtimeState.ServerRole) { case ServerRole.Replica: _logger.Debug <HealthCheckNotifier>("Does not run on replica servers."); return(true); // DO repeat, server role can change case ServerRole.Unknown: _logger.Debug <HealthCheckNotifier>("Does not run on servers with unknown role."); return(true); // DO repeat, server role can change } // ensure we do not run if not main domain, but do NOT lock it if (_runtimeState.IsMainDom == false) { _logger.Debug <HealthCheckNotifier>("Does not run if not MainDom."); return(false); // do NOT repeat, going down } using (_logger.DebugDuration <HealthCheckNotifier>("Health checks executing", "Health checks complete")) { var healthCheckConfig = Current.Configs.HealthChecks(); // Don't notify for any checks that are disabled, nor for any disabled // just for notifications var disabledCheckIds = healthCheckConfig.NotificationSettings.DisabledChecks .Select(x => x.Id) .Union(healthCheckConfig.DisabledChecks .Select(x => x.Id)) .Distinct() .ToArray(); var checks = _healthChecks .Where(x => disabledCheckIds.Contains(x.Id) == false); var results = new HealthCheckResults(checks); results.LogResults(); // Send using registered notification methods that are enabled foreach (var notificationMethod in _notifications.Where(x => x.Enabled)) { await notificationMethod.SendAsync(results, token); } } return(true); // repeat }
public override async Task PerformExecuteAsync(object?state) { if (_keepAliveSettings.DisableKeepAliveTask) { return; } // Don't run on replicas nor unknown role servers switch (_serverRegistrar.CurrentServerRole) { case ServerRole.Subscriber: _logger.LogDebug("Does not run on subscriber servers."); return; case ServerRole.Unknown: _logger.LogDebug("Does not run on servers with unknown role."); return; } // Ensure we do not run if not main domain, but do NOT lock it if (_mainDom.IsMainDom == false) { _logger.LogDebug("Does not run if not MainDom."); return; } using (_profilingLogger.DebugDuration <KeepAlive>("Keep alive executing", "Keep alive complete")) { var umbracoAppUrl = _hostingEnvironment.ApplicationMainUrl?.ToString(); if (umbracoAppUrl.IsNullOrWhiteSpace()) { _logger.LogWarning("No umbracoApplicationUrl for service (yet), skip."); return; } // If the config is an absolute path, just use it var keepAlivePingUrl = WebPath.Combine( umbracoAppUrl !, _hostingEnvironment.ToAbsolute(_keepAliveSettings.KeepAlivePingUrl)); try { var request = new HttpRequestMessage(HttpMethod.Get, keepAlivePingUrl); HttpClient httpClient = _httpClientFactory.CreateClient(Constants.HttpClients.IgnoreCertificateErrors); _ = await httpClient.SendAsync(request); } catch (Exception ex) { _logger.LogError(ex, "Keep alive failed (at '{keepAlivePingUrl}').", keepAlivePingUrl); } } }
/// <summary> /// Returns a list of all installed file paths /// </summary> /// <param name="compiledPackage"></param> /// <param name="packageFile"></param> /// <param name="targetRootFolder"> /// The absolute path of where to extract the package files (normally the application root) /// </param> /// <returns></returns> public IEnumerable <string> InstallFiles(CompiledPackage compiledPackage, FileInfo packageFile, string targetRootFolder) { using (_logger.DebugDuration <PackageFileInstallation>( "Installing package files for package " + compiledPackage.Name, "Package file installation complete for package " + compiledPackage.Name)) { var sourceAndRelativeDest = _parser.ExtractSourceDestinationFileInformation(compiledPackage.Files); var sourceAndAbsDest = AppendRootToDestination(targetRootFolder, sourceAndRelativeDest); _packageExtraction.CopyFilesFromArchive(packageFile, sourceAndAbsDest); return(sourceAndRelativeDest.Select(sd => sd.appRelativePath).ToArray()); } }
public override async Task <bool> PerformRunAsync(CancellationToken token) { // not on replicas nor unknown role servers switch (_runtime.ServerRole) { case ServerRole.Replica: _logger.Debug <KeepAlive>("Does not run on replica servers."); return(true); // role may change! case ServerRole.Unknown: _logger.Debug <KeepAlive>("Does not run on servers with unknown role."); return(true); // role may change! } // ensure we do not run if not main domain, but do NOT lock it if (_runtime.IsMainDom == false) { _logger.Debug <KeepAlive>("Does not run if not MainDom."); return(false); // do NOT repeat, going down } using (_logger.DebugDuration <KeepAlive>("Keep alive executing", "Keep alive complete")) { var keepAlivePingUrl = _keepAliveSection.KeepAlivePingUrl; try { if (keepAlivePingUrl.Contains("{umbracoApplicationUrl}")) { var umbracoAppUrl = _runtime.ApplicationUrl.ToString(); if (umbracoAppUrl.IsNullOrWhiteSpace()) { _logger.Warn <KeepAlive>("No umbracoApplicationUrl for service (yet), skip."); return(true); // repeat } keepAlivePingUrl = keepAlivePingUrl.Replace("{umbracoApplicationUrl}", umbracoAppUrl.TrimEnd(Constants.CharArrays.ForwardSlash)); } var request = new HttpRequestMessage(HttpMethod.Get, keepAlivePingUrl); var result = await _httpClient.SendAsync(request, token); } catch (Exception ex) { _logger.Error <KeepAlive>(ex, "Keep alive failed (at '{keepAlivePingUrl}').", keepAlivePingUrl); } } return(true); // repeat }
public override bool PerformRun() { if (!_fullTextConfig.IsFullTextIndexingEnabled()) { return(false); } if (!_examineManager.TryGetIndex("ExternalIndex", out IIndex index)) { _logger.Error <PerformCacheTasks>(new InvalidOperationException("No index found by name ExternalIndex")); return(false); } try { using (_profilingLogger.DebugDuration <PerformCacheTasks>("PerformCacheTasks", "PerformCacheTasks done")) { var tasks = _cacheService.GetCacheTasks(); foreach (var task in tasks) { _cacheService.SetTaskAsStarted(task); } foreach (var task in tasks) { var content = _contentService.GetById(task.NodeId); if (content != null) { _cacheService.AddToCache(task.NodeId); index.IndexItems(_valueSetBuilder.GetValueSets(content)); } else { _cacheService.DeleteFromCache(task.NodeId); } _cacheService.DeleteCacheTask(task.Id); } } } catch (Exception e) { _logger.Error <PerformCacheTasks>(e); } return(true); }
public void Initialize() { if (runtimeState.Level <= RuntimeLevel.Run) { logger.Info <uSyncBackofficeComponent>("Umbraco is not in Run Mode {0} so uSync is not going to run", runtimeState.Level); return; } if (runtimeState.ServerRole == Umbraco.Core.Sync.ServerRole.Replica) { logger.Info <uSyncBackofficeComponent>("This is a replica server, uSync will not run any of the startup events"); return; } using (logger.DebugDuration <uSyncBackofficeComponent>("uSync Starting")) { InitBackOffice(); } }
/// <summary> /// Returns a unique hash for a combination of FileInfo objects. /// </summary> /// <param name="filesAndFolders">A collection of files.</param> /// <param name="logger">A profiling logger.</param> /// <returns>The hash.</returns> // internal for tests public static string GetFileHash(IEnumerable <FileSystemInfo> filesAndFolders, IProfilingLogger logger) { using (logger.DebugDuration <TypeLoader>("Determining hash of code files on disk", "Hash determined")) { using (var generator = new HashGenerator()) { // get the distinct file infos to hash var uniqInfos = new HashSet <string>(); foreach (var fileOrFolder in filesAndFolders) { if (uniqInfos.Contains(fileOrFolder.FullName)) { continue; } uniqInfos.Add(fileOrFolder.FullName); generator.AddFileSystemItem(fileOrFolder); } return(generator.GenerateHash()); } } }