554 lines
12 KiB
Go
554 lines
12 KiB
Go
package core
|
|
|
|
import (
|
|
"context"
|
|
"encoding/gob"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"net/url"
|
|
"time"
|
|
|
|
"github.com/go-redis/redis/v8"
|
|
"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 accountID = primitive.ObjectID
|
|
type ticketID = primitive.ObjectID
|
|
type groupID = primitive.ObjectID
|
|
|
|
func init() {
|
|
gob.Register(memberDoc{})
|
|
gob.Register(groupDoc{})
|
|
gob.Register(Invitation{})
|
|
gob.Register(InvitationFail{})
|
|
}
|
|
|
|
func makeTid(gid groupID, in accountID) string {
|
|
var out primitive.ObjectID
|
|
for i := range in {
|
|
out[12-i-1] = gid[i] ^ in[12-i-1]
|
|
}
|
|
return out.Hex()
|
|
}
|
|
|
|
type Invitation struct {
|
|
GroupID groupID `json:"_gid"`
|
|
TicketID string `json:"_tid"`
|
|
Inviter bson.M `json:"_inviter"` // memberDoc.Body
|
|
ExpireAtUTC int64 `json:"_expire_at_utc"`
|
|
}
|
|
|
|
// 플레이어한테 공유하는 멤버 정보
|
|
type memberDoc struct {
|
|
Body bson.M `json:"_body"`
|
|
Invite bool `json:"_invite"`
|
|
InviteExpire int64 `json:"_invite_exp"`
|
|
}
|
|
|
|
type InvitationFail bson.M
|
|
|
|
type groupDoc struct {
|
|
Members map[string]any `json:"_members"`
|
|
InCharge string `json:"_incharge"`
|
|
Gid string `json:"_gid"`
|
|
|
|
rh *gocommon.RedisonHandler
|
|
id groupID
|
|
}
|
|
|
|
func (gd *groupDoc) loadMemberFull(tid string) (bson.M, error) {
|
|
full, err := gd.rh.JSONGet(gd.strid(), "$._members."+tid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
bt := []byte(full.(string))
|
|
bt = bt[1 : len(bt)-1]
|
|
|
|
var doc bson.M
|
|
if err = json.Unmarshal(bt, &doc); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return doc, nil
|
|
}
|
|
|
|
func (gd *groupDoc) loadFull() (doc bson.M) {
|
|
// 새 멤버에 그룹 전체를 알림
|
|
full, err := gd.rh.JSONGet(gd.strid(), "$")
|
|
if err == nil {
|
|
bt := []byte(full.(string))
|
|
bt = bt[1 : len(bt)-1]
|
|
err = json.Unmarshal(bt, &doc)
|
|
if err != nil {
|
|
logger.Println("loadFull err :", err)
|
|
}
|
|
} else {
|
|
logger.Println("loadFull err :", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (gd *groupDoc) strid() string {
|
|
if len(gd.Gid) == 0 {
|
|
gd.Gid = gd.id.Hex()
|
|
}
|
|
return gd.Gid
|
|
}
|
|
|
|
func (gd *groupDoc) tid(in accountID) string {
|
|
return makeTid(gd.id, in)
|
|
}
|
|
|
|
func (gd *groupDoc) mid(tid string) accountID {
|
|
tidobj, _ := primitive.ObjectIDFromHex(tid)
|
|
var out primitive.ObjectID
|
|
for i := range tidobj {
|
|
out[12-i-1] = gd.id[i] ^ tidobj[12-i-1]
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (gd *groupDoc) addInvite(inviteeDoc bson.M, ttl time.Duration, max int) (*memberDoc, error) {
|
|
targetmid := inviteeDoc["_mid"].(accountID)
|
|
targetbody := inviteeDoc["body"].(bson.M)
|
|
|
|
// 초대 가능한 빈 자리가 있나
|
|
tids, err := gd.rh.JSONObjKeys(gd.strid(), "$._members")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
createNewDoc := func() *memberDoc {
|
|
return &memberDoc{
|
|
Body: targetbody,
|
|
Invite: true,
|
|
InviteExpire: now.Add(ttl).Unix(),
|
|
}
|
|
}
|
|
|
|
newtid := gd.tid(targetmid)
|
|
if len(tids) < max {
|
|
// 빈자리를 찾았다.
|
|
newdoc := createNewDoc()
|
|
_, err := gd.rh.JSONSet(gd.strid(), "$._members."+newtid, newdoc)
|
|
return newdoc, err
|
|
}
|
|
|
|
expires, err := gd.rh.JSONGetInt64(gd.strid(), "$._members.._invite_exp")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var delpaths []string
|
|
for i, expire := range expires {
|
|
if expire < now.Unix() {
|
|
// 만료된 초대가 있네? 지우자
|
|
delpaths = append(delpaths, "$._members."+tids[i])
|
|
}
|
|
}
|
|
|
|
if len(delpaths) == 0 {
|
|
// 빈자리가 없다
|
|
return nil, nil
|
|
}
|
|
|
|
if err := gd.rh.JSONMDel(gd.strid(), delpaths); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
newdoc := createNewDoc()
|
|
_, err = gd.rh.JSONSet(gd.strid(), "$._members."+newtid, newdoc)
|
|
return newdoc, err
|
|
}
|
|
|
|
func (gd *groupDoc) addMember(mid accountID, doc bson.M) (bson.M, error) {
|
|
tid := gd.tid(mid)
|
|
prefix := "$._members." + tid
|
|
|
|
if _, err := gd.rh.JSONMerge(gd.strid(), prefix+"._body", doc, gocommon.RedisonSetOptionXX); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := gd.rh.JSONMDel(gd.strid(), []string{prefix + "._invite", prefix + "._invite_exp"}); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return gd.loadMemberFull(tid)
|
|
}
|
|
|
|
func (gd *groupDoc) removeMember(mid accountID) error {
|
|
_, err := gd.rh.JSONDel(gd.strid(), "$._members."+gd.tid(mid))
|
|
return err
|
|
}
|
|
|
|
func (gd *groupDoc) getMembers() (map[string]any, error) {
|
|
res, err := gd.rh.JSONGet(gd.strid(), "$._members")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var temp []map[string]any
|
|
err = json.Unmarshal([]byte(res.(string)), &temp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
out := make(map[string]any)
|
|
for k, v := range temp[0] {
|
|
body := v.(map[string]any)["_body"]
|
|
out[gd.mid(k).Hex()] = body
|
|
}
|
|
|
|
return out, nil
|
|
}
|
|
|
|
type groupInMemory struct {
|
|
*groupConfig
|
|
sendUpstreamMessage func(*wshandler.UpstreamMessage)
|
|
sendEnterRoomMessage func(groupID, accountID)
|
|
sendLeaveRoomMessage func(groupID, accountID)
|
|
rh *gocommon.RedisonHandler
|
|
}
|
|
|
|
func (gm *groupInMemory) createGroup(newid groupID, charge accountID, chargeDoc bson.M) (*groupDoc, error) {
|
|
tid := makeTid(newid, charge)
|
|
|
|
gd := &groupDoc{
|
|
Members: map[string]any{
|
|
tid: &memberDoc{
|
|
Body: chargeDoc,
|
|
Invite: false,
|
|
InviteExpire: 0,
|
|
},
|
|
},
|
|
InCharge: tid,
|
|
|
|
rh: gm.rh,
|
|
id: newid,
|
|
}
|
|
|
|
_, err := gm.rh.JSONSet(gd.strid(), "$", gd, gocommon.RedisonSetOptionNX)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return gd, nil
|
|
}
|
|
|
|
func (gm *groupInMemory) find(id groupID) (*groupDoc, error) {
|
|
if id.IsZero() {
|
|
return nil, nil
|
|
}
|
|
|
|
_, err := gm.rh.JSONObjLen(id.Hex(), "$")
|
|
if err == redis.Nil {
|
|
return nil, nil
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &groupDoc{
|
|
rh: gm.rh,
|
|
id: id,
|
|
}, nil
|
|
}
|
|
|
|
func (gm *groupInMemory) Create(form url.Values, base bson.M) (groupID, error) {
|
|
return primitive.NilObjectID, nil
|
|
}
|
|
|
|
func (gm *groupInMemory) Candidate(gid groupID, mid accountID, doc bson.M) error {
|
|
logger.Error("not implemented func : Canidate")
|
|
return nil
|
|
}
|
|
|
|
var errGroupNotExist = errors.New("group does not exist")
|
|
|
|
func (gm *groupInMemory) Join(gid groupID, mid accountID, doc bson.M) error {
|
|
gd, err := gm.find(gid)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if gd == nil {
|
|
// 그룹이 없다. 실패
|
|
return errGroupNotExist
|
|
}
|
|
|
|
// 내 정보 업데이트할 때에도 사용됨
|
|
if memdoc, err := gd.addMember(mid, doc); err == nil {
|
|
// 기존 유저에게 새 유저 알림
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + gid.Hex(),
|
|
Body: map[string]any{
|
|
gd.tid(mid): memdoc,
|
|
},
|
|
Tag: []string{"MemberDocFull"},
|
|
})
|
|
|
|
gm.sendEnterRoomMessage(gid, mid)
|
|
|
|
// 새 멤버에 그룹 전체를 알림
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "@" + mid.Hex(),
|
|
Body: gd.loadFull(),
|
|
Tag: []string{"GroupDocFull"},
|
|
})
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
var errInviteeDocMidMissing = errors.New("inviteeDoc must have '_mid' field")
|
|
var errAlreadyInvited = errors.New("this target is already invited by someone or me")
|
|
|
|
func (gm *groupInMemory) Invite(gid groupID, mid accountID, inviterDoc bson.M, inviteeDoc bson.M) (string, error) {
|
|
targetid, ok := inviteeDoc["_mid"].(accountID)
|
|
if !ok {
|
|
return "", errInviteeDocMidMissing
|
|
}
|
|
|
|
// targetid에 초대한 mid가 들어있다.
|
|
already, err := gm.rh.Get(context.Background(), targetid.Hex()).Result()
|
|
if err != nil && err != redis.Nil {
|
|
return "", err
|
|
}
|
|
|
|
if len(already) > 0 {
|
|
if already != mid.Hex() {
|
|
// 이미 초대 중이다.
|
|
// inviter한테 알려줘야 한다.
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "@" + mid.Hex(),
|
|
Body: inviteeDoc,
|
|
Tag: []string{"InvitationFail"},
|
|
})
|
|
}
|
|
return "", errAlreadyInvited
|
|
}
|
|
|
|
gd, err := gm.find(gid)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if gd == nil {
|
|
gd, err = gm.createGroup(gid, mid, inviterDoc)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
// 내가 wshandler room에 입장
|
|
gm.sendEnterRoomMessage(gid, mid)
|
|
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "@" + mid.Hex(),
|
|
Body: gd,
|
|
Tag: []string{"GroupDocFull"},
|
|
})
|
|
}
|
|
|
|
newdoc, err := gd.addInvite(inviteeDoc, time.Duration(gm.InviteExpire+1)*time.Second, gm.MaxMember)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// 초대 중 표시
|
|
_, err = gm.rh.SetNX(context.Background(), targetid.Hex(), mid.Hex(), time.Duration(gm.InviteExpire)*time.Second).Result()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// invitee에게 알림
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "@" + targetid.Hex(),
|
|
Body: Invitation{
|
|
GroupID: gid,
|
|
TicketID: gd.tid(targetid),
|
|
Inviter: inviterDoc,
|
|
ExpireAtUTC: newdoc.InviteExpire,
|
|
},
|
|
Tag: []string{"Invitation"},
|
|
})
|
|
|
|
return gd.strid(), nil
|
|
}
|
|
|
|
func (gm *groupInMemory) CancelInvitation(gid groupID, tid ticketID) error {
|
|
return nil
|
|
}
|
|
|
|
var errInvitationExpired = errors.New("invitation is already expired")
|
|
|
|
func (gm *groupInMemory) AcceptInvitation(gid groupID, mid accountID, member bson.M) error {
|
|
cnt, err := gm.rh.Del(context.Background(), mid.Hex()).Result()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if cnt == 0 {
|
|
// 만료됨
|
|
return errInvitationExpired
|
|
}
|
|
|
|
gd := &groupDoc{
|
|
id: gid,
|
|
rh: gm.rh,
|
|
}
|
|
|
|
memberDoc, err := gd.addMember(mid, member)
|
|
if err == nil {
|
|
// 기존 멤버에게 새 멤버를 알림
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + gid.Hex(),
|
|
Body: map[string]any{
|
|
gd.tid(mid): memberDoc,
|
|
},
|
|
Tag: []string{"MemberDocFull"},
|
|
})
|
|
|
|
gm.sendEnterRoomMessage(gid, mid)
|
|
|
|
// 새 멤버에 그룹 전체를 알림
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "@" + mid.Hex(),
|
|
Body: gd.loadFull(),
|
|
Tag: []string{"GroupDocFull"},
|
|
})
|
|
}
|
|
|
|
// 실패
|
|
return err
|
|
}
|
|
|
|
func (gm *groupInMemory) QueryGroupMembers(gid groupID) (bson.M, error) {
|
|
gd := groupDoc{
|
|
id: gid,
|
|
rh: gm.rh,
|
|
}
|
|
return gd.getMembers()
|
|
}
|
|
|
|
func (gm *groupInMemory) DenyInvitation(gid groupID, mid accountID, tid ticketID) error {
|
|
gm.rh.Del(context.Background(), mid.Hex()).Result()
|
|
gd := groupDoc{
|
|
id: gid,
|
|
rh: gm.rh,
|
|
}
|
|
return gd.removeMember(mid)
|
|
}
|
|
|
|
func (gm *groupInMemory) QueryInvitations(mid accountID, after primitive.Timestamp) ([]bson.M, error) {
|
|
return nil, nil
|
|
}
|
|
func (gm *groupInMemory) Exist(gid groupID, filter bson.M) (bool, error) {
|
|
return false, nil
|
|
}
|
|
func (gm *groupInMemory) FindAll(filter bson.M, projection string, after primitive.Timestamp) ([]bson.M, error) {
|
|
return nil, nil
|
|
}
|
|
func (gm *groupInMemory) FindOne(gid groupID, projection string) (bson.M, error) {
|
|
return nil, nil
|
|
}
|
|
func (gm *groupInMemory) Leave(gid groupID, mid accountID) error {
|
|
gd := groupDoc{
|
|
id: gid,
|
|
rh: gm.rh,
|
|
}
|
|
if err := gd.removeMember(mid); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 나한테는 빈 GroupDocFull을 보낸다. 그러면 지워짐
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "@" + mid.Hex(),
|
|
Body: bson.M{"gid": gid},
|
|
Tag: []string{"GroupDocFull", gid.Hex()},
|
|
})
|
|
gm.sendLeaveRoomMessage(gid, mid)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (gm *groupInMemory) UpdateMemberDocument(gid groupID, mid accountID, doc bson.M) error {
|
|
gd := &groupDoc{
|
|
id: gid,
|
|
rh: gm.rh,
|
|
}
|
|
|
|
prefixPath := fmt.Sprintf("$._members.%s.", gd.tid(mid))
|
|
err := gm.rh.JSONMSetRel(gd.strid(), prefixPath, doc)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + gid.Hex(),
|
|
Body: map[string]any{
|
|
gd.tid(mid): doc,
|
|
},
|
|
Tag: []string{"MemberDocFragment"},
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (gm *groupInMemory) Dismiss(gid groupID) error {
|
|
return nil
|
|
}
|
|
|
|
func (gm *groupInMemory) UpdateGroupDocument(gid groupID, frag bson.M) error {
|
|
gd := groupDoc{
|
|
id: gid,
|
|
rh: gm.rh,
|
|
}
|
|
|
|
if err := gm.rh.JSONMSetRel(gd.strid(), "$.", frag); err != nil {
|
|
return err
|
|
}
|
|
|
|
// 업데이트 알림
|
|
gm.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + gid.Hex(),
|
|
Body: frag,
|
|
Tag: []string{"GroupDocFragment"},
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (cfg *groupConfig) prepareInMemory(ctx context.Context, typename string, sub *subTavern) (group, error) {
|
|
// group document
|
|
// member document
|
|
region := sub.region
|
|
wsh := sub.wsh
|
|
storage := config.RegionStorage[sub.region]
|
|
redisClient, err := gocommon.NewRedisClient(storage.Redis["tavern"])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// 여기서는 subscribe channel
|
|
// 각 함수에서는 publish
|
|
gm := &groupInMemory{
|
|
groupConfig: cfg,
|
|
rh: gocommon.NewRedisonHandler(ctx, redisClient),
|
|
sendUpstreamMessage: func(msg *wshandler.UpstreamMessage) {
|
|
wsh.SendUpstreamMessage(region, msg)
|
|
},
|
|
sendEnterRoomMessage: func(gid groupID, accid accountID) {
|
|
wsh.EnterRoom(region, gid.Hex(), accid)
|
|
},
|
|
sendLeaveRoomMessage: func(gid groupID, accid accountID) {
|
|
wsh.LeaveRoom(region, gid.Hex(), accid)
|
|
},
|
|
}
|
|
|
|
return gm, nil
|
|
}
|