rui_orig/appServer.go

487 lines
9.7 KiB
Go
Raw Normal View History

2022-10-27 16:14:30 +03:00
//go:build !wasm
package rui
import (
"context"
_ "embed"
"fmt"
"io"
"log"
"math/rand"
"net/http"
"os/exec"
"runtime"
2026-07-28 12:26:03 +03:00
"slices"
2022-10-27 16:14:30 +03:00
"strconv"
"strings"
"time"
2024-06-11 15:03:13 +03:00
"golang.org/x/crypto/acme/autocert"
2022-10-27 16:14:30 +03:00
)
//go:embed app_socket.js
var socketScripts string
2024-03-12 19:32:22 +03:00
//go:embed app_post.js
var httpPostScripts string
2022-11-09 13:40:08 +03:00
func debugLog(text string) {
log.Println("\033[34m" + text)
}
func errorLog(text string) {
log.Println("\033[31m" + text)
}
2024-03-12 19:32:22 +03:00
type sessionInfo struct {
session Session
response chan string
}
2022-10-27 16:14:30 +03:00
type application struct {
server *http.Server
params AppParams
createContentFunc func(Session) SessionContent
2024-03-12 19:32:22 +03:00
sessions map[int]sessionInfo
2026-07-28 12:26:03 +03:00
usedSessionIds []int
2022-10-27 16:14:30 +03:00
}
func (app *application) getStartPage() string {
buffer := allocStringBuilder()
defer freeStringBuilder(buffer)
buffer.WriteString("<!DOCTYPE html>\n<html>\n")
2026-07-28 12:26:03 +03:00
getStartPage(buffer, app.nextSessionID(), app.params)
2022-10-27 16:14:30 +03:00
buffer.WriteString("\n</html>")
return buffer.String()
}
func (app *application) Params() AppParams {
params := app.params
if params.NoSocket {
params.SocketAutoClose = 0
}
return params
}
2022-10-27 16:14:30 +03:00
func (app *application) Finish() {
for _, session := range app.sessions {
2024-03-12 19:32:22 +03:00
session.session.close()
if session.response != nil {
close(session.response)
session.response = nil
}
2022-10-27 16:14:30 +03:00
}
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := app.server.Shutdown(ctx); err != nil {
log.Println(err.Error())
}
}
2026-07-28 12:26:03 +03:00
func (app *application) getCreateContentFunc() func(Session) SessionContent {
return app.createContentFunc
}
2022-10-27 16:14:30 +03:00
func (app *application) nextSessionID() int {
2026-07-28 12:26:03 +03:00
if app.usedSessionIds == nil {
app.usedSessionIds = []int{}
}
for {
n := rand.Intn(0x7FFFFFFE) + 1
if !slices.Contains(app.usedSessionIds, n) {
app.usedSessionIds = append(app.usedSessionIds, n)
slices.Sort(app.usedSessionIds)
return n
}
2022-10-27 16:14:30 +03:00
}
}
func (app *application) removeSession(id int) {
2024-03-12 19:32:22 +03:00
if info, ok := app.sessions[id]; ok {
if info.response != nil {
close(info.response)
}
delete(app.sessions, id)
}
2022-10-27 16:14:30 +03:00
}
func (app *application) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if ProtocolInDebugLog {
DebugLogF("%s %s", req.Method, req.URL.Path)
}
switch req.Method {
2025-08-06 16:02:39 +03:00
case http.MethodPost:
2024-03-12 19:32:22 +03:00
if req.URL.Path == "/" {
app.postHandler(w, req)
}
2025-08-06 16:02:39 +03:00
case http.MethodGet:
2022-10-27 16:14:30 +03:00
switch req.URL.Path {
case "/":
w.WriteHeader(http.StatusOK)
io.WriteString(w, app.getStartPage())
2026-08-06 16:52:19 +03:00
case "/e":
app.sseHandler(w, req)
2022-10-27 16:14:30 +03:00
case "/ws":
2024-03-12 19:32:22 +03:00
if bridge := createSocketBridge(w, req); bridge != nil {
2022-11-02 21:05:55 +03:00
go app.socketReader(bridge)
2022-10-27 16:14:30 +03:00
}
2024-03-12 19:32:22 +03:00
case "/script.js":
w.WriteHeader(http.StatusOK)
if app.params.NoSocket {
io.WriteString(w, httpPostScripts)
} else {
io.WriteString(w, socketScripts)
}
io.WriteString(w, "\n")
io.WriteString(w, defaultScripts)
2022-10-27 16:14:30 +03:00
default:
filename := req.URL.Path[1:]
if size := len(filename); size > 0 && filename[size-1] == '/' {
filename = filename[:size-1]
}
if !serveResourceFile(filename, w, req) &&
!serveDownloadFile(filename, w, req) {
w.WriteHeader(http.StatusNotFound)
}
}
}
}
2026-08-06 16:52:19 +03:00
/*
2024-03-12 19:32:22 +03:00
func setSessionIDCookie(w http.ResponseWriter, sessionID int) {
cookie := http.Cookie{
Name: "session",
Value: strconv.Itoa(sessionID),
HttpOnly: true,
}
http.SetCookie(w, &cookie)
}
2026-07-22 18:47:24 +03:00
func getSessionIDCookie(req *http.Request) (int, error) {
cookie, err := req.Cookie("session")
if err != nil {
return 0, err
}
return strconv.Atoi(cookie.Value)
}
2026-08-06 16:52:19 +03:00
*/
2026-07-22 18:47:24 +03:00
2024-03-12 19:32:22 +03:00
func (app *application) postHandler(w http.ResponseWriter, req *http.Request) {
2026-07-28 12:26:03 +03:00
reqBody, err := io.ReadAll(req.Body)
if err != nil {
ErrorLog(err.Error())
return
}
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
message := string(reqBody)
if ProtocolInDebugLog {
DebugLog(message)
}
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
obj, err := ParseDataText(message)
if err != nil {
ErrorLog(err.Error())
return
}
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
sessionID, ok := getSessionID(obj)
if !ok {
return
}
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
var session Session = nil
var response chan string = nil
if info, ok := app.sessions[sessionID]; ok && info.response != nil {
response = info.response
session = info.session
}
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
command := obj.Tag()
2024-03-12 19:32:22 +03:00
2026-08-06 16:52:19 +03:00
if session == nil {
if command != "start-session" {
io.WriteString(w, "reloadPage();")
return
}
2026-07-28 12:26:03 +03:00
events := make(chan DataObject, 1024)
bridge := createHttpBridge(req)
response = bridge.response
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
session = app.createSession(obj, events, bridge, response)
if session == nil {
return
}
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
go sessionEventHandler(session, events, bridge)
}
2024-03-13 15:01:02 +03:00
2026-07-28 12:26:03 +03:00
switch command {
2026-07-28 12:26:03 +03:00
case "session-close":
session.onFinish()
session.App().removeSession(session.ID())
return
2026-08-06 16:52:19 +03:00
case "nop":
if len(response) == 0 {
session.addToEventsQueue(obj)
}
2026-07-28 12:26:03 +03:00
default:
if !session.handleAnswer(command, obj) {
session.addToEventsQueue(obj)
2026-08-06 16:52:19 +03:00
} else {
io.WriteString(w, "sendNop();")
}
2026-07-28 12:26:03 +03:00
}
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
io.WriteString(w, <-response)
for len(response) > 0 {
io.WriteString(w, <-response)
2024-03-12 19:32:22 +03:00
}
}
2026-08-06 16:52:19 +03:00
func (app *application) sseHandler(w http.ResponseWriter, req *http.Request) {
/*
sessionID, err := strconv.Atoi(req.URL.Query().Get("id"))
if err != nil {
ErrorLog("SessionID error: " + err.Error())
return
}
if sessionInfo, ok := app.sessions[sessionID]; ok {
}
*/
}
2026-07-28 12:26:03 +03:00
func getSessionID(obj DataObject) (int, bool) {
sessionText, ok := obj.PropertyValue("session")
if !ok {
ErrorLog(`"session" key not found`)
return 0, false
}
sessionID, err := strconv.Atoi(sessionText)
if err != nil {
ErrorLog(`"session" key text strconv.Atoi error: ` + err.Error())
return 0, false
}
return sessionID, true
}
2024-03-12 19:32:22 +03:00
func (app *application) socketReader(bridge *wsBridge) {
2022-10-27 16:14:30 +03:00
var session Session
events := make(chan DataObject, 1024)
for {
2022-11-02 21:05:55 +03:00
message, ok := bridge.readMessage()
2022-10-27 16:14:30 +03:00
if !ok {
events <- NewDataObject("disconnect")
return
}
if ProtocolInDebugLog {
2026-05-29 16:07:48 +03:00
DebugLog("🖥️ → " + message)
2022-10-27 16:14:30 +03:00
}
obj, err := ParseDataText(message)
if err != nil {
ErrorLog(err.Error())
2026-08-06 16:52:19 +03:00
continue
}
switch command := obj.Tag(); command {
2026-08-06 16:52:19 +03:00
case "start-session":
2026-07-28 12:26:03 +03:00
if session = app.createSession(obj, events, bridge, nil); session != nil {
go sessionEventHandler(session, events, bridge)
2026-08-06 16:52:19 +03:00
events <- obj
}
case "reconnect":
session = nil
2026-07-28 12:26:03 +03:00
if sessionID, ok := getSessionID(obj); ok {
if info, ok := app.sessions[sessionID]; ok {
session = info.session
session.setBridge(events, bridge)
go sessionEventHandler(session, events, bridge)
session.onReconnect()
2022-10-27 16:14:30 +03:00
} else {
2026-07-28 12:26:03 +03:00
DebugLogF("Session #%d not exists", sessionID)
2022-10-27 16:14:30 +03:00
}
}
2022-10-27 16:14:30 +03:00
if session == nil {
bridge.writeMessage("reloadPage();")
return
}
2022-10-27 16:14:30 +03:00
default:
if !session.handleAnswer(command, obj) {
events <- obj
2022-10-27 16:14:30 +03:00
}
}
}
}
2024-03-12 19:32:22 +03:00
func sessionEventHandler(session Session, events chan DataObject, bridge bridge) {
2022-10-27 16:14:30 +03:00
for {
data := <-events
switch command := data.Tag(); command {
case "disconnect":
2026-08-06 16:52:19 +03:00
session.setBridge(nil, nil)
2022-10-27 16:14:30 +03:00
session.onDisconnect()
return
case "session-close":
session.onFinish()
session.App().removeSession(session.ID())
2022-11-02 21:05:55 +03:00
bridge.close()
2026-07-28 12:26:03 +03:00
return
2022-10-27 16:14:30 +03:00
2026-08-06 16:52:19 +03:00
case "nop":
session.sendResponse()
2022-10-27 16:14:30 +03:00
default:
2026-08-06 16:52:19 +03:00
session.handleEvent(command, data)
2022-10-27 16:14:30 +03:00
}
}
}
2026-07-28 12:26:03 +03:00
func (app *application) createSession(params DataObject, events chan DataObject,
bridge bridge, response chan string) Session {
2024-03-12 19:32:22 +03:00
2026-07-28 12:26:03 +03:00
sessionID, ok := getSessionID(params)
if !ok || app.createContentFunc == nil {
return nil
2022-10-27 16:14:30 +03:00
}
2026-07-28 12:26:03 +03:00
session := newSession(app, sessionID, "", params)
2022-11-02 21:05:55 +03:00
session.setBridge(events, bridge)
2022-10-27 16:14:30 +03:00
2026-07-28 12:26:03 +03:00
app.sessions[sessionID] = sessionInfo{
2024-03-12 19:32:22 +03:00
session: session,
response: response,
}
2022-10-27 16:14:30 +03:00
2026-07-28 12:26:03 +03:00
return session
}
2022-10-27 16:14:30 +03:00
var apps = []*application{}
// StartApp - create the new application and start it
func StartApp(addr string, createContentFunc func(Session) SessionContent, params AppParams) {
2024-05-20 16:51:30 +03:00
resources.scanDefaultResourcePath()
2022-10-27 16:14:30 +03:00
app := new(application)
app.params = params
2024-03-12 19:32:22 +03:00
app.sessions = map[int]sessionInfo{}
2022-10-27 16:14:30 +03:00
app.createContentFunc = createContentFunc
apps = append(apps, app)
redirectAddr := ""
2024-06-11 15:03:13 +03:00
https := params.AutoCertDomain != "" || (params.CertFile != "" && params.KeyFile != "")
2022-10-27 16:14:30 +03:00
if index := strings.IndexRune(addr, ':'); index >= 0 {
redirectAddr = addr[:index] + ":80"
} else {
redirectAddr = addr + ":80"
2024-06-11 15:03:13 +03:00
if https {
2022-10-27 16:14:30 +03:00
addr += ":443"
} else {
addr += ":80"
}
}
serverRun := func(err error) {
if err != nil {
if err == http.ErrServerClosed {
log.Println(err)
} else {
log.Fatal(err)
}
}
}
2024-06-11 15:03:13 +03:00
if https {
2022-10-27 16:14:30 +03:00
if params.Redirect80 {
redirectTLS := func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "https://"+addr+r.RequestURI, http.StatusMovedPermanently)
}
go func() {
serverRun(http.ListenAndServe(redirectAddr, http.HandlerFunc(redirectTLS)))
}()
}
2024-06-11 15:03:13 +03:00
if params.AutoCertDomain != "" {
mux := http.NewServeMux()
mux.Handle("/", app)
serverRun(http.Serve(autocert.NewListener(params.AutoCertDomain), mux))
} else {
app.server = &http.Server{Addr: addr}
http.Handle("/", app)
serverRun(app.server.ListenAndServeTLS(params.CertFile, params.KeyFile))
}
2022-10-27 16:14:30 +03:00
} else {
2024-06-11 15:03:13 +03:00
app.server = &http.Server{Addr: addr}
http.Handle("/", app)
2022-10-27 16:14:30 +03:00
serverRun(app.server.ListenAndServe())
}
}
// FinishApp finishes application
2022-10-27 16:14:30 +03:00
func FinishApp() {
for _, app := range apps {
app.Finish()
}
apps = []*application{}
}
// OpenBrowser open browser with specific URL locally. Useful for applications which run on local machine
// or for debug purposes.
2022-10-27 16:14:30 +03:00
func OpenBrowser(url string) bool {
var err error
switch runtime.GOOS {
case "linux":
for _, provider := range []string{"xdg-open", "x-www-browser", "www-browser"} {
if _, err = exec.LookPath(provider); err == nil {
2024-02-27 17:08:05 +03:00
if err = exec.Command(provider, url).Start(); err == nil {
2022-10-27 16:14:30 +03:00
return true
}
}
}
case "windows":
err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
case "darwin":
err = exec.Command("open", url).Start()
default:
err = fmt.Errorf("unsupported platform")
}
return err != nil
}