amuse/router.go

package main

import (
	"notabug.org/apiote/amuse/front"
	"notabug.org/apiote/amuse/libamuse"
	"notabug.org/apiote/amuse/network"
	"notabug.org/apiote/amuse/utils"

	"crypto/sha256"
	"encoding/base64"
	"errors"
	"flag"
	"fmt"
	"io"
	"mime"
	"net/http"
	"os"
	//"path/filepath"
	"strconv"
	"strings"
)

func person(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	etag := r.Header.Get("Etag")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)

	path := strings.Split(r.URL.Path[1:], "/")
	_, err := strconv.ParseInt(path[1], 10, 64)
	if err != nil {
		renderError(400, w, err, acceptLanguages, mimetype)
		return
	} else if len(path) > 2 {
		renderError(404, w, nil, acceptLanguages, mimetype)
		return
	}
	person, err := libamuse.ShowPerson(path[1], etag, acceptLanguages, mimetype)
	render(person, err, w, acceptLanguages, mimetype)
}

func tvSerie(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	etag := r.Header.Get("Etag")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)

	path := strings.Split(r.URL.Path[1:], "/")
	_, err := strconv.ParseInt(path[1], 10, 64)
	if err != nil {
		renderError(400, w, err, acceptLanguages, mimetype)
		return
	} else if len(path) > 2 {
		renderError(404, w, nil, acceptLanguages, mimetype)
		return
	}
	tvSerie, err := libamuse.ShowTvSerie(path[1], etag, acceptLanguages, mimetype)
	render(tvSerie, err, w, acceptLanguages, mimetype)
}

func film(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)

	path := strings.Split(r.URL.Path[1:], "/")
	_, err := strconv.ParseInt(path[1], 10, 64)
	if err != nil {
		renderError(400, w, err, acceptLanguages, mimetype)
		return
	} else if len(path) > 2 {
		renderError(404, w, nil, acceptLanguages, mimetype)
		return
	}
	film, err := libamuse.ShowFilm(path[1], acceptLanguages, mimetype)
	render(film, err, w, acceptLanguages, mimetype)
}

func book(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)
	path := strings.Split(r.URL.Path[1:], "/")
	if len(path) > 2 {
		renderError(404, w, nil, acceptLanguages, mimetype)
		return
	}
	book, err := libamuse.ShowBook(path[1], acceptLanguages, mimetype)
	render(book, err, w, acceptLanguages, mimetype)
}

func bookSerie(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)
	path := strings.Split(r.URL.Path[1:], "/")
	if len(path) > 2 {
		renderError(404, w, nil, acceptLanguages, mimetype)
		return
	}
	bookSerie, err := libamuse.ShowBookSerie(path[1], acceptLanguages, mimetype)
	render(bookSerie, err, w, acceptLanguages, mimetype)
}

func search(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)

	path := strings.Split(r.URL.Path[1:], "/")
	if len(path) > 2 {
		renderError(404, w, nil, acceptLanguages, mimetype)
		return
	}
	query := r.URL.Query().Get("q")
	page := r.URL.Query().Get("page")
	results, err := libamuse.PerformSearch(query, acceptLanguages, mimetype, page)
	render(results, err, w, acceptLanguages, mimetype)
}

func index(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)

	path := strings.Split(r.URL.Path[1:], "/")
	if path[0] != "" {
		renderError(404, w, nil, acceptLanguages, mimetype)
		return
	}
	index, err := libamuse.ShowIndex(acceptLanguages, mimetype)
	render(index, err, w, acceptLanguages, mimetype)
}

func about(w http.ResponseWriter, r *http.Request) {
	acceptLanguages := r.Header.Get("Accept-Language")
	mimetype := strings.Split(r.Header.Get("Accept"), ",")[0]

	defer recovery(acceptLanguages, mimetype, w)

	about, err := libamuse.ShowAbout(acceptLanguages, mimetype)
	render(about, err, w, acceptLanguages, mimetype)
}

func static(w http.ResponseWriter, r *http.Request) {
	etagReq := r.Header.Get("If-None-Match")
	f, err := os.Open(utils.DataHome + "/" + r.URL.Path[1:])
	if err != nil {
		w.WriteHeader(500)
		return
	}
	defer f.Close()
	h := sha256.New()
	if _, err := io.Copy(h, f); err != nil {
		w.WriteHeader(500)
		return
	}
	etag := base64.StdEncoding.EncodeToString(h.Sum(nil))

	mime.AddExtensionType(".woff2", "font/woff2")

	w.Header().Set("ETag", etag)
	if etagReq == etag {
		w.WriteHeader(304)
	} else {
		s := strings.Split(f.Name(), ".")
		ext := "." + s[len(s)-1]
		mimetype := mime.TypeByExtension(ext)
		w.Header().Set("Content-Type", mimetype+"; charset=utf-8")
		f.Seek(0, 0)
		if _, err := io.Copy(w, f); err != nil {
			w.WriteHeader(500)
		}
	}
}

func main() {
	port := flag.Int("p", 5008, "port to run amuse on")
	dataHome := flag.String("d", "/usr/local/share/amuse", "data directory")
	flag.Parse()
	portStr := fmt.Sprintf(":%d", *port)
	utils.DataHome = *dataHome

	libamuse.InitDB()

	http.HandleFunc("/", index)
	http.HandleFunc("/static/", static)
	http.HandleFunc("/about", about)
	http.HandleFunc("/items/", search)
	http.HandleFunc("/films/", film)
	http.HandleFunc("/tvseries/", tvSerie)
	http.HandleFunc("/persons/", person)
	http.HandleFunc("/books/", book)
	http.HandleFunc("/bookseries/", bookSerie)
	fmt.Printf("running on %s\n", portStr)
	e := http.ListenAndServe(portStr, nil)
	if e != nil {
		fmt.Println(e)
	}
}

func recovery(languages, mimetype string, w http.ResponseWriter) {
	if r := recover(); r != nil {
		renderError(500, w, errors.New(r.(string)), languages, mimetype)
	}
}

func render(result string, e error, w http.ResponseWriter, languages, mimetype string) {
	if e != nil {
		fmt.Println(e)
		if _, ok := e.(front.NoSuchRendererError); ok {
			renderError(406, w, e, languages, mimetype)
		} else if httpError, ok := e.(network.HttpError); ok {
			renderError(httpError.Status, w, httpError, languages, mimetype)
		} else {
			renderError(500, w, e, languages, mimetype)
		}
	} else {
		fmt.Fprint(w, result)
	}
}

func renderError(code int, w http.ResponseWriter, e error, languages, mimetype string) {
	w.WriteHeader(code)
	if code != 406 {
		errorPage, err := libamuse.ShowErrorPage(code, languages, mimetype)
		if err != nil {
			fmt.Fprintf(w, "Fatal error while rendering error %d.\nContact admin.", code)
		}
		fmt.Fprint(w, errorPage)
	}
}