Serve game content and API

.gitignore

@@ -3,3 +3,4 @@
 pokerogue-server*
 userdata/*
 secret.key
+www/

api/common.go

@@ -10,9 +10,31 @@ import (
 	"github.com/pagefaultgames/pokerogue-server/db"
 )
 
-func Init() {
+func Init(mux *http.ServeMux) {
 	scheduleStatRefresh()
 	daily.Init()
+
+	// account
+	mux.HandleFunc("GET /api/account/info", handleAccountInfo)
+	mux.HandleFunc("POST /api/account/register", handleAccountRegister)
+	mux.HandleFunc("POST /api/account/login", handleAccountLogin)
+	mux.HandleFunc("GET /api/account/logout", handleAccountLogout)
+
+	// game
+	mux.HandleFunc("GET /api/game/playercount", handleGamePlayerCount)
+	mux.HandleFunc("GET /api/game/titlestats", handleGameTitleStats)
+	mux.HandleFunc("GET /api/game/classicsessioncount", handleGameClassicSessionCount)
+
+	// savedata
+	mux.HandleFunc("GET /api/savedata/get", handleSaveData)
+	mux.HandleFunc("POST /api/savedata/update", handleSaveData)
+	mux.HandleFunc("GET /api/savedata/delete", handleSaveData)
+	mux.HandleFunc("POST /api/savedata/clear", handleSaveData)
+
+	// daily
+	mux.HandleFunc("GET /api/daily/seed", handleDailySeed)
+	mux.HandleFunc("GET /api/daily/rankings", handleDailyRankings)
+	mux.HandleFunc("GET /api/daily/rankingpagecount", handleDailyRankingPageCount)
 }
 
 func getUsernameFromRequest(r *http.Request) (string, error) {

api/endpoints.go

@@ -7,7 +7,6 @@ import (
 	"log"
 	"net/http"
 	"strconv"
-	"sync"
 
 	"github.com/pagefaultgames/pokerogue-server/api/account"
 	"github.com/pagefaultgames/pokerogue-server/api/daily"
@@ -15,36 +14,13 @@ import (
 	"github.com/pagefaultgames/pokerogue-server/defs"
 )
 
-type Server struct {
-	Debug bool
-	Exit *sync.RWMutex
-}
-
 /*
 	The caller of endpoint handler functions are responsible for extracting the necessary data from the request.
 	Handler functions are responsible for checking the validity of this data and returning a result or error.
 	Handlers should not return serialized JSON, instead return the struct itself.
 */
 
-func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+func handleAccountInfo(w http.ResponseWriter, r *http.Request) {
-	// kind of misusing the RWMutex but it doesn't matter
-	s.Exit.RLock()
-	defer s.Exit.RUnlock()
-
-	if s.Debug {
-		w.Header().Set("Access-Control-Allow-Headers", "*")
-		w.Header().Set("Access-Control-Allow-Methods", "*")
-		w.Header().Set("Access-Control-Allow-Origin", "*")
-
-		if r.Method == "OPTIONS" {
-			w.WriteHeader(http.StatusOK)
-			return
-		}
-	}
-
-	switch r.URL.Path {
-	// /account
-	case "/account/info":
 	username, err := getUsernameFromRequest(r)
 	if err != nil {
 		httpError(w, r, err, http.StatusBadRequest)
@@ -68,7 +44,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
 		return
 	}
-	case "/account/register":
+}
+
+func handleAccountRegister(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		httpError(w, r, fmt.Errorf("failed to parse request form: %s", err), http.StatusBadRequest)
@@ -82,7 +60,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	w.WriteHeader(http.StatusOK)
-	case "/account/login":
+}
+
+func handleAccountLogin(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		httpError(w, r, fmt.Errorf("failed to parse request form: %s", err), http.StatusBadRequest)
@@ -100,7 +80,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
 		return
 	}
-	case "/account/logout":
+}
+
+func handleAccountLogout(w http.ResponseWriter, r *http.Request) {
 	token, err := base64.StdEncoding.DecodeString(r.Header.Get("Authorization"))
 	if err != nil {
 		httpError(w, r, fmt.Errorf("failed to decode token: %s", err), http.StatusBadRequest)
@@ -114,11 +96,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	w.WriteHeader(http.StatusOK)
+}
 
-	// /game
+func handleGamePlayerCount(w http.ResponseWriter, r *http.Request) {
-	case "/game/playercount":
 	w.Write([]byte(strconv.Itoa(playerCount)))
-	case "/game/titlestats":
+}
+
+func handleGameTitleStats(w http.ResponseWriter, r *http.Request) {
 	err := json.NewEncoder(w).Encode(defs.TitleStats{
 		PlayerCount: playerCount,
 		BattleCount: battleCount,
@@ -127,11 +111,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
 		return
 	}
-	case "/game/classicsessioncount":
+}
-		w.Write([]byte(strconv.Itoa(classicSessionCount)))
 
-	// /savedata
+func handleGameClassicSessionCount(w http.ResponseWriter, r *http.Request) {
-	case "/savedata/get", "/savedata/update", "/savedata/delete", "/savedata/clear":
+	w.Write([]byte(strconv.Itoa(classicSessionCount)))
+}
+
+func handleSaveData(w http.ResponseWriter, r *http.Request) {
 	uuid, err := getUUIDFromRequest(r)
 	if err != nil {
 		httpError(w, r, err, http.StatusBadRequest)
@@ -158,7 +144,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	var save any
 	// /savedata/get and /savedata/delete specify datatype, but don't expect data in body
-		if r.URL.Path != "/savedata/get" && r.URL.Path != "/savedata/delete" {
+	if r.URL.Path != "/api/savedata/get" && r.URL.Path != "/api/savedata/delete" {
 		if datatype == 0 {
 			var system defs.SystemSaveData
 			err = json.NewDecoder(r.Body).Decode(&system)
@@ -169,7 +155,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 			save = system
 		// /savedata/clear doesn't specify datatype, it is assumed to be 1 (session)
-			} else if datatype == 1 || r.URL.Path == "/savedata/clear" {
+		} else if datatype == 1 || r.URL.Path == "/api/savedata/clear" {
 			var session defs.SessionSaveData
 			err = json.NewDecoder(r.Body).Decode(&session)
 			if err != nil {
@@ -182,13 +168,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	switch r.URL.Path {
-		case "/savedata/get":
+	case "/api/savedata/get":
 		save, err = savedata.Get(uuid, datatype, slot)
-		case "/savedata/update":
+	case "/api/savedata/update":
 		err = savedata.Update(uuid, slot, save)
-		case "/savedata/delete":
+	case "/api/savedata/delete":
 		err = savedata.Delete(uuid, datatype, slot)
-		case "/savedata/clear":
+	case "/api/savedata/clear":
 		s, ok := save.(defs.SessionSaveData)
 		if !ok {
 			httpError(w, r, fmt.Errorf("save data is not type SessionSaveData"), http.StatusBadRequest)
@@ -203,7 +189,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-		if save == nil || r.URL.Path == "/savedata/update" {
+	if save == nil || r.URL.Path == "/api/savedata/update" {
 		w.WriteHeader(http.StatusOK)
 		return
 	}
@@ -213,11 +199,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
 		return
 	}
+}
 
-	// /daily
+func handleDailySeed(w http.ResponseWriter, r *http.Request) {
-	case "/daily/seed":
 	w.Write([]byte(daily.Seed()))
-	case "/daily/rankings":
+}
+
+func handleDailyRankings(w http.ResponseWriter, r *http.Request) {
 	uuid, err := getUUIDFromRequest(r)
 	if err != nil {
 		httpError(w, r, err, http.StatusBadRequest)
@@ -253,7 +241,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
 		return
 	}
-	case "/daily/rankingpagecount":
+}
+
+func handleDailyRankingPageCount(w http.ResponseWriter, r *http.Request) {
 	var category int
 	if r.URL.Query().Has("category") {
 		var err error
@@ -271,7 +261,6 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	w.Write([]byte(strconv.Itoa(count)))
 }
-}
 
 func httpError(w http.ResponseWriter, r *http.Request, err error, code int) {
 	log.Printf("%s: %s\n", r.URL.Path, err)

pokerogue-server.go

@@ -4,12 +4,7 @@ import (
 	"encoding/gob"
 	"flag"
 	"log"
-	"net"
 	"net/http"
-	"os"
-	"os/signal"
-	"sync"
-	"syscall"
 
 	"github.com/pagefaultgames/pokerogue-server/api"
 	"github.com/pagefaultgames/pokerogue-server/db"
@@ -17,10 +12,10 @@ import (
 
 func main() {
 	// flag stuff
-	debug := flag.Bool("debug", false, "debug mode")
+	addr := flag.String("addr", "0.0.0.0:80", "network address for api to listen on")
-
+	wwwpath := flag.String("wwwpath", "www", "path to static content to serve")
-	proto := flag.String("proto", "tcp", "protocol for api to use (tcp, unix)")
+	tlscert := flag.String("tlscert", "", "path to tls certificate to use for https")
-	addr := flag.String("addr", "0.0.0.0", "network address for api to listen on")
+	tlskey := flag.String("tlskey", "", "path to tls private key to use for https")
 
 	dbuser := flag.String("dbuser", "pokerogue", "database username")
 	dbpass := flag.String("dbpass", "", "database password")
@@ -30,7 +25,6 @@ func main() {
 
 	flag.Parse()
 
-
 	// register gob types
 	gob.Register([]interface{}{})
 	gob.Register(map[string]interface{}{})
@@ -41,55 +35,19 @@ func main() {
 		log.Fatalf("failed to initialize database: %s", err)
 	}
 
-	// create listener
-	listener, err := createListener(*proto, *addr)
-	if err != nil {
-		log.Fatalf("failed to create net listener: %s", err)
-	}
-
-	// create exit handler
-	var exit sync.RWMutex
-	createExitHandler(&exit)
-
-	// init api
-	api.Init()
-
 	// start web server
-	err = http.Serve(listener, &api.Server{Debug: *debug, Exit: &exit})
+	mux := http.NewServeMux()
+
+	api.Init(mux)
+
+	mux.Handle("/", http.FileServer(http.Dir(*wwwpath)))
+	
+	if *tlscert != "" && *tlskey != "" {
+		err = http.ListenAndServeTLS(*addr, *tlscert, *tlskey, mux)
+	} else {
+		err = http.ListenAndServe(*addr, mux)
+	}
 	if err != nil {
 		log.Fatalf("failed to create http server or server errored: %s", err)
 	}
 }
-
-func createListener(proto, addr string) (net.Listener, error) {
-	if proto == "unix" {
-		os.Remove(addr)
-	}
-
-	listener, err := net.Listen(proto, addr)
-	if err != nil {
-		return nil, err
-	}
-
-	if proto == "unix" {
-		os.Chmod(addr, 0777)
-	}
-
-	return listener, nil
-}
-
-func createExitHandler(mtx *sync.RWMutex) {
-	s := make(chan os.Signal, 1)
-	signal.Notify(s, syscall.SIGINT, syscall.SIGTERM)
-
-	go func() {
-		// wait for exit signal of some kind
-		<-s
-
-		// block new requests and wait for existing ones to finish
-		mtx.Lock()
-
-		// bail
-		os.Exit(0)
-	}()
-}