make use of AppX and CoreState in program modules

2026-01-05 13:32:26 +00:00 · 2025-07-29 17:54:57 +03:00
parent 92c89996f5
commit 74f166e6cf
9 changed files with 74 additions and 83 deletions
--- a/internal/server/gateway/general_types.go
+++ b/internal/server/gateway/general_types.go
@@ -1,10 +1,10 @@
 package gateway

 import (
-	"log/slog"
 	"net/http"

-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
 	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
 )

@@ -22,6 +22,6 @@ type GatewayServer struct {
 	// The key is the version string, and the value is the server implementing GeneralServerApi
 	servers map[serversApiVer]ServerApiContract

-	log *slog.Logger
-	cfg *config.Conf
+	cs *corestate.CoreState
+	x  *app.AppX
 }
--- a/internal/server/gateway/init.go
+++ b/internal/server/gateway/init.go
@@ -2,23 +2,23 @@ package gateway

 import (
 	"errors"
-	"log/slog"

-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
 )

 // GeneralServerInit structure only for initialization general server.
 type GatewayServerInit struct {
-	Log    *slog.Logger
-	Config *config.Conf
+	CS *corestate.CoreState
+	X  *app.AppX
 }

 // InitGeneral initializes a new GeneralServer with the provided configuration and registered servers.
 func InitGateway(o *GatewayServerInit, servers ...ServerApiContract) *GatewayServer {
 	general := &GatewayServer{
 		servers: make(map[serversApiVer]ServerApiContract),
-		cfg:     o.Config,
-		log:     o.Log,
+		cs:      o.CS,
+		x:       o.X,
 	}

 	// register the provided servers
--- a/internal/server/gateway/route.go
+++ b/internal/server/gateway/route.go
@@ -24,7 +24,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 				"message": rpc.ErrInternalErrorS,
 			},
 		})
-		gs.log.Info("invalid request received", slog.String("issue", rpc.ErrInternalErrorS))
+		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInternalErrorS))
 		return
 	}

@@ -43,7 +43,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 					"message": rpc.ErrParseErrorS,
 				},
 			})
-			gs.log.Info("invalid request received", slog.String("issue", rpc.ErrParseErrorS))
+			gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrParseErrorS))
 			return
 		}
 		resp := gs.Route(r, &single)
@@ -78,17 +78,17 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {

 func (gs *GatewayServer) Route(r *http.Request, req *rpc.RPCRequest) (resp *rpc.RPCResponse) {
 	defer utils.CatchPanicWithFallback(func(rec any) {
-		gs.log.Error("panic caught in handler", slog.Any("error", rec))
+		gs.x.SLog.Error("panic caught in handler", slog.Any("error", rec))
 		resp = rpc.NewError(rpc.ErrInternalError, "Internal server error (panic)", req.ID)
 	})
 	if req.JSONRPC != rpc.JSONRPCVersion {
-		gs.log.Info("invalid request received", slog.String("issue", rpc.ErrInvalidRequestS), slog.String("requested-version", req.JSONRPC))
+		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidRequestS), slog.String("requested-version", req.JSONRPC))
 		return rpc.NewError(rpc.ErrInvalidRequest, rpc.ErrInvalidRequestS, req.ID)
 	}

 	server, ok := gs.servers[serversApiVer(req.ContextVersion)]
 	if !ok {
-		gs.log.Info("invalid request received", slog.String("issue", rpc.ErrContextVersionS), slog.String("requested-version", req.ContextVersion))
+		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrContextVersionS), slog.String("requested-version", req.ContextVersion))
 		return rpc.NewError(rpc.ErrContextVersion, rpc.ErrContextVersionS, req.ID)
 	}

--- a/internal/server/sv1/handle.go
+++ b/internal/server/sv1/handle.go
@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strconv"

 	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
 	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
@@ -13,17 +14,17 @@ import (

 func (h *HandlerV1) Handle(r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse {
 	if req.Method == "" {
-		h.log.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
+		h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
 		return rpc.NewError(rpc.ErrMethodIsMissing, rpc.ErrMethodIsMissingS, req.ID)
 	}

 	method, err := h.resolveMethodPath(req.Method)
 	if err != nil {
 		if err.Error() == rpc.ErrInvalidMethodFormatS {
-			h.log.Info("invalid request received", slog.String("issue", rpc.ErrInvalidMethodFormatS), slog.String("requested-method", req.Method))
+			h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidMethodFormatS), slog.String("requested-method", req.Method))
 			return rpc.NewError(rpc.ErrInvalidMethodFormat, rpc.ErrInvalidMethodFormatS, req.ID)
 		} else if err.Error() == rpc.ErrMethodNotFoundS {
-			h.log.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
+			h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
 			return rpc.NewError(rpc.ErrMethodNotFound, rpc.ErrMethodNotFoundS, req.ID)
 		}
 	}
@@ -37,7 +38,7 @@ func (h *HandlerV1) HandleLUA(path string, req *rpc.RPCRequest) *rpc.RPCResponse

 	inTable := L.NewTable()
 	paramsTable := L.NewTable()
-	if fetchedParams, ok := req.Params.(map[string]interface{}); ok {
+	if fetchedParams, ok := req.Params.(map[string]any); ok {
 		for k, v := range fetchedParams {
 			L.SetField(paramsTable, k, utils.ConvertGolangTypesToLua(L, v))
 		}
@@ -50,7 +51,7 @@ func (h *HandlerV1) HandleLUA(path string, req *rpc.RPCRequest) *rpc.RPCResponse
 	L.SetField(outTable, "Result", resultTable)
 	L.SetGlobal("Out", outTable)

-	prep := filepath.Join(h.cfg.ComDir, "_prepare.lua")
+	prep := filepath.Join(h.x.Config.Conf.ComDir, "_prepare.lua")
 	if _, err := os.Stat(prep); err == nil {
 		if err := L.DoFile(prep); err != nil {
 			return rpc.NewError(rpc.ErrInternalError, err.Error(), req.ID)
@@ -77,6 +78,7 @@ func (h *HandlerV1) HandleLUA(path string, req *rpc.RPCRequest) *rpc.RPCResponse
 			if msg := errTbl.RawGetString("message"); msg.Type() == lua.LTString {
 				message = msg.String()
 			}
+			h.x.SLog.Error("the script terminated with an error", slog.String("code", strconv.Itoa(code)), slog.String("message", message))
 			return rpc.NewError(code, message, req.ID)
 		}
 		return rpc.NewError(rpc.ErrInternalError, "Out.Error is not a table", req.ID)
@@ -93,5 +95,7 @@ func (h *HandlerV1) HandleLUA(path string, req *rpc.RPCRequest) *rpc.RPCResponse
 	resultTbl.ForEach(func(key lua.LValue, value lua.LValue) {
 		out[key.String()] = utils.ConvertLuaTypesToGolang(value)
 	})
+
+	out["responsible-node"] = h.cs.UUID32
 	return rpc.NewResponse(out, req.ID)
 }
--- a/internal/server/sv1/path.go
+++ b/internal/server/sv1/path.go
@@ -16,7 +16,7 @@ func (h *HandlerV1) resolveMethodPath(method string) (string, error) {

 	parts := strings.Split(method, ">")
 	relPath := filepath.Join(parts...) + ".lua"
-	fullPath := filepath.Join(h.cfg.ComDir, relPath)
+	fullPath := filepath.Join(h.x.Config.Conf.ComDir, relPath)

 	if _, err := os.Stat(fullPath); os.IsNotExist(err) {
 		return "", errors.New(rpc.ErrMethodNotFoundS)
--- a/internal/server/sv1/server.go
+++ b/internal/server/sv1/server.go
@@ -3,26 +3,24 @@
 package sv1

 import (
-	"log/slog"
 	"regexp"

-	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
 )

 // HandlerV1InitStruct structure is only for initialization
 type HandlerV1InitStruct struct {
-	Ver            string
-	Log            slog.Logger
-	Config         *config.Conf
-	AllowedCmd     *regexp.Regexp
-	ListAllowedCmd *regexp.Regexp
+	Ver        string
+	CS         *corestate.CoreState
+	X          *app.AppX
+	AllowedCmd *regexp.Regexp
 }

 // HandlerV1 implements the ServerV1UtilsContract and serves as the main handler for API requests.
 type HandlerV1 struct {
-	log *slog.Logger
-
-	cfg *config.Conf
+	cs *corestate.CoreState
+	x  *app.AppX

 	// allowedCmd and listAllowedCmd are regular expressions used to validate command names.
 	allowedCmd *regexp.Regexp
@@ -35,8 +33,8 @@ type HandlerV1 struct {
 // because there is no validation of parameters in this function.
 func InitV1Server(o *HandlerV1InitStruct) *HandlerV1 {
 	return &HandlerV1{
-		log:        &o.Log,
-		cfg:        o.Config,
+		cs:         o.CS,
+		x:          o.X,
 		allowedCmd: o.AllowedCmd,
 		ver:        o.Ver,
 	}