private void AddCyclicRedirectResult( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var cyclicRedirectResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals(ResultTypes.CyclicRedirect)) as RedirectResult; if (cyclicRedirectResult == null) { return; } processedRedirectRecord.CyclicRedirect = true; processedRedirectRecord.CyclicRedirectMessage = cyclicRedirectResult.Message; processedRedirectRecord.CyclicRedirectUrl = cyclicRedirectResult.Url; processedRedirectRecord.CyclicRedirectCount = cyclicRedirectResult.RedirectCount; processedRedirectRecord.CyclicRedirectVisitedUrls = string.Join( ",", cyclicRedirectResult.UrlsVisited); processedRedirectRecord.CyclicRedirectVisitedRedirects = string.Join( ",", cyclicRedirectResult.RedirectsVisited.Select( x => string.Format( "{0} -> {1}", x.OldUrl.Formatted, x.NewUrl.Formatted))); }
public bool IsValid( IProcessedRedirect processedRedirect, bool includeNotMatchingNewUrl) { if (processedRedirect.Results.Any( r => _invalidResultTypes.Contains(r.Type, StringComparer.OrdinalIgnoreCase))) { return(false); } else { var urlResponseResult = processedRedirect .Results .OfType <UrlResponseResult>() .FirstOrDefault(r => r.Type.Equals(ResultTypes.UrlResponse)); // return false, if url response result is null or result status code is 200 and old url and result url are identical if (urlResponseResult == null || (urlResponseResult.StatusCode == 200 && _urlHelper.AreIdentical(processedRedirect.ParsedRedirect.OldUrl.Formatted, urlResponseResult.Url))) { return(false); } return(includeNotMatchingNewUrl ? urlResponseResult.StatusCode == 200 : _urlHelper.AreIdentical( processedRedirect.ParsedRedirect.NewUrl.Formatted, urlResponseResult.Url) && urlResponseResult.StatusCode == 200); } }
private void DetectDuplicateOfLast( string oldUrlFormatted, IProcessedRedirect processedRedirect) { if (_oldUrlDuplicateOfLastIndex.ContainsKey(oldUrlFormatted)) { var duplicateOfLastResult = new Result { Type = ResultTypes.DuplicateOfLast, Message = string.Format( "Duplicate redirect from old url '{0}'! Redirect to new url '{1}' skipped by last found redirect to new url '{2}'", processedRedirect.ParsedRedirect.OldUrl.Formatted, _oldUrlDuplicateOfLastIndex[oldUrlFormatted].ParsedRedirect.NewUrl.Formatted, processedRedirect.ParsedRedirect.NewUrl.Formatted), Url = processedRedirect.ParsedRedirect.OldUrl.Formatted }; _oldUrlDuplicateOfLastIndex[oldUrlFormatted].Results.Add( duplicateOfLastResult); _results.Add( duplicateOfLastResult); } _oldUrlDuplicateOfLastIndex[oldUrlFormatted] = processedRedirect; }
public void Process(IProcessedRedirect processedRedirect) { if (!processedRedirect.ParsedRedirect.IsValid) { return; } if (!_urlHelper.AreIdentical( processedRedirect.ParsedRedirect.OldUrl.Formatted, processedRedirect.ParsedRedirect.NewUrl.Formatted)) { return; } var identicalResult = new Result { Type = ResultTypes.IdenticalResult, Message = string.Format( "Identical redirect of from and to url '{0}'", processedRedirect.ParsedRedirect.OldUrl.Formatted), Url = processedRedirect.ParsedRedirect.OldUrl.Formatted }; processedRedirect.Results.Add( identicalResult); _results.Add( identicalResult); }
private void AddTooManyRedirectsResult( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var tooManyRedirectsResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals(ResultTypes.TooManyRedirects)) as RedirectResult; if (tooManyRedirectsResult == null) { return; } processedRedirectRecord.TooManyRedirects = true; processedRedirectRecord.TooManyRedirectsMessage = tooManyRedirectsResult.Message; processedRedirectRecord.TooManyRedirectsUrl = tooManyRedirectsResult.Url; processedRedirectRecord.TooManyRedirectsCount = tooManyRedirectsResult.RedirectCount; processedRedirectRecord.TooManyRedirectsVisitedUrls = string.Join( ",", tooManyRedirectsResult.UrlsVisited); processedRedirectRecord.TooManyRedirectsVisitedRedirects = string.Join( ",", tooManyRedirectsResult.RedirectsVisited.Select( x => string.Format( "{0} -> {1}", x.OldUrl.Formatted, x.NewUrl.Formatted))); }
public void Process(IProcessedRedirect processedRedirect) { processedRedirect.Results.Add( new Result { Type = Name, Message = Name, Url = processedRedirect.ParsedRedirect.OldUrl.Formatted }); }
private void AddOutputRedirectUrls( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var outputRedirect = _outputRedirectBuilder.Build( processedRedirect); processedRedirectRecord.OutputRedirectOldUrl = outputRedirect.OldUrl; processedRedirectRecord.OutputRedirectNewUrl = outputRedirect.NewUrl; processedRedirectRecord.OutputRedirectValidMatchingOriginalNewUrl = outputRedirect.ValidMatchingOriginalNewUrl; processedRedirectRecord.OutputRedirectValidNotMatchingOriginalNewUrl = outputRedirect.ValidNotMatchingOriginalNewUrl; }
private void AddIdenticalRedirect( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var identicalRedirectResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals( ResultTypes.IdenticalResult)); if (identicalRedirectResult == null) { return; } processedRedirectRecord.IdenticalRedirect = true; processedRedirectRecord.IdenticalRedirectMessage = identicalRedirectResult.Message; }
private void AddUnknownError( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var unknownErrorResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals( ResultTypes.UnknownErrorResult)); if (unknownErrorResult == null) { return; } processedRedirectRecord.UnknownError = true; processedRedirectRecord.UnknownErrorMessage = unknownErrorResult.Message; }
private void AddExcludedRedirectResult( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var excludedRedirectResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals( ResultTypes.ExcludedRedirect)); if (excludedRedirectResult == null) { return; } processedRedirectRecord.ExcludedRedirect = true; processedRedirectRecord.ExcludedRedirectMessage = excludedRedirectResult.Message; processedRedirectRecord.ExcludedRedirectUrl = excludedRedirectResult.Url; }
private void AddDuplicateOfLastResult( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var duplicateOfLastResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals( ResultTypes.DuplicateOfLast)); if (duplicateOfLastResult == null) { return; } processedRedirectRecord.DuplicateOfLast = true; processedRedirectRecord.DuplicateOfLastMessage = duplicateOfLastResult.Message; processedRedirectRecord.DuplicateOfLastUrl = duplicateOfLastResult.Url; }
public void Process(IProcessedRedirect processedRedirect) { if (processedRedirect.ParsedRedirect.IsValid) { return; } var oldUrlInvalid = false; var messageBuilder = new StringBuilder("Invalid "); string invalidUrl = string.Empty; if (processedRedirect.ParsedRedirect.OldUrl != null && !processedRedirect.ParsedRedirect.OldUrl.IsValid) { oldUrlInvalid = true; invalidUrl = processedRedirect.ParsedRedirect.OldUrl.Raw; messageBuilder.Append(string.Format( "old url '{0}'", processedRedirect.ParsedRedirect.OldUrl.Raw)); } if (processedRedirect.ParsedRedirect.NewUrl != null && !processedRedirect.ParsedRedirect.NewUrl.IsValid) { if (oldUrlInvalid) { messageBuilder.Append(" and "); invalidUrl = processedRedirect.ParsedRedirect.NewUrl.Raw; } messageBuilder.Append(string.Format( "new url '{0}'", processedRedirect.ParsedRedirect.NewUrl.Raw)); } var invalidResult = new Result { Type = ResultTypes.InvalidResult, Message = messageBuilder.ToString(), Url = invalidUrl }; processedRedirect.Results.Add( invalidResult); _results.Add( invalidResult); }
public void Process(IProcessedRedirect processedRedirect) { if (!processedRedirect.ParsedRedirect.IsValid) { return; } // old url formatted var oldUrlFormatted = processedRedirect.ParsedRedirect.OldUrl.Formatted; switch (_configuration.DuplicateOldUrlStrategy) { case DuplicateUrlStrategy.KeepFirst: DetectDuplicateOfFirst(oldUrlFormatted, processedRedirect); break; case DuplicateUrlStrategy.KeepLast: DetectDuplicateOfLast(oldUrlFormatted, processedRedirect); break; } }
private void AddUrlResponseResult( IProcessedRedirect processedRedirect, ProcessedRedirectRecord processedRedirectRecord) { var urlResponseResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals( ResultTypes.UrlResponse)) as UrlResponseResult; if (urlResponseResult == null) { return; } processedRedirectRecord.UrlResponse = true; processedRedirectRecord.UrlResponseMessage = urlResponseResult.Message; processedRedirectRecord.UrlResponseUrl = urlResponseResult.Url; processedRedirectRecord.UrlResponseStatusCode = urlResponseResult.StatusCode; processedRedirectRecord.UrlResponseLocation = urlResponseResult.Location; }
public OutputRedirect Build( IProcessedRedirect processedRedirect) { var urlResponseResult = processedRedirect .Results .OfType <UrlResponseResult>() .FirstOrDefault(r => r.Type.Equals(ResultTypes.UrlResponse)); var newUrl = urlResponseResult != null && !string.IsNullOrWhiteSpace(urlResponseResult.Url) ? urlResponseResult.Url : processedRedirect.ParsedRedirect.NewUrl.Formatted; return(new OutputRedirect { OldUrl = processedRedirect.ParsedRedirect.OldUrl.Formatted, NewUrl = newUrl, ValidMatchingOriginalNewUrl = _processedRedirectValidator.IsValid( processedRedirect, false), ValidNotMatchingOriginalNewUrl = _processedRedirectValidator.IsValid( processedRedirect, true) }); }
public void Process(IProcessedRedirect processedRedirect) { throw new InvalidOperationException( "Error caused for testing unknown error"); }
public RedirectProcessedEventArgs( IProcessedRedirect processedRedirect) { ProcessedRedirect = processedRedirect; }
public void Process(IProcessedRedirect processedRedirect) { if (!processedRedirect.ParsedRedirect.IsValid) { return; } var oldUrlPatternMatches = GetMatchingUrlPatterns( processedRedirect.ParsedRedirect.OldUrl.Formatted, _configuration.OldUrlExcludePatterns) .ToList(); var newUrlPatternMatches = GetMatchingUrlPatterns( processedRedirect.ParsedRedirect.NewUrl.Formatted, _configuration.NewUrlExcludePatterns) .ToList(); if (!oldUrlPatternMatches.Any() && !newUrlPatternMatches.Any()) { return; } var message = new StringBuilder( "Excluded redirect matches "); IUrl url = null; if (oldUrlPatternMatches.Any()) { message.Append( string.Format( "old url exclude patterns '{0}'", string.Join(",", oldUrlPatternMatches))); url = processedRedirect.ParsedRedirect.OldUrl; } if (newUrlPatternMatches.Any()) { if (oldUrlPatternMatches.Any()) { message.Append(" and "); } { url = processedRedirect.ParsedRedirect.NewUrl; } message.Append( string.Format( "new url exclude patterns '{0}'", string.Join(",", newUrlPatternMatches))); } var excludedRedirectResult = new Result { Type = ResultTypes.ExcludedRedirect, Message = message.ToString(), Url = url.Formatted }; processedRedirect.Results.Add( excludedRedirectResult); _results.Add(excludedRedirectResult); }
public void Process(IProcessedRedirect processedRedirect) { // skip processed redirect if it's invalid or contains one or more of skip result types if (!processedRedirect.ParsedRedirect.IsValid || processedRedirect.Results .Select(r => r.Type) .Distinct() .Count(r => _skipResultTypes.Contains(r, StringComparer.OrdinalIgnoreCase)) > 0) { return; } var checkRedirect = false; var isCyclicRedirect = false; var redirectCount = -1; var urlsIndex = new HashSet <string>(); var redirectsVisited = new List <IParsedRedirect>(); string url = null; string newUrl = processedRedirect.ParsedRedirect.OldUrl.Formatted; string lastVisitedUrl; UrlResponseResult urlResponseResult = null; var urlsVisited = new List <string>(new [] { newUrl }); do { url = newUrl; newUrl = null; var urlFormatted = _urlHelper.FormatUrl(url); redirectCount++; checkRedirect = false; // get response from url HttpResponse response; if (_responseCache.ContainsKey(urlFormatted)) { // get response from cache response = _responseCache[urlFormatted]; } else { // get response from url response = _httpClient.Get(urlFormatted); // add response to cache _responseCache.Add(urlFormatted, response); } lastVisitedUrl = url; // set has redirect and url to response location, // if url returns 301 and has location if (response != null) { var statusCode = response.StatusCode; string locationUrl; if (response.Headers.ContainsKey("Location")) { var location = response.Headers["Location"] ?? string.Empty; locationUrl = !Regex.IsMatch( location ?? string.Empty, "^https?://", RegexOptions.IgnoreCase | RegexOptions.Compiled) ? _urlHelper.Combine(url, location) : location ?? string.Empty; } else { locationUrl = string.Empty; } urlResponseResult = new UrlResponseResult { Type = ResultTypes.UrlResponse, Message = string.Format( "Url '{0}' returned response with status code '{1}'", url, statusCode), Url = url, StatusCode = statusCode, Location = locationUrl }; switch (response.StatusCode) { case 301: case 302: // url returns 301 or 302 // update redirect with url from location newUrl = locationUrl; break; case 404: // url returns 404, check if a redirect exists checkRedirect = true; break; default: // urls not returning 301 or 404 are considered a url with a response // stop redirecting url = null; break; } } else { urlResponseResult = null; } // check redirect for url var matchingRedirectResult = GetMatchingRedirect(urlFormatted); if (checkRedirect && matchingRedirectResult.HasMatch) { redirectsVisited.Add( matchingRedirectResult.ParsedRedirect); if (matchingRedirectResult.ResultRedirectType == RedirectType.Replace) { // update redirect with new url from replaced redirect newUrl = _redirectHelper.Replace(urlFormatted, matchingRedirectResult.ParsedRedirect); } else { // update redirect with new url from existing redirect newUrl = matchingRedirectResult.ParsedRedirect.NewUrl.Formatted; } } // add new url to urls visited, if not null if (!string.IsNullOrWhiteSpace(newUrl)) { urlsVisited.Add(newUrl); } // cyclic redirect, if url and new url is not https redirect and url exists in url index if (newUrl != null && !_urlHelper.IsHttpsRedirect( url, newUrl) && urlsIndex.Contains(_urlHelper.FormatUrl(newUrl))) { isCyclicRedirect = true; break; } // add formatted url to urls index, if it doesn't exist if (!urlsIndex.Contains(urlFormatted)) { urlsIndex.Add(urlFormatted); } } while (!string.IsNullOrWhiteSpace(newUrl) && redirectCount < 20); // add url response result, if it's defined if (urlResponseResult != null) { processedRedirect.Results.Add( urlResponseResult); _results.Add(urlResponseResult); } if (isCyclicRedirect) { // add cyclic redirect result var cyclicResult = new RedirectResult { Type = ResultTypes.CyclicRedirect, Message = string.Format( "Cyclic redirect at url '{0}'", lastVisitedUrl), Url = lastVisitedUrl, RedirectCount = redirectCount, UrlsVisited = urlsVisited, RedirectsVisited = redirectsVisited }; processedRedirect.Results.Add( cyclicResult); _results.Add(cyclicResult); } else if (redirectCount >= _configuration.MaxRedirectCount) { // add too many redirects result as redirect count is // higher then max redirect count var tooManyRedirectsResult = new RedirectResult { Type = ResultTypes.TooManyRedirects, Message = string.Format( "Too many redirect at url '{0}' exceeding max redirect count of {1}", lastVisitedUrl, _configuration.MaxRedirectCount), Url = lastVisitedUrl, RedirectCount = redirectCount, UrlsVisited = urlsVisited, RedirectsVisited = redirectsVisited }; processedRedirect.Results.Add( tooManyRedirectsResult); _results.Add( tooManyRedirectsResult); } else if (redirectCount > 1 && redirectCount < _configuration.MaxRedirectCount) { // add optimized redirect result as redirect count is higher than 1 // and less than max redirect count var optimizedRedirectResult = new RedirectResult { Type = ResultTypes.OptimizedRedirect, Message = string.Format( "Optimized redirect to url '{0}'", lastVisitedUrl), Url = lastVisitedUrl, RedirectCount = redirectCount, UrlsVisited = urlsVisited, RedirectsVisited = redirectsVisited }; processedRedirect.Results.Add( optimizedRedirectResult); _results.Add( optimizedRedirectResult); } }