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