public virtual void OnPageRedirected(object sender, EventArgs e) { var eventArgumets = e as PageRedirectedEventArgs; if (eventArgumets != null) { RedirectProcessor.UpdateLastUseInThread(eventArgumets); LogManager.WriteInfo($"Update last use for {eventArgumets.RedirectId} is completed"); } }
public void DetectCyclicRedirect() { // create redirect processor var configuration = new Configuration { ForceHttpHostPatterns = new[] { "www\\.test\\.local" } }; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), new TestHttpClient(), urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // parsed redirects var redirects = TestData.TestData.GetParsedRedirects(); // preload redirects redirectProcessor.PreloadParsedRedirects( redirects); // process redirects using redirect processor var processedRedirects = TestData.TestData.GetProcessedRedirects( redirects, new[] { redirectProcessor }); // verify cyclic redirect is detected var cyclicRedirect = processedRedirects .FirstOrDefault(pr => pr.Results.Any(r => r.Type.Equals(ResultTypes.CyclicRedirect))); Assert.IsNotNull(cyclicRedirect); Assert.AreEqual( "http://www.test.local/example/path", cyclicRedirect.ParsedRedirect.OldUrl.Formatted); Assert.AreEqual( "http://www.test.local/new-url", cyclicRedirect.ParsedRedirect.NewUrl.Formatted); }
/// <summary> /// Dialogs the processor. /// </summary> /// <param name="args">The arguments.</param> protected void DialogProcessor(ClientPipelineArgs args) { if (args.IsPostBack) { if (args.Result == "yes") { var rootItem = Factory.GetDatabase(Configuration.Database).GetItem(Items.ItemIDs.RedirectsFolderItem); if (rootItem == null) { return; } var children = rootItem.Axes.GetDescendants(); if (!children.Any()) { return; } using (new EventDisabler()) { var currentDate = DateTime.Now; foreach (var item in from item in children.Where(x => x.IsItemOfType(Templates.Settings.TemplateId)) let settings = new Templates.Settings(item) where (currentDate - settings.LastUse.DateTime).Days >= Configuration.RemovalDate select item) { item.Delete(); } } RedirectProcessor.CreateListOfRedirects(); var load = string.Concat(new object[] { "item:load(id=", rootItem.ID, ",language=", rootItem.Language, ",version=", rootItem.Version, ")" }); Context.ClientPage.SendMessage(this, load); var refresh = string.Format("item:refreshchildren(id={0})", rootItem.Parent.ID); Context.ClientPage.ClientResponse.Timer(refresh, 2); } } else { Context.ClientPage.ClientResponse.Confirm(Translate.Text("Redirect_Remove Old Redirects").Replace("[0]", Configuration.RemovalDate.ToString(CultureInfo.InvariantCulture))); args.WaitForPostBack(); } }
/// <summary> /// Builds the section to section node. /// </summary> /// <param name="item">The item.</param> /// <returns>section to section node</returns> private static string BuildSectionToSectionNode(SectionToSection item) { if (item == null) { return(string.Empty); } return(string.Format( "<div class=\"block-name\"><div class=\"name\">{0}</div><div class=\"title\">Base Section Url: {2}, Target Url: {3}</div></div><div class=\"description\">Redirect Code: {4}, Multisites: {6}, Last Use: {5}, ID: {1}</div>", item.Name, item.ID, string.IsNullOrEmpty(item.BaseSection.Value) ? "Empty" : UrlNormalizer.EncodeUrl(UrlNormalizer.CheckPageExtension(UrlNormalizer.Normalize(item.BaseSection.Value))), item.TargetSection.TargetItem != null ? UrlNormalizer.CheckPageExtension(UrlNormalizer.EncodeUrl(UrlNormalizer.GetItemUrl(item.TargetSection.TargetItem))) : "Empty", item.RedirectCode != 0 ? item.RedirectCode : Configuration.RedirectStatusCode, item.LastUse.DateTime.ToString("MM/dd/yy") != "01/01/01" ? item.LastUse.DateTime.ToString("MM/dd/yy") : "Never", UrlNormalizer.EncodeUrl(RedirectProcessor.ConvertMultisites(item.Multisites)))); }
public void CyclicRedirectsNotDetectedWithoutPreload() { // create redirect processor var configuration = TestData.TestData.DefaultConfiguration; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), new TestHttpClient(), urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // process redirects var processedRedirects = TestData.TestData.GetProcessedRedirects( new[] { redirectProcessor }); // verify no cyclic redirects are detected var cyclicRedirects = processedRedirects .Where(pr => pr.Results.Any(r => r.Type.Equals(ResultTypes.CyclicRedirect))) .ToList(); Assert.AreEqual(0, cyclicRedirects.Count); }
/// <summary> /// Checks the acceptable page mode and args and redirect page if needed /// </summary> /// <param name="args">The args.</param> public override void Process(HttpRequestArgs args) { Assert.ArgumentNotNull(args, "RedirectManager"); if (!Configuration.Enabled) { return; } try { if (!Configuration.RedirectsListIsInitialized) { Configuration.RedirectsListIsInitialized = true; RedirectProcessor.Initialize(); RedirectProcessor.CreateListOfRedirectsInThread(); } } catch (Exception e) { LogManager.WriteError(e.Message); LogManager.WriteError(e.StackTrace); } if (Context.Item != null) { CyclingProtectionManager.ClearCurrentCycle(args.Context.Response, args.Context.Request); if (RedirectProcessor.CheckPresentation(Context.Item)) { return; } } if (!CheckPageMode() || Context.Database == null || Context.Request.FilePath == null || Context.Database.Name == "core" || CheckIgnorePages()) { CyclingProtectionManager.ClearCurrentCycle(args.Context.Response, args.Context.Request); return; } if (!CyclingProtectionManager.CheckCycle(args.Context.Response, args.Context.Request)) { LogManager.WriteInfo(string.Format("Reached limit of cycles for the request: \"{0}\"", Context.Request.FilePath)); CyclingProtectionManager.ClearCurrentCycle(args.Context.Response, args.Context.Request); return; } var sw = new Stopwatch(); sw.Start(); int redirectCode; string redirectId; var baseUrl = UrlNormalizer.CheckPageExtension(UrlNormalizer.Normalize(Context.Request.FilePath, true)); var targetUrl = RedirectProcessor.FindRedirect(baseUrl, out redirectCode, out redirectId); if (string.IsNullOrEmpty(targetUrl)) { if (Configuration.EnableNotFounds) { LogManager.WriteInfo(string.Format("Redirect for the page: \"{0}\" was not found", Context.Request.FilePath)); } CyclingProtectionManager.ClearCurrentCycle(args.Context.Response, args.Context.Request); return; } RedirectProcessor.UpdateLastUseInThread(redirectId); sw.Stop(); LogManager.WriteInfo( string.Format( "Page \"{0}\" was redirected to \"{1}\": redirect item id - {2}, elapsed time - {3} milliseconds", Context.Request.FilePath, targetUrl, redirectId, sw.ElapsedMilliseconds)); Response(args, targetUrl, redirectCode); }
public virtual void RefreshRedirects(object sender, EventArgs e) { RedirectProcessor.CreateListOfRedirectsInThread(); LogManager.WriteInfo($"Refresh redirects is completed"); }
public void RedirectProcessorRedirectsOldUrlWithReplaceType() { var configuration = TestData.TestData.DefaultConfiguration; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectParser = new RedirectParser( configuration, urlParser, urlFormatter); // create redirect processor var testHttpClient = new TestHttpClient(); var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), testHttpClient, urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // parse redirect with old url replace type var parsedRedirects = TestData.TestData.GetParsedRedirects( configuration, new[] { new Redirect { OldUrl = "/url1", NewUrl = "/url2", RedirectType = RedirectType.Replace } }) .ToList(); // parse redirects to verify replace redirect works var parsedRedirects2 = TestData.TestData.GetParsedRedirects( configuration, new[] { new Redirect { OldUrl = "/url1/replace/redirect", NewUrl = "/url2/replace/redirect" } }) .ToList(); // preload parsed redirects redirectProcessor.PreloadParsedRedirects( parsedRedirects); var processedRedirects = new [] { new ProcessedRedirect { ParsedRedirect = parsedRedirects[0] }, new ProcessedRedirect { ParsedRedirect = parsedRedirects2[0] } }; // process redirects foreach (var processedRedirect in processedRedirects) { redirectProcessor.Process( processedRedirect); } // verify var urlResponseResult = processedRedirects[1] .Results .FirstOrDefault(x => x.Type == ResultTypes.UrlResponse); Assert.IsNotNull(urlResponseResult); Assert.AreEqual( "http://www.test.local/url2/replace/redirect", urlResponseResult.Url); }
public void RedirectProcessorHandlesLowercasedRedirects() { var configuration = TestData.TestData.DefaultConfiguration; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectParser = new RedirectParser( configuration, urlParser, urlFormatter); // create redirect processor var testHttpClient = new TestHttpClient(); var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), testHttpClient, urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // parse redirects with uppercased old url var parsedRedirects = TestData.TestData.GetParsedRedirects( configuration, new[] { new Redirect { OldUrl = "/Url1", NewUrl = "/url2" } }) .ToList(); // simulate uppercased url redirects to lowercased url testHttpClient.Responses[ parsedRedirects[0].OldUrl.Formatted] = new HttpResponse { StatusCode = 301, Headers = new Dictionary <string, string> { { "Location", "/url1" } } }; // preload parsed redirects redirectProcessor.PreloadParsedRedirects( parsedRedirects); // process redirects var processedRedirect = new ProcessedRedirect { ParsedRedirect = parsedRedirects[0] }; redirectProcessor.Process( processedRedirect); // verify var urlResponseResult = processedRedirect .Results .FirstOrDefault(x => x.Type == ResultTypes.UrlResponse); Assert.IsNotNull(urlResponseResult); Assert.AreEqual( "http://www.test.local/url2", urlResponseResult.Url); }
public void RedirectProcessorCachesResponse() { var configuration = TestData.TestData.DefaultConfiguration; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectParser = new RedirectParser( configuration, urlParser, urlFormatter); // create redirect processor var testHttpClient = new TestHttpClient(); var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), testHttpClient, urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // create and parse redirects var redirects = new List <IRedirect> { new Redirect { OldUrl = "/url1", NewUrl = "/url3" }, new Redirect { OldUrl = "/url2", NewUrl = "/url3" } }; var parsedRedirects = new List <IParsedRedirect>(); foreach (var redirect in redirects) { parsedRedirects.Add( redirectParser.ParseRedirect( redirect)); } // preload parsed redirects redirectProcessor.PreloadParsedRedirects( parsedRedirects); // verify controlled http client doesn't have any responses Assert.AreEqual( 0, testHttpClient.Responses.Count); // process redirects and verify responses are cached by overriding responses UrlResponseResult urlResponseResult = null; var processedRedirects = new List <IProcessedRedirect>(); foreach (var parsedRedirect in parsedRedirects) { var processedRedirect = new ProcessedRedirect { ParsedRedirect = parsedRedirect }; redirectProcessor.Process( processedRedirect); // get url response result, if url response result is null and // controlled http client has a response for old url if (urlResponseResult == null && testHttpClient.Responses.ContainsKey( parsedRedirect.NewUrl.Formatted)) { urlResponseResult = processedRedirect.Results .FirstOrDefault(r => r.Type.Equals( ResultTypes.UrlResponse)) as UrlResponseResult; } else { // override response with forbidden status code testHttpClient.Responses[ parsedRedirect.NewUrl.Formatted] = new HttpResponse { StatusCode = 401 }; } } // verify url response result for /url3 has status code ok and not forbidden Assert.IsNotNull( urlResponseResult); Assert.AreEqual( "http://www.test.local/url3", urlResponseResult.Url); Assert.AreEqual( 404, urlResponseResult.StatusCode ); }
public void DetectTooManyRedirects() { var configuration = TestData.TestData.DefaultConfiguration; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectParser = new RedirectParser( configuration, urlParser, urlFormatter); // create redirect processor var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), new TestHttpClient(), urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // add redirects var parsedRedirects = new List <IParsedRedirect>(); for (var i = 1; i <= configuration.MaxRedirectCount; i++) { var redirect = new Redirect { OldUrl = string.Format("/url{0}", i), NewUrl = string.Format("/url{0}", i + 1) }; parsedRedirects.Add( redirectParser.ParseRedirect( redirect)); } // preload redirects redirectProcessor.PreloadParsedRedirects( parsedRedirects); // process redirects using redirect processor var processedRedirects = TestData.TestData.GetProcessedRedirects( parsedRedirects, new[] { redirectProcessor }); // verify processed redirects has too many redirects result var redirectWithTooManyRedirects = processedRedirects .Where(pr => pr.Results.Any(r => r.Type.Equals(ResultTypes.TooManyRedirects))) .ToList(); Assert.AreEqual( 1, redirectWithTooManyRedirects.Count); var redirectWithTooManyRedirect = redirectWithTooManyRedirects .FirstOrDefault(); Assert.IsNotNull(redirectWithTooManyRedirect); Assert.AreEqual( "http://www.test.local/url1", redirectWithTooManyRedirect.ParsedRedirect.OldUrl.Formatted); Assert.AreEqual( "http://www.test.local/url2", redirectWithTooManyRedirect.ParsedRedirect.NewUrl.Formatted); }
public void DetectOptimizedRedirect() { var configuration = TestData.TestData.DefaultConfiguration; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectParser = new RedirectParser( configuration, urlParser, urlFormatter); // create redirect processor var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), new TestHttpClient(), urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // add redirects for optimizing var redirect1 = new Redirect { OldUrl = "/optimize-url1", NewUrl = "/optimize-url2" }; var redirect2 = new Redirect { OldUrl = "/optimize-url2", NewUrl = "/optimize-url3" }; var parsedRedirects = new List <IParsedRedirect>(); foreach (var redirect in new[] { redirect1, redirect2 }) { parsedRedirects.Add( redirectParser.ParseRedirect( redirect)); } // preload redirects redirectProcessor.PreloadParsedRedirects( parsedRedirects); // process redirects using redirect processor var processedRedirects = TestData.TestData.GetProcessedRedirects( parsedRedirects, new[] { redirectProcessor }); // verify processed redirects has optimized redirect result var optimizedRedirects = processedRedirects .Where(pr => pr.Results.Any(r => r.Type.Equals(ResultTypes.OptimizedRedirect))) .ToList(); Assert.AreNotEqual(0, optimizedRedirects.Count); var optimizedRedirect = optimizedRedirects .FirstOrDefault(or => or.ParsedRedirect.OldUrl.Formatted.Equals("http://www.test.local/optimize-url1")); Assert.IsNotNull(optimizedRedirect); var optimizedRedirectResult = optimizedRedirect.Results .FirstOrDefault(r => r.Type.Equals(ResultTypes.OptimizedRedirect) && r.Url != null && r.Url.Equals("http://www.test.local/optimize-url3")); Assert.IsNotNull(optimizedRedirectResult); }
public void DetectUrlResponse() { // create test http client var testHttpClient = new TestHttpClient(); // parsed redirects var parsedRedirects = TestData.TestData.GetParsedRedirects(); // add moved response for parsed redirects foreach (var redirect in parsedRedirects) { testHttpClient.Responses[ redirect.OldUrl.Formatted] = new HttpResponse { StatusCode = 301, Headers = new Dictionary <string, string> { { "Location", redirect.NewUrl.Formatted } } }; } // override redirect old url with ok response testHttpClient.Responses[ "http://www.test.local/new-url"] = new HttpResponse { StatusCode = 200 }; // create redirect processor var configuration = new Configuration { DefaultUrl = TestData.TestData.DefaultHost, ForceHttpHostPatterns = new[] { "www\\.test\\.local" } }; var urlParser = new UrlParser(); var urlFormatter = new UrlFormatter(); var redirectProcessor = new RedirectProcessor( configuration, new UrlHelper( configuration, urlParser, urlFormatter), testHttpClient, urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // preload redirects redirectProcessor.PreloadParsedRedirects( parsedRedirects); // process redirects var processedRedirects = TestData.TestData.GetProcessedRedirects( parsedRedirects, new[] { redirectProcessor }); // verify redirect processor detects overridden url with response var urlResponse = redirectProcessor.Results .FirstOrDefault(x => x.Type.Equals(ResultTypes.UrlResponse)); Assert.IsNotNull(urlResponse); Assert.AreEqual( "http://www.test.local/new-url", urlResponse.Url); }
public void HttpsRedirectDoesntReturnCyclicRedirect() { // create redirect processor var configuration = new Configuration { DefaultUrl = TestData.TestData.DefaultHost, ForceHttpHostPatterns = new[] { "www\\.test\\.local" } }; // create url and redirect parser var urlFormatter = new UrlFormatter(); var urlParser = new UrlParser(); var urlHelper = new UrlHelper( configuration, urlParser, urlFormatter); var redirectParser = new RedirectParser( configuration, urlParser, urlFormatter); // create redirect processor var testHttpClient = new TestHttpClient(); var redirectProcessor = new RedirectProcessor( configuration, urlHelper, testHttpClient, urlParser, urlFormatter, new RedirectHelper( configuration, urlParser, urlFormatter)); // parse redirects var redirects = new[] { new Redirect { OldUrl = "http://www.test.local/url1", NewUrl = "https://www.test.local/url1" }, new Redirect { OldUrl = "https://www.test.local/url1", NewUrl = "https://www.test.local/url2" }, new Redirect { OldUrl = "https://www.test.local/url2", NewUrl = "https://www.test.local/url3" } }; // parse redirects var parsedRedirects = new List <IParsedRedirect>(); foreach (var redirect in redirects) { parsedRedirects.Add( redirectParser.ParseRedirect( redirect)); } // preload parsed redirects redirectProcessor.PreloadParsedRedirects( parsedRedirects); // process redirects using redirect processor var processedRedirects = TestData.TestData.GetProcessedRedirects( parsedRedirects, new[] { redirectProcessor }); // verify cyclic redirect is not detected var cyclicRedirect = processedRedirects .FirstOrDefault(pr => pr.Results.Any( r => r.Type.Equals(ResultTypes.CyclicRedirect))); Assert.IsNull(cyclicRedirect); // verify optimized redirect is detected var optimizedRedirect = processedRedirects .FirstOrDefault(pr => pr.Results.Any( r => r.Type.Equals(ResultTypes.OptimizedRedirect))); Assert.IsNotNull(optimizedRedirect); }