모듈 업데이트

This reverts commit e18a5eafe0.

.gitignore

@@ -2,3 +2,4 @@
 __debug_bin.exe
 *.log
 config.json
+tavern.exe

config.json

@@ -1 +1,49 @@
-{}
+{
+    "region_storage": {
+        "default": {
+            "mongo": "mongodb://192.168.8.94:27017/?replicaSet=repl01&retrywrites=false",
+            "redis": {
+                "cache": "redis://192.168.8.94:6380/0",
+                "session": "redis://192.168.8.94:6380/1",
+                "tx": "redis://192.168.8.94:6380/2",
+                "tavern": "redis://192.168.8.94:6380/3",
+                "wshandler": "redis://192.168.8.94:6380/4"
+            }
+        }
+    },
+    "session_storage": "redis://192.168.8.94:6380/3",
+    "session_ttl": 3600,
+        
+    "maingate_session_storage": "redis://192.168.8.94:6380/1",
+    "maingate_session_ttl" : 3600,
+    "maingate_api_token": "63d08aa34f0162622c11284b",
+    
+    "tavern_redis_url": "redis://192.168.8.94:6380/4",
+    "tavern_service_url": "http://localhost/tavern",
+    "tavern_group_types": {
+        "party": {
+            "max_member": 3,
+            "invite_ttl": 30
+        },
+        "chat" : {
+            "default_capacity" : 1000,
+            "channels" : {
+                "bazzar-1" : {
+                    "name" : "FText(bazzar-1)"
+                },
+                "bazzar-2" : {
+                    "name" : "FText(bazzar-2)"
+                },
+                "bazzar-3" : {
+                    "name" : "FText(bazzar-3)"
+                },
+                "bazzar-4" : {
+                    "name" : "FText(bazzar-4)"
+                },
+                "bazzar-5" : {
+                    "name" : "FText(bazzar-5)"
+                }
+            }
+        }
+    }
+}

config_template.json

@@ -11,10 +11,12 @@
             }
         }
     },
-    "maingate_session_storage": "redis://192.168.8.94:6380/1",
-    "maingate_session_ttl" : 3600,
+    "session_storage": "redis://192.168.8.94:6380/5",
+    "session_ttl": 3600,
+        
     "maingate_api_token": "63d08aa34f0162622c11284b",
     
+    "tavern_redis_url": "redis://192.168.8.94:6380/7",
     "tavern_service_url": "http://localhost/tavern",
     "tavern_group_types": {
         "party": {

core/group_chat.go

@@ -1,12 +1,16 @@
 package core
 
 import (
+	"encoding/gob"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/go-redis/redis/v8"
+	"github.com/gorilla/websocket"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 	"repositories.action2quare.com/ayo/gocommon"
 	"repositories.action2quare.com/ayo/gocommon/logger"
 	"repositories.action2quare.com/ayo/gocommon/wshandler"
@@ -17,7 +21,9 @@ type channelConfig struct {
 	Capacity  int64            `json:"capacity"`
 	Size      int64            `json:"size"`
 	Key       string           `json:"key"`
+	Members   map[string]int32 `json:"members"`
 	emptyJson string
+	inoutChan chan string
 }
 
 type chatConfig struct {
@@ -33,6 +39,10 @@ type groupChat struct {
 	sendUpstreamMessage func(msg *wshandler.UpstreamMessage)
 }
 
+func init() {
+	gob.Register(map[string]string{})
+}
+
 func (gc *groupChat) Initialize(tv *Tavern, cfg configDocument) error {
 	rem, _ := json.Marshal(cfg)
 	if err := json.Unmarshal(rem, &gc.chatConfig); err != nil {
@@ -60,7 +70,7 @@ func (gc *groupChat) Initialize(tv *Tavern, cfg configDocument) error {
 
 		jm, _ := json.Marshal(cfg)
 		cfg.emptyJson = fmt.Sprintf("[%s]", string(jm))
-
+		cfg.Members = make(map[string]int32)
 		_, err := gc.rh.JSONSet(name, "$", cfg)
 		if *devflag && err != nil {
 			gc.rh.JSONDel(name, "$")
@@ -70,69 +80,147 @@ func (gc *groupChat) Initialize(tv *Tavern, cfg configDocument) error {
 		if err != nil {
 			return err
 		}
+
+		inoutchan := make(chan string, 10)
+		cfg.inoutChan = inoutchan
+
+		go func(chanid string) {
+			var cur []string
+			tick := time.After(3 * time.Second)
+			for {
+				select {
+				case <-tick:
+					tick = time.After(3 * time.Second)
+					if len(cur) > 0 {
+						gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
+							Target: "#" + chanid,
+							Body:   map[string]any{"inout": cur},
+							Tag:    []string{"ChattingChannelProperties"},
+						})
+						cur = nil
+					}
+
+				case m := <-inoutchan:
+					cur = append(cur, m)
+				}
+			}
+		}(name)
 	}
 
 	return nil
 }
 
-func (gc *groupChat) ClientConnected(ctx wshandler.ApiCallContext) {
-	gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel", map[string]any{})
+func (gc *groupChat) ClientConnected(conn *websocket.Conn, callby *wshandler.Sender) {
 }
 
-func (gc *groupChat) ClientDisconnected(ctx wshandler.ApiCallContext) {
-	docs, _ := gc.rh.JSONGetDocuments(ctx.CallBy.Accid.Hex(), "$.channel")
+func (gc *groupChat) ClientDisconnected(msg string, callby *wshandler.Sender) {
+	if msg == wshandler.ForceShutdownCloseMessage {
+		gc.rh.Del(gc.rh.Context(), "gc-"+callby.Accid.Hex()).Result()
+		return
+	}
 
-	if len(docs) > 0 {
-		for k, v := range docs[0] {
-			typename := k
-			chanid := v.(string)
-			gc.leaveRoom(chanid, ctx.CallBy.Accid)
-			if k == "public" {
-				gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
+	chans, _ := gc.rh.HGetAll(gc.rh.Context(), "gc-"+callby.Accid.Hex()).Result()
+	gc.rh.Del(gc.rh.Context(), "gc-"+callby.Accid.Hex()).Result()
+
+	for typename, chanid := range chans {
+		gc.leaveRoom(chanid, callby.Accid)
+		if typename == "public" {
+			cnt, err := gc.rh.JSONDel(chanid, "$.members."+callby.Alias)
+			if cnt > 0 {
+				if cfg, ok := gc.chatConfig.Channels[chanid]; ok {
+					cfg.inoutChan <- "-" + callby.Alias
+				}
+			} else if err != nil {
+				logger.Println("groupchat ClientDisconnected JSONDel err :", err, callby.Alias)
 			} else {
+				logger.Println("groupchat ClientDisconnected JSONDel cnt 0 :", callby.Alias)
+			}
+		} else {
+			logger.Println("groupchat ClientDisconnected leave private channel :", chanid, callby.Alias)
 			gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
 				Target: "#" + chanid,
-					Body:   map[string]any{"sender": ctx.CallBy.Alias, "typename": typename},
-					Tag:    []string{"LeavePrivateChannel"},
+				Body:   map[string]any{"sender": callby.Alias},
+				Tag:    []string{typename + ".LeavePrivateChannel"},
 			})
 		}
 	}
-	}
 }
 
 func (gc *groupChat) EnterPublicChannel(ctx wshandler.ApiCallContext) {
+	gc.LeavePublicChannel(ctx)
+
 	chanid := ctx.Arguments[0].(string)
-	if cfg, ok := gc.chatConfig.Channels[chanid]; ok {
-		size, err := gc.rh.JSONGetInt64(chanid, "$.size")
-		if err != nil || len(size) == 0 {
-			logger.Println("JSONGetInt64 failed :", chanid, err)
-		} else if size[0] < cfg.Capacity {
-			// 입장
-			newsize, err := gc.rh.JSONNumIncrBy(chanid, "$.size", 1)
-			if err == nil {
+	cfg, ok := gc.chatConfig.Channels[chanid]
+	if !ok {
+		return
+	}
+
+	atomicsize, _ := gc.rh.JSONObjLen(chanid, "$.members")
+	if len(atomicsize) == 0 {
+		return
+	}
+
+	if atomicsize[0] >= cfg.Capacity {
+		logger.Println("chatting channel is full :", chanid, atomicsize[0], cfg.Capacity)
+		return
+	}
+
+	cnt, _ := gc.rh.HSet(gc.rh.Context(), "gc-"+ctx.CallBy.Accid.Hex(), "public", chanid).Result()
+	if cnt == 0 {
+		logger.Println("HSet cnt 0 :", chanid, ctx.CallBy.Alias)
+		return
+	}
+
+	ok, err := gc.rh.JSONSet(chanid, "$.members."+ctx.CallBy.Alias, 1)
+	if err != nil {
+		gc.rh.HDel(gc.rh.Context(), "gc-"+ctx.CallBy.Accid.Hex(), "public").Result()
+		logger.Println("JSONSet $.members failed :", err, chanid, ctx.CallBy.Alias)
+		return
+	}
+
+	if !ok {
+		gc.rh.HDel(gc.rh.Context(), "gc-"+ctx.CallBy.Accid.Hex(), "public").Result()
+		logger.Println("JSONSet $.members not ok :", chanid, ctx.CallBy.Alias)
+		return
+	}
+
 	gc.enterRoom(chanid, ctx.CallBy.Accid)
-				gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel.public", chanid)
+	cfg.inoutChan <- "+" + ctx.CallBy.Alias
+
+	members, _ := gc.rh.JSONGetDocuments(chanid, "$.members")
+	var toarr []string
+	if len(members) > 0 {
+		toarr = make([]string, 0, len(members[0]))
+		for k := range members[0] {
+			toarr = append(toarr, k)
+		}
+	} else {
+		toarr = []string{}
+	}
+
 	gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
-					Target: "#" + chanid,
-					Body:   map[string]any{"size": newsize[0]},
+		Target: ctx.CallBy.Accid.Hex(),
+		Body:   map[string]any{"members": toarr},
 		Tag:    []string{"ChattingChannelProperties"},
 	})
-			}
-		} else {
-			// 풀방
-			logger.Println("chatting channel is full :", chanid, size, cfg.Capacity)
-		}
-	} else {
-		logger.Println("chatting channel not valid :", chanid)
-	}
 }
 
 func (gc *groupChat) LeavePublicChannel(ctx wshandler.ApiCallContext) {
-	chanid := ctx.Arguments[0].(string)
-	cnt, _ := gc.rh.JSONDel(ctx.CallBy.Accid.Hex(), "$.channel.public")
+	oldchan, _ := gc.rh.HGet(gc.rh.Context(), "gc-"+ctx.CallBy.Accid.Hex(), "public").Result()
+	if len(oldchan) > 0 {
+		gc.rh.HDel(gc.rh.Context(), "gc-"+ctx.CallBy.Accid.Hex(), "public")
+
+		cnt, err := gc.rh.JSONDel(oldchan, "$.members."+ctx.CallBy.Alias)
 		if cnt > 0 {
-		gc.leaveRoom(chanid, ctx.CallBy.Accid)
-		gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
+			gc.leaveRoom(oldchan, ctx.CallBy.Accid)
+			if cfg, ok := gc.chatConfig.Channels[oldchan]; ok {
+				cfg.inoutChan <- "-" + ctx.CallBy.Alias
+			}
+		} else if err != nil {
+			logger.Println("groupchat LeavePublicChannel JSONDel err :", err, oldchan, ctx.CallBy.Alias)
+		} else {
+			logger.Println("groupchat LeavePublicChannel JSONDel cnt 0 :", oldchan, ctx.CallBy.Alias)
+		}
 	}
 }
 
@@ -156,15 +244,13 @@ func (gc *groupChat) EnterPrivateChannel(ctx wshandler.ApiCallContext) {
 
 	if len(reason) > 0 {
 		// 수락
-		ok, err := gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel."+typename, channel, gocommon.RedisonSetOptionNX)
+		ok, err := gc.rh.HSetNX(gc.rh.Context(), "gc-"+ctx.CallBy.Accid.Hex(), typename, channel).Result()
 		if err != nil || !ok {
 			// 이미 다른 private channel 참여 중
 			logger.Println("EnterPrivateChannel failed. HSetNX return err :", err, ctx.CallBy.Accid.Hex(), typename, channel)
 			return
 		}
 		gc.enterRoom(channel, ctx.CallBy.Accid)
-	} else {
-		// 내가 이미 private channel에 있다는 것을 다른 사람들에게 알려주기 위함
 	}
 
 	gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
@@ -172,156 +258,33 @@ func (gc *groupChat) EnterPrivateChannel(ctx wshandler.ApiCallContext) {
 		Body: map[string]any{
 			"sender": ctx.CallBy.Alias,
 			"msg":    reason,
-			"typename": typename,
 		},
-		Tag: []string{"EnterPrivateChannel"},
+		Tag: []string{typename + ".EnterPrivateChannel"},
 	})
 }
 
 func (gc *groupChat) LeavePrivateChannel(ctx wshandler.ApiCallContext) {
 	typename := ctx.Arguments[0].(string)
 	chanid := ctx.Arguments[1].(string)
-	cnt, _ := gc.rh.JSONDel(ctx.CallBy.Accid.Hex(), "$.channel."+typename)
+	cnt, _ := gc.rh.HDel(gc.rh.Context(), "gc-"+ctx.CallBy.Accid.Hex(), typename).Result()
 	if cnt > 0 {
 		gc.leaveRoom(chanid, ctx.CallBy.Accid)
 		gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
 			Target: "#" + chanid,
-			Body:   map[string]any{"sender": ctx.CallBy.Alias, "typename": typename},
-			Tag:    []string{"LeavePrivateChannel"},
+			Body:   map[string]any{"sender": ctx.CallBy.Alias},
+			Tag:    []string{typename + ".LeavePrivateChannel"},
 		})
 	}
 }
 
-// func (gc *groupChat) ClientMessageReceived(sender *wshandler.Sender, mt wshandler.WebSocketMessageType, message any) {
-// 	if mt == wshandler.Disconnected {
-// 		if _, err := gc.rh.Del(gc.rh.Context(), accidHex(sender.Accid)).Result(); err != nil {
-// 			logger.Println(err)
-// 		}
-// 	} else if mt == wshandler.BinaryMessage {
-// 		commandline := message.([]any)
-// 		cmd := commandline[0].(string)
-// 		args := commandline[1:]
-// 		switch cmd {
-// 		case "EnterPublicChannel":
-// 			chanid := args[0].(string)
-// 			if cfg, ok := gc.chatConfig.Channels[chanid]; ok {
-// 				size, err := gc.rh.JSONGetInt64(chanid, "$.size")
-// 				if err != nil || len(size) == 0 {
-// 					logger.Println("JSONGetInt64 failed :", chanid, err)
-// 				} else if size[0] < cfg.Capacity {
-// 					// 입장
-// 					newsize, err := gc.rh.JSONNumIncrBy(chanid, "$.size", 1)
-// 					if err == nil {
-// 						gc.enterRoom(chanid, sender.Accid)
-// 						sender.RegistDisconnectedCallback(chanid, func() {
-// 							size, err := gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
-// 							if err == nil {
-// 								gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
-// 									Target: "#" + chanid,
-// 									Body:   map[string]any{"size": size},
-// 									Tag:    []string{"ChattingChannelProperties"},
-// 								})
-// 							}
-// 						})
-
-// 						gc.rh.HSet(gc.rh.Context(), accidHex(sender.Accid), "cc_pub", chanid)
-// 						gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
-// 							Target: "#" + chanid,
-// 							Body:   map[string]any{"size": newsize[0]},
-// 							Tag:    []string{"ChattingChannelProperties"},
-// 						})
-// 					}
-// 				} else {
-// 					// 풀방
-// 					logger.Println("chatting channel is full :", chanid, size, cfg.Capacity)
-// 				}
-// 			} else {
-// 				logger.Println("chatting channel not valid :", chanid)
-// 			}
-
-// 		case "LeavePublicChannel":
-// 			chanid := args[0].(string)
-// 			gc.rh.HDel(gc.rh.Context(), accidHex(sender.Accid), "cc_pub")
-// 			gc.leaveRoom(chanid, sender.Accid)
-// 			if f := sender.PopDisconnectedCallback(chanid); f != nil {
-// 				f()
-// 			}
-
-// 		case "TextMessage":
-// 			chanid := args[0].(string)
-// 			msg := args[1].(string)
-// 			gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
-// 				Target: "#" + chanid,
-// 				Body:   map[string]any{"sender": sender.Alias, "msg": msg},
-// 				Tag:    []string{"TextMessage"},
-// 			})
-
-// 		case "EnterPrivateChannel":
-// 			typename := args[0].(string)
-// 			channel := args[1].(string)
-// 			var reason string
-// 			if len(args) > 2 {
-// 				reason = args[2].(string)
-// 			}
-
-// 			if len(reason) > 0 {
-// 				// 수락
-// 				// 이거 HSet 하면 안되겠는데? JSONSet해야할 듯?
-// 				ok, err := gc.rh.HSetNX(gc.rh.Context(), accidHex(sender.Accid), "cc_"+typename, channel).Result()
-// 				if err != nil || !ok {
-// 					// 이미 다른 private channel 참여 중
-// 					logger.Println("EnterPrivateChannel failed. HSetNX return err :", err, sender.Accid.Hex(), typename, channel)
-// 					return
-// 				}
-// 				gc.enterRoom(channel, sender.Accid)
-
-// 				sender.RegistDisconnectedCallback(channel, func() {
-// 					gc.rh.JSONDel(channel, "$."+sender.Accid.Hex())
-// 					// 이거 HDel 하면 안되겠는데? JSONDel해야할 듯?
-// 					cnt, _ := gc.rh.HDel(gc.rh.Context(), accidHex(sender.Accid), "cc_"+typename).Result()
-// 					if cnt > 0 {
-// 						gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
-// 							Target: "#" + channel,
-// 							Body:   map[string]any{"sender": sender.Alias, "typename": typename},
-// 							Tag:    []string{"LeavePrivateChannel"},
-// 						})
-// 					}
-// 				})
-// 			} else {
-// 				// 내가 이미 private channel에 있다는 것을 다른 사람들에게 알려주기 위함
-// 			}
-
-// 			gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
-// 				Target: "#" + channel,
-// 				Body: map[string]any{
-// 					"sender":   sender.Alias,
-// 					"msg":      reason,
-// 					"typename": typename,
-// 				},
-// 				Tag: []string{"EnterPrivateChannel"},
-// 			})
-
-// 		case "LeavePrivateChannel":
-// 			channel := args[1].(string)
-// 			gc.leaveRoom(channel, sender.Accid)
-// 			if f := sender.PopDisconnectedCallback(channel); f != nil {
-// 				f()
-// 			}
-// 		}
-// 	}
-// }
-
 func (gc *groupChat) FetchChattingChannels(w http.ResponseWriter, r *http.Request) {
-	var data struct {
-		Prefix string `bson:"prefix"`
-	}
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &data); err != nil {
+	var prefix string
+	if err := gocommon.MakeDecoder(r).Decode(&prefix); err != nil {
 		logger.Println("FetchChattingChannels failed. ReadJsonDocumentFromBody returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	prefix := data.Prefix
 	if len(prefix) == 0 {
 		logger.Println("FetchChattingChannel failed. prefix is missing")
 		w.WriteHeader(http.StatusBadRequest)
@@ -346,53 +309,36 @@ func (gc *groupChat) FetchChattingChannels(w http.ResponseWriter, r *http.Reques
 		if err == redis.Nil || onechan == nil {
 			rows = append(rows, cfg.emptyJson)
 		} else {
-			rows = append(rows, onechan.(string))
+			// json array로 나온다
+			rows = append(rows, strings.Trim(onechan.(string), "[]"))
 		}
 	}
 
-	if len(rows) == 0 {
-		w.Write([]byte("[]"))
-	} else if len(rows) == 1 {
-		w.Write([]byte(rows[0]))
-	} else {
-		first := rows[0]
-		w.Write([]byte(first[:len(first)-1]))
-		for i := 1; i < len(rows); i++ {
-			mid := rows[i]
-			w.Write([]byte(","))
-			w.Write([]byte(mid[1 : len(mid)-1]))
-		}
-		w.Write([]byte("]"))
-	}
+	gocommon.MakeEncoder(w, r).Encode(rows)
 }
 
 func (gc *groupChat) QueryPlayerChattingChannel(w http.ResponseWriter, r *http.Request) {
-	var data struct {
-		Accid    string `bson:"accid"`
-		Typename string `bson:"typename"`
-	}
-	err := gocommon.ReadJsonDocumentFromBody(r.Body, &data)
-	if err != nil {
+	var accid primitive.ObjectID
+	if err := gocommon.MakeDecoder(r).Decode(&accid); err != nil {
 		logger.Println("QueryPlayerChattingChannel failed. ReadJsonDocumentFromBody returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	accid := data.Accid
-	sub, err := gc.rh.JSONGetDocuments(accid, "$.channel")
+	sub, err := gc.rh.HGetAll(gc.rh.Context(), "gc-"+accid.Hex()).Result()
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	if len(sub) > 0 {
-		enc := json.NewEncoder(w)
-		enc.Encode(sub[0])
+	if sub == nil {
+		sub = make(map[string]string)
 	}
+	gocommon.MakeEncoder(w, r).Encode(sub)
 }
 
 func (gc *groupChat) SendMessageOnChannel(w http.ResponseWriter, r *http.Request) {
 	var msg wshandler.UpstreamMessage
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &msg); err != nil {
+	if err := gocommon.MakeDecoder(r).Decode(&msg); err != nil {
 		logger.Println("SendMessageOnChannel failed. ReadJsonDocumentFromBody return err :", err)
 		w.WriteHeader(http.StatusBadRequest)
 		return

core/group_instant.go

@@ -0,0 +1,243 @@
+package core
+
+import (
+	"errors"
+	"net/http"
+
+	"repositories.action2quare.com/ayo/gocommon"
+	"repositories.action2quare.com/ayo/gocommon/logger"
+	"repositories.action2quare.com/ayo/gocommon/wshandler"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+type instantDoc struct {
+	Members map[string]primitive.M `json:"_members"`
+	Count   int64                  `json:"_count"`
+	Body    primitive.M            `json:"_body"`
+	Gid     primitive.ObjectID     `json:"_gid"`
+
+	rh    *gocommon.RedisonHandler
+	idstr string
+}
+
+func (gd *instantDoc) strid() string {
+	if len(gd.idstr) == 0 {
+		gd.idstr = gd.Gid.Hex()
+	}
+	return gd.idstr
+}
+
+func (gd *instantDoc) tid(in accountID) string {
+	return makeTid(gd.Gid, in)
+}
+
+var errGroupAlreadyDestroyed = errors.New("instant group is already destroyed")
+
+func (gd *instantDoc) removeMember(mid accountID) error {
+	counts, _ := gd.rh.JSONNumIncrBy(gd.strid(), "$._count", -1)
+	if len(counts) == 0 {
+		// 이미 지워진 인스턴트그룹
+		return errGroupAlreadyDestroyed
+	}
+
+	if _, err := gd.rh.JSONDel(gd.strid(), "$._members."+gd.tid(mid)); err != nil {
+		return err
+	}
+
+	gd.Count = counts[0]
+	return nil
+}
+
+type groupInstant struct {
+	sendUpstreamMessage func(*wshandler.UpstreamMessage)
+	enterRoom           func(groupID, accountID)
+	leaveRoom           func(groupID, accountID)
+	rh                  *gocommon.RedisonHandler
+}
+
+func (gi *groupInstant) Initialize(tv *Tavern) error {
+	gi.rh = tv.redison
+	gi.sendUpstreamMessage = func(msg *wshandler.UpstreamMessage) {
+		tv.wsh.SendUpstreamMessage(msg)
+	}
+	gi.enterRoom = func(gid groupID, accid accountID) {
+		tv.wsh.EnterRoom(gid.Hex(), accid)
+	}
+	gi.leaveRoom = func(gid groupID, accid accountID) {
+		tv.wsh.LeaveRoom(gid.Hex(), accid)
+	}
+
+	return nil
+}
+
+func (gi *groupInstant) UpdateInstantDocument(w http.ResponseWriter, r *http.Request) {
+	var data struct {
+		Gid    primitive.ObjectID
+		Doc    primitive.M
+		Result string
+	}
+	if err := gocommon.MakeDecoder(r).Decode(&data); err != nil {
+		logger.Println("UpdateInstantDocument failed. Decode returns err :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	gd := partyDoc{
+		id: data.Gid,
+		rh: gi.rh,
+	}
+	if err := gi.rh.JSONMSetRel(gd.strid(), "$.", data.Doc); err != nil {
+		logger.Println("UpdateInstantDocument failed. JSONMSetRel returns err :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	// 업데이트 알림
+	gi.sendUpstreamMessage(&wshandler.UpstreamMessage{
+		Target: "#" + gd.strid(),
+		Body:   data.Doc,
+		Tag:    []string{"GroupDocFragment"},
+	})
+
+	if data.Result == "after" {
+		fulldoc := gd.loadFull()
+		if fulldoc != nil {
+			tids := fulldoc["_members"].(map[string]any)
+			mids := make(map[string]any)
+			for k, v := range tids {
+				mid := midFromTid(data.Gid, k)
+				mids[mid.Hex()] = v
+			}
+			fulldoc["_members"] = mids
+		}
+		gocommon.MakeEncoder(w, r).Encode(fulldoc)
+	}
+}
+
+func (gi *groupInstant) Build(w http.ResponseWriter, r *http.Request) {
+	var data struct {
+		Members []struct {
+			Mid       primitive.ObjectID
+			Character primitive.M
+		}
+		Body primitive.M
+	}
+	if err := gocommon.MakeDecoder(r).Decode(&data); err != nil {
+		logger.Println("JoinParty failed. DecodeGob returns err :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	// data.Members가 다 살아있는지 부터 확인
+	var result struct {
+		Gid     primitive.ObjectID // 실패하면 없음
+		Success []primitive.ObjectID
+	}
+	for _, m := range data.Members {
+		count, err := gi.rh.Exists(gi.rh.Context(), m.Mid.Hex()).Result()
+		if err != nil {
+			logger.Println("instant.Build failed. Exists returns err :", err)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+
+		if count != 0 {
+			result.Success = append(result.Success, m.Mid)
+		}
+	}
+
+	if len(result.Success) < len(data.Members) {
+		// 이탈자가 있군
+		// 여기서 중단
+		gocommon.MakeEncoder(w, r).Encode(result)
+		return
+	}
+
+	newid := primitive.NewObjectID()
+	members := make(map[string]primitive.M)
+	for _, m := range data.Members {
+		tid := makeTid(newid, m.Mid)
+		members[tid] = m.Character
+	}
+
+	gd := &instantDoc{
+		Members: members,
+		Body:    data.Body,
+		Count:   int64(len(members)),
+
+		rh:  gi.rh,
+		Gid: newid,
+	}
+
+	_, err := gi.rh.JSONSet(gd.strid(), "$", gd, gocommon.RedisonSetOptionNX)
+	if err != nil {
+		logger.Println("instant.Build failed. JSONSet returns err :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	result.Gid = newid
+	for _, char := range members {
+		delete(char, "_id")
+	}
+
+	// 멤버에 그룹 전체를 알림
+	for _, m := range data.Members {
+		midstr := m.Mid.Hex()
+		gi.rh.JSONSet(midstr, "$.instant", bson.M{"id": gd.strid()})
+		gi.enterRoom(newid, m.Mid)
+		gi.sendUpstreamMessage(&wshandler.UpstreamMessage{
+			Target: midstr,
+			Body:   gd,
+			Tag:    []string{"GroupDocFull"},
+		})
+	}
+
+	gocommon.MakeEncoder(w, r).Encode(result)
+}
+
+func (gi *groupInstant) makeClientClean(accid primitive.ObjectID) {
+	gids, _ := gi.rh.JSONGetString(accid.Hex(), "$.instant.id")
+
+	if len(gids) > 0 && len(gids[0]) > 0 {
+		gidstr := gids[0]
+		gid, _ := primitive.ObjectIDFromHex(gidstr)
+
+		gi.rh.JSONDel(accid.Hex(), "$.instant.id")
+		gi.leaveRoom(gid, accid)
+
+		// gid에는 제거 메시지 보냄
+		gd := instantDoc{
+			Gid: gid,
+			rh:  gi.rh,
+		}
+
+		gi.sendUpstreamMessage(&wshandler.UpstreamMessage{
+			Target: "#" + gd.strid(),
+			Body: bson.M{
+				gd.tid(accid): bson.M{},
+			},
+			Tag: []string{"MemberDocFull"},
+		})
+
+		gd.removeMember(accid)
+		if gd.Count == 0 {
+			gd.rh.Del(gd.rh.Context(), gd.strid()).Result()
+		}
+	}
+}
+
+func (gi *groupInstant) MakeClientClean(w http.ResponseWriter, r *http.Request) {
+	var accid primitive.ObjectID
+	if err := gocommon.MakeDecoder(r).Decode(&accid); err != nil {
+		logger.Println("MakeClientClean failed. decode returns err :", err)
+		return
+	}
+	gi.makeClientClean(accid)
+}
+
+func (gi *groupInstant) ClientDisconnected(msg string, callby *wshandler.Sender) {
+	gi.makeClientClean(callby.Accid)
+}

core/group_party.go

@@ -2,6 +2,7 @@ package core
 
 import (
 	"context"
+	"encoding/gob"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -54,7 +55,7 @@ type memberDoc struct {
 
 type InvitationFail bson.M
 
-type groupDoc struct {
+type partyDoc struct {
 	Members  map[string]any `json:"_members"`
 	InCharge string         `json:"_incharge"`
 	Gid      string         `json:"_gid"`
@@ -63,7 +64,12 @@ type groupDoc struct {
 	id groupID
 }
 
-func (gd *groupDoc) loadMemberFull(tid string) (bson.M, error) {
+func init() {
+	gob.Register(partyDoc{})
+	gob.Register(Invitation{})
+}
+
+func (gd *partyDoc) loadMemberFull(tid string) (bson.M, error) {
 	full, err := gd.rh.JSONGet(gd.strid(), "$._members."+tid)
 	if err != nil {
 		return nil, err
@@ -80,7 +86,7 @@ func (gd *groupDoc) loadMemberFull(tid string) (bson.M, error) {
 	return doc, nil
 }
 
-func (gd *groupDoc) loadFull() (doc bson.M) {
+func (gd *partyDoc) loadFull() (doc bson.M) {
 	// 새 멤버에 그룹 전체를 알림
 	full, err := gd.rh.JSONGet(gd.strid(), "$")
 	if err == nil {
@@ -96,18 +102,18 @@ func (gd *groupDoc) loadFull() (doc bson.M) {
 	return
 }
 
-func (gd *groupDoc) strid() string {
+func (gd *partyDoc) strid() string {
 	if len(gd.Gid) == 0 {
 		gd.Gid = gd.id.Hex()
 	}
 	return gd.Gid
 }
 
-func (gd *groupDoc) tid(in accountID) string {
+func (gd *partyDoc) tid(in accountID) string {
 	return makeTid(gd.id, in)
 }
 
-func (gd *groupDoc) mid(tid string) accountID {
+func (gd *partyDoc) mid(tid string) accountID {
 	tidobj, _ := primitive.ObjectIDFromHex(tid)
 	var out primitive.ObjectID
 	for i := range tidobj {
@@ -116,7 +122,7 @@ func (gd *groupDoc) mid(tid string) accountID {
 	return out
 }
 
-func (gd *groupDoc) addInvite(mid accountID, body bson.M, ttl time.Duration, max int) (*memberDoc, error) {
+func (gd *partyDoc) addInvite(mid accountID, body bson.M, ttl time.Duration, max int) (*memberDoc, error) {
 	targetmid := mid
 	targetbody := body
 
@@ -170,10 +176,15 @@ func (gd *groupDoc) addInvite(mid accountID, body bson.M, ttl time.Duration, max
 	return newdoc, err
 }
 
-func (gd *groupDoc) addMember(mid accountID, character bson.M) (bson.M, error) {
+func (gd *partyDoc) addMember(mid accountID, character bson.M, option string) (bson.M, error) {
 	tid := gd.tid(mid)
 	prefix := "$._members." + tid
 
+	if option == gocommon.RedisonSetOptionNX {
+		if _, err := gd.rh.JSONSet(gd.strid(), prefix, bson.M{"_body": character}, gocommon.RedisonSetOptionNX); err != nil {
+			return nil, err
+		}
+	} else {
 		if _, err := gd.rh.JSONSet(gd.strid(), prefix+"._body", character, gocommon.RedisonSetOptionXX); err != nil {
 			return nil, err
 		}
@@ -181,12 +192,24 @@ func (gd *groupDoc) addMember(mid accountID, character bson.M) (bson.M, error) {
 		if err := gd.rh.JSONMDel(gd.strid(), []string{prefix + "._invite", prefix + "._invite_exp"}); err != nil {
 			return nil, err
 		}
+	}
 	gd.rh.Persist(gd.rh.Context(), gd.strid()).Result()
 
 	return gd.loadMemberFull(tid)
 }
 
-func (gd *groupDoc) removeMemberByTid(tid string) error {
+func (gd *partyDoc) getIncharge() string {
+	if len(gd.InCharge) == 0 {
+		incharge, err := gd.rh.JSONGet(gd.strid(), "$._incharge")
+		if err == nil && incharge != nil {
+			gd.InCharge = strings.Trim(incharge.(string), "[]\"")
+		}
+	}
+
+	return gd.InCharge
+}
+
+func (gd *partyDoc) removeMemberByTid(tid string) error {
 	_, err := gd.rh.JSONDel(gd.strid(), "$._members."+tid)
 	if err != nil {
 		return err
@@ -204,11 +227,11 @@ func (gd *groupDoc) removeMemberByTid(tid string) error {
 	return err
 }
 
-func (gd *groupDoc) removeMember(mid accountID) error {
+func (gd *partyDoc) removeMember(mid accountID) error {
 	return gd.removeMemberByTid(gd.tid(mid))
 }
 
-func (gd *groupDoc) getMembers() (map[string]any, error) {
+func (gd *partyDoc) getMembers() (map[string]any, error) {
 	res, err := gd.rh.JSONGet(gd.strid(), "$._members")
 	if err != nil {
 		return nil, err
@@ -259,16 +282,13 @@ func (gp *groupParty) Initialize(tv *Tavern, cfg configDocument) error {
 		tv.wsh.EnterRoom(gid.Hex(), accid)
 	}
 	gp.leaveRoom = func(gid groupID, accid accountID) {
+		gp.rh.JSONDel(accid.Hex(), "$.party.state")
 		tv.wsh.LeaveRoom(gid.Hex(), accid)
 	}
 
 	return nil
 }
 
-func (gp *groupParty) RegisterApiFunctions() {
-
-}
-
 // JoinParty : 그룹에 참가
 // - type : 그룹 타입
 // - 그룹 타입에 맞는 키(주로 _id)
@@ -276,20 +296,23 @@ func (gp *groupParty) RegisterApiFunctions() {
 // - body : 멤버의 속성 bson document
 func (gp *groupParty) JoinParty(w http.ResponseWriter, r *http.Request) {
 	var data struct {
-		Gid       primitive.ObjectID `bson:"gid"`
-		Mid       primitive.ObjectID `bson:"mid"`
-		Character bson.M             `bson:"character"`
-		First     bool               `bson:"first"`
+		Gid       primitive.ObjectID
+		Mid       primitive.ObjectID
+		Character bson.M
+		Option    string
 	}
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &data); err != nil {
-		logger.Println("JoinParty failed. ReadJsonDocumentFromBody returns err :", err)
+	if err := gocommon.MakeDecoder(r).Decode(&data); err != nil {
+		logger.Println("JoinParty failed. DecodeGob returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
+	// Option : ["NX" | "XX" | ""]
+
 	character := data.Character
 	gid := data.Gid
 	mid := data.Mid
+	option := strings.ToUpper(data.Option)
 
 	if gid.IsZero() || mid.IsZero() {
 		logger.Println("JoinParty failed. mid should be exist")
@@ -304,14 +327,30 @@ func (gp *groupParty) JoinParty(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if gd == nil {
-		// 그룹이 없다. 실패
-		w.Write([]byte("{}"))
+		// 그룹이 없다. 없을 수도 있지
+		gocommon.MakeEncoder(w, r).Encode("")
 		return
 	}
 
 	// 내 정보 업데이트할 때에도 사용됨
-	if data.First {
-		if memdoc, err := gd.addMember(mid, character); err == nil {
+	if option == "XX" {
+		// 이미 멤버여야 재입장 가능
+		path := "$._members." + gd.tid(mid) + "._body"
+		if _, err := gd.rh.JSONSet(gd.strid(), path, character, gocommon.RedisonSetOptionXX); err != nil {
+			// 멤버가 아니네? 그새 파티장이 쫓아냈을 수도 있다.
+			gocommon.MakeEncoder(w, r).Encode("")
+			return
+		}
+	}
+
+	gp.rh.JSONSet(mid.Hex(), "$.party", bson.M{"id": gid.Hex()})
+	memdoc, err := gd.addMember(mid, character, option)
+	if err != nil {
+		logger.Println("JoinParty failed :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
 	// 기존 유저에게 새 유저 알림
 	gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
 		Target: "#" + gid.Hex(),
@@ -323,40 +362,90 @@ func (gp *groupParty) JoinParty(w http.ResponseWriter, r *http.Request) {
 
 	gp.enterRoom(gid, mid)
 
-			// 최초 입장이라면 새 멤버에 그룹 전체를 알림
 	gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
 		Target: mid.Hex(),
 		Body:   gd.loadFull(),
 		Tag:    []string{"GroupDocFull"},
 	})
-			enc := json.NewEncoder(w)
-			enc.Encode(map[string]string{
-				"gid": gid.Hex(),
-				"tid": gd.tid(mid),
-			})
-		} else if err != nil {
-			logger.Error("JoinParty failed :", err)
-			w.WriteHeader(http.StatusInternalServerError)
+
+	gocommon.MakeEncoder(w, r).Encode(gd.strid())
+}
+
+func (gp *groupParty) ForceClearPartyMember(w http.ResponseWriter, r *http.Request) {
+	var doc struct {
+		Gid primitive.ObjectID
+		Mid primitive.ObjectID
 	}
-	} else {
-		path := "$._members." + gd.tid(mid) + "._body"
-		if _, err := gd.rh.JSONSet(gd.strid(), path, character, gocommon.RedisonSetOptionXX); err != nil {
-			logger.Error("JoinParty failed :", err)
+
+	if err := gocommon.MakeDecoder(r).Decode(&doc); err != nil {
+		logger.Println("ConditionalClearPartyMember failed. DecodeGob returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-		// 기존 유저에게 캐릭터 알림
-		gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
-			Target: "#" + gid.Hex(),
-			Body: map[string]any{
-				gd.tid(mid): bson.M{
-					"_body": character,
-				},
-			},
-			Tag: []string{"MemberDocFragment"},
-		})
+	gd := partyDoc{
+		id: doc.Gid,
+		rh: gp.rh,
+	}
 
+	gd.removeMember(doc.Mid)
+}
+
+func (gp *groupParty) ConditionalClearPartyMember(w http.ResponseWriter, r *http.Request) {
+	var doc struct {
+		Gid string
+		Mid string
+	}
+
+	// accid가 접속해 있지 않으면 파티에서 나간 걸로 간주하고
+	// accid가 접속해 있으면 아무것도 하지 않는다.
+	if err := gocommon.MakeDecoder(r).Decode(&doc); err != nil {
+		logger.Println("ConditionalClearPartyMember failed. DecodeGob returns err :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	pids, err := gp.rh.JSONGetString(doc.Mid, "$.party.id")
+	if err != nil {
+		logger.Println("ConditionalClearPartyMember failed. gp.rh.JSONGetString returns err :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	removeMember := func() {
+		gid, _ := primitive.ObjectIDFromHex(doc.Gid)
+		mid, _ := primitive.ObjectIDFromHex(doc.Mid)
+		gd := partyDoc{
+			id: gid,
+			rh: gp.rh,
+		}
+		if gd.getIncharge() == gd.tid(mid) {
+			// 방장이 나갔다.
+			gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
+				Target: "#" + doc.Gid,
+				Body:   bson.M{"gid": gid},
+				Tag:    []string{"GroupDocFull", gid.Hex()},
+			})
+			gd.rh.Del(gd.rh.Context(), gd.strid()).Result()
+		} else {
+			gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
+				Target: "#" + doc.Gid,
+				Body: bson.M{
+					gd.tid(mid): bson.M{},
+				},
+				Tag: []string{"MemberDocFull"},
+			})
+			gd.removeMember(mid)
+		}
+	}
+
+	if len(pids) == 0 {
+		// 없다.
+		// doc.Gid에서 제거
+		removeMember()
+	} else if pids[0] != doc.Gid {
+		// 다른 파티? 기존 파티에서 제거
+		removeMember()
 	}
 }
 
@@ -368,20 +457,21 @@ func (gp *groupParty) JoinParty(w http.ResponseWriter, r *http.Request) {
 // - (body) : 검색시 노출되는 document
 func (gp *groupParty) InviteToParty(w http.ResponseWriter, r *http.Request) {
 	var doc struct {
-		Gid      primitive.ObjectID `bson:"gid"`
-		Mid      primitive.ObjectID `bson:"mid"`
-		Targetid primitive.ObjectID `bson:"targetid"`
-		Inviter  bson.M             `bson:"inviter"`
-		Invitee  bson.M             `bson:"invitee"`
+		Gid             primitive.ObjectID
+		Mid             primitive.ObjectID
+		Target          primitive.ObjectID
+		Inviter         bson.M
+		Invitee         bson.M
+		InitialPartyDoc bson.M
 	}
 
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &doc); err != nil {
-		logger.Println("InviteToParty failed. ReadJsonDocumentFromBody returns err :", err)
+	if err := gocommon.MakeDecoder(r).Decode(&doc); err != nil {
+		logger.Println("InviteToParty failed. DecodeGob returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	targetid := doc.Targetid
+	targetid := doc.Target
 	gid := doc.Gid
 	mid := doc.Mid
 
@@ -412,12 +502,14 @@ func (gp *groupParty) InviteToParty(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if gd == nil {
-		gd, err = gp.createGroup(gid, mid, doc.Inviter)
+		gid = primitive.NewObjectID()
+		gd, err = gp.createGroup(gid, mid, doc.Inviter, doc.InitialPartyDoc)
 		if err != nil {
 			logger.Println("InviteToParty failed. gp.createGroup() return err :", err)
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
+
 		// 내가 wshandler room에 입장
 		gp.enterRoom(gid, mid)
 		gp.rh.JSONSet(mid.Hex(), "$.party", bson.M{"id": gid.Hex()})
@@ -448,18 +540,46 @@ func (gp *groupParty) InviteToParty(w http.ResponseWriter, r *http.Request) {
 		Tag: []string{"Invitation"},
 	})
 
-	w.Write([]byte(gd.strid()))
+	// 그룹에게 알림
+	gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
+		Target: "#" + gid.Hex(),
+		Body: bson.M{
+			gd.tid(targetid): bson.M{
+				"nickname": doc.Invitee["nickname"],
+				"_invite":  true,
+			},
+		},
+		Tag: []string{"MemberDocFull"},
+	})
+}
+
+func (gp *groupParty) UpdatePartyMemberDocument(w http.ResponseWriter, r *http.Request) {
+	var doc struct {
+		Gid      string
+		Tid      string
+		Fragment bson.M
+	}
+	if err := gocommon.MakeDecoder(r).Decode(&doc); err != nil {
+		logger.Println("UpdatePartyMemberDocument failed. DecodeGob returns err :", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	gidobj, _ := primitive.ObjectIDFromHex(doc.Gid)
+	mid := midFromTid(gidobj, doc.Tid)
+
+	gp.updateMemberDocument(gidobj, mid, doc.Fragment)
 }
 
 func (gp *groupParty) AcceptPartyInvitation(w http.ResponseWriter, r *http.Request) {
 	var doc struct {
-		Gid       primitive.ObjectID `bson:"gid"`
-		Mid       primitive.ObjectID `bson:"mid"`
-		Tid       string             `bson:"tid"`
-		Character bson.M             `bson:"character"`
+		Gid       primitive.ObjectID
+		Mid       primitive.ObjectID
+		Tid       string
+		Character bson.M
 	}
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &doc); err != nil {
-		logger.Println("AcceptPartyInvitation failed. ReadJsonDocumentFromBody returns err :", err)
+	if err := gocommon.MakeDecoder(r).Decode(&doc); err != nil {
+		logger.Println("AcceptPartyInvitation failed. DecodeGob returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -470,20 +590,20 @@ func (gp *groupParty) AcceptPartyInvitation(w http.ResponseWriter, r *http.Reque
 
 	cnt, err := gp.rh.Del(context.Background(), "inv."+mid.Hex()).Result()
 	if err != nil {
-		logger.Error("AcceptPartyInvitation failed. gp.rh.Del returns err :", err)
+		logger.Println("AcceptPartyInvitation failed. gp.rh.Del returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
 	if cnt == 0 {
 		// 만료됨
-		w.Write([]byte("expired"))
+		w.WriteHeader(http.StatusGatewayTimeout)
 		return
 	}
 
 	pids, err := gp.rh.JSONGetString(mid.Hex(), "$.party.id")
 	if err != nil {
-		logger.Error("AcceptPartyInvitation failed. gp.rh.JSONGetString returns err :", err)
+		logger.Println("AcceptPartyInvitation failed. gp.rh.JSONGetString returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -492,7 +612,7 @@ func (gp *groupParty) AcceptPartyInvitation(w http.ResponseWriter, r *http.Reque
 		// 기존에 이미 파티에 들어가 있다.
 		// 기존 파티에서는 탈퇴
 		oldgid, _ := primitive.ObjectIDFromHex(pids[0])
-		oldgd := &groupDoc{
+		oldgd := &partyDoc{
 			id: oldgid,
 			rh: gp.rh,
 		}
@@ -509,12 +629,12 @@ func (gp *groupParty) AcceptPartyInvitation(w http.ResponseWriter, r *http.Reque
 		gp.leaveRoom(oldgid, mid)
 	}
 
-	gd := &groupDoc{
+	gd := &partyDoc{
 		id: gid,
 		rh: gp.rh,
 	}
 
-	memberDoc, err := gd.addMember(mid, member)
+	memberDoc, err := gd.addMember(mid, member, "XX")
 	if err == nil {
 		// 기존 멤버에게 새 멤버를 알림
 		gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
@@ -543,35 +663,32 @@ func (gp *groupParty) AcceptPartyInvitation(w http.ResponseWriter, r *http.Reque
 }
 
 func (gp *groupParty) QueryPartyMemberState(w http.ResponseWriter, r *http.Request) {
-	var data struct {
-		Mid primitive.ObjectID `bson:"mid"`
-	}
-
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &data); err != nil {
-		logger.Println("DenyPartyInvitation failed. ReadJsonDocumentFromBody returns err :", err)
+	var mid primitive.ObjectID
+	if err := gocommon.MakeDecoder(r).Decode(&mid); err != nil {
+		logger.Println("DenyPartyInvitation failed. DecodeGob returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-	mid := data.Mid
 
-	states, err := gp.rh.JSONGetString(mid.Hex(), "$.party.state")
-	if err == redis.Nil {
+	if cnt, _ := gp.rh.Exists(gp.rh.Context(), mid.Hex()).Result(); cnt == 0 {
 		return
 	}
 
+	states, _ := gp.rh.JSONGetString(mid.Hex(), "$.party.state")
 	if len(states) > 0 && len(states[0]) > 0 {
-		w.Write([]byte(states[0]))
+		gocommon.MakeEncoder(w, r).Encode(states[0])
 	} else {
-		w.Write([]byte("connected"))
+		gocommon.MakeEncoder(w, r).Encode("connected")
 	}
 }
 
 func (gp *groupParty) updateMemberDocument(gid groupID, mid accountID, doc bson.M) error {
-	gd := &groupDoc{
+	gd := &partyDoc{
 		id: gid,
 		rh: gp.rh,
 	}
-	prefixPath := fmt.Sprintf("$._members.%s.", gd.tid(mid))
+	prefixPath := fmt.Sprintf("$._members.%s._body.", gd.tid(mid))
+
 	err := gp.rh.JSONMSetRel(gd.strid(), prefixPath, doc)
 	if err != nil {
 		return err
@@ -592,7 +709,7 @@ func (gp *groupParty) updateMemberDocument(gid groupID, mid accountID, doc bson.
 }
 
 func (gp *groupParty) updatePartyDocument(gid groupID, frag bson.M) error {
-	gd := groupDoc{
+	gd := partyDoc{
 		id: gid,
 		rh: gp.rh,
 	}
@@ -610,12 +727,12 @@ func (gp *groupParty) updatePartyDocument(gid groupID, frag bson.M) error {
 
 func (gp *groupParty) UpdatePartyDocument(w http.ResponseWriter, r *http.Request) {
 	var data struct {
-		Gid primitive.ObjectID `bson:"gid"`
-		Doc bson.M             `bson:"doc"`
+		Gid primitive.ObjectID
+		Doc bson.M
 	}
 
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &data); err != nil {
-		logger.Println("UpdatePartyDocument failed. ReadJsonDocumentFromBody returns err :", err)
+	if err := gocommon.MakeDecoder(r).Decode(&data); err != nil {
+		logger.Println("UpdatePartyDocument failed. DecodeGob returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
@@ -624,48 +741,43 @@ func (gp *groupParty) UpdatePartyDocument(w http.ResponseWriter, r *http.Request
 	frag := data.Doc
 
 	if err := gp.updatePartyDocument(gid, frag); err != nil {
-		logger.Error("UpdatePartyDocument failed. group.UpdatePartyDocument returns err :", err)
+		logger.Println("UpdatePartyDocument failed. group.UpdatePartyDocument returns err :", err)
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
 }
 
 func (gp *groupParty) QueryPartyMembers(w http.ResponseWriter, r *http.Request) {
-	var data struct {
-		Gid primitive.ObjectID `bson:"gid"`
-	}
-
-	if err := gocommon.ReadJsonDocumentFromBody(r.Body, &data); err != nil {
-		logger.Println("QueryPartyMembers failed. ReadJsonDocumentFromBody returns err :", err)
+	var gid primitive.ObjectID
+	if err := gocommon.MakeDecoder(r).Decode(&gid); err != nil {
+		logger.Println("QueryPartyMembers failed. DecodeGob returns err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	gid := data.Gid
-	gd := groupDoc{
+	gd := partyDoc{
 		id: gid,
 		rh: gp.rh,
 	}
 
 	members, err := gd.getMembers()
 	if err != nil {
-		logger.Error("QueryPartyMembers failed. group.QueryPartyMembers returns err :", err)
+		logger.Println("QueryPartyMembers failed. group.QueryPartyMembers returns err :", err)
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
 
-	enc := json.NewEncoder(w)
-	if err := enc.Encode(members); err != nil {
-		logger.Error("QueryPartyMembers failed. writeBsonDoc return err :", err)
+	if err := gocommon.MakeEncoder(w, r).Encode(members); err != nil {
+		logger.Println("QueryPartyMembers failed. writeBsonDoc return err :", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 }
 
-func (gp *groupParty) createGroup(newid groupID, charge accountID, chargeDoc bson.M) (*groupDoc, error) {
+func (gp *groupParty) createGroup(newid groupID, charge accountID, chargeDoc bson.M, initialGroupDoc bson.M) (*partyDoc, error) {
 	tid := makeTid(newid, charge)
 
-	gd := &groupDoc{
+	gd := &partyDoc{
 		Members: map[string]any{
 			tid: &memberDoc{
 				Body:         chargeDoc,
@@ -674,19 +786,31 @@ func (gp *groupParty) createGroup(newid groupID, charge accountID, chargeDoc bso
 			},
 		},
 		InCharge: tid,
+		Gid:      newid.Hex(),
 
 		rh: gp.rh,
 		id: newid,
 	}
 
-	_, err := gp.rh.JSONSet(gd.strid(), "$", gd, gocommon.RedisonSetOptionNX)
+	var err error
+	if initialGroupDoc != nil {
+		initialGroupDoc["_members"] = gd.Members
+		initialGroupDoc["_incharge"] = gd.InCharge
+		initialGroupDoc["_gid"] = gd.Gid
+
+		_, err = gp.rh.JSONSet(gd.strid(), "$", initialGroupDoc, gocommon.RedisonSetOptionNX)
+	} else {
+		_, err = gp.rh.JSONSet(gd.strid(), "$", gd, gocommon.RedisonSetOptionNX)
+	}
+
 	if err != nil {
 		return nil, err
 	}
+
 	return gd, nil
 }
 
-func (gp *groupParty) find(id groupID) (*groupDoc, error) {
+func (gp *groupParty) find(id groupID) (*partyDoc, error) {
 	if id.IsZero() {
 		return nil, nil
 	}
@@ -699,57 +823,49 @@ func (gp *groupParty) find(id groupID) (*groupDoc, error) {
 		return nil, err
 	}
 
-	return &groupDoc{
+	return &partyDoc{
 		rh: gp.rh,
 		id: id,
 	}, nil
 }
 
-func (gp *groupParty) memberDisconnected(room string, mid primitive.ObjectID) {
-	gid, err := primitive.ObjectIDFromHex(room)
-	if err != nil {
-		return
-	}
-	gd := &groupDoc{
-		id: gid,
-		rh: gp.rh,
-	}
-
-	gd.removeMember(mid)
-	// 퇴장을 알림
-	gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
-		Target: "#" + room,
-		Body: bson.M{
-			gd.tid(mid): bson.M{},
-		},
-		Tag: []string{"MemberDocFull"},
-	})
-}
-
-func (gp *groupParty) ClientDisconnected(ctx wshandler.ApiCallContext) {
-	gids, _ := gp.rh.JSONGetString(ctx.CallBy.Accid.Hex(), "$.party.id")
+func (gp *groupParty) ClientDisconnected(msg string, callby *wshandler.Sender) {
+	gids, _ := gp.rh.JSONGetString(callby.Accid.Hex(), "$.party.id")
 
 	if len(gids) > 0 && len(gids[0]) > 0 {
 		// mid한테는 빈 GroupDocFull을 보낸다. 그러면 지워짐
 		gidstr := gids[0]
 		gid, _ := primitive.ObjectIDFromHex(gidstr)
 
+		// 나를 먼저 룸에서 빼야 나한테 메시지가 안감
+		gp.leaveRoom(gid, callby.Accid)
+
+		if msg != "pending" {
+			gd := &partyDoc{
+				rh: gp.rh,
+				id: gid,
+			}
+
+			if gd.getIncharge() == gd.tid(callby.Accid) {
+				// 방장이 나감. 방 폭파
 				gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
-			Target: ctx.CallBy.Accid.Hex(),
+					Target: "#" + gidstr,
 					Body:   bson.M{"gid": gid},
 					Tag:    []string{"GroupDocFull", gidstr},
 				})
-
+				gd.rh.Del(gd.rh.Context(), gd.strid()).Result()
+			} else {
 				// gid에는 제거 메시지 보냄
 				gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
 					Target: "#" + gidstr,
 					Body: bson.M{
-				makeTid(gid, ctx.CallBy.Accid): bson.M{},
+						makeTid(gid, callby.Accid): bson.M{},
 					},
 					Tag: []string{"MemberDocFull"},
 				})
-
-		gp.leaveRoom(gid, ctx.CallBy.Accid)
+				gd.removeMember(callby.Accid)
+			}
+		}
 	}
 }
 
@@ -779,7 +895,7 @@ func (gp *groupParty) LeaveParty(ctx wshandler.ApiCallContext) {
 	mid := ctx.CallBy.Accid
 	tid := ctx.Arguments[0].(string)
 
-	gd := groupDoc{
+	gd := partyDoc{
 		id: gid,
 		rh: gp.rh,
 	}
@@ -812,6 +928,15 @@ func (gp *groupParty) LeaveParty(ctx wshandler.ApiCallContext) {
 		return
 	}
 
+	if gd.getIncharge() == gd.tid(mid) {
+		// 방장이 나감. 방 폭파
+		gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
+			Target: "#" + gidstr,
+			Body:   bson.M{"gid": gid},
+			Tag:    []string{"GroupDocFull", gidstr},
+		})
+		gd.rh.Del(gd.rh.Context(), gd.strid()).Result()
+	} else {
 		// mid한테는 빈 GroupDocFull을 보낸다. 그러면 지워짐
 		gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
 			Target: mid.Hex(),
@@ -827,6 +952,8 @@ func (gp *groupParty) LeaveParty(ctx wshandler.ApiCallContext) {
 			},
 			Tag: []string{"MemberDocFull"},
 		})
+		gd.removeMember(mid)
+	}
 
 	gp.leaveRoom(gid, mid)
 }
@@ -836,9 +963,17 @@ func (gp *groupParty) DenyPartyInvitation(ctx wshandler.ApiCallContext) {
 	mid := ctx.CallBy.Accid
 
 	gp.rh.Del(context.Background(), "inv."+mid.Hex()).Result()
-	gd := groupDoc{
+	gd := partyDoc{
 		id: gid,
 		rh: gp.rh,
 	}
 	gd.removeMember(mid)
+
+	gp.sendUpstreamMessage(&wshandler.UpstreamMessage{
+		Target: "#" + gd.strid(),
+		Body: bson.M{
+			gd.tid(mid): bson.M{},
+		},
+		Tag: []string{"MemberDocFull"},
+	})
 }

core/tavern.go

@@ -10,9 +10,11 @@ import (
 	"time"
 
 	"github.com/go-redis/redis/v8"
+	"github.com/gorilla/websocket"
 	"repositories.action2quare.com/ayo/gocommon"
 	"repositories.action2quare.com/ayo/gocommon/flagx"
 	"repositories.action2quare.com/ayo/gocommon/logger"
+	"repositories.action2quare.com/ayo/gocommon/metric"
 	"repositories.action2quare.com/ayo/gocommon/session"
 	"repositories.action2quare.com/ayo/gocommon/wshandler"
 
@@ -26,6 +28,9 @@ type TavernConfig struct {
 	Group                 map[string]configDocument `json:"tavern_group_types"`
 	MaingateApiToken      string                    `json:"maingate_api_token"`
 	RedisURL              string                    `json:"tavern_redis_url"`
+	EosClientId           string                    `json:"eos_client_id"`
+	EosClientSecret       string                    `json:"eos_client_secret"`
+	EosDeploymentId       string                    `json:"eos_deployment_id"`
 	macAddr               string
 }
 
@@ -35,7 +40,7 @@ type Tavern struct {
 	wsh           *wshandler.WebsocketHandler
 	mongoClient   gocommon.MongoClient
 	redison       *gocommon.RedisonHandler
-	httpApiBorker gocommon.HttpApiHandlerContainer
+	httpApiBorker gocommon.HttpApiBroker
 }
 
 func getMacAddr() (string, error) {
@@ -57,12 +62,12 @@ func getMacAddr() (string, error) {
 // New :
 func New(context context.Context, wsh *wshandler.WebsocketHandler) (*Tavern, error) {
 	if err := gocommon.LoadConfig(&config); err != nil {
-		return nil, err
+		return nil, logger.ErrorWithCallStack(err)
 	}
 
 	macaddr, err := getMacAddr()
 	if err != nil {
-		return nil, err
+		return nil, logger.ErrorWithCallStack(err)
 	}
 	config.macAddr = macaddr
 	tv := &Tavern{
@@ -71,43 +76,54 @@ func New(context context.Context, wsh *wshandler.WebsocketHandler) (*Tavern, err
 
 	if err = tv.prepare(context); err != nil {
 		logger.Println("tavern prepare() failed :", err)
-		return nil, err
+		return nil, logger.ErrorWithCallStack(err)
 	}
 
 	return tv, nil
 }
 
+var ccu = metric.MetricWriterNil
+
 func (tv *Tavern) Cleanup() {
+	ccu.Set(0)
 	tv.mongoClient.Close()
 }
 
 func (tv *Tavern) prepare(ctx context.Context) error {
 	redisClient, err := gocommon.NewRedisClient(config.RedisURL)
 	if err != nil {
-		return err
+		return logger.ErrorWithCallStack(err)
 	}
 
 	tv.redison = gocommon.NewRedisonHandler(redisClient.Context(), redisClient)
-	tv.wsh.RegisterApiHandler(wshandler.MakeWebsocketApiHandler(tv, "tv"))
+	tv.wsh.AddHandler(wshandler.MakeWebsocketApiHandler(tv, "tv"))
 
 	if cfg, ok := config.Group["chat"]; ok {
 		chat := new(groupChat)
 		if err := chat.Initialize(tv, cfg); err != nil {
-			return err
+			return logger.ErrorWithCallStack(err)
 		}
-		tv.httpApiBorker.RegisterApiHandler(gocommon.MakeHttpApiHandler(chat, "chat"))
-		tv.wsh.RegisterApiHandler(wshandler.MakeWebsocketApiHandler(chat, "chat"))
+		tv.httpApiBorker.AddHandler(gocommon.MakeHttpApiHandler(chat, "chat"))
+		tv.wsh.AddHandler(wshandler.MakeWebsocketApiHandler(chat, "chat"))
 	}
 
 	if cfg, ok := config.Group["party"]; ok {
 		party := new(groupParty)
 		if err := party.Initialize(tv, cfg); err != nil {
-			return err
+			return logger.ErrorWithCallStack(err)
 		}
-		tv.httpApiBorker.RegisterApiHandler(gocommon.MakeHttpApiHandler(party, "party"))
-		tv.wsh.RegisterApiHandler(wshandler.MakeWebsocketApiHandler(party, "party"))
+		tv.httpApiBorker.AddHandler(gocommon.MakeHttpApiHandler(party, "party"))
+		tv.wsh.AddHandler(wshandler.MakeWebsocketApiHandler(party, "party"))
 	}
 
+	instant := new(groupInstant)
+	if err := instant.Initialize(tv); err != nil {
+		return logger.ErrorWithCallStack(err)
+	}
+	tv.httpApiBorker.AddHandler(gocommon.MakeHttpApiHandler(instant, "instant"))
+	tv.wsh.AddHandler(wshandler.MakeWebsocketApiHandler(instant, "instant"))
+
+	ccu = metric.NewMetric(metric.MetricGuage, "concurrent_user", "concurrent user count", map[string]string{"game": "lobby"})
 	return nil
 }
 
@@ -127,18 +143,18 @@ func (tv *Tavern) LeaveChannel(ctx wshandler.ApiCallContext) {
 	tv.wsh.LeaveRoom(ctx.Arguments[0].(string), ctx.CallBy.Accid)
 }
 
-func (tv *Tavern) ClientConnected(ctx wshandler.ApiCallContext) {
-	logger.Println("ClientConnected :", ctx.CallBy.Alias)
-	tv.redison.Del(tv.redison.Context(), ctx.CallBy.Accid.Hex())
-	_, err := tv.redison.JSONSet(ctx.CallBy.Accid.Hex(), "$", bson.M{"_ts": time.Now().UTC().Unix()})
+func (tv *Tavern) ClientConnected(conn *websocket.Conn, callby *wshandler.Sender) {
+	ccu.Add(1)
+	tv.redison.Del(tv.redison.Context(), callby.Accid.Hex())
+	_, err := tv.redison.JSONSet(callby.Accid.Hex(), "$", bson.M{"_ts": time.Now().UTC().Unix()})
 	if err != nil {
 		logger.Println("OnClientMessageReceived HSet error :", err)
 	}
 }
 
-func (tv *Tavern) ClientDisconnected(ctx wshandler.ApiCallContext) {
-	tv.redison.Del(tv.redison.Context(), ctx.CallBy.Accid.Hex()).Result()
-	logger.Println("ClientDisconnected :", ctx.CallBy.Alias)
+func (tv *Tavern) ClientDisconnected(msg string, callby *wshandler.Sender) {
+	ccu.Add(-1)
+	tv.redison.Del(tv.redison.Context(), callby.Accid.Hex()).Result()
 }
 
 func (tv *Tavern) OnRoomCreated(name string) {
@@ -182,12 +198,5 @@ func (tv *Tavern) api(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	funcname := r.URL.Query().Get("call")
-	if len(funcname) == 0 {
-		logger.Println("query param 'call' is missing")
-		w.WriteHeader(http.StatusBadRequest)
-		return
-	}
-
-	tv.httpApiBorker.Call(funcname, w, r)
+	tv.httpApiBorker.Call(w, r)
 }

core/tavern_test.go

@@ -84,7 +84,7 @@ func TestReJSON(t *testing.T) {
 		},
 	}
 
-	gd := groupDoc{
+	gd := partyDoc{
 		id: primitive.NewObjectID(),
 	}
 

go.mod

@@ -1,29 +1,30 @@
 module repositories.action2quare.com/ayo/tavern
 
-go 1.20
+go 1.22.1
 
 require (
 	github.com/go-redis/redis/v8 v8.11.5
 	go.mongodb.org/mongo-driver v1.11.7
-	repositories.action2quare.com/ayo/gocommon v0.0.0-20230908091916-23231dc6d705
+	repositories.action2quare.com/ayo/gocommon v0.0.0-20250805124812-38a3da271a8e
 )
 
 require (
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/go-cmp v0.5.4 // indirect
+	github.com/google/go-cmp v0.5.9 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
 	github.com/klauspost/compress v1.16.6 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
 	github.com/montanaflynn/stats v0.7.1 // indirect
 	github.com/pires/go-proxyproto v0.7.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
+	github.com/rogpeppe/go-internal v1.10.0 // indirect
 	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
 	github.com/xdg-go/scram v1.1.2 // indirect
 	github.com/xdg-go/stringprep v1.0.4 // indirect
 	github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a // indirect
-	golang.org/x/crypto v0.10.0 // indirect
-	golang.org/x/sync v0.3.0 // indirect
-	golang.org/x/text v0.10.0 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	golang.org/x/crypto v0.18.0 // indirect
+	golang.org/x/sync v0.6.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 )

go.sum

@@ -1,41 +1,52 @@
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
 github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
-github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
 github.com/klauspost/compress v1.16.6 h1:91SKEy4K37vkp255cJ8QesJhjyRO0hn9i9G0GoUwLsk=
 github.com/klauspost/compress v1.16.6/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
 github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
 github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
 github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
+github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs=
 github.com/pires/go-proxyproto v0.7.0 h1:IukmRewDQFWC7kfnb66CSomk2q/seBuilHBYFwyq0Hs=
 github.com/pires/go-proxyproto v0.7.0/go.mod h1:Vz/1JPY/OACxWGQNIRY2BeyDmpoaWmEP40O9LbuiFR4=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
@@ -59,20 +70,21 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.10.0 h1:LKqV2xt9+kDzSTfOhx4FrkEBcMrAgHSYgzywV9zcGmM=
-golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -80,7 +92,8 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.9.0 h1:KS/R3tvhPqvJvwcKfnBHJwwthS11LRhmM5D59eEXa0s=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -88,29 +101,23 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.10.0 h1:UpjohKhiEgNc0CSauXmwYftY1+LlaC75SJwh0SgCX58=
-golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230906142024-eb54fa2e3a44 h1:90XY5WSLtxvfi6YktDY4Sv1CMPRViZvPLPunA1eIxZA=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230906142024-eb54fa2e3a44/go.mod h1:PdpZ16O1czKKxCxn+0AFNaEX/0kssYwC3G8jR0V7ybw=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908023557-6cbf32c3868b h1:Rx6tP6IhlGlVGGgMDZ7OuIDU9cHfvm2L05L2tqF7G58=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908023557-6cbf32c3868b/go.mod h1:XvklTTSvQX5uviivGBcZo8eIL+mV94W2e4uBBXcT5JY=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908025007-3603c0386b29 h1:Ts40m9MLMMx4uaQWko5QXkg/HX4uYQB9TGGEN6twhiU=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908025007-3603c0386b29/go.mod h1:XvklTTSvQX5uviivGBcZo8eIL+mV94W2e4uBBXcT5JY=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908062630-46ce5f09897a h1:xKUI2xlP6LcUV5fy+4QEHoaZOhkSsMYgeIp6H5ADBCM=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908062630-46ce5f09897a/go.mod h1:XvklTTSvQX5uviivGBcZo8eIL+mV94W2e4uBBXcT5JY=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908091916-23231dc6d705 h1:sK2mbRwqTMTZFmP9F50MIFZG9hcQ+EeW7tsGTzBgAow=
-repositories.action2quare.com/ayo/gocommon v0.0.0-20230908091916-23231dc6d705/go.mod h1:XvklTTSvQX5uviivGBcZo8eIL+mV94W2e4uBBXcT5JY=
+repositories.action2quare.com/ayo/gocommon v0.0.0-20250805124037-fb3f0385067a h1:NkFjJVZTNO6HsivUEikISfqF4O5zHk0VRdKOEOVTOG4=
+repositories.action2quare.com/ayo/gocommon v0.0.0-20250805124037-fb3f0385067a/go.mod h1:q64I6gqlD61qwi9FfuPkwqy6Z6uzSHdcEjoHAJC27gQ=
+repositories.action2quare.com/ayo/gocommon v0.0.0-20250805124812-38a3da271a8e h1:jxfkCjnDBPg4zw5oqecEdxjclpiBysBtNvI2ENqeG4E=
+repositories.action2quare.com/ayo/gocommon v0.0.0-20250805124812-38a3da271a8e/go.mod h1:q64I6gqlD61qwi9FfuPkwqy6Z6uzSHdcEjoHAJC27gQ=

main.go

@@ -41,12 +41,16 @@ func main() {
 		serveMux := http.NewServeMux()
 		wsh.RegisterHandlers(serveMux, *prefix)
 		tv.RegisterHandlers(ctx, serveMux, *prefix)
+
 		server := gocommon.NewHTTPServer(serveMux)
 		logger.Println("tavern is started")
 		wsh.Start(ctx)
-		server.Start()
+
+		if err := server.Start(); err != nil {
+			logger.Println(err)
+		}
 		cancel()
-		tv.Cleanup()
 		wsh.Cleanup()
+		tv.Cleanup()
 	}
 }