aboutsummaryrefslogtreecommitdiff
path: root/router/router.go
blob: 35d17f66f1de24c78e2a4de7b71f0ef4853daaa0 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
package router

import (
  "net/http"
  "html/template"
  "regexp"
  "log"
  "strconv"
  "strings"
  "path"
  "os"
  "errors"
  "fmt"
)

type Router struct {
  /* This is the template for error pages */
  Fallback template.Template
  /* Routes are only filled by using the appropriate methods. */
  routes []Route
  /* StaticPaths can be filled from outside when constructing the Router.
   * key = uri
   * value = file path
   */
  StaticPaths map[string]string
}


type Route struct {
  path *regexp.Regexp
  handlerMap map[string]http.Handler
}

/* This represents what the server should do with a given request. */
type ServerTask struct {
  /* template and apiFmt are mutually exclusive. */
  template *template.Template
  apiFmt string

  /* doWork represents serverside work to fulfill the request.
   * This function can be composed any way you see fit when creating
   * a route.
   */
  doWork func(http.ResponseWriter, *http.Request)
}

func (self *Router) Get(path string, h http.Handler) {
  self.AddRoute("GET", path, h)
}

func (self *Router) Post(path string, h http.Handler) {
  self.AddRoute("POST", path, h)
}

func (self *Router) Put(path string,  h http.Handler) {
  self.AddRoute("PUT", path, h)
}

func (self *Router) Delete(path string, h http.Handler) {
  self.AddRoute("DELETE", path, h)
}

func (self *Router) AddRoute(method string, path string, h http.Handler) {

  exactPath := regexp.MustCompile("^" + path + "$")

  /* If the route already exists, try to add this method to the ServerTask map. */
  for _, r := range self.routes {
    if r.path == exactPath {
      r.handlerMap[method] = h
      return
    }
  }

  /* Otherwise add a new route */
  self.routes = append(self.routes, Route{
    path: exactPath,
    handlerMap: map[string]http.Handler{method: h},
  })

}

func (self *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
  /* Show the 500 error page if we panic */
  defer func() {
    if r := recover(); r != nil {
      log.Println("ERROR:", r)
      self.ErrorPage(w, req, 500, "There was an error on the server.")
    }
  }()

  /* If the request matches any our StaticPaths, try to serve a file. */
  for uri, dir := range self.StaticPaths {
    if req.Method == "GET" && strings.HasPrefix(req.URL.Path, uri) {
      restOfUri := strings.TrimPrefix(req.URL.Path, uri)
      p := path.Join(dir, restOfUri)
      p = path.Clean(p)

      /* If the file exists, try to serve it. */
      info, err := os.Stat(p);
      if err == nil && !info.IsDir() {
        http.ServeFile(w, req, p)
      /* Handle the common errors */
      } else if errors.Is(err, os.ErrNotExist) || errors.Is(err, os.ErrExist) {
        self.ErrorPage(w, req, 404, "The requested file does not exist")
      } else if errors.Is(err, os.ErrPermission) || info.IsDir() {
        self.ErrorPage(w, req, 403, "Access forbidden")
      /* If it's some weird error, serve a 500. */
      } else {
        self.ErrorPage(w, req, 500, "Internal server error")
      }

      return
    }
  }

  /* Otherwise, this is a normal route */
  for _, r := range self.routes {

    /* Pull the params out of the regex;
     * If the path doesn't match the regex, params will be nil.
     */
    params := r.Match(req)
    if params == nil {
      continue
    }
    for method, handler := range r.handlerMap {
      if method == req.Method {
        /* Parse the form and add the params to it */
        req.ParseForm()
        ProcessParams(req, params)
        /* handle the request! */
        handler.ServeHTTP(w, req);
        return
      }
    }
  }
  self.ErrorPage(w, req, 404, "The page you requested does not exist!")
}

/*******************
 * Utility Methods *
 *******************/

func ProcessParams(req *http.Request, params map[string]string) {
  for key, value := range params {
    req.Form.Add(key, value)
  }
}

func (self *Route) Match(r *http.Request) map[string]string {
  match := self.path.FindStringSubmatch(r.URL.Path)
  if match == nil {
    return nil
  }

  params := map[string]string{}
  groupNames := self.path.SubexpNames()

  for i, group := range match {
    params[groupNames[i]] = group
  }

  return params
}

func (self *Router) ErrorPage(w http.ResponseWriter, req *http.Request, code int, errMsg string) {
  w.WriteHeader(code)
  req.ParseForm()
  req.Form.Add("ErrorCode", strconv.Itoa(code))
  req.Form.Add("ErrorMessage", errMsg)
  self.Fallback.Execute(w, req)
}