dominick/GameServer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

server initial commit

Browse Source
This commit is contained in:
김도한 [dominick]
2022-10-18 11:50:10 +09:00
commit 8fe1f31bf2
10 changed files with 1899 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
*.log
*.exe

421
core/AEGS_methods.go Normal file
View File

@ -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"))
}
}

91
core/AEGS_test.go Normal file
View File

@ -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))
}
}

366
core/AeGameServer.go Normal file
View File

@ -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("<p>IP: %s</p>", ip)
// // gs.Logger.Printf("<p>Port: %s</p>", port)
// // gs.Logger.Printf("<p>Forwarded for: %s</p>", 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
}

75
core/SocketContext.go Normal file
View File

@ -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)
}

17
go.mod Normal file
View File

@ -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
)

190
go.sum Normal file
View File

@ -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=

34
main.go Normal file
View File

@ -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)
}
}
}

322
shared/mongo.go Normal file
View File

@ -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
}

381
shared/server.go Normal file
View File

@ -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))
}