commit 8fe1f31bf2c96c25d4558d4c9db18fa0db6ec005 Author: 김도한 [dominick] Date: Tue Oct 18 11:50:10 2022 +0900 server initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..eaffb3b --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +*.log +*.exe diff --git a/core/AEGS_methods.go b/core/AEGS_methods.go new file mode 100644 index 0000000..94dc50b --- /dev/null +++ b/core/AEGS_methods.go @@ -0,0 +1,421 @@ +package core + +import ( + "anvil/shared" + "errors" + "net" + + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo/options" +) + +/* +func (gs *AeGameServer) LobbyCheckIn(ip net.IP, inSocketPort int32) { + gs.lock.Lock() + defer gs.lock.Unlock() + + gs.LobbyIp = ip + gs.LobbyPort = inSocketPort +} + +func (gs *AeGameServer) GetUrlLobbyChekedIn() string { + gs.lock.Lock() + defer gs.lock.Unlock() + + if len(gs.LobbyIp) != 0 { + return fmt.Sprintf("%s:%d", gs.LobbyIp.String(), gs.LobbyPort) + } else { + return "" + } +} + +func (gs *AeGameServer) WorldCheckIn(ip net.IP, inSocketPort int32) { + gs.lock.Lock() + defer gs.lock.Unlock() + + gs.WorldIp = ip + gs.WorldPort = inSocketPort +} + +func (gs *AeGameServer) GetUrlWorldChekedIn() string { + gs.lock.Lock() + defer gs.lock.Unlock() + + if len(gs.WorldIp) != 0 { + return fmt.Sprintf("%s:%d", gs.WorldIp.String(), gs.LobbyPort) + } else { + return "" + } +} +*/ + +func (gs *AeGameServer) FindDsCheckedIn(Type int32, Version string) string { + gs.lock.Lock() + defer gs.lock.Unlock() + + var priority float32 = 0 + url := "" + + for _, s := range gs.sockets { + + if s.IsCompatible(Type, Version) { + if tmpUrl := s.GetUrlChekedIn(); tmpUrl != "" { + tmpPriority := s.GetPriority() + if tmpPriority >= priority { + url = tmpUrl + priority = tmpPriority + } + } + } + } + + return url +} + +func (tx *transaction) Hello() shared.RPCReturnType { + tx.gs.Logger.Println("hello, too") + return shared.MakeRPCReturn("hello, too.", nil) +} + +func externalIP() (net.IP, error) { + ifaces, err := net.Interfaces() + if err != nil { + return nil, err + } + for _, iface := range ifaces { + if iface.Flags&net.FlagUp == 0 { + continue // interface down + } + if iface.Flags&net.FlagLoopback != 0 { + continue // loopback interface + } + addrs, err := iface.Addrs() + if err != nil { + return nil, err + } + for _, addr := range addrs { + var ip net.IP + switch v := addr.(type) { + case *net.IPNet: + ip = v.IP + case *net.IPAddr: + ip = v.IP + } + if ip == nil || ip.IsLoopback() { + continue + } + ip = ip.To4() + if ip == nil { + continue // not an ipv4 address + } + return ip, nil + } + } + return nil, errors.New("are you connected to the network?") + +} + +/* +func (tx *transaction) LobbyCheckIn(inSocketPort int32) shared.RPCReturnType { + // list.Append(test) + tx.gs.Logger.Printf("remoteaddr %s : %d", tx.r.RemoteAddr, inSocketPort) + + ip, _, err := net.SplitHostPort(tx.r.RemoteAddr) + if err != nil { + tx.gs.Logger.Printf("userip: %q is not IP:port", tx.r.RemoteAddr) + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + + userIP := net.ParseIP(ip) + if userIP == nil { + tx.gs.Logger.Printf("userip: %q is not IP:port", tx.r.RemoteAddr) + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + + if userIP.IsLoopback() { + if tmpIp, err := externalIP(); err == nil { + userIP = tmpIp + } else { + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + } + + tx.gs.LobbyCheckIn(userIP, inSocketPort) + + return shared.MakeRPCReturn("lobby checked in.", nil) +} + +func (tx *transaction) WorldCheckIn(inSocketPort int32) shared.RPCReturnType { + // list.Append(test) + tx.gs.Logger.Printf("remoteaddr %s : %d", tx.r.RemoteAddr, inSocketPort) + + ip, _, err := net.SplitHostPort(tx.r.RemoteAddr) + if err != nil { + tx.gs.Logger.Printf("userip: %q is not IP:port", tx.r.RemoteAddr) + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + + userIP := net.ParseIP(ip) + if userIP == nil { + tx.gs.Logger.Printf("userip: %q is not IP:port", tx.r.RemoteAddr) + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + + if userIP.IsLoopback() { + if tmpIp, err := externalIP(); err == nil { + userIP = tmpIp + } else { + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + } + + tx.gs.WorldCheckIn(userIP, inSocketPort) + + return shared.MakeRPCReturn("world checked in.", nil) +} +*/ + +func (tx *transaction) GetCheckedIn(Type int32, Version string) shared.RPCReturnType { + + // url := tx.gs.GetUrlLobbyChekedIn() + url := tx.gs.FindDsCheckedIn(Type, Version) + tx.gs.Logger.Println("lobby url checked in : ", url) + if url == "" { + return shared.MakeRPCReturn(nil, errors.New("no url")) + } else { + return shared.MakeRPCReturn(url, nil) + } +} + +// func (tx *transaction) GetLobbyCheckedIn() shared.RPCReturnType { + +// // url := tx.gs.GetUrlLobbyChekedIn() +// url := tx.gs.FindDsCheckedIn(2) +// tx.gs.Logger.Println("lobby url checked in : ", url) +// if url == "" { +// return shared.MakeRPCReturn(nil, errors.New("no url")) +// } else { +// return shared.MakeRPCReturn(url, nil) +// } +// } + +// func (tx *transaction) GetWorldCheckedIn() shared.RPCReturnType { + +// // url := tx.gs.GetUrlWorldChekedIn() +// url := tx.gs.FindDsCheckedIn(1) +// tx.gs.Logger.Println("world url checked in : ", url) +// if url == "" { +// return shared.MakeRPCReturn(nil, errors.New("no url")) +// } else { +// return shared.MakeRPCReturn(url, nil) +// } +// } + +func (tx *transaction) ReadDB(collection string, _id interface{}) shared.RPCReturnType { + + raw, err := tx.gs.mongoClient.FindOneAndUpdate(shared.CollectionName(collection), + bson.M{"_id": _id}, + bson.M{ + "$setOnInsert": bson.M{"_id": _id}, + }, + options.FindOneAndUpdate().SetProjection(bson.M{"_id": 0, "_ts": 0}), + options.FindOneAndUpdate().SetReturnDocument(options.After), + options.FindOneAndUpdate().SetUpsert(true)) + + tx.gs.Logger.Println("db read : ", _id, raw) + + return shared.MakeRPCReturn(raw, err) +} + +func (tx *transaction) ReadMany(collection string, in []interface{}) shared.RPCReturnType { + + raw, err := tx.gs.mongoClient.FindAll(shared.CollectionName(collection), bson.M{"_id": bson.M{"$in": in}}, + options.Find().SetProjection(bson.M{"_ts": 0})) + + tx.gs.Logger.Println("db read : ", raw) + + return shared.MakeRPCReturn(raw, err) +} + +func (tx *transaction) WriteDB(collection string, raw map[string]interface{}) shared.RPCReturnType { + + tx.gs.Logger.Println("db access in collection : ", collection, raw) + + _, _, err := tx.gs.mongoClient.Update(shared.CollectionName(collection), + bson.M{"_id": raw["_id"]}, + bson.M{ + "$currentDate": bson.M{"_ts": true}, + "$set": raw, + }, options.Update().SetUpsert(true)) + + return shared.MakeRPCReturn(nil, err) +} + +func (tx *transaction) RemoveDB(collection string, keys []interface{}) shared.RPCReturnType { + + count, err := tx.gs.mongoClient.DeleteMany(shared.CollectionName(collection), bson.M{"_id": bson.M{"$in": keys}}) + + return shared.MakeRPCReturn(count, err) +} + +func (tx *transaction) UpdatePlayerInfo(raw map[string]interface{}) shared.RPCReturnType { + + var playerid string + if v, ok := tx.r.Header["Player-Id"]; ok && len(v) > 0 { + playerid = v[0] + } else { + return shared.MakeRPCReturn(nil, errors.New("no player id")) + } + + tx.gs.Logger.Println("db write : ", playerid, raw) + + _, _, err := tx.gs.mongoClient.Update("PlayerInfo", + bson.M{"_id": playerid}, + bson.M{ + "$currentDate": bson.M{"_ts": true}, + "$set": raw, + }, options.Update().SetUpsert(true)) + + if err == nil { + return shared.MakeRPCReturn("update success", err) + } else { + return shared.MakeRPCReturn(nil, errors.New("invalid body")) + } +} + +func (tx *transaction) GetPlayerInfo() shared.RPCReturnType { + + var playerid string + if v, ok := tx.r.Header["Player-Id"]; ok && len(v) > 0 { + playerid = v[0] + } else { + return shared.MakeRPCReturn(nil, errors.New("no player id")) + } + + raw, err := tx.gs.mongoClient.FindOneAndUpdate("PlayerInfo", + bson.M{"_id": playerid}, + bson.M{ + "$setOnInsert": bson.M{"_id": playerid, "charId": 101}, + }, + options.FindOneAndUpdate().SetProjection(bson.M{"_id": 0, "_ts": 0}), + options.FindOneAndUpdate().SetReturnDocument(options.After), + options.FindOneAndUpdate().SetUpsert(true)) + + tx.gs.Logger.Println("db read : ", playerid, raw) + + if err == nil { + return shared.MakeRPCReturn(raw, err) + } else { + return shared.MakeRPCReturn(nil, errors.New("not matched")) + } +} + +func (tx *transaction) UpdateInventory(charId int32, raw map[string]interface{}) shared.RPCReturnType { + + var playerid string + if v, ok := tx.r.Header["Player-Id"]; ok && len(v) > 0 { + playerid = v[0] + } else { + return shared.MakeRPCReturn(nil, errors.New("no player id")) + } + + tx.gs.Logger.Println("inventory write : ", playerid, raw) + + var err error + + q, _ := tx.gs.mongoClient.FindOne("Inventory", bson.M{"_id": playerid, "inven.charId": charId}, + options.FindOne().SetProjection(bson.M{"inven.$": 1})) + + if q == nil { + _, _, err = tx.gs.mongoClient.Update("Inventory", + bson.M{"_id": playerid}, + bson.M{ + "$currentDate": bson.M{"_ts": true}, + "$addToSet": bson.M{"inven": bson.M{"charId": charId, "slots": raw}}, + }, + options.Update().SetUpsert(true)) + } else { + // _, _, err = tx.gs.mongoClient.Update("Inventory", + // bson.M{"_id": playerid}, + // bson.M{ + // "$currentDate": bson.M{"_ts": true}, + // "$set": bson.M{"inven.$[x].slots": raw}, + // }, + // options.Update().SetArrayFilters(options.ArrayFilters{Filters: bson.A{bson.M{"x.charId": charId}}}), + // options.Update().SetUpsert(true)) + + slots := q["inven"].(bson.A)[0].(map[string]interface{})["slots"].(map[string]interface{}) + tx.gs.Logger.Println("current inventory", slots) + + for k, v := range raw { + slots[k] = v + } + + tx.gs.Logger.Println("new inventory", slots) + + _, _, err = tx.gs.mongoClient.Update("Inventory", + bson.M{"_id": playerid, "inven.charId": charId}, + bson.M{ + "$currentDate": bson.M{"_ts": true}, + "$set": bson.M{"inven.$.slots": slots}, + }) + } + + if err == nil { + tx.gs.Logger.Println("inventory write success") + + return shared.MakeRPCReturn(raw, err) + } else { + return shared.MakeRPCReturn(nil, errors.New("invalid body")) + } +} + +func (tx *transaction) GetInventory(charId int32) shared.RPCReturnType { + + var playerid string + if v, ok := tx.r.Header["Player-Id"]; ok && len(v) > 0 { + playerid = v[0] + } else { + return shared.MakeRPCReturn(nil, errors.New("no player id")) + } + + raw, err := tx.gs.mongoClient.FindOne("Inventory", + bson.M{"_id": playerid, "inven.charId": charId}, + options.FindOne().SetProjection(bson.M{"inven.$": 1})) + + if raw == nil { + _, err = tx.gs.mongoClient.FindOneAndUpdate("Inventory", + bson.M{"_id": playerid}, + bson.M{ + "$setOnInsert": bson.M{"_id": playerid, "inven": bson.A{}}, + }, + options.FindOneAndUpdate().SetUpsert(true)) + + raw, err = tx.gs.mongoClient.FindOneAndUpdate("Inventory", + bson.M{"_id": playerid}, + bson.M{ + "$currentDate": bson.M{"_ts": true}, + "$addToSet": bson.M{"inven": bson.M{"charId": charId, "slots": bson.M{}}}, + }, + options.FindOneAndUpdate().SetProjection(bson.M{"inven": bson.M{"$elemMatch": bson.M{"charId": charId}}}), + options.FindOneAndUpdate().SetReturnDocument(options.After), + options.FindOneAndUpdate().SetUpsert(true)) + } + + // raw, err := tx.gs.mongoClient.FindOneAndUpdate("Inventory", + // bson.M{"_id": playerid, "inven.charId": charId}, + // bson.M{ + // "$setOnInsert": bson.M{"_id": playerid, "inven": bson.A{bson.M{"charId": charId, "slots": bson.M{}}}}, + // }, + // options.FindOneAndUpdate().SetProjection(bson.M{"inven.$": 1}), + // options.FindOneAndUpdate().SetReturnDocument(options.After), + // options.FindOneAndUpdate().SetUpsert(true)) + + if err == nil { + slots := raw["inven"].(bson.A)[0].(map[string]interface{})["slots"] + tx.gs.Logger.Println("inventory read : ", playerid, slots) + return shared.MakeRPCReturn(slots, err) + } else { + return shared.MakeRPCReturn(nil, errors.New("not matched")) + } +} diff --git a/core/AEGS_test.go b/core/AEGS_test.go new file mode 100644 index 0000000..347a4f1 --- /dev/null +++ b/core/AEGS_test.go @@ -0,0 +1,91 @@ +package core + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestDSRegister(t *testing.T) { + // if tt, err := New(); err != nil { + // panic(err) + // } else { + // err := tt.Start(nil) + // if err != nil { + // panic(err) + // } + + // time.Sleep(5) + + // tt.Shutdown(shared.ShutdownFlagTerminating) + // } + + assert := assert.New(t) + + tt, _ := New() + mux := http.NewServeMux() + tt.registerHandlers(mux, "") + + // hello call + { + helloCall := struct { + Method string + }{Method: "Hello"} + + res := httptest.NewRecorder() + content, _ := json.Marshal(helloCall) + req := httptest.NewRequest("POST", "/", bytes.NewBuffer(content)) + + mux.ServeHTTP(res, req) + + assert.Equal(http.StatusOK, res.Code) + } + + // url := "127.0.0.2" + + // checkin call + { + // helloCall := struct { + // Method string + // Args []interface{} + // }{Method: "CheckIn", Args: []interface{}{url /*"fuck", struct{ test string }{test: "numb"}*/}} + checkInCall := struct { + Method string + }{Method: "CheckIn"} + + res := httptest.NewRecorder() + content, _ := json.Marshal(checkInCall) + req := httptest.NewRequest("POST", "/", bytes.NewBuffer(content)) + + mux.ServeHTTP(res, req) + + assert.Equal(http.StatusOK, res.Code) + } + + // is checked in + { + helloCall := struct { + Method string + Args []interface{} + }{Method: "GetCheckedIn"} + + res := httptest.NewRecorder() + content, _ := json.Marshal(helloCall) + req := httptest.NewRequest("POST", "/", bytes.NewBuffer(content)) + + mux.ServeHTTP(res, req) + + assert.Equal(http.StatusOK, res.Code) + data, _ := io.ReadAll(res.Body) + assert.Equal(req.RemoteAddr, string(data)) + + fmt.Println("return : ", string(data)) + } + +} diff --git a/core/AeGameServer.go b/core/AeGameServer.go new file mode 100644 index 0000000..0314b59 --- /dev/null +++ b/core/AeGameServer.go @@ -0,0 +1,366 @@ +package core + +import ( + "anvil/shared" + "bytes" + "fmt" + "io" + "io/ioutil" + "log" + "net" + "net/http" + "os" + "path" + "runtime/debug" + "sync" + "time" + + "github.com/gorilla/websocket" +) + +// Warehouse : +type AeGameServer struct { + version string + fullversion string + Logger *log.Logger + + server *shared.Server + + mongoClient shared.MongoClient + + WorldIp net.IP + WorldPort int32 + + LobbyIp net.IP + LobbyPort int32 + + sockets []*SocketContext + + lock sync.Mutex +} + +type transaction struct { + gs *AeGameServer + + w http.ResponseWriter + r *http.Request +} + +type SocketContext struct { + connection *websocket.Conn + + gs *AeGameServer + + Type int32 + Port int32 + Ip net.IP + Version string + + lock sync.Mutex +} + +// type category struct { +// gs *TestTest +// name string +// } + +// type constCategory struct { +// category +// w http.ResponseWriter +// r *http.Request +// } + +// Version : +func (gs *AeGameServer) Version() string { + return gs.version +} + +// New : +func New() (*AeGameServer, error) { + + logfilename := fmt.Sprintf("AEGS_%s.log", time.Now().Format("2006-01-02T15-04-05")) + logFile, err := os.OpenFile(logfilename, os.O_CREATE|os.O_WRONLY|os.O_CREATE, 0666) + if err != nil { + panic(err) + } + + w := &AeGameServer{ + version: "0.0.1", + fullversion: "0.0.1.0", + Logger: log.New(io.MultiWriter(logFile, os.Stdout), "[AEGS]", log.LstdFlags), + } + + return w, nil +} + +// IsRunning : +func (gs *AeGameServer) IsRunning() bool { + return gs.server.ShutdownFlag() == shared.ShutdownFlagRunning +} + +// Start : +func (gs *AeGameServer) Start(serveMux *http.ServeMux) error { + http.DefaultClient.Timeout = time.Minute * 1 + gs.sockets = make([]*SocketContext, 0, 10) + + if serveMux != nil { + // 외부 serveMux가 있을 때는 registerHandler를 한번만 해야한다. + gs.registerHandlers(serveMux, "AeGameServer") + gs.server = shared.NewDependentServer(nil) + } + + printStartErr := false + for { + if serveMux == nil { + serveMux = http.NewServeMux() + gs.registerHandlers(serveMux, "") + gs.server = shared.NewHTTPServer(serveMux, nil) + } + + err := gs.startimpl() + if err != nil { + if !printStartErr { + printStartErr = true + fmt.Println(err) + } + time.Sleep(time.Second) + continue + } + + printStartErr = false + for { + sf := gs.server.ShutdownFlag() + if sf == shared.ShutdownFlagTerminating { + return err + } else if sf == shared.ShutdownFlagIdle { + time.Sleep(time.Second) + } else if sf == shared.ShutdownFlagRestarting { + break + } + } + } +} + +func (gs *AeGameServer) startimpl() (err error) { + + gs.Logger.Println("creating MongoClient...") + gs.mongoClient, err = shared.NewMongoClient(&shared.ConnectionInfo{ + Url: "mongodb://192.168.8.94:27017/?replicaSet=repl01", + Database: "AEtest", + }) + if err != nil { + gs.Logger.Println("failed to create MongoClient. shutting down.") + gs.server.Shutdown(shared.ShutdownFlagTerminating) + return err + } + defer gs.mongoClient.Close() + + gs.server.Start() + + return nil +} + +func (gs *AeGameServer) Shutdown(flag shared.ShutdownFlag) { + gs.server.Shutdown(flag) +} + +func (gs *AeGameServer) registerHandlers(serveMux *http.ServeMux, prefix string) error { + + if len(prefix) > 0 && prefix[0] != '/' { + prefix = "/" + prefix + } + + if len(prefix) > 0 && prefix[len(prefix)-1] == '/' { + prefix = prefix[0 : len(prefix)-1] + } + + if len(prefix) == 0 { + prefix = "/" + } + + var upgrader = websocket.Upgrader{} // use default options + + serveMux.HandleFunc(prefix, func(w http.ResponseWriter, r *http.Request) { + + defer func() { + s := recover() + if s != nil { + debug.PrintStack() + gs.Logger.Println(s) + } + + io.Copy(ioutil.Discard, r.Body) + r.Body.Close() + }() + + if r.ContentLength == 0 { + w.Write([]byte("no content")) + return + } + + body, err := ioutil.ReadAll(r.Body) + if err != nil { + w.WriteHeader(http.StatusInternalServerError) + return + } + + tx := &transaction{ + gs: gs, + w: w, + r: r, + } + + if retval, err := shared.CallMethod(tx, body); err != nil { + gs.Logger.Println("CallMethod failed : ", r.RemoteAddr, string(body), r.Header, err) + w.WriteHeader(http.StatusInternalServerError) + } else { + retval.Serialize(w) + } + + }) + + serveMux.HandleFunc(path.Join(prefix, "ws"), func(w http.ResponseWriter, r *http.Request) { + + gs.lock.Lock() + defer gs.lock.Unlock() + + defer func() { + s := recover() + if s != nil { + debug.PrintStack() + gs.Logger.Println(s) + } + + io.Copy(ioutil.Discard, r.Body) + r.Body.Close() + }() + + conn, err := upgrader.Upgrade(w, r, nil) + + st := &SocketContext{ + gs: gs, + connection: conn, + } + + gs.sockets = append(gs.sockets, st) + + if err != nil { + gs.Logger.Printf("upgrader.Upgrade: %v", err) + return + } + + go func() { + for { + _, body, err := st.connection.ReadMessage() + + if err != nil { + gs.Logger.Printf("conn.ReadMessage: %v", err) + + func() { + gs.lock.Lock() + defer gs.lock.Unlock() + + for i, s := range gs.sockets { + if st == s { + gs.sockets[i] = gs.sockets[len(gs.sockets)-1] + gs.sockets = gs.sockets[:len(gs.sockets)-1] + break + } + } + }() + + st.connection.Close() + + return + } else { + + gs.Logger.Printf("msg from socket %s %s %s", st.connection.LocalAddr(), st.connection.RemoteAddr(), body) + + if retval, err := shared.CallMethod(st, body); err != nil { + gs.Logger.Println("CallMethod failed : ", r.RemoteAddr, string(body), r.Header, err) + w.WriteHeader(http.StatusInternalServerError) + } else { + var b bytes.Buffer + retval.Serialize(&b) + st.connection.WriteMessage(websocket.TextMessage, b.Bytes()) + } + } + } + }() + }) + + // categoryHandler := func(name string, receiver interface{}, w http.ResponseWriter, r *http.Request) { + + // defer func() { + // s := recover() + // if s != nil { + // debug.PrintStack() + // gs.Logger.Println(s) + // } + + // io.Copy(ioutil.Discard, r.Body) + // r.Body.Close() + // }() + + // // ip, port, err := net.SplitHostPort(r.RemoteAddr) + // // if err != nil { + // // //return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr) + + // // gs.Logger.Printf("userip: %q is not IP:port", r.RemoteAddr) + // // } + + // // userIP := net.ParseIP(ip) + // // if userIP == nil { + // // //return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr) + // // gs.Logger.Printf("userip: %q is not IP:port", r.RemoteAddr) + // // return + // // } + + // // // This will only be defined when site is accessed via non-anonymous proxy + // // // and takes precedence over RemoteAddr + // // // Header.Get is case-insensitive + // // forward := r.Header.Get("X-Forwarded-For") + + // // gs.Logger.Printf("

IP: %s

", ip) + // // gs.Logger.Printf("

Port: %s

", port) + // // gs.Logger.Printf("

Forwarded for: %s

", forward) + + // if r.ContentLength == 0 { + // w.Write([]byte("no content")) + // return + // } + + // body, err := ioutil.ReadAll(r.Body) + // if err != nil { + // w.WriteHeader(http.StatusInternalServerError) + // } + + // if len(body) == 0 { + // w.Write([]byte("no body")) + // gs.Logger.Println("no body") + // return + // } + + // if retval, err := shared.CallMethod(receiver, body); err != nil { + // gs.Logger.Println("CallMethod failed : ", r.RemoteAddr, string(body), r.Header, err) + // } else { + // retval.Serialize(w) + // } + // } + + // serveMux.HandleFunc(prefix+"/const", func(w http.ResponseWriter, r *http.Request) { + // // 읽기 전용 + // constcat := constCategory{ + // category: category{ + // gs: gs, + // name: "const", + // }, + // w: w, + // r: r, + // } + + // categoryHandler(constcat.name, &constcat, w, r) + // }) + + return nil +} diff --git a/core/SocketContext.go b/core/SocketContext.go new file mode 100644 index 0000000..e631aa6 --- /dev/null +++ b/core/SocketContext.go @@ -0,0 +1,75 @@ +package core + +import ( + "anvil/shared" + "errors" + "fmt" + "math/rand" + "net" +) + +func (st *SocketContext) Hello() shared.RPCReturnType { + st.gs.Logger.Println("hello from socket client.") + return shared.MakeRPCReturn("hello from socket server, too.", nil) +} + +func (st *SocketContext) IsCompatible(Type int32, Version string) bool { + st.lock.Lock() + defer st.lock.Unlock() + + return st.Type == Type && st.Version == Version +} + +func (st *SocketContext) GetUrlChekedIn() string { + st.lock.Lock() + defer st.lock.Unlock() + + if len(st.Ip) != 0 { + return fmt.Sprintf("%s:%d", st.Ip.String(), st.Port) + } else { + return "" + } +} + +func (st *SocketContext) GetPriority() float32 { + return rand.Float32() +} + +func (st *SocketContext) DSCheckIn(DsType int32, inSocketPort int32, Version string) shared.RPCReturnType { + st.lock.Lock() + defer st.lock.Unlock() + + addr := st.connection.RemoteAddr().String() + + st.gs.Logger.Printf("remoteaddr %s : %d", addr, inSocketPort) + + ip, _, err := net.SplitHostPort(addr) + if err != nil { + st.gs.Logger.Printf("userip: %q is not IP:port", addr) + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + + userIP := net.ParseIP(ip) + if userIP == nil { + st.gs.Logger.Printf("userip: %q is not IP:port", addr) + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + + if userIP.IsLoopback() { + if tmpIp, err := externalIP(); err == nil { + userIP = tmpIp + } else { + return shared.MakeRPCReturn(nil, errors.New("IP invalid")) + } + } + + // st.gs.LobbyCheckIn(userIP, inSocketPort) + st.Ip = userIP + st.Port = inSocketPort + st.Type = DsType + st.Version = Version + + st.gs.Logger.Printf("type : %d, id : %s, port : %d, version : %s", DsType, userIP, inSocketPort, st.Version) + + return shared.MakeRPCReturn("ds checked in.", nil) +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..be65efe --- /dev/null +++ b/go.mod @@ -0,0 +1,17 @@ +module anvil + +go 1.16 + +require ( + github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0 + github.com/golang-jwt/jwt v3.2.1+incompatible + github.com/gomodule/redigo v1.8.5 + github.com/gorilla/websocket v1.4.2 + github.com/oschwald/geoip2-golang v1.5.0 // indirect + github.com/shirou/gopsutil/v3 v3.21.6 + github.com/stretchr/testify v1.8.0 // indirect + go.mongodb.org/mongo-driver v1.7.0 + golang.org/x/tools v0.1.12 // indirect + gopkg.in/square/go-jose.v2 v2.6.0 // indirect + software.sslmate.com/src/go-pkcs12 v0.0.0-20210415151418-c5206de65a78 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..3d2ac26 --- /dev/null +++ b/go.sum @@ -0,0 +1,190 @@ +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d h1:G0m3OIz70MZUWq3EgK3CesDbo8upS2Vm9/P3FtgI+Jk= +github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= +github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0 h1:BVts5dexXf4i+JX8tXlKT0aKoi38JwTXSe+3WUneX0k= +github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0/go.mod h1:FDIQmoMNJJl5/k7upZEnGvgWVZfFeE6qHeN7iCMbCsA= +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/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI= +github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM= +github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0= +github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY= +github.com/gobuffalo/depgen v0.1.0/go.mod h1:+ifsuy7fhi15RWncXQQKjWS9JPkdah5sZvtHc2RXGlg= +github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= +github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= +github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs= +github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI= +github.com/gobuffalo/flect v0.1.3/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI= +github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk= +github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28= +github.com/gobuffalo/genny v0.1.0/go.mod h1:XidbUqzak3lHdS//TPu2OgiFB+51Ur5f7CSnXZ/JDvo= +github.com/gobuffalo/genny v0.1.1/go.mod h1:5TExbEyY48pfunL4QSXxlDOmdsD44RRq4mVZ0Ex28Xk= +github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw= +github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360= +github.com/gobuffalo/gogen v0.1.0/go.mod h1:8NTelM5qd8RZ15VjQTFkAW6qOMx5wBbW4dSCS3BY8gg= +github.com/gobuffalo/gogen v0.1.1/go.mod h1:y8iBtmHmGc4qa3urIyo1shvOD8JftTtfcKi+71xfDNE= +github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8= +github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= +github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= +github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= +github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= +github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ= +github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0= +github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw= +github.com/golang-jwt/jwt v3.2.1+incompatible h1:73Z+4BJcrTC+KczS6WvTPvRGOp1WmfEP4Q1lOd9Z/+c= +github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4= +github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/gomodule/redigo v1.8.5 h1:nRAxCa+SVsyjSBrtZmG/cqb6VbTmuRzpg/PoTFlpumc= +github.com/gomodule/redigo v1.8.5/go.mod h1:P9dn9mFrCBvWhGE1wpxx6fgq7BAeLBk+UUUzlpkBYO0= +github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= +github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4= +github.com/karrick/godirwalk v1.10.3/go.mod h1:RoGL9dQei4vP9ilrpETWE8CLOZ1kiN0LhBygSwrAsHA= +github.com/klauspost/compress v1.9.5 h1:U+CaK85mrNNb4k8BNOfgJtJ/gr6kswUCFj6miSzVC6M= +github.com/klauspost/compress v1.9.5/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE= +github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0= +github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= +github.com/oschwald/geoip2-golang v1.5.0 h1:igg2yQIrrcRccB1ytFXqBfOHCjXWIoMv85lVJ1ONZzw= +github.com/oschwald/geoip2-golang v1.5.0/go.mod h1:xdvYt5xQzB8ORWFqPnqMwZpCpgNagttWdoZLlJQzg7s= +github.com/oschwald/maxminddb-golang v1.8.0 h1:Uh/DSnGoxsyp/KYbY1AuP0tYEwfs0sCph9p/UMXK/Hk= +github.com/oschwald/maxminddb-golang v1.8.0/go.mod h1:RXZtst0N6+FY/3qCNmZMBApR19cdQj43/NM9VkrNAis= +github.com/pelletier/go-toml v1.7.0/go.mod h1:vwGMzjaWMwyfHwgIBhI2YUM4fB6nL6lVAvS1LBMMhTE= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +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.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/shirou/gopsutil/v3 v3.21.6 h1:vU7jrp1Ic/2sHB7w6UNs7MIkn7ebVtTb5D9j45o9VYE= +github.com/shirou/gopsutil/v3 v3.21.6/go.mod h1:JfVbDpIBLVzT8oKbvMg9P3wEIMDDpVn+LwHTKj0ST88= +github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= +github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= +github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= +github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/tidwall/pretty v1.0.0 h1:HsD+QiTn7sK6flMKIvNmpqz1qrpP3Ps6jOKIKMooyg4= +github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= +github.com/tklauser/go-sysconf v0.3.6 h1:oc1sJWvKkmvIxhDHeKWvZS4f6AW+YcoguSfRF2/Hmo4= +github.com/tklauser/go-sysconf v0.3.6/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI= +github.com/tklauser/numcpus v0.2.2 h1:oyhllyrScuYI6g+h/zUvNXNp1wy7x8qQy3t/piefldA= +github.com/tklauser/numcpus v0.2.2/go.mod h1:x3qojaO3uyYt0i56EW/VUYs7uBvdl2fkfZFu0T9wgjM= +github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c= +github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI= +github.com/xdg-go/scram v1.0.2 h1:akYIkZ28e6A96dkWNJQu3nmCzH3YfwMPQExUYDaRv7w= +github.com/xdg-go/scram v1.0.2/go.mod h1:1WAq6h33pAW+iRreB34OORO2Nf7qel3VV3fjBj+hCSs= +github.com/xdg-go/stringprep v1.0.2 h1:6iq84/ryjjeRmMJwxutI51F2GIPlP5BfTvXHeYjyhBc= +github.com/xdg-go/stringprep v1.0.2/go.mod h1:8F9zXuvzgwmyT5DUm4GUfZGDdT3W+LCvS6+da4O5kxM= +github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA= +github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA= +github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.mongodb.org/mongo-driver v1.7.0 h1:hHrvOBWlWB2c7+8Gh/Xi5jj82AgidK/t7KVXBZ+IyUA= +go.mongodb.org/mongo-driver v1.7.0/go.mod h1:Q4oFMbo1+MSNqICAdYMlC/zSTrwCogR4R8NzkI+yfU8= +golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190422162423-af44ce270edf/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= +golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073 h1:xMPOj6Pz6UipU1wXLkrtqpHbR0AVFnyPEQq/wRWz9lM= +golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g= +golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= +golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 h1:/UOmuWzQfxxo9UtlXMwuQU8CMgg1eZXqTRwkSQJWKOI= +golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 h1:7I4JAnoQBe7ZtJcBaYHi5UtiO8tQHbUSXxL+pnGRANg= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +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-20220722155237-a158d28d115b h1:PxfKdU9lEEDYjdIzOtC4qFWgkU2rGHdKlKowJSMN9h0= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190419153524-e8e3143a4f4a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190531175056-4c3a928424d2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191224085550-c709ea063b76/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa h1:ZYxPR6aca/uhfRJyaOAtflSHjJYiktO7QnJC5ut7iY4= +golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4= +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 h1:v4INt8xihDGvnrfjMDVXGxw9wrfxYyCjk0KbXjhR55s= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= +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= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5 h1:i6eZZ+zk0SOf0xgBpEpPD18qWcJda6q1sxt3S0kzyUQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190416151739-9c9e1878f421/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190420181800-aa740d480789/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190531172133-b3315ee88b7d/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12 h1:VveCTK38A2rkS8ZqFY25HIDFscX5X9OoEhJd3quQmXU= +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 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/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/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/square/go-jose.v2 v2.6.0 h1:NGk74WTnPKBNUhNzQX7PYcTLUjoq7mzKk2OKbvwk2iI= +gopkg.in/square/go-jose.v2 v2.6.0/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +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= +software.sslmate.com/src/go-pkcs12 v0.0.0-20210415151418-c5206de65a78 h1:SqYE5+A2qvRhErbsXFfUEUmpWEKxxRSMgGLkvRAFOV4= +software.sslmate.com/src/go-pkcs12 v0.0.0-20210415151418-c5206de65a78/go.mod h1:B7Wf0Ya4DHF9Yw+qfZuJijQYkWicqDa+79Ytmmq3Kjg= diff --git a/main.go b/main.go new file mode 100644 index 0000000..5792e3f --- /dev/null +++ b/main.go @@ -0,0 +1,34 @@ +// warroom project main.go +package main + +import ( + "anvil/core" +) + +func main() { + // lobby, world server 자동 실행 + // { + // cmd := exec.Command("cmd.exe", "/C", "RunDS_FFA.bat") + // cmd.Dir = ".." + // if err := cmd.Run(); err != nil { + // log.Fatal(err) + // } + // } + + // { + // cmd := exec.Command("cmd.exe", "/C", "RunDS_FFALobby.bat") + // cmd.Dir = ".." + // if err := cmd.Run(); err != nil { + // log.Fatal(err) + // } + // } + + if wh, err := core.New(); err != nil { + panic(err) + } else { + err := wh.Start(nil) + if err != nil { + panic(err) + } + } +} diff --git a/shared/mongo.go b/shared/mongo.go new file mode 100644 index 0000000..539c304 --- /dev/null +++ b/shared/mongo.go @@ -0,0 +1,322 @@ +package shared + +import ( + "context" + "errors" + "flag" + "os" + "time" + + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/bson/primitive" + "go.mongodb.org/mongo-driver/mongo" + "go.mongodb.org/mongo-driver/mongo/options" +) + +type MongoClient struct { + db *mongo.Database + c *mongo.Client +} + +type ConnectionInfo struct { + Url string + Database string +} + +var Devflag = flag.Bool("dev", false, "") + +type CollectionName string + +const ( + CollectionCoupon = CollectionName("coupon") + CollectionCouponUse = CollectionName("coupon_use") + CollectionAccount = CollectionName("account") + CollectionAuth = CollectionName("auth") + CollectionMatch = CollectionName("match") +) + +func mongourl() string { + v := os.Getenv("MONGO_URL") + if len(v) > 0 { + return v + } + return "mongodb://redis-dev.actionsquare.corp:27017/?replicaSet=repl01" +} + +func NewMongoConnectionInfo() *ConnectionInfo { + if !flag.Parsed() { + flag.Parse() + } + dbname := "anvil" + if *Devflag { + dbname, _ = os.Hostname() + } + + return &ConnectionInfo{ + Url: mongourl(), + Database: dbname, + } +} +func (ci *ConnectionInfo) SetURL(url string) *ConnectionInfo { + ci.Url = url + return ci +} + +func (ci *ConnectionInfo) SetDatabase(dbname string) *ConnectionInfo { + ci.Database = dbname + return ci +} + +func NewMongoClient(ci *ConnectionInfo) (MongoClient, error) { + if len(ci.Url) == 0 { + return MongoClient{}, errors.New("mongo connection string is empty") + } + + client, err := mongo.NewClient(options.Client().ApplyURI(ci.Url)) + if err != nil { + return MongoClient{}, err + } + + ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second) + defer cancel() + + err = client.Connect(ctx) + if err != nil { + return MongoClient{}, err + } + err = client.Ping(ctx, nil) + if err != nil { + return MongoClient{}, err + } + + anvildb := client.Database(ci.Database, nil) + makeExpiredIndex := func(collname CollectionName, expireSeconds int32) error { + matchcoll := anvildb.Collection(string(collname)) + indices, err := matchcoll.Indexes().List(ctx, options.ListIndexes().SetMaxTime(time.Second)) + if err != nil { + return err + } + + allindices := make([]interface{}, 0) + err = indices.All(context.Background(), &allindices) + if err != nil { + return err + } + + tsfound := false + var tsname string + var exp int32 + for _, index := range allindices { + d := index.(bson.D) + key := d.Map()["key"].(bson.D) + for _, kd := range key { + if kd.Key == "_ts" { + tsfound = true + } + } + + if v, ok := d.Map()["name"]; ok { + tsname = v.(string) + } + if v, ok := d.Map()["expireAfterSeconds"]; ok { + exp = v.(int32) + } + } + + if tsfound { + if exp == expireSeconds { + return nil + } + _, err = matchcoll.Indexes().DropOne(ctx, tsname) + if err != nil { + return err + } + } + + mod := mongo.IndexModel{ + Keys: primitive.M{"_ts": 1}, + Options: options.Index().SetExpireAfterSeconds(expireSeconds), + } + + _, err = matchcoll.Indexes().CreateOne(ctx, mod) + return err + } + + if err = makeExpiredIndex(CollectionMatch, 30); err != nil { + return MongoClient{}, err + } + if err = makeExpiredIndex(CollectionAuth, 300); err != nil { + return MongoClient{}, err + } + + return MongoClient{c: client, db: anvildb}, nil +} + +func (mc MongoClient) Close() { + if mc.c != nil { + mc.c.Disconnect(context.Background()) + } +} + +func (mc MongoClient) Watch(coll CollectionName, pipeline mongo.Pipeline) (*mongo.ChangeStream, error) { + return mc.Collection(coll).Watch(context.Background(), pipeline, options.ChangeStream().SetFullDocument(options.UpdateLookup).SetMaxAwaitTime(0)) +} + +func (mc MongoClient) Collection(collname CollectionName) *mongo.Collection { + return mc.db.Collection(string(collname)) +} + +func (mc MongoClient) All(coll CollectionName, opts ...*options.FindOptions) ([]bson.M, error) { + cursor, err := mc.Collection(coll).Find(context.Background(), bson.D{}, opts...) + if err != nil { + return nil, err + } + var all []bson.M + err = cursor.All(context.Background(), &all) + if err != nil { + return nil, err + } + + return all, nil +} + +func (mc MongoClient) FindOneAndDelete(coll CollectionName, filter bson.M) (bson.M, error) { + result := mc.Collection(coll).FindOneAndDelete(context.Background(), filter) + err := result.Err() + if err != nil { + if err == mongo.ErrNoDocuments { + return nil, nil + } + return nil, err + } + + tmp := make(map[string]interface{}) + err = result.Decode(&tmp) + if err != nil { + return nil, err + } + + return bson.M(tmp), nil +} + +func (mc MongoClient) Delete(coll CollectionName, filter bson.M) (bool, error) { + r, err := mc.Collection(coll).DeleteOne(context.Background(), filter) + if err != nil { + return false, err + } + + return r.DeletedCount > 0, nil +} + +func (mc MongoClient) UnsetField(coll CollectionName, filter bson.M, doc bson.M) error { + _, err := mc.Collection(coll).UpdateOne(context.Background(), filter, bson.M{ + "$unset": doc, + }) + return err +} + +func (mc MongoClient) DeleteMany(coll CollectionName, filters bson.M, opts ...*options.DeleteOptions) (int, error) { + result, err := mc.Collection(coll).DeleteMany(context.Background(), filters, opts...) + if err != nil { + return 0, err + } + + return int(result.DeletedCount), nil +} + +func (mc MongoClient) InsertMany(coll CollectionName, documents []interface{}, opts ...*options.InsertManyOptions) (int, error) { + result, err := mc.Collection(coll).InsertMany(context.Background(), documents, opts...) + if err != nil { + return 0, err + } + + return len(result.InsertedIDs), nil +} + +func (mc MongoClient) UpdateMany(coll CollectionName, filter bson.M, doc bson.M, opts ...*options.UpdateOptions) (count int, err error) { + result, e := mc.Collection(coll).UpdateMany(context.Background(), filter, doc, opts...) + + if e != nil { + return 0, e + } + + err = nil + count = int(result.UpsertedCount + result.ModifiedCount) + return +} + +func (mc MongoClient) Update(coll CollectionName, filter bson.M, doc bson.M, opts ...*options.UpdateOptions) (worked bool, newid interface{}, err error) { + result, e := mc.Collection(coll).UpdateOne(context.Background(), filter, doc, opts...) + + if e != nil { + return false, "", e + } + + err = nil + worked = result.UpsertedCount > 0 || result.ModifiedCount > 0 + newid = result.UpsertedID + return +} + +func (mc MongoClient) UpsertOne(coll CollectionName, filter bson.M, doc bson.M) (worked bool, newid interface{}, err error) { + return mc.Update(coll, filter, bson.M{ + "$set": doc, + }, options.Update().SetUpsert(true)) +} + +func (mc MongoClient) FindOne(coll CollectionName, filter bson.M, opts ...*options.FindOneOptions) (doc bson.M, err error) { + result := mc.Collection(coll).FindOne(context.Background(), filter, opts...) + tmp := make(map[string]interface{}) + err = result.Decode(&tmp) + if err == nil { + doc = bson.M(tmp) + } else if err == mongo.ErrNoDocuments { + err = nil + } + + return +} + +func (mc MongoClient) FindOneAndUpdate(coll CollectionName, filter bson.M, doc bson.M, opts ...*options.FindOneAndUpdateOptions) (olddoc bson.M, err error) { + result := mc.Collection(coll).FindOneAndUpdate(context.Background(), filter, doc, opts...) + tmp := make(map[string]interface{}) + err = result.Decode(&tmp) + if err == nil { + olddoc = bson.M(tmp) + } else if err == mongo.ErrNoDocuments { + err = nil + } + + return +} + +func (mc MongoClient) Exists(coll CollectionName, filter bson.M) (bool, error) { + cnt, err := mc.Collection(coll).CountDocuments(context.Background(), filter, options.Count().SetLimit(1)) + if err != nil { + return false, err + } + return cnt > 0, nil +} + +func (mc MongoClient) FindAll(coll CollectionName, filter bson.M, opts ...*options.FindOptions) ([]bson.M, error) { + cursor, err := mc.Collection(coll).Find(context.Background(), filter, opts...) + if err != nil { + return nil, err + } + + output := make([]interface{}, 0) + err = cursor.All(context.Background(), &output) + if err != nil { + return nil, err + } + + docs := make([]bson.M, 0, len(output)) + for _, doc := range output { + one := make(bson.M) + for _, kv := range doc.(bson.D) { + one[kv.Key] = kv.Value + } + docs = append(docs, one) + } + return docs, nil +} diff --git a/shared/server.go b/shared/server.go new file mode 100644 index 0000000..3d9c3c7 --- /dev/null +++ b/shared/server.go @@ -0,0 +1,381 @@ +package shared + +import ( + "context" + "encoding/json" + "errors" + "flag" + "fmt" + "io" + "io/ioutil" + "net/http" + "os" + "os/signal" + "reflect" + "runtime/debug" + "strconv" + "strings" + "sync/atomic" + "syscall" +) + +const ( + // HTTPStatusReloginRequired : http status를 이걸 받으면 클라이언트는 로그아웃하고 로그인 화면으로 돌아가야 한다. + HTTPStatusReloginRequired = 599 + // HTTPStatusReloginRequiredDupID : + HTTPStatusReloginRequiredDupID = 598 + // HTTPStatusPlayerBlocked : + HTTPStatusPlayerBlocked = 597 +) + +type ShutdownFlag int32 + +const ( + ShutdownFlagRunning = ShutdownFlag(0) + ShutdownFlagTerminating = ShutdownFlag(1) + ShutdownFlagRestarting = ShutdownFlag(2) + ShutdownFlagIdle = ShutdownFlag(3) +) + +type functionCallContext struct { + Method string + Args []interface{} +} + +// RPCReturnType : RPC 호출 가능한 함수가 유일하게 리턴할 수 있는 타입 +type RPCReturnType interface { + Serialize(io.Writer) error + Error() error +} + +type rpcReturnTypeImpl struct { + value reflect.Value + err error + serialized []byte +} + +// Bytes : RPCReturnType.Serialize 구현 +func (r rpcReturnTypeImpl) Serialize(w io.Writer) (err error) { + err = r.err + if err != nil { + return err + } + + if len(r.serialized) > 0 { + w.Write(r.serialized) + return nil + } + + if !r.value.IsValid() { + return nil + } + + switch r.value.Kind() { + case reflect.String: + _, err = w.Write([]byte(r.value.String())) + + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + _, err = w.Write([]byte(fmt.Sprintf("%d", r.value.Int()))) + + case reflect.Float32, reflect.Float64: + _, err = w.Write([]byte(fmt.Sprintf("%f", r.value.Float()))) + + case reflect.Slice: + switch r.value.Type().Elem().Kind() { + case reflect.Uint8: + _, err = w.Write(r.value.Bytes()) + + default: + var conv []interface{} + for i := 0; i < r.value.Len(); i++ { + conv = append(conv, r.value.Index(i).Interface()) + } + if len(conv) == 0 { + _, err = w.Write([]byte("[]")) + } else { + err = json.NewEncoder(w).Encode(conv) + } + } + + case reflect.Interface, reflect.Struct, reflect.Map: + err = json.NewEncoder(w).Encode(r.value.Interface()) + + case reflect.Ptr: + if !r.value.IsNil() { + err = json.NewEncoder(w).Encode(r.value.Interface()) + } + } + + return err +} + +// Error : RPCReturnType.Error 구현 +func (r rpcReturnTypeImpl) Error() error { + return r.err +} + +// MakeRPCReturn : +func MakeRPCReturn(value interface{}, err error) RPCReturnType { + return rpcReturnTypeImpl{ + value: reflect.ValueOf(value), + err: err, + } +} + +// MakeRPCReturnSerialized : 이미 시리얼라이즈 한 Return +func MakeRPCReturnSerialized(serialized []byte) RPCReturnType { + return rpcReturnTypeImpl{ + serialized: serialized, + } +} + +// MakeRPCError : +func MakeRPCError(args ...interface{}) RPCReturnType { + return rpcReturnTypeImpl{ + value: reflect.ValueOf(nil), + err: errors.New(fmt.Sprint(args...)), + } +} + +// MakeRPCErrorf : +func MakeRPCErrorf(format string, v ...interface{}) RPCReturnType { + return rpcReturnTypeImpl{ + value: reflect.ValueOf(nil), + err: fmt.Errorf(format, v...), + } +} + +// Server : +type Server struct { + httpserver *http.Server + shutdownFlag ShutdownFlag + preShutdown func() + stopfunc func() +} + +var prefixptr = flag.String("prefix", "", "'") +var portptr = flag.Int("port", 80, "") +var tls = flag.String("tls", "", "") + +func welcomeHandler(w http.ResponseWriter, r *http.Request) { + w.Write([]byte("welcome")) + // welcome은 accesslog 안 남김 + // if atomic.LoadInt32(&serveMux.Shutdowning) == 0 { + // w.Write([]byte("welcome")) + // } else { + // w.WriteHeader(http.StatusServiceUnavailable) + // } + io.Copy(ioutil.Discard, r.Body) + r.Body.Close() +} + +func NewDependentServer(preShutdown func()) *Server { + server := &Server{ + httpserver: nil, + shutdownFlag: ShutdownFlagIdle, + preShutdown: preShutdown, + } + + c := make(chan os.Signal, 1) + signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT) + go func() { + <-c + signal.Stop(c) + server.Shutdown(ShutdownFlagTerminating) + }() + + return server +} + +// NewHTTPServer : +func NewHTTPServer(serveMux *http.ServeMux, preShutdown func()) *Server { + server := NewDependentServer(preShutdown) + // 시작시 자동으로 enable됨 + if len(*tls) > 0 && *portptr == 80 { + *portptr = 443 + } + addr := fmt.Sprintf(":%d", *portptr) + serveMux.HandleFunc("/welcome", welcomeHandler) + + server.httpserver = &http.Server{Addr: addr, Handler: serveMux} + server.httpserver.SetKeepAlivesEnabled(true) + return server +} + +func (server *Server) ShutdownFlag() ShutdownFlag { + return ShutdownFlag(atomic.LoadInt32((*int32)(&server.shutdownFlag))) +} + +// Shutdown : +func (server *Server) Shutdown(flag ShutdownFlag) { + atomic.StoreInt32((*int32)(&server.shutdownFlag), int32(flag)) + + if server.preShutdown != nil { + server.preShutdown() + } + + if server.httpserver != nil { + server.httpserver.Shutdown(context.Background()) + server.httpserver = nil + } else if server.stopfunc != nil { + server.stopfunc() + server.stopfunc = nil + } +} + +// Start : +func (server *Server) Start() { + if !flag.Parsed() { + flag.Parse() + } + + atomic.StoreInt32((*int32)(&server.shutdownFlag), int32(ShutdownFlagRunning)) + + if server.httpserver != nil { + var err error + if len(*tls) > 0 { + crtfile := *tls + ".crt" + keyfile := *tls + ".key" + err = server.httpserver.ListenAndServeTLS(crtfile, keyfile) + } else { + err = server.httpserver.ListenAndServe() + } + if err != http.ErrServerClosed { + fmt.Println(err) + } + } else { + ctx, stopfunc := context.WithCancel(context.Background()) + server.stopfunc = stopfunc + <-ctx.Done() + } +} + +// ConvertInterface : +func ConvertInterface(from interface{}, toType reflect.Type) reflect.Value { + if toType.Kind() == reflect.String { + return reflect.ValueOf(from.(string)) + } + + fromrv := reflect.ValueOf(from) + fromtype := reflect.TypeOf(from) + + if toType.Kind() == reflect.Struct { + if frommap, ok := from.(map[string]interface{}); ok { + out := reflect.New(toType) + for k, v := range frommap { + if fieldval := out.Elem().FieldByName(k); fieldval.IsValid() { + fieldval.Set(ConvertInterface(v, fieldval.Type())) + } + } + + return out + } + } + + if fromtype.Kind() == reflect.Slice { + if fromtype.Elem() == toType.Elem() { + return fromrv + } + + convslice := reflect.MakeSlice(toType, 0, fromrv.Len()) + for i := 0; i < fromrv.Len(); i++ { + convslice = reflect.Append(convslice, ConvertInterface(fromrv.Index(i).Interface(), toType.Elem())) + } + + return convslice + } + + if toType.Kind() == reflect.Bool { + val, _ := strconv.ParseBool(from.(string)) + return reflect.ValueOf(val) + } + + return fromrv.Convert(toType) +} + +// ErrUnmarshalRequestFailed : +var ErrUnmarshalRequestFailed = errors.New("Unmarshal failed at rpc handler") + +// CallMethodInternal : +func CallMethodInternal(receiver interface{}, context functionCallContext) (interface{}, error) { + methodTokens := strings.Split(context.Method, ".") + context.Method = methodTokens[len(methodTokens)-1] + for i := 0; i < len(methodTokens)-1; i++ { + token := methodTokens[i] + if strings.HasSuffix(token, "()") { + token = token[:len(token)-2] + } + + fn := reflect.ValueOf(receiver).MethodByName(token) + // 이 fn은 인자를 받지 않고 하나만 리턴하는 함수여야 한다. + fnType := fn.Type() + if fnType.NumOut() != 1 || fnType.NumIn() != 0 { + return nil, errors.New(fmt.Sprint("method tokens are not correct :", token)) + } + + returnVals := fn.Call(nil) + if returnVals[0].IsNil() { + return nil, errors.New(fmt.Sprint("method token returns nil :", token)) + } + + receiver = returnVals[0].Interface() + } + + fn := reflect.ValueOf(receiver).MethodByName(context.Method) + if fn.IsValid() { + fnType := fn.Type() + + if fnType.NumOut() != 1 { + return nil, errors.New(fmt.Sprint("method should return only RPCReturnType :", context.Method)) + } + + if len(context.Args) != fnType.NumIn() { + return nil, errors.New(fmt.Sprint("argument is not matching :", context.Method)) + } + + var argv []reflect.Value + for i := 0; i < len(context.Args); i++ { + argv = append(argv, ConvertInterface(context.Args[i], fnType.In(i))) + } + returnVals := fn.Call(argv) + + return returnVals[0].Interface(), nil + } + + return nil, errors.New(fmt.Sprint("method is missing :", receiver, context.Method)) +} + +// CallMethod : +func CallMethod(receiver interface{}, context []byte) (retval RPCReturnType, err error) { + defer func() { + r := recover() + if r != nil && err == nil { + debug.PrintStack() + err = errors.New(fmt.Sprintf("%v", r)) + } + }() + + var meta functionCallContext + if err := json.Unmarshal(context, &meta); err != nil { + fmt.Println(string(context)) + return nil, ErrUnmarshalRequestFailed + } else { + fmt.Printf("%+v\n", meta) + } + + var v interface{} + v, err = CallMethodInternal(receiver, meta) + if err != nil { + return nil, err + } + + // v는 RPCReturnType이어야 한다. + if cast, ok := v.(RPCReturnType); ok { + if cast.Error() != nil { + return nil, cast.Error() + } + return cast, nil + } + + return nil, errors.New(fmt.Sprint("method should return only RPCReturnType", meta)) +}