Apache rewrite for Go and Iris

Greetings gophers,

Today we'll take a quick look to a rewrite middleware that I've created 2 months ago for the Iris Web Framework.

We all remember the old good times, I assume, most of us used apache mod_rewrite in the past to map pattern with URL paths.

Rewrite is useful for Search engine optimization (SEO). It lets you convert an "ugly" path to a more human-readable one.

Without spending most of your time, let's start, the code speaks for itself.

First of all, install Iris version 12, if you haven't already(!):

go get github.com/kataras/iris/v12@master

The rewrite middleware is a builtin package, so you don't need to install anything else.

The Rewrite Middleware supports rewrite URL path, subdomain or host based on a regular expression search and replace.

The syntax is familiar to the majority of the backend developers out there and it looks like that:

| REDIRECT_CODE_DIGITS | PATTERN_REGEX | TARGET_REPL |
|----------------------|---------------|-------------|
| 301                  | /seo/(.*)     | /$1         |

The above will redirect all requests from relative path /seo/* to /* using the 301 (Moved Permanently) HTTP Status Code. Learn more about regex.

Usage

First of all, you should import the builtin middleware as follows:

import "github.com/kataras/iris/v12/middleware/rewrite"

There are two ways to load rewrite options in order to parse and register the redirect rules:

1. Through a yaml or json file using the Load function. It is the most common scenario and the simplest one. It panics on parse errors.

func main() {
    app := iris.New()
    // [...routes]
    redirects := rewrite.Load("redirects.yml")
    app.WrapRouter(redirects)
    app.Listen(":80")
}

It is highly recommended that you should register the Rewrite Middleware as a Router Wrapper through Application.WrapRouter right before Application.Listen/Run.

The "redirects.yml" file looks like that:

RedirectMatch:
  # Redirects /seo/* to /*
  - 301 /seo/(.*) /$1

  # Redirects /docs/v12* to /docs
  - 301 /docs/v12(.*) /docs

  # Redirects /old(.*) to /
  - 301 /old(.*) /

  # Redirects http or https://test.* to http or https://newtest.*
  - 301 ^(http|https)://test.(.*) $1://newtest.$2

  # Handles /*.json or .xml as *?format=json or xml,
  # without redirect. See /users route.
  # When Code is 0 then it does not redirect the request,
  # instead it changes the request URL
  # and leaves a route handle the request.
  - 0 /(.*).(json|xml) /$1?format=$2

# Redirects root domain to www.
# Creation of a www subdomain inside the Application is unnecessary,
# all requests are handled by the root Application itself.
PrimarySubdomain: www

2. Through code using the New function. Parse errors can be handled and rules can be programmatically stored.

opts := rewrite.Options{
    RedirectMatch: []string{
        "301 /seo/(.*) /$1",
        "301 /docs/v12(.*) /docs",
        "301 /old(.*) /",
        "301 ^(http|https)://test.(.*) $1://newtest.$2",
        "0 /(.*).(json|xml) /$1?format=$2",
    },
    PrimarySubdomain: "www",
}
rw, err := rewrite.New(opts)
if err != nil { panic(err) }
app.WrapRouter(rw.Rewrite)

Example

Let's write a simple application which follows the redirect rules of:

SOURCE	TARGET
http://mydomain.com:8080/seo/about	http://www.mydomain.com:8080/about
http://test.mydomain.com:8080	http://newtest.mydomain.com:8080
http://test.mydomain.com:8080/seo/about	http://newtest.mydomain.com:8080/about
http://localhost:8080/seo	http://localhost:8080
http://localhost:8080/about	http://localhost:8080/about
http://localhost:8080/docs/v12/hello	http://localhost:8080/docs
http://localhost:8080/docs/v12some	http://localhost:8080/docs
http://localhost:8080/oldsome	http://localhost:8080
http://localhost:8080/oldindex/random	http://localhost:8080
http://localhost:8080/users.json	http://localhost:8080/users?format=json

package main

import (
    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/rewrite"
)

func main() {
    app := iris.New()

    app.Get("/", index)
    app.Get("/about", about)
    app.Get("/docs", docs)
    app.Get("/users", listUsers)

    app.Subdomain("test").Get("/", testIndex)

    newtest := app.Subdomain("newtest")
    newtest.Get("/", newTestIndex)
    newtest.Get("/", newTestAbout)

    //
    redirects := rewrite.Load("redirects.yml")
    app.WrapRouter(redirects)
    // 

    app.Listen(":8080")
}

func index(ctx iris.Context) {
    ctx.WriteString("Index")
}

func about(ctx iris.Context) {
    ctx.WriteString("About")
}

func docs(ctx iris.Context) {
    ctx.WriteString("Docs")
}

func listUsers(ctx iris.Context) {
    format := ctx.URLParamDefault("format", "text")
    /*
        switch format{
            case "json":
                ctx.JSON(response)
            case "xml":
                ctx.XML(response)
            // [...]
        }
    */
    ctx.Writef("Format: %s", format)
}

func testIndex(ctx iris.Context) {
    ctx.WriteString(`Test Subdomain Index
                (This should never be executed,
                redirects to newtest subdomain)`)
}

func newTestIndex(ctx iris.Context) {
    ctx.WriteString("New Test Subdomain Index")
}

func newTestAbout(ctx iris.Context) {
    ctx.WriteString("New Test Subdomain About")
}

Hosts File

127.0.0.1   mydomain.com
127.0.0.1   www.mydomain.com
127.0.0.1   test.mydomain.com
127.0.0.1   newtest.mydomain.com

Navigate here if you don't know how to modify the system's hosts file.

---

Thanks for the reading! Please upvote the Post if you liked it. Feel free to follow my Twitter and GitHub. Have fun and be safe 🦾