server.go

package main

import (
	"fmt"
	"net/http"
	"strconv"

	"github.com/reugn/auth-server/auth"
	"github.com/reugn/auth-server/proxy"
	"github.com/reugn/auth-server/repository"
	"github.com/reugn/auth-server/utils"
)

// HTTPServer is an auth http server wrapper
type HTTPServer struct {
	addr         string
	parser       proxy.RequestParser
	repo         repository.Repository
	jwtGenerator *auth.JWTGenerator
	jwtValidtor  *auth.JWTValidator
}

// NewHTTPServer returns a new instance of HTTPServer
func NewHTTPServer(host string, port int, keys *auth.Keys) *HTTPServer {
	addr := host + ":" + strconv.Itoa(port)
	repository := parseRepo()
	generator := auth.NewJWTGenerator(keys, parseAlgo())
	validator := auth.NewJWTValidator(keys, repository)

	return &HTTPServer{
		addr,
		parseProxy(),
		repository,
		generator,
		validator,
	}
}

func (ws *HTTPServer) start() {
	// root route
	http.HandleFunc("/", rootActionHandler)

	// health route
	http.HandleFunc("/health", healthActionHandler)

	// readiness route
	http.HandleFunc("/ready", readyActionHandler)

	// version route
	http.HandleFunc("/version", versionActionHandler)

	// token issuing route
	// uses basic authentication
	http.HandleFunc("/token", ws.tokenActionHandler)

	// authorization route
	// validates bearer JWT
	http.HandleFunc("/auth", ws.authActionHandler)

	err := http.ListenAndServe(ws.addr, nil)
	utils.Check(err)
}

func rootActionHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		w.WriteHeader(http.StatusNotFound)
	}
	fmt.Fprintf(w, "")
}

func healthActionHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Ok")
}

func readyActionHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Ok")
}

func versionActionHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, authServerVersion)
}

func (ws *HTTPServer) tokenActionHandler(w http.ResponseWriter, r *http.Request) {
	user, pass, ok := r.BasicAuth()
	if !ok {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

	userDetails := ws.repo.AuthenticateBasic(user, pass)
	if userDetails == nil {
		w.WriteHeader(http.StatusUnauthorized)
		return
	}

	token, err := ws.jwtGenerator.Generate(userDetails.UserName, userDetails.UserRole)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	fmt.Fprintf(w, "%s", token.Marshal())
}

func (ws *HTTPServer) authActionHandler(w http.ResponseWriter, r *http.Request) {
	requestDetails := ws.parser.ParseRequestDetails(r)
	auth := ws.parser.ParseAuthorizationToken(r)

	if !ws.jwtValidtor.Authorize(auth, requestDetails) {
		w.WriteHeader(http.StatusUnauthorized)
	}
}