222 lines
7.3 KiB
Go
222 lines
7.3 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
|
|
"git.send.nrw/sendnrw/raccws/racc_common"
|
|
"git.send.nrw/sendnrw/raccws/racc_filebrowser"
|
|
"git.send.nrw/sendnrw/raccws/racc_httpstatus"
|
|
"git.send.nrw/sendnrw/raccws/racc_logging"
|
|
"git.send.nrw/sendnrw/raccws/racc_middleware"
|
|
"git.send.nrw/sendnrw/raccws/racc_session"
|
|
"git.send.nrw/sendnrw/raccws/racc_sysauth"
|
|
"git.send.nrw/sendnrw/raccws/racc_template"
|
|
)
|
|
|
|
var DefaultAppPath string = "/"
|
|
var DefaultLogNumber int = 500
|
|
|
|
var CORE_SESSIONFILE string = "serversessions.json"
|
|
var CORE_SERVERLOG string = "serverlog.json"
|
|
var CORE_RELPATH string = "./"
|
|
|
|
func DefaultRoute(w http.ResponseWriter, r *http.Request) {
|
|
//fmt.Println(r.URL.Path)
|
|
if r.URL.Path == "/" {
|
|
http.Redirect(w, r, DefaultAppPath, http.StatusMovedPermanently)
|
|
}
|
|
fileInfo, err := os.Stat(CORE_RELPATH + r.URL.Path)
|
|
if os.IsNotExist(err) {
|
|
racc_httpstatus.Default404(w, r)
|
|
return
|
|
}
|
|
if !fileInfo.IsDir() {
|
|
http.ServeFile(w, r, CORE_RELPATH+r.URL.Path)
|
|
return
|
|
} else {
|
|
racc_httpstatus.Default404(w, r)
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
func prepareExit() {
|
|
fmt.Println("Running exit tasks...")
|
|
// Hier können Sie Ihre Aufräumarbeiten ausführen
|
|
SaveFile(CORE_SESSIONFILE, &racc_session.SessionStore)
|
|
SaveFile(CORE_SERVERLOG, racc_logging.GetLastXitems(DefaultLogNumber))
|
|
fmt.Println("Exit completed.")
|
|
}
|
|
|
|
func main() {
|
|
/* */
|
|
//app_adinfo.MakeDefault()
|
|
/* */
|
|
/*server_port := flag.String("port", "8080", "Port to be used for http server")
|
|
server_mode := flag.String("mode", "http", "Security mode the server should run (http/https)")
|
|
server_tls_key := flag.String("key", "private.key", "Private key file")
|
|
server_tls_cert := flag.String("cert", "public.crt", "Public cert file")
|
|
flag.Parse()*/
|
|
|
|
HTTP_PORT := racc_common.GetENV("HTTP_PORT", "8080")
|
|
HTTP_TLS := racc_common.GetENV("HTTP_TLS", "0")
|
|
HTTP_TLS_PRIVATEKEY := racc_common.GetENV("HTTP_TLS_PRIVATEKEY", "")
|
|
HTTP_TLS_CERTIFICATE := racc_common.GetENV("HTTP_TLS_CERTIFICATE", "")
|
|
|
|
CORE_SESSIONFILE = racc_common.GetENV("CORE_SESSIONFILE", "serversessions.json")
|
|
CORE_SERVERLOG = racc_common.GetENV("CORE_SERVERLOG", "serverlog.json")
|
|
CORE_RELPATH = racc_common.GetENV("CORE_RELPATH", "./")
|
|
|
|
/* Print actual settings */
|
|
fmt.Println("----------")
|
|
fmt.Println("Service configured with settings:")
|
|
fmt.Println("----------")
|
|
fmt.Println("HTTP-PORT: "+HTTP_PORT, "HTTP_TLS: "+HTTP_TLS, "HTTP_TLS_PRIVATEKEY: "+HTTP_TLS_PRIVATEKEY, "HTTP_TLS_CERTIFICATE: "+HTTP_TLS_CERTIFICATE)
|
|
fmt.Println("CORE_SESSIONFILE: "+CORE_SESSIONFILE, "CORE_SERVERLOG: "+CORE_SERVERLOG, "CORE_RELPATH: "+CORE_RELPATH)
|
|
fmt.Println("----------")
|
|
|
|
// Signal-Kanal einrichten
|
|
stop := make(chan os.Signal, 1)
|
|
signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
|
|
|
|
// Goroutine, die auf Signale wartet
|
|
go func() {
|
|
<-stop
|
|
fmt.Println("Received stop signal")
|
|
prepareExit()
|
|
os.Exit(0)
|
|
}()
|
|
|
|
// Hauptprogramm
|
|
fmt.Println("Program is running. Press Ctrl+C to exit.")
|
|
|
|
/* Load Infrastructure */
|
|
/* Load Server-Log */
|
|
LoadFile(CORE_SERVERLOG, &racc_logging.LogBook)
|
|
/* Load Session-Data */
|
|
LoadFile(CORE_SESSIONFILE, &racc_session.SessionStore)
|
|
|
|
/* Router-Definition */
|
|
mainRouter := http.NewServeMux()
|
|
defaultRouter := http.NewServeMux()
|
|
apiRouter := http.NewServeMux()
|
|
portalRouter := http.NewServeMux()
|
|
//adminRouter := http.NewServeMux()
|
|
userRouter := http.NewServeMux()
|
|
|
|
/* Main-Router-Middleware */
|
|
mainMiddlewareStack := racc_middleware.CreateStack(
|
|
racc_session.SessionMiddleware,
|
|
)
|
|
|
|
/* Admin-Router-Middleware */
|
|
defaultMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
|
|
apiMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging, racc_sysauth.BearerAuthMiddleware("auth_bearer.json"))
|
|
portalMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging, racc_template.RenderApplicationTemplate("html-templates/application_1.html", nil))
|
|
//adminMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging, racc_sysauth.BasicAuthMiddleware("auth_basic_admin.json"))
|
|
userMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
|
|
//appDemoMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
|
|
appFileMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
|
|
//appDynDNSMiddlewareStack := racc_middleware.CreateStack(racc_logging.Logging)
|
|
|
|
/* Main-Router-Routen */
|
|
mainRouter.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
|
|
mainRouter.Handle("/api/", apiMiddlewareStack(http.StripPrefix("/api", apiRouter)))
|
|
mainRouter.Handle("/portal/", portalMiddlewareStack(http.StripPrefix("/portal", portalRouter)))
|
|
//mainRouter.Handle("/admin/", adminMiddlewareStack(http.StripPrefix("/admin", app_admin.Main())))
|
|
mainRouter.Handle("/user/", userMiddlewareStack(http.StripPrefix("/user", userRouter)))
|
|
//mainRouter.Handle("/demo/", appDemoMiddlewareStack(http.StripPrefix("/demo", app_demo.Main())))
|
|
mainRouter.Handle("/files/", appFileMiddlewareStack(http.StripPrefix("/files", racc_filebrowser.Router())))
|
|
//mainRouter.Handle("/dns/", appDynDNSMiddlewareStack(http.StripPrefix("/dns", app_dyndns.Main())))
|
|
|
|
/* Default-Route (Should stay here forever) */
|
|
mainRouter.Handle("/", defaultMiddlewareStack(http.StripPrefix("", defaultRouter)))
|
|
defaultRouter.HandleFunc("/", DefaultRoute)
|
|
|
|
/* Sub-Router-Routen */
|
|
//adminRouter.HandleFunc("/sessions", app_admin.adminSessionHandler)
|
|
apiRouter.HandleFunc("/", HttpSaveFile(CORE_SERVERLOG, &racc_logging.LogBook))
|
|
/* */
|
|
server := http.Server{
|
|
Addr: ":" + HTTP_PORT,
|
|
Handler: mainMiddlewareStack(mainRouter),
|
|
}
|
|
|
|
/* */
|
|
fmt.Println("Server listening on port :" + HTTP_PORT)
|
|
if HTTP_TLS == "0" {
|
|
fmt.Println("Protocol is http (insecure)")
|
|
StopServer(server.ListenAndServe())
|
|
}
|
|
if HTTP_TLS == "1" {
|
|
fmt.Println("Protocol is https (secure)")
|
|
StopServer(server.ListenAndServeTLS(HTTP_TLS_CERTIFICATE, HTTP_TLS_PRIVATEKEY))
|
|
}
|
|
|
|
}
|
|
|
|
func StopServer(e error) {
|
|
fmt.Println("Stopping server...")
|
|
prepareExit()
|
|
fmt.Println("Server stopped!")
|
|
}
|
|
|
|
func HttpSaveFile(xfile string, a any) racc_httpstatus.App {
|
|
return func(next_w http.ResponseWriter, next_r *http.Request) {
|
|
file, _ := os.Create(xfile)
|
|
encoder := json.NewEncoder(file)
|
|
err := encoder.Encode(a)
|
|
if err != nil {
|
|
fmt.Println("Error encoding JSON:", err)
|
|
}
|
|
file.Close()
|
|
}
|
|
}
|
|
|
|
func SaveFile(xfile string, a any) {
|
|
file, _ := os.Create(xfile)
|
|
encoder := json.NewEncoder(file)
|
|
err := encoder.Encode(a)
|
|
if err != nil {
|
|
fmt.Println("Error encoding JSON:", err)
|
|
}
|
|
file.Close()
|
|
fmt.Println("Saved content to: ", xfile)
|
|
}
|
|
|
|
func HttpLoadFile(xfile string, a any) racc_httpstatus.App {
|
|
return func(next_w http.ResponseWriter, next_r *http.Request) {
|
|
if _, err := os.Stat(xfile); os.IsNotExist(err) {
|
|
fmt.Println("Speicherdatei nicht gefunden, neue Map wird erstellt")
|
|
} else {
|
|
file, _ := os.Open(xfile)
|
|
decoder := json.NewDecoder(file)
|
|
err := decoder.Decode(a)
|
|
if err != nil {
|
|
fmt.Println("Fehler in JSON-Datei:", err)
|
|
}
|
|
file.Close()
|
|
}
|
|
}
|
|
}
|
|
|
|
func LoadFile(xfile string, a any) {
|
|
if _, err := os.Stat(xfile); os.IsNotExist(err) {
|
|
fmt.Println("Speicherdatei nicht gefunden, neue Map wird erstellt")
|
|
} else {
|
|
file, _ := os.Open(xfile)
|
|
decoder := json.NewDecoder(file)
|
|
err := decoder.Decode(a)
|
|
if err != nil {
|
|
fmt.Println("Fehler in JSON-Datei:", err)
|
|
}
|
|
file.Close()
|
|
}
|
|
fmt.Println("Loaded content from: ", xfile)
|
|
}
|