telebit/rvpn/server/api_interface.go

package server

import (
	"context"
	"net/http"
	"runtime"
	"strconv"
	"strings"

	"github.com/gorilla/mux"

	"git.daplie.com/Daplie/go-rvpn-server/rvpn/envelope"
)

const (
	endPointPrefix = "/api/com.daplie.tunnel/"
)

var connectionTable *Table
var serverStatus *Status
var serverStatusAPI *Status

//handleAdminClient -
// - expecting an existing oneConnListener with a qualified wss client connected.
// - auth will happen again since we were just peeking at the token.
func handleAdminClient(ctx context.Context, oneConn *oneConnListener) {
	serverStatus = ctx.Value(ctxServerStatus).(*Status)

	connectionTable = serverStatus.ConnectionTable
	serverStatusAPI = serverStatus
	router := mux.NewRouter().StrictSlash(true)

	router.PathPrefix("/admin/").Handler(http.StripPrefix("/admin/", http.FileServer(http.Dir("html/admin"))))

	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		loginfo.Println("HandleFunc /")

		serverStatus.AdminStats.IncRequests()

		switch url := r.URL.Path; url {
		case "/":
			// check to see if we are using the administrative Host
			if strings.Contains(r.Host, "rvpn.daplie.invalid") {
				http.Redirect(w, r, "/admin", 301)
				serverStatus.AdminStats.IncResponses()

			}

		default:
			http.Error(w, "Not Found", 404)
		}
	})

	router.HandleFunc(endPointPrefix+"domains", getDomainsEndpoint).Methods("GET")
	router.HandleFunc(endPointPrefix+"domain/", getDomainEndpoint).Methods("GET")
	router.HandleFunc(endPointPrefix+"domain/{domain-name}", getDomainEndpoint).Methods("GET")
	router.HandleFunc(endPointPrefix+"servers", getServersEndpoint).Methods("GET")
	router.HandleFunc(endPointPrefix+"server/", getServerEndpoint).Methods("GET")
	router.HandleFunc(endPointPrefix+"server/{server-id}", getServerEndpoint).Methods("GET")
	router.HandleFunc(endPointPrefix+"status/", getStatusEndpoint).Methods("GET")

	s := &http.Server{
		Addr:    ":80",
		Handler: router,
	}

	err := s.Serve(oneConn)
	if err != nil {
		loginfo.Println("Serve error: ", err)
	}

	select {
	case <-ctx.Done():
		loginfo.Println("Cancel signal hit")
		return
	}
}

func getStatusEndpoint(w http.ResponseWriter, r *http.Request) {
	pc, _, _, _ := runtime.Caller(0)
	loginfo.Println(runtime.FuncForPC(pc).Name())

	serverStatus.AdminStats.IncRequests()

	statusContainer := NewStatusAPI(serverStatusAPI)

	w.Header().Set("Content-Type", "application/json; charset=UTF-8")

	env := envelope.NewEnvelope("domains/GET")
	env.Result = statusContainer
	env.GenerateWriter(w)
	serverStatus.AdminStats.IncResponses()
}

func getDomainsEndpoint(w http.ResponseWriter, r *http.Request) {
	pc, _, _, _ := runtime.Caller(0)
	loginfo.Println(runtime.FuncForPC(pc).Name())

	serverStatus.AdminStats.IncRequests()

	domainsContainer := NewDomainsAPI(connectionTable.domains)

	w.Header().Set("Content-Type", "application/json; charset=UTF-8")

	env := envelope.NewEnvelope("domains/GET")
	env.Result = domainsContainer
	env.GenerateWriter(w)
	serverStatus.AdminStats.IncResponses()
}

func getDomainEndpoint(w http.ResponseWriter, r *http.Request) {
	pc, _, _, _ := runtime.Caller(0)
	loginfo.Println(runtime.FuncForPC(pc).Name())

	serverStatus.AdminStats.IncRequests()

	env := envelope.NewEnvelope("domain/GET")

	params := mux.Vars(r)
	if id, ok := params["domain-name"]; !ok {
		env.Error = "domain-name is missing"
		env.ErrorURI = r.RequestURI
		env.ErrorDescription = "domain API requires a domain-name"
	} else {
		domainName := id
		if domainLB, ok := connectionTable.domains[domainName]; !ok {
			env.Error = "domain-name was not found"
			env.ErrorURI = r.RequestURI
			env.ErrorDescription = "domain-name not found"
		} else {
			var domainAPIContainer []*ServerDomainAPI
			conns := domainLB.Connections()
			for pos := range conns {
				conn := conns[pos]
				domainAPI := NewServerDomainAPI(conn, conn.DomainTrack[domainName])
				domainAPIContainer = append(domainAPIContainer, domainAPI)
			}
			env.Result = domainAPIContainer
		}
	}
	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
	env.GenerateWriter(w)
	serverStatus.AdminStats.IncResponses()
}

func getServersEndpoint(w http.ResponseWriter, r *http.Request) {
	pc, _, _, _ := runtime.Caller(0)
	loginfo.Println(runtime.FuncForPC(pc).Name())

	serverStatus.AdminStats.IncRequests()

	serverContainer := NewServerAPIContainer()

	for c := range connectionTable.Connections() {
		serverAPI := NewServersAPI(c)
		serverContainer.Servers = append(serverContainer.Servers, serverAPI)

	}

	w.Header().Set("Content-Type", "application/json; charset=UTF-8")

	env := envelope.NewEnvelope("servers/GET")
	env.Result = serverContainer
	env.GenerateWriter(w)
	serverStatus.AdminStats.IncResponses()
}

func getServerEndpoint(w http.ResponseWriter, r *http.Request) {
	pc, _, _, _ := runtime.Caller(0)
	loginfo.Println(runtime.FuncForPC(pc).Name())

	serverStatus.AdminStats.IncRequests()

	env := envelope.NewEnvelope("server/GET")

	params := mux.Vars(r)
	if id, ok := params["server-id"]; !ok {
		env.Error = "server-id is missing"
		env.ErrorURI = r.RequestURI
		env.ErrorDescription = "server API requires a server-id"
	} else {
		serverID, err := strconv.Atoi(id)
		if err != nil {
			env.Error = "server-id is not an integer"
			env.ErrorURI = r.RequestURI
			env.ErrorDescription = "server API requires a server-id"

		} else {
			conn, err := connectionTable.GetConnection(int64(serverID))
			if err != nil {
				env.Error = "server-id was not found"
				env.ErrorURI = r.RequestURI
				env.ErrorDescription = "missing server-id, make sure desired service-id is in servers"
			} else {
				loginfo.Println("test")
				serverAPI := NewServerAPI(conn)
				env.Result = serverAPI

			}
		}
	}
	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
	env.GenerateWriter(w)
	serverStatus.AdminStats.IncResponses()
}