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

package robot

import (
	"fmt"
	"time"

	"gitee.com/KyleChenSource/lib-robot/robottest/common"
	"gitee.com/KyleChenSource/lib-robot/robottest/log"
	"gitee.com/KyleChenSource/lib-robot/robottest/protos"
	c "gitee.com/KyleChenSource/lib-robot/robottest/robot/net"
	"gitee.com/KyleChenSource/lib-robot/robottest/robot/statistic"
	ts "gitee.com/KyleChenSource/lib-robot/robottest/robot/testcase"
)

type RobotState int

const (
	ROBOT_STATE_NONE     RobotState = iota // 未启动
	ROBOT_STATE_LOGINING                   // 登录中
	ROBOT_STATE_RUN                        // 正常运行过程
	ROBOT_STATE_RELOGIN                    // 重登状态
	ROBOT_STATE_END                        // 结束
)

// Robot继承于TestFlowRunner
type Robot struct {
	_id      int
	_mgr     *RobotManager
	_state   RobotState
	_closing bool // 正在关闭中
	_run     bool
	_err     error

	_net       c.IClient // 底层网络
	_net_err   error     // 记录网络上抛错误。如果没有错误进行关闭，就是主动关闭.重新连接清空
	_net_close bool      // 主动关闭网络标记.重新连接清空

	_server     string // 服务器地址 ip:prot
	_account    string
	_cnfName    string
	_cnf        *RobotConfig
	_msgPrint   bool
	_msgIgnores map[protos.ProtoID]bool
	_msgFocuses map[protos.ProtoID]bool

	_msgHandlers map[protos.ProtoID]map[ts.ITestcaseAction]bool // 关注消息的所有Action清单 msgid -> set<action>
	_timerMgr    *common.TimeList

	_runner_index  int          // 当前进行的testCase index
	_runner_id     int          // 自增，用于生成testcase唯一id
	_runner_cnt    int          // 当前testcase运行次数
	_testcase      *ts.Testcase // 当前执行的testcase, testcase执行完毕会根据配置执行列表
	_testcaseLogin *ts.Testcase // login or relogin case

	_netMsgs chan *c.Msg   // net需要处理的事件消息
	_signal  chan struct{} // 关闭信号
	ts.TestCtxImp

	_statistics_time_start int64 // 开始时间,ms
	_statistics_time_end   int64 // 结束时间,ms
}

func (this *Robot) Initialize(id int, mgr *RobotManager, server string, account string, file string, cnfName string, msgPrint bool, msgIgnores map[protos.ProtoID]bool, msgFocuses map[protos.ProtoID]bool) error {
	fullname := fmt.Sprintf("%s/%s", file, cnfName)
	cnf, ok := ROBOT_CNF[fullname]
	if !ok {
		return fmt.Errorf("%s Nil", fullname)
	}

	cnf.Name = cnfName
	return this.InitializeCnf(id, mgr, server, account, cnf, msgPrint, msgIgnores, msgFocuses)
}

func (this *Robot) InitializeCnf(id int, mgr *RobotManager, server string, account string, cnf *RobotConfig, msgPrint bool, msgIgnores map[protos.ProtoID]bool, msgFocuses map[protos.ProtoID]bool) error {
	this._id = id
	this._msgPrint = msgPrint
	this._msgIgnores = msgIgnores
	this._msgFocuses = msgFocuses
	this._cnf = cnf
	this._mgr = mgr
	this._state = ROBOT_STATE_NONE
	this._run = true
	this._server = server
	this._account = account

	this._msgHandlers = make(map[protos.ProtoID]map[ts.ITestcaseAction]bool)
	this._timerMgr = common.TimeListNew()

	this._runner_index = 0
	this._runner_id = 3 // 1 : loginCase, 2: reloginCase
	this._runner_cnt = 1
	this._cnfName = cnf.Name
	this._netMsgs = make(chan *c.Msg, 1024)
	this._signal = make(chan struct{}, 1)
	// 临时网络代码
	this._net = &c.ClientTcp{}
	err := this._net.Initialize(this, mgr.Msglen_get, mgr.Msgmin_get, mgr.Msg_decode, mgr.Msg_encode)
	if err != nil {
		return err
	}

	this.TestCtxImp.Initialize()
	this.Set("account", account)

	log.LogInfo("robot:%s Initialize OK", this._account)
	return nil
}

func (this *Robot) Get(s string) (any, bool) {
	if s == "now" {
		return time.Now().UnixMilli(), true
	}

	return this.TestCtxImp.Get(s)
}

func (this *Robot) Set(s string, v any) {
	log.LogInfo("robot:%s state:%d Set:%s=%#v", this.Name(), this._state, s, v)
	this.TestCtxImp.Set(s, v)
}

func (this *Robot) TestCtx() ts.ITestCtx {
	return this
}

func (this *Robot) MsgChannel() chan<- *c.Msg {
	return this._netMsgs
}

func (this *Robot) Close(err error) {
	if this._closing {
		log.LogError("robot:%s state:%d Close err:%v Closing", this.Name(), this._state, err)
		return
	}

	if err != nil {
		this._err = err
		log.LogError("robot:%s state:%d Close err:%s", this.Name(), this._state, err.Error())
	} else {
		log.LogInfo("robot:%s state:%d Close Success", this.Name(), this._state)
	}

	if this._net_err == nil {
		this._net_close = true
	}

	this._closing = true
	this._net.Close()
}

// 只能在消息处理中，调用。不允许其他方式调用
func (this *Robot) end() {
	if this._testcase != nil {
		this._testcase.Stop()
		this._testcase = nil
	}

	if this._testcaseLogin != nil {
		this._testcaseLogin.Stop()
		this._testcaseLogin = nil
	}

	this._run = false
	if this._err != nil {
		log.LogError("robot:%s end err:%s index:%d time:%d", this.Name(), this._err.Error(), this._runner_index, this._runner_cnt)
	} else {
		log.LogInfo("robot:%s end success", this._account)
	}
}

// ------------------------------------------- TestcaseRunner Start --------------------------------------
func (this *Robot) Name() string {
	return this._account
}

func (this *Robot) ID() int {
	return this._id
}

func (this *Robot) CnfName() string {
	return this._cnfName
}

func (this *Robot) TimerAdd(delay int64, callback common.TimeCallback, data any) (*common.TimeInterface, error) {
	return this._timerMgr.AddTimer(delay, 0, 0, callback, data)
}

func (this *Robot) TimerDel(t *common.TimeInterface) {
	this._timerMgr.DelTimer(t)
}

func (this *Robot) MsgHandleReg(protoId protos.ProtoID, a ts.ITestcaseAction) {
	if _, ok := this._msgHandlers[protoId]; !ok {
		this._msgHandlers[protoId] = make(map[ts.ITestcaseAction]bool)
	}

	this._msgHandlers[protoId][a] = true
}

func (this *Robot) MsgHandleUnreg(protoId protos.ProtoID, a ts.ITestcaseAction) {
	delete(this._msgHandlers[protoId], a)
}

func (this *Robot) Send(protoId protos.ProtoID, data protos.JsonString) error {
	if this._closing {
		// 关闭过程中，不发送了
		log.LogInfo("robot:%s Send[%d]:%s when closing", this._account, protoId, data)
		return nil
	}

	if this._msgPrint {
		if len(this._msgFocuses) > 0 {
			if _, ok := (this._msgFocuses)[protoId]; ok {
				log.LogInfo("robot:%s Send[%d]:%s", this._account, protoId, data)
			}
		} else {
			if _, ok := (this._msgIgnores)[protoId]; !ok {
				log.LogInfo("robot:%s Send[%d]:%s", this._account, protoId, data)
			}
		}
	}
	return this._net.Send(protoId, data)
}

func (this *Robot) NetClose(s string) {
	log.LogInfo("robot:%s NetClose:%s", this._account, s)
	this.Close(nil)
}

func (this *Robot) TestcaseEnd(err error, tc *ts.Testcase, c ts.TestcaseFailedType) {
	if err != nil {
		log.LogError("Testcase Failed. robot:%s case:%d-%s err:%s", this._account, tc.ID(), tc.Name(), err.Error())
		if c != ts.TESTCASEFAILED_CONTINUE_ROBOT {
			this.Close(err)
			return
		}
	} else {
		costTime := time.Now().UnixMilli() - tc.TimeStart()
		log.LogInfo("Testcase OK. robot:%s case:%d-%s costTime:%d", this._account, tc.ID(), tc.Name(), costTime)
	}

	if tc == this._testcase {
		// 当前正在运行的testcase
		if this._cnf.Cases[this._runner_index].Count >= 0 && this._runner_cnt >= this._cnf.Cases[this._runner_index].Count {
			this._runner_index++
			this._runner_cnt = 1

			if this._runner_index >= len(this._cnf.Cases) {
				// 执行完毕
				// 成功结束
				this._state = ROBOT_STATE_END
				this.Close(nil)
				return
			}
		} else {
			this._runner_cnt++
		}

		this._runner_id++
		_, err := this.startCase_internal(this._cnf.Cases[this._runner_index].File, this._cnf.Cases[this._runner_index].Do, this._runner_id, false)
		if err != nil {
			this.Close(err)
		}
		return
	}

	if tc == this._testcaseLogin {
		// 登录成功
		this._testcaseLogin.Stop()
		this._testcaseLogin = nil

		if this._testcase == nil {
			this._runner_id++
			_, err := this.startCase_internal(this._cnf.Cases[this._runner_index].File, this._cnf.Cases[this._runner_index].Do, this._runner_id, false)
			if err != nil {
				this.Close(err)
				return
			}
			return
		}

		// 重连，继续之前的Testcase
		err = this._testcase.Start()
		if err != nil {
			err = fmt.Errorf("case:%d-%s start err:%s", this._testcase.ID(), this._testcase.Name(), err.Error())
			this.Close(err)
		}
		return
	}

	log.LogError("robot:%s case:%d-%s nowcase:%v nowlogin:%v not active", this._account, tc.ID(), tc.Name(), this._testcase, this._testcaseLogin)
}

// ------------------------------------------- INetworkHandler Start --------------------------------------
func (this *Robot) Server() string {
	return this._server
}

// ------------------------------------------- INetworkHandler End --------------------------------------
func (this *Robot) startCase_internal(file string, name string, id int, login bool) (*ts.Testcase, error) {
	fullname := fmt.Sprintf("%s/%s", file, name)
	testcase_cnf, find := TESTCASE_CNF[fullname]
	if !find {
		return nil, fmt.Errorf("case:%d-%s nil", id, fullname)
	}

	testcase := ts.Testcase{}
	err := testcase.Initialize(this, id, testcase_cnf)
	if err != nil {
		return nil, fmt.Errorf("case:%d-%s intialize err:%s", id, name, err.Error())
	}

	if login {
		this._testcaseLogin = &testcase
	} else {
		this._testcase = &testcase
	}

	err = testcase.Start()
	if err != nil {
		if login {
			this._testcaseLogin = nil
		} else {
			this._testcase = nil
		}
		return nil, fmt.Errorf("case:%d-%s start err:%s", id, name, err.Error())
	}

	return &testcase, nil
}

func (this *Robot) startLogin() error {
	c := ""
	testcaseID := 0
	if this._state == ROBOT_STATE_NONE {
		this._state = ROBOT_STATE_LOGINING
		c = this._cnf.Case_Login
		testcaseID = 1
	} else if this._cnf.Case_Relogin != "" {
		c = this._cnf.Case_Relogin
		this._state = ROBOT_STATE_RELOGIN
		testcaseID = 2
	} else {
		c = this._cnf.Case_Login
		this._state = ROBOT_STATE_RELOGIN
		testcaseID = 2
	}

	_, err := this.startCase_internal(this._cnf.File_Login, c, testcaseID, true)
	if err != nil {
		return err
	}

	log.LogInfo("robot:%s case_login:%s intialize OK", this._account, c)

	return nil
}

func (this *Robot) netStart() error {
	this._err = nil
	this._net_err = nil
	this._net_close = false

	err := this._net.Start(this._server)
	statistic.Record(&statistic.StatisticEvent{
		Type: statistic.StatisticType_Net_Start,
	})

	if err != nil {
		statistic.Record(&statistic.StatisticEvent{
			Type: statistic.StatisticType_Net_Err,
		})
		return err
	}
	log.LogInfo("robot:%s Network Start OK", this._account)

	return nil
}

func (this *Robot) Start() error {
	log.LogInfo("robot:%s Start", this._account)
	err := this.netStart()
	if err != nil {
		return err
	}

	go this.run()

	return nil
}

func (this *Robot) onMsg(msg *c.Msg) {
	switch msg.Type {
	case c.MSGTYPE_CONNECTED:
		// 连接成功
		log.LogInfo("robot:%s startLogin", this._account)
		err := this.startLogin()
		if err != nil {
			err = fmt.Errorf("robot:%s stop. startLogin err:%s", this._account, err.Error())
			this.Close(err)
			return
		}
	case c.MSGTYPE_RECV:
		// 根据注册的回调，进行回调
		protoId, err := this._mgr.Msg_decode_protoid(msg.Data)
		if err != nil {
			log.LogError("robot:%s Network Close ByMe. ProtoID err:%s", this._account, msg.Err.Error())
			this.Close(err)
			return
		}

		a, bHandle := this._msgHandlers[protoId]
		bPrint := false

		if this._msgPrint {
			if len(this._msgFocuses) > 0 {
				if _, ok := (this._msgFocuses)[protoId]; ok {
					bPrint = true
				}
			} else {
				if _, ok := this._msgIgnores[protoId]; !ok {
					bPrint = true

				}
			}
		}

		if !bHandle && !bPrint {
			// 消息不处理
			return
		}
		protoId, header, data, err := this._mgr.Msg_decode(msg.Data)
		if err != nil {
			log.LogError("robot:%s Network Close ByMe. Decode err:%s", this._account, msg.Err.Error())
			this.Close(err)
			return
		}

		if bPrint {
			log.LogInfo("robot:%s Recv[%d]:%s", this._account, protoId, data)
		}

		if bHandle {
			for k, _ := range a {
				k.OnMsg(protoId, header, data)
			}
		}
		// log.LogDebug("robot:%s msg:%d recved", this._account, msg.ProtoId)
	case c.MSGTYPE_ERR:
		if this._net_close {
			// 主动关闭，不用再处理网络异常
			log.LogInfo("robot:%s Network Close ByMe. net err:%s", this._account, msg.Err.Error())

			statistic.Record(&statistic.StatisticEvent{
				Type: statistic.StatisticType_Net_Close,
			})
		} else if this._net_err == nil {
			log.LogError("robot:%s Network Close NetErr. net err:%s", this._account, msg.Err.Error())
			statistic.Record(&statistic.StatisticEvent{
				Type: statistic.StatisticType_Net_Err,
			})
			this._net_err = msg.Err
			this.Close(msg.Err)
		} else {
			log.LogError("robot:%s Network Close Dup. net err:%s", this._account, msg.Err.Error())
		}
	case c.MSGTYPE_CLOSED:
		log.LogInfo("robot:%s msg Closed state=%d relogin=%t", this._account, this._state, this._cnf.Relogin)
		this._closing = false
		// 根据是否需要重连，判定进行重连
		if this._state == ROBOT_STATE_END {
			// 结束了
			this._err = nil
			this.end()
			return
		}

		if !this._cnf.Relogin {
			// 异常退出
			this.end()
			return
		}

		log.LogInfo("robot:%s Restart after Close", this._account)
		if this._testcase != nil {
			this._testcase.Stop()
		}

		if this._testcaseLogin != nil {
			this._testcaseLogin.Stop()
			this._testcaseLogin = nil
		}

		err := this.netStart()
		if err != nil {
			this.Close(err)
		}
	}
}

func (this *Robot) kill() {
	if len(this._signal) == 0 {
		this._signal <- struct{}{}
	}
}

func (this *Robot) run() {
	defer func() {
		close(this._netMsgs)
		this._netMsgs = nil
		this._statistics_time_end = time.Now().UnixMilli()

		this._mgr.RobotFinCallback(this, this._err)
	}()
	defer common.PanicLog(func() {
		this._err = fmt.Errorf("robot run panic")
	})

	this._statistics_time_start = time.Now().UnixMilli()

	for this._run {
		select {
		case msg := <-this._netMsgs:
			this.onMsg(msg)
		case <-this._timerMgr.Timer():
			this._timerMgr.Update()
		case <-this._signal:
			log.LogInfo("robot:%s Close from signal", this._account)
			this._state = ROBOT_STATE_END
			this.Close(fmt.Errorf("Close from signal"))
		}
	}
}