github/nps
1
0
Fork 0
mirror of https://github.com/ehang-io/nps.git synced 2025-09-02 11:56:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change pool, change mux connection close ,change copy buffer

Browse Source
This commit is contained in:
ffdfgdfg
2019-08-30 20:05:09 +08:00
parent 41c282b38b
commit bb2cffe10a
11 changed files with 257 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
lib/mux/conn.go
View File

@@ -3,7 +3,6 @@ package mux
import (
"errors"
"github.com/cnlh/nps/lib/common"
"github.com/cnlh/nps/lib/pool"
"github.com/cnlh/nps/vender/github.com/astaxie/beego/logs"
"io"
"net"
@@ -27,7 +26,8 @@ type conn struct {
connId int32
isClose bool
readWait bool
sendClose bool
sendClose bool // MUX_CONN_CLOSE already send
writeClose bool // close conn Write
hasWrite int
mux *Mux
}
@@ -69,12 +69,14 @@ func (s *conn) Read(buf []byte) (n int, err error) {
return 0, errors.New("the conn has closed")
}
if node, err := s.readQueue.Pop(); err != nil {
logs.Warn("conn close by read pop err", s.connId, err)
s.Close()
return 0, io.EOF
} else {
if node.val == nil {
//close
s.sendClose = true
logs.Warn("conn close by read ", s.connId)
s.Close()
return 0, io.EOF
} else {
@@ -90,7 +92,7 @@ func (s *conn) Read(buf []byte) (n int, err error) {
} else {
n = copy(buf, s.readBuffer[s.startRead:s.endRead])
s.startRead += n
pool.CopyBuff.Put(s.readBuffer)
common.CopyBuff.Put(s.readBuffer)
}
return
}
@@ -99,6 +101,12 @@ func (s *conn) Write(buf []byte) (n int, err error) {
if s.isClose {
return 0, errors.New("the conn has closed")
}
if s.writeClose {
s.sendClose = true
logs.Warn("conn close by write ", s.connId)
s.Close()
return 0, errors.New("io: write on closed conn")
}
ch := make(chan struct{})
go s.write(buf, ch)
if t := s.writeTimeOut.Sub(time.Now()); t > 0 {
@@ -112,19 +120,22 @@ func (s *conn) Write(buf []byte) (n int, err error) {
} else {
<-ch
}
if s.isClose {
return 0, io.EOF
}
close(ch)
//if s.isClose {
// return 0, io.ErrClosedPipe
//}
return len(buf), nil
}
func (s *conn) write(buf []byte, ch chan struct{}) {
start := 0
l := len(buf)
for {
if l-start > pool.PoolSizeCopy {
s.mux.sendInfo(common.MUX_NEW_MSG, s.connId, buf[start:start+pool.PoolSizeCopy])
start += pool.PoolSizeCopy
if l-start > common.PoolSizeCopy {
logs.Warn("conn write > poolsizecopy")
s.mux.sendInfo(common.MUX_NEW_MSG, s.connId, buf[start:start+common.PoolSizeCopy])
start += common.PoolSizeCopy
} else {
logs.Warn("conn write <= poolsizecopy, start, len", start, l)
s.mux.sendInfo(common.MUX_NEW_MSG, s.connId, buf[start:l])
break
}
@@ -137,21 +148,16 @@ func (s *conn) Close() (err error) {
return errors.New("the conn has closed")
}
s.isClose = true
pool.CopyBuff.Put(s.readBuffer)
s.mux.connMap.Delete(s.connId)
common.CopyBuff.Put(s.readBuffer)
if s.readWait {
s.readCh <- struct{}{}
}
s.readQueue.Clear()
s.mux.connMap.Delete(s.connId)
if !s.mux.IsClose {
if !s.sendClose {
err = s.mux.sendInfo(common.MUX_CONN_CLOSE, s.connId, nil)
logs.Warn("send closing msg ok ", s.connId)
if err != nil {
logs.Warn(err)
return
}
} else {
logs.Warn("conn send close")
go s.mux.sendInfo(common.MUX_CONN_CLOSE, s.connId, nil)
}
}
return

74
lib/mux/mux.go
View File

@@ -4,7 +4,6 @@ import (
"bytes"
"errors"
"github.com/cnlh/nps/lib/common"
"github.com/cnlh/nps/lib/pool"
"github.com/cnlh/nps/vender/github.com/astaxie/beego/logs"
"math"
"net"
@@ -42,7 +41,7 @@ func NewMux(c net.Conn, connType string) *Mux {
go m.readSession()
//ping
go m.ping()
//go m.writeSession()
go m.writeSession()
return m
}
@@ -53,9 +52,8 @@ func (s *Mux) NewConn() (*conn, error) {
conn := NewConn(s.getId(), s)
//it must be set before send
s.connMap.Set(conn.connId, conn)
if err := s.sendInfo(common.MUX_NEW_CONN, conn.connId, nil); err != nil {
return nil, err
}
s.sendInfo(common.MUX_NEW_CONN, conn.connId, nil)
logs.Warn("send mux new conn ", conn.connId)
//set a timer timeout 30 second
timer := time.NewTimer(time.Minute * 2)
defer timer.Stop()
@@ -83,34 +81,41 @@ func (s *Mux) Addr() net.Addr {
return s.conn.LocalAddr()
}
func (s *Mux) sendInfo(flag uint8, id int32, content []byte) (err error) {
func (s *Mux) sendInfo(flag uint8, id int32, content []byte) {
var err error
if flag == common.MUX_NEW_MSG {
if len(content) == 0 {
logs.Warn("send info content is nil")
}
}
buf := pool.BuffPool.Get()
pack := common.MuxPackager{}
buf := common.BuffPool.Get()
//defer pool.BuffPool.Put(buf)
pack := common.MuxPack.Get()
err = pack.NewPac(flag, id, content)
if err != nil {
s.Close()
logs.Warn("new pack err", err)
common.BuffPool.Put(buf)
return
}
err = pack.Pack(buf)
if err != nil {
s.Close()
logs.Warn("pack err", err)
common.BuffPool.Put(buf)
return
}
//s.writeQueue <- buf
_, err = buf.WriteTo(s.conn)
if err != nil {
s.Close()
logs.Warn("write err", err)
}
pool.BuffPool.Put(buf)
if flag == common.MUX_CONN_CLOSE {
}
if flag == common.MUX_NEW_MSG {
}
s.writeQueue <- buf
common.MuxPack.Put(pack)
//_, err = buf.WriteTo(s.conn)
//if err != nil {
// s.Close()
// logs.Warn("write err, close mux", err)
//}
//if flag == common.MUX_CONN_CLOSE {
//}
//if flag == common.MUX_NEW_MSG {
//}
return
}
@@ -120,7 +125,7 @@ func (s *Mux) writeSession() {
buf := <-s.writeQueue
l := buf.Len()
n, err := buf.WriteTo(s.conn)
pool.BuffPool.Put(buf)
common.BuffPool.Put(buf)
if err != nil || int(n) != l {
logs.Warn("close from write to ", err, n, l)
s.Close()
@@ -142,7 +147,9 @@ func (s *Mux) ping() {
if (math.MaxInt32 - s.id) < 10000 {
s.id = 0
}
if err := s.sendInfo(common.MUX_PING_FLAG, common.MUX_PING, nil); err != nil || (s.pingOk > 10 && s.connType == "kcp") {
//logs.Warn("send mux ping")
s.sendInfo(common.MUX_PING_FLAG, common.MUX_PING, nil)
if s.pingOk > 10 && s.connType == "kcp" {
s.Close()
break
}
@@ -155,28 +162,30 @@ func (s *Mux) ping() {
}
func (s *Mux) readSession() {
var pack common.MuxPackager
go func() {
for {
pack := common.MuxPack.Get()
if pack.UnPack(s.conn) != nil {
break
}
if pack.Flag != 0 && pack.Flag != 7 {
if pack.Length > 10 {
logs.Warn(pack.Flag, pack.Id, pack.Length, string(pack.Content[:10]))
//logs.Warn(pack.Flag, pack.Id, pack.Length, string(pack.Content[:10]))
}
}
s.pingOk = 0
switch pack.Flag {
case common.MUX_NEW_CONN: //new conn
//logs.Warn("mux new conn", pack.Id)
logs.Warn("mux new conn", pack.Id)
conn := NewConn(pack.Id, s)
s.connMap.Set(pack.Id, conn) //it has been set before send ok
s.newConnCh <- conn
s.sendInfo(common.MUX_NEW_CONN_OK, pack.Id, nil)
logs.Warn("send mux new conn ok", pack.Id)
continue
case common.MUX_PING_FLAG: //ping
s.sendInfo(common.MUX_PING_RETURN, common.MUX_PING, nil)
//logs.Warn("send mux ping return")
go s.sendInfo(common.MUX_PING_RETURN, common.MUX_PING, nil)
continue
case common.MUX_PING_RETURN:
continue
@@ -185,6 +194,7 @@ func (s *Mux) readSession() {
switch pack.Flag {
case common.MUX_NEW_MSG: //new msg from remote conn
//insert wait queue
logs.Warn("mux new msg ", pack.Id)
conn.readQueue.Push(NewBufNode(pack.Content, int(pack.Length)))
//judge len if >xxx ,send stop
if conn.readWait {
@@ -192,21 +202,29 @@ func (s *Mux) readSession() {
conn.readCh <- struct{}{}
}
case common.MUX_NEW_CONN_OK: //conn ok
logs.Warn("mux new conn ok ", pack.Id)
conn.connStatusOkCh <- struct{}{}
case common.MUX_NEW_CONN_Fail:
logs.Warn("mux new conn fail", pack.Id)
conn.connStatusFailCh <- struct{}{}
case common.MUX_CONN_CLOSE: //close the connection
logs.Warn("mux conn close", pack.Id)
s.connMap.Delete(pack.Id)
conn.writeClose = true
conn.readQueue.Push(NewBufNode(nil, 0))
if conn.readWait {
logs.Warn("close read wait", pack.Id)
conn.readWait = false
conn.readCh <- struct{}{}
}
s.connMap.Delete(pack.Id)
logs.Warn("receive mux conn close, finish", conn.connId)
}
} else if pack.Flag == common.MUX_NEW_MSG {
pool.CopyBuff.Put(pack.Content)
common.CopyBuff.Put(pack.Content)
} else if pack.Flag == common.MUX_CONN_CLOSE {
logs.Warn("mux conn close no id ", pack.Id)
}
common.MuxPack.Put(pack)
}
s.Close()
}()
@@ -228,7 +246,7 @@ func (s *Mux) Close() error {
select {
case s.closeChan <- struct{}{}:
}
//s.closeChan <- struct{}{}
s.closeChan <- struct{}{}
close(s.writeQueue)
close(s.newConnCh)
return s.conn.Close()

65
lib/mux/mux_test.go
View File

@@ -2,9 +2,7 @@ package mux
import (
"github.com/cnlh/nps/lib/common"
"github.com/cnlh/nps/lib/pool"
"github.com/cnlh/nps/vender/github.com/astaxie/beego/logs"
"log"
"net"
"net/http"
_ "net/http/pprof"
@@ -27,19 +25,29 @@ func TestNewMux(t *testing.T) {
go func() {
m2 := NewMux(conn2, "tcp")
for {
logs.Warn("npc starting accept")
c, err := m2.Accept()
if err != nil {
log.Fatalln(err)
logs.Warn(err)
continue
}
c2, err := net.Dial("tcp", "127.0.0.1:8080")
logs.Warn("npc accept success ")
c2, err := net.Dial("tcp", "127.0.0.1:80")
if err != nil {
log.Fatalln(err)
logs.Warn(err)
continue
}
var npcToServer common.ConnCopy
npcToServer.New(c2, c, 0)
go npcToServer.CopyConn()
var serverToNpc common.ConnCopy
serverToNpc.New(c, c2, 10000)
_, err = serverToNpc.CopyConn()
if err == nil {
logs.Warn("close npc")
c2.Close()
c.Close()
}
go common.CopyBuffer(c2, c,0)
common.CopyBuffer(c, c2,0)
c2.Close()
c.Close()
logs.Warn("close npc")
}
}()
@@ -47,24 +55,33 @@ func TestNewMux(t *testing.T) {
m1 := NewMux(conn1, "tcp")
l, err := net.Listen("tcp", "127.0.0.1:7777")
if err != nil {
log.Fatalln(err)
logs.Warn(err)
}
for {
logs.Warn("nps starting accept")
conn, err := l.Accept()
if err != nil {
log.Fatalln(err)
logs.Warn(err)
continue
}
logs.Warn("nps accept success starting new conn")
tmpCpnn, err := m1.NewConn()
if err != nil {
log.Fatalln(err)
logs.Warn("nps new conn err ", err)
continue
}
logs.Warn("nps new conn success ", tmpCpnn.connId)
var userToNps common.ConnCopy
userToNps.New(tmpCpnn, conn, tmpCpnn.connId)
go userToNps.CopyConn()
var npsToUser common.ConnCopy
npsToUser.New(conn, tmpCpnn, tmpCpnn.connId+10000)
_, err = npsToUser.CopyConn()
if err == nil {
logs.Warn("close from out nps ", tmpCpnn.connId)
conn.Close()
tmpCpnn.Close()
}
go common.CopyBuffer(tmpCpnn, conn,tmpCpnn.connId)
_, err = common.CopyBuffer(conn, tmpCpnn,tmpCpnn.connId)
logs.Warn(err, tmpCpnn.connId)
conn.Close()
tmpCpnn.Close()
logs.Warn("close from out nps ", tmpCpnn.connId)
}
}()
@@ -77,12 +94,12 @@ func server() {
var err error
l, err := net.Listen("tcp", "127.0.0.1:9999")
if err != nil {
log.Fatalln(err)
logs.Warn(err)
}
go func() {
conn1, err = l.Accept()
if err != nil {
log.Fatalln(err)
logs.Warn(err)
}
}()
return
@@ -92,12 +109,12 @@ func client() {
var err error
conn2, err = net.Dial("tcp", "127.0.0.1:9999")
if err != nil {
log.Fatalln(err)
logs.Warn(err)
}
}
func TestNewConn(t *testing.T) {
buf := pool.GetBufPoolCopy()
buf := common.GetBufPoolCopy()
logs.Warn(len(buf), cap(buf))
//b := pool.GetBufPoolCopy()
//b[0] = 1

4
lib/mux/queue.go
View File

@@ -2,7 +2,7 @@ package mux
import (
"errors"
"github.com/cnlh/nps/lib/pool"
"github.com/cnlh/nps/lib/common"
"sync"
)
@@ -63,7 +63,7 @@ func (entry *sliceEntry) Clear() bool {
return false
}
for i := 0; i < entry.Size(); i++ {
pool.CopyBuff.Put(entry.element[i].val)
common.CopyBuff.Put(entry.element[i].val)
entry.element[i] = nil
}
entry.element = nil