wshandler에서 authcache제거하고 config 포맷 변경

wshandler/wshandler.go

@@ -88,7 +88,6 @@ type Sender struct {
 type WebSocketMessageReceiver func(sender *Sender, messageType WebSocketMessageType, body io.Reader)
 
 type subhandler struct {
-	authCache         *gocommon.AuthCollection
 	redisMsgChanName  string
 	redisCmdChanName  string
 	redisSync         *redis.Client
@@ -98,28 +97,26 @@ type subhandler struct {
 	callReceiver      WebSocketMessageReceiver
 	connWaitGroup     sync.WaitGroup
 	region            string
+	receiverChain     []WebSocketMessageReceiver
 }
 
 // WebsocketHandler  :
 type WebsocketHandler struct {
-	authCaches    map[string]*subhandler
-	RedisSync     *redis.Client
-	receiverChain map[string][]WebSocketMessageReceiver
+	subhandlers map[string]*subhandler
 }
 
 type wsConfig struct {
-	SyncPipeline string `json:"ws_sync_pipeline"`
+	gocommon.RegionStorageConfig
+	Maingate string `json:"maingate_service_url"`
 }
 
-func NewWebsocketHandler(authglobal gocommon.AuthCollectionGlobal) (wsh *WebsocketHandler) {
-	var config wsConfig
+var config wsConfig
+
+func init() {
 	gocommon.LoadConfig(&config)
+}
 
-	redisSync, err := gocommon.NewRedisClient(config.SyncPipeline, 0)
-	if err != nil {
-		panic(err)
-	}
-
+func NewWebsocketHandler() (*WebsocketHandler, error) {
 	// decoder := func(r io.Reader) *T {
 	// 	if r == nil {
 	// 		// 접속이 끊겼을 때.
@@ -135,10 +132,14 @@ func NewWebsocketHandler(authglobal gocommon.AuthCollectionGlobal) (wsh *Websock
 	// 	return &m
 	// }
 
-	authCaches := make(map[string]*subhandler)
-	for _, region := range authglobal.Regions() {
+	subhandlers := make(map[string]*subhandler)
+	for region, cfg := range config.RegionStorage {
+		redisSync, err := gocommon.NewRedisClient(cfg.Redis["wshandler"])
+		if err != nil {
+			return nil, err
+		}
+
 		sh := &subhandler{
-			authCache:         authglobal.Get(region),
 			redisMsgChanName:  fmt.Sprintf("_wsh_msg_%s", region),
 			redisCmdChanName:  fmt.Sprintf("_wsh_cmd_%s", region),
 			redisSync:         redisSync,
@@ -148,23 +149,23 @@ func NewWebsocketHandler(authglobal gocommon.AuthCollectionGlobal) (wsh *Websock
 			region:            region,
 		}
 
-		authCaches[region] = sh
+		subhandlers[region] = sh
 	}
 
 	return &WebsocketHandler{
-		authCaches:    authCaches,
-		RedisSync:     redisSync,
-		receiverChain: make(map[string][]WebSocketMessageReceiver),
-	}
+		subhandlers: subhandlers,
+	}, nil
 }
 
 func (ws *WebsocketHandler) RegisterReceiver(region string, receiver WebSocketMessageReceiver) {
-	ws.receiverChain[region] = append(ws.receiverChain[region], receiver)
+	if sh := ws.subhandlers[region]; sh != nil {
+		sh.receiverChain = append(sh.receiverChain, receiver)
+	}
 }
 
 func (ws *WebsocketHandler) Start(ctx context.Context) {
-	for region, sh := range ws.authCaches {
-		chain := ws.receiverChain[region]
+	for _, sh := range ws.subhandlers {
+		chain := sh.receiverChain
 		if len(chain) == 0 {
 			sh.callReceiver = func(sender *Sender, messageType WebSocketMessageType, body io.Reader) {}
 		} else if len(chain) == 1 {
@@ -182,13 +183,13 @@ func (ws *WebsocketHandler) Start(ctx context.Context) {
 }
 
 func (ws *WebsocketHandler) Cleanup() {
-	for _, sh := range ws.authCaches {
+	for _, sh := range ws.subhandlers {
 		sh.connWaitGroup.Wait()
 	}
 }
 
 func (ws *WebsocketHandler) RegisterHandlers(serveMux *http.ServeMux, prefix string) error {
-	for region, sh := range ws.authCaches {
+	for region, sh := range ws.subhandlers {
 		if region == "default" {
 			region = ""
 		}
@@ -204,26 +205,28 @@ func (ws *WebsocketHandler) RegisterHandlers(serveMux *http.ServeMux, prefix str
 }
 
 func (ws *WebsocketHandler) GetState(region string, accid primitive.ObjectID) string {
-	state, err := ws.RedisSync.Get(context.Background(), accid.Hex()).Result()
-	if err == redis.Nil {
-		return ""
+	if sh := ws.subhandlers[region]; sh != nil {
+		state, _ := sh.redisSync.Get(context.Background(), accid.Hex()).Result()
+		return state
 	}
-	return state
+	return ""
 }
 
 func (ws *WebsocketHandler) SetState(region string, accid primitive.ObjectID, state string) {
-	ws.RedisSync.SetArgs(context.Background(), accid.Hex(), state, redis.SetArgs{Mode: "XX"}).Result()
+	if sh := ws.subhandlers[region]; sh != nil {
+		sh.redisSync.SetArgs(context.Background(), accid.Hex(), state, redis.SetArgs{Mode: "XX"}).Result()
+	}
 }
 
 func (ws *WebsocketHandler) SendUpstreamMessage(region string, msg *UpstreamMessage) {
-	sh := ws.authCaches[region]
+	sh := ws.subhandlers[region]
 	if sh != nil {
 		sh.localDeliveryChan <- msg
 	}
 }
 
 func (ws *WebsocketHandler) EnterRoom(region string, room string, accid primitive.ObjectID) {
-	sh := ws.authCaches[region]
+	sh := ws.subhandlers[region]
 	if sh != nil {
 		sh.localDeliveryChan <- &commandMessage{
 			Cmd:  commandType_JoinRoom,
@@ -233,7 +236,7 @@ func (ws *WebsocketHandler) EnterRoom(region string, room string, accid primitiv
 }
 
 func (ws *WebsocketHandler) LeaveRoom(region string, room string, accid primitive.ObjectID) {
-	sh := ws.authCaches[region]
+	sh := ws.subhandlers[region]
 	if sh != nil {
 		sh.localDeliveryChan <- &commandMessage{
 			Cmd:  commandType_LeaveRoom,
@@ -529,17 +532,25 @@ func (sh *subhandler) upgrade(w http.ResponseWriter, r *http.Request) {
 	}()
 
 	sk := r.Header.Get("AS-X-SESSION")
-	auth := strings.Split(r.Header.Get("Authorization"), " ")
-	if len(auth) != 2 {
-		//TODO : 클라이언트는 BadRequest를 받으면 로그인 화면으로 돌아가야 한다.
-		w.WriteHeader(http.StatusBadRequest)
+	auth := r.Header.Get("Authorization")
+
+	req, _ := http.NewRequest("GET", fmt.Sprintf("%s/query?sk=%s", config.Maingate, sk), nil)
+	req.Header.Add("Authorization", auth)
+
+	client := http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		logger.Error("authorize query failed :", err)
 		return
 	}
-	authtoken := auth[1]
+	defer resp.Body.Close()
 
-	accid, success := sh.authCache.IsValid(sk, authtoken)
-	if !success {
-		w.WriteHeader(http.StatusUnauthorized)
+	var authinfo gocommon.Authinfo
+	dec := json.NewDecoder(resp.Body)
+	if err = dec.Decode(&authinfo); err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		logger.Error("authorize query failed :", err)
 		return
 	}
 
@@ -554,8 +565,8 @@ func (sh *subhandler) upgrade(w http.ResponseWriter, r *http.Request) {
 	if v := r.Header.Get("AS-X-ALIAS"); len(v) > 0 {
 		alias = v
 	} else {
-		alias = accid.Hex()
+		alias = authinfo.Accid.Hex()
 	}
 
-	upgrade_core(sh, conn, accid, alias)
+	upgrade_core(sh, conn, authinfo.Accid, alias)
 }