gitee.com/KyleChenSource/lib-robot@v1.0.2/robottest/robot/net/network_tcp.go

package net

import (
	"fmt"
	"io"
	"net"
	"sync"

	"gitee.com/KyleChenSource/lib-robot/robottest/common"
	"gitee.com/KyleChenSource/lib-robot/robottest/protos"
)

// 接口都只允许在一个goroutine中调用
type ClientTcp struct {
	_handler    IClientHandler
	_msglen_get MsgLenGet
	_msgmin_get MsgMinGet
	_msg_decode MsgDecode
	_msg_encode MsgEncode
	_tcp        *net.TCPConn

	_join    *sync.WaitGroup // 用来等待开启的协程结束
	_closing bool            // 正在关闭中标记位。因为chan的容量，导致了关闭可能死锁
}

func (this *ClientTcp) Initialize(h IClientHandler, func_msglen_get MsgLenGet, func_msgmin_get MsgMinGet, func_msg_decode MsgDecode, func_msg_encode MsgEncode) error {
	this._handler = h
	this._msglen_get = func_msglen_get
	this._msgmin_get = func_msgmin_get
	this._msg_decode = func_msg_decode
	this._msg_encode = func_msg_encode

	return nil
}

func (this *ClientTcp) co_recv() {
	defer func() {
		this._join.Done()
	}()
	defer common.PanicLog(func() {
		this._handler.MsgChannel() <- &Msg{
			Type: MSGTYPE_ERR,
			Err:  fmt.Errorf("recv panic error"),
		}
	})

	minlen := this._msgmin_get()
	minBuf := make([]byte, minlen)
	rl := 0 // 目前接收数据长度
	for {
		r, err := this._tcp.Read(minBuf[rl:])
		if err != nil {
			this._handler.MsgChannel() <- &Msg{
				Type: MSGTYPE_ERR,
				Err:  err,
			}
			break
		}

		if r == 0 {
			this._handler.MsgChannel() <- &Msg{
				Type: MSGTYPE_ERR,
				Err:  fmt.Errorf("disconnected by remote"),
			}
			break
		}

		rl += r
		if rl < minlen {
			continue
		}

		msglen, err := this._msglen_get(minBuf)
		if err != nil {
			this._handler.MsgChannel() <- &Msg{
				Type: MSGTYPE_ERR,
				Err:  err,
			}
			break
		}

		msgBuf := make([]byte, msglen)
		copy(msgBuf, minBuf)

		if msglen <= minlen {
			// 包已经足够大
			copy(minBuf, minBuf[msglen:])
			rl = minlen - msglen
		} else {
			rl = 0
			_, err = io.ReadFull(this._tcp, msgBuf[minlen:])
			if err != nil {
				this._handler.MsgChannel() <- &Msg{
					Type: MSGTYPE_ERR,
					Err:  err,
				}
				break
			}
		}

		// protoId, err := this._msg_decodeprotoid(msgBuf)
		// if err != nil {
		// 	this._handler.MsgChannel() <- &Msg{
		// 		Type: MSGTYPE_ERR,
		// 		Err:  err,
		// 	}
		// 	break
		// }

		// switch this._msg_filtertype {
		// case ProtoFilterType_Focus:
		// 	_, ok := this._msg_filter.Load(protoId)
		// 	if !ok {
		// 		continue
		// 	}
		// default:
		// 	_, ok := this._msg_filter.Load(protoId)
		// 	if ok {
		// 		continue
		// 	}
		// }

		// protoId, header, data, err := this._msg_decode(msgBuf)
		// if err != nil {
		// 	this._handler.MsgChannel() <- &Msg{
		// 		Type: MSGTYPE_ERR,
		// 		Err:  err,
		// 	}
		// 	break
		// }

		this._handler.MsgChannel() <- &Msg{
			Type: MSGTYPE_RECV,
			Data: msgBuf,
		}
	}
}

func (this *ClientTcp) connect(addr string) {
	defer common.PanicLog(func() {
		this._handler.MsgChannel() <- &Msg{
			Type: MSGTYPE_ERR,
			Err:  fmt.Errorf("connect panic error"),
		}
	})

	tcp, err := net.Dial("tcp", addr)
	if err != nil {
		this._handler.MsgChannel() <- &Msg{
			Type: MSGTYPE_ERR,
			Err:  err,
		}
		this._join.Done()
		return
	}

	this._tcp = tcp.(*net.TCPConn)
	err = this._tcp.SetLinger(5)
	if err != nil {
		this._handler.MsgChannel() <- &Msg{
			Type: MSGTYPE_ERR,
			Err:  err,
		}
		this._join.Done()
		return
	}

	this._handler.MsgChannel() <- &Msg{
		Type: MSGTYPE_CONNECTED,
	}

	go this.co_recv()
}

func (this *ClientTcp) Start(addr string) error {
	// 不能使用this._tcp作为判断，因为连接过程中_tcp == nil
	if this._join != nil {
		return fmt.Errorf("ClientTcp Not Close")
	}

	this._closing = false

	this._join = &sync.WaitGroup{}
	this._join.Add(1)
	go this.connect(addr)

	return nil
}

func (this *ClientTcp) join() {
	if this._join != nil {
		this._join.Wait()
		this._join = nil
	}

	this._tcp = nil

	this._handler.MsgChannel() <- &Msg{
		Type: MSGTYPE_CLOSED,
	}
}

func (this *ClientTcp) Close() {
	if this._closing {
		return
	}

	this._closing = true
	if this._tcp != nil {
		this._tcp.Close()
	}

	go this.join()
}

func (this *ClientTcp) Send(protoId protos.ProtoID, data protos.JsonString) error {
	bytes, err := this._msg_encode(protoId, data)
	if err != nil {
		return err
	}

	l := len(bytes)
	for l > 0 {
		s, err := this._tcp.Write(bytes)
		if err != nil {
			this._handler.MsgChannel() <- &Msg{
				Type: MSGTYPE_ERR,
				Err:  err,
			}
			return err
		}

		l -= s
		bytes = bytes[s:]
	}

	return nil
}