Support redirects in preview (#1270)

This add support for parsing the redirects.conf file that we've been
including in every do build for a while. It is *technically* an nginx
config file but it is safe to treat it as a list of regex substitutions.

Author: nik9000

integtest/spec/all_books_spec.rb

@@ -449,9 +449,10 @@ def self.setup_example(repo, lang, hash)
       HTML
     end
     it 'serves a legacy redirect' do
-      expect(legacy_redirect.code).to eq('301')
-      expect(legacy_redirect['location']).to eq(
-        "#{root}/en/elasticsearch/reference/current/setup.html"
+      expect(legacy_redirect).to redirect_to(
+        eq(
+          "#{root}/en/elasticsearch/reference/current/setup.html"
+        )
       )
     end
     context 'for a JPG' do

integtest/spec/helper/dsl.rb

@@ -46,12 +46,10 @@ def dest_file(file)
 
   RSpec.shared_examples 'the root' do
     context 'the root' do
-      let(:root) do
-        Net::HTTP.get_response(URI('http://localhost:8000/'))
-      end
+      let(:root_uri) { 'http://localhost:8000' }
+      let(:root) { Net::HTTP.get_response(URI(root_uri)) }
       it 'redirects to the guide root' do
-        expect(root.code).to eq('301')
-        expect(root['Location']).to eq('http://localhost:8000/guide/index.html')
+        expect(root).to redirect_to(eq("#{root_uri}/guide/index.html"))
       end
     end
   end

integtest/spec/helper/matcher/redirect_to.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+##
+# Matches http responses.
+RSpec::Matchers.define :redirect_to do |expected|
+  match do |actual|
+    return false unless actual.code == '301'
+
+    expected.matches? actual['Location']
+  end
+  failure_message do |actual|
+    unless actual.code == '301'
+      return "expected status [301] but was [#{actual.code}]. Body:\n" +
+             actual.body
+    end
+
+    message = expected.failure_message
+    "status was [301] but the location didn't match: #{message}"
+  end
+end

integtest/spec/preview_spec.rb

@@ -92,6 +92,9 @@ def get(watermark, branch, path)
     let(:directory) do
       get watermark, branch, 'guide'
     end
+    let(:legacy_redirect) do
+      get watermark, branch, 'guide/reference/setup/'
+    end
   end
 
   let(:expected_js_state) { {} }
@@ -105,8 +108,7 @@ def get(watermark, branch, path)
   shared_examples 'serves some docs' do |supports_gapped: true|
     context 'the root' do
       it 'redirects to the guide root' do
-        expect(root.code).to eq('301')
-        expect(root['Location']).to eq("http://#{host}:8000/guide/index.html")
+        expect(root).to redirect_to(eq("http://#{host}:8000/guide/index.html"))
       end
       it 'logs the access to the docs root' do
         wait_for_access '/'
@@ -177,6 +179,21 @@ def get(watermark, branch, path)
       TXT
       expect(robots_txt['Content-Type']).to eq('text/plain')
     end
+    context 'for a legacy redirect' do
+      it 'serves the redirect' do
+        expect(legacy_redirect).to redirect_to(
+          eq(
+            '/guide/en/elasticsearch/reference/current/setup.html'
+          )
+        )
+      end
+      it 'logs the access to the legacy redirect' do
+        wait_for_access '/guide/reference/setup/'
+        expect(logs).to include(<<~LOGS)
+          #{watermark} #{host} GET /guide/reference/setup/ HTTP/1.1 301
+        LOGS
+      end
+    end
   end
   shared_examples '404s' do
     it '404s for the docs root' do
@@ -252,8 +269,7 @@ def get(watermark, branch, path)
     end
     context 'when you request a directory' do
       it 'redirects to index.html' do
-        expect(directory.code).to eq('301')
-        expect(directory['Location']).to eq('/guide/index.html')
+        expect(directory).to redirect_to(eq('/guide/index.html'))
       end
     end
   end

integtest/spec/spec_helper.rb

@@ -3,6 +3,7 @@
 require_relative 'helper/matcher/doc_body'
 require_relative 'helper/matcher/have_same_keys'
 require_relative 'helper/matcher/initial_js_state'
+require_relative 'helper/matcher/redirect_to'
 require_relative 'helper/matcher/serve'
 require_relative 'helper/console_alternative_examples'
 require_relative 'helper/dest'

preview/core.js

@@ -52,6 +52,7 @@ const GitCore = (defaultTemplate, ignoreHost, repoPath) => {
 
     return {
       diff: () => Readable.from(bufferItr(diffItr(git, branch), 16 * 1024)),
+      redirects: () => git.catBlob(`${branch}:redirects.conf`),
       file: async requestedPath => {
         const templateExists = await hasTemplate(git, branch);
         /*
@@ -113,6 +114,7 @@ const FsCore = (defaultTemplate, ignoreHost, rootPath) => {
         r.push(null);
         return r;
       },
+      redirects: () => null,
       file: async requestedPath => {
         const realPath = `${rootPath}/${requestedPath}`;
         let pathStat;

preview/preview.js

@@ -40,8 +40,15 @@ const requestHandler = async (core, parsedUrl, response) => {
   }
 
   const path = parsedUrl.pathname.substring("/guide".length);
-  const type = contentType(path);
-  const file = await core.file(path, type);
+  const redirect = await checkRedirects(core, path);
+  if (redirect) {
+    response.statusCode = 301;
+    response.setHeader('Location', redirect);
+    response.end();
+    return;
+  }
+
+  const file = await core.file(path);
   if (file === "dir") {
     response.statusCode = 301;
     const sep = parsedUrl.pathname.endsWith('/') ? '' : '/';
@@ -55,6 +62,7 @@ const requestHandler = async (core, parsedUrl, response) => {
     return;
   }
 
+  const type = contentType(path);
   response.setHeader('Content-Type', type);
   if (file.hasTemplate && !path.endsWith("toc.html") && type === "text/html; charset=utf-8") {
     const template = Template(file.template);
@@ -126,6 +134,47 @@ const hostPrefix = host => {
   return host.substring(0, dot);
 };
 
+const checkRedirects = async (core, path) => {
+  /*
+   * This parses the nginx redirects.conf file we have in the built docs and
+   * performs the redirects. It makes no effort to properly emulate nginx. It
+   * just runs the regexes from start to finish. Which is fine becaues of the
+   * redirects that we have. But it is ugly.
+   *
+   * It also doesen't make any effort to be fast or efficient, buffering the
+   * entire file into memory then splitting it into lines and compiling all of
+   * the regexes on the fly. We can absolutely do better. But this feels like
+   * a fine place to start.
+   */
+  // TODO Rebuild redirects file without nginx stuff. And stream it properly.
+  let target = "/guide" + path;
+  const redirectsStart = Date.now();
+  const streamToString = stream => {
+    const chunks = []
+    return new Promise((resolve, reject) => {
+      stream.on('data', chunk => chunks.push(chunk));
+      stream.on('error', reject);
+      stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    });
+  }
+  const redirectsStream = await core.redirects();
+  if (!redirectsStream) {
+    // If we don't have the redirects file we skip redirects.
+    return;
+  }
+  const redirectsString = await streamToString(redirectsStream);
+  for (const line of redirectsString.split('\n')) {
+    if (!line.startsWith("rewrite")) {
+      continue;
+    }
+    const [_marker, regexText, replacement] = line.split(' ');
+    const regex = new RegExp(regexText.replace('(?i)', ''), 'i');
+    target = target.replace(regex, replacement);
+  }
+  console.log("took", Date.now() - redirectsStart);
+  return "/guide" + path === target ? null : target;
+}
+
 module.exports = Core => {
   const server = http.createServer((request, response) => {
     const parsedUrl = url.parse(request.url);