panshiqu / framework Goto Github PK

View Code? Open in Web Editor NEW

68.0 68.0 35.0 242 KB

a simple game framework

Go 98.60% Shell 1.40%

framework's People

Contributors

Stargazers

Watchers

framework's Issues

session.RecvMessage 中，login/game中的任意一个，就把client连接断开？

framework/proxy/session.go

Lines 115 to 136 in af6c952

 func (s *Session) RecvMessage(conn net.Conn) { 

 defer utils.Trace("Session RecvMessage")() 

 for { 

 mcmd, scmd, data, err := network.RecvMessage(conn) 

 if err != nil { 

 break 

 } 

 if mcmd == define.LoginCommon && scmd == define.LoginFastRegister { 

 replyFastRegister := &define.ReplyFastRegister{} 

 json.Unmarshal(data, replyFastRegister) 

 s.userid = replyFastRegister.UserID 

 } 

 if err := network.SendMessage(s.client, mcmd, scmd, data); err != nil { 

 break 

 } 

 } 

 s.client.Close() 

 }

为什么这么设计呢？

为什么,这里 s.connections 要置为nil, 如果不置为nil的化,好像很多地方,都不用判断是否是nil

framework/network/server.go

Lines 52 to 60 in af6c952

 func (s *Server) stop() { 

 s.mutex.Lock() 

 for conn := range s.connections { 

 conn.Close() 

 } 

 s.connections = nil 

 s.mutex.Unlock() 

 s.waitgroup.Wait() 

 }

学习下

framework/network/server.go

Lines 95 to 115 in af6c952

 for { 

 mcmd, scmd, data, err := RecvMessage(conn) 

 if err != nil { 

 break 

 } 

 if err := s.processor.OnMessage(conn, mcmd, scmd, data); err != nil { 

 me, ok := err.(*define.MyError) 

 if !ok { 

 me = &define.MyError{ 

 Errno: define.ErrnoFailure, 

 Errdesc: err.Error(), 

 } 

 } 

 if err := SendMessage(conn, mcmd, scmd, []byte(me.Error())); err != nil { 

 break 

 } 

 } 

 }

我看你，network 里面的 server 似乎，只能被动发消息给conn （只有收到消息后，处理消息时，才有机会发送消息给 conn）似乎没有主动发送消息给conn 的途径

如果服务端，需要广播消息给用户，怎么办？

学习一下，多谢作者

感觉这个方法应该换下

framework/proxy/session.go

Lines 139 to 167 in af6c952

 func (s *Session) KeepAlive() { 

 defer utils.Trace("Session KeepAlive")() 

 ticker := time.NewTicker(10 * time.Second) 

 defer ticker.Stop() 

 for { 

 select { 

 case <-s.close: 

 return 

 case <-ticker.C: 

 switch atomic.LoadInt32(&s.status) { 

 case define.KeepAliveSafe: 

 atomic.StoreInt32(&s.status, define.KeepAliveWarn) 

 case define.KeepAliveWarn: 

 atomic.StoreInt32(&s.status, define.KeepAliveDead) 

 network.SendMessage(s.client, define.GLobalCommon, define.GLobalKeepAlive, nil) 

 case define.KeepAliveDead: 

 s.client.Close() 

 } 

 default: 

 time.Sleep(time.Second) 

 } 

 } 

 }

这个

atomic.StoreInt32(&s.status, define.KeepAliveWarn)

换成：

atomic.CompareAndSwapInt32(&s.status, define.KeepAliveSafe, define.KeepAliveWarn)

防止客户端收到报文，刚设定为KeepAliveSafe，然后就被替换成KeepAliveWarn

一个疑问，内部节点，是否需要保活

代理节点，到各个服务器节点的连接，是否需要保活？

panshiqu / framework Goto Github PK

framework's People

Contributors

Stargazers

Watchers

Forkers

framework's Issues

session.RecvMessage 中，login/game中的任意一个，就把client连接断开？

为什么,这里 s.connections 要置为nil, 如果不置为nil的化,好像很多地方,都不用判断是否是nil

学习下

学习一下，多谢作者

感觉这个方法应该换下

一个疑问，内部节点，是否需要保活

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	func (s *Session) RecvMessage(conn net.Conn) {
	defer utils.Trace("Session RecvMessage")()

	for {
	mcmd, scmd, data, err := network.RecvMessage(conn)
	if err != nil {
	break
	}

	if mcmd == define.LoginCommon && scmd == define.LoginFastRegister {
	replyFastRegister := &define.ReplyFastRegister{}
	json.Unmarshal(data, replyFastRegister)
	s.userid = replyFastRegister.UserID
	}

	if err := network.SendMessage(s.client, mcmd, scmd, data); err != nil {
	break
	}
	}

	s.client.Close()
	}

	func (s *Server) stop() {
	s.mutex.Lock()
	for conn := range s.connections {
	conn.Close()
	}
	s.connections = nil
	s.mutex.Unlock()
	s.waitgroup.Wait()
	}

	for {
	mcmd, scmd, data, err := RecvMessage(conn)
	if err != nil {
	break
	}

	if err := s.processor.OnMessage(conn, mcmd, scmd, data); err != nil {
	me, ok := err.(*define.MyError)

	if !ok {
	me = &define.MyError{
	Errno: define.ErrnoFailure,
	Errdesc: err.Error(),
	}
	}

	if err := SendMessage(conn, mcmd, scmd, []byte(me.Error())); err != nil {
	break
	}
	}
	}

	func (s *Session) KeepAlive() {
	defer utils.Trace("Session KeepAlive")()

	ticker := time.NewTicker(10 * time.Second)
	defer ticker.Stop()

	for {
	select {
	case <-s.close:
	return

	case <-ticker.C:
	switch atomic.LoadInt32(&s.status) {
	case define.KeepAliveSafe:
	atomic.StoreInt32(&s.status, define.KeepAliveWarn)

	case define.KeepAliveWarn:
	atomic.StoreInt32(&s.status, define.KeepAliveDead)
	network.SendMessage(s.client, define.GLobalCommon, define.GLobalKeepAlive, nil)

	case define.KeepAliveDead:
	s.client.Close()
	}

	default:
	time.Sleep(time.Second)
	}
	}
	}