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

package robot

import (
	"fmt"
	"os"

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

type co_bot_end_msg struct {
	_err   error
	_robot *Robot
}
type RobotManager struct {
	Msglen_get         net.MsgLenGet
	Msgmin_get         net.MsgMinGet
	Msg_decode         net.MsgDecode
	Msg_encode         net.MsgEncode
	Msg_decode_protoid net.MsgDecodeProtoID

	_count         int
	_robots        []*Robot
	_chan_bot_quit chan co_bot_end_msg

	_statistics_cnt_success int // 成功结束robots
	_statistics_cnt_failed  int // 失败结束robots

	_signal chan os.Signal
}

func (this *RobotManager) robotAdd(r *Robot) {
	this._robots = append(this._robots, r)
	this._count++
	statistic.Record(&statistic.StatisticEvent{
		Type: statistic.StatisticType_Robot_Create,
		Name: r._cnfName,
	})
}

func (this *RobotManager) InitializeBrutetest() error {
	// 进行暴力协议测试
	log.LogInfo("RobotManager Brutetest %s", TEST_CNF.Brute.File)
	err := brutetest.BruteTestCreate(TEST_CNF.Brute.File)
	if err != nil {
		return err
	}

	for cid, cnfs := range brutetest.BrutetestCaselistMap {
		caseName := fmt.Sprintf("brute_%d", cid)
		robotCnf := RobotConfig{
			Relogin:      true,
			Case_Login:   TEST_CNF.Brute.Login,
			Case_Relogin: TEST_CNF.Brute.Relogin,
			Cases:        make([]*TestCaseRunnerConfig, 1),
		}
		robotCnf.Cases[0] = &TestCaseRunnerConfig{
			Do:    caseName,
			Count: 0,
		}

		testcaseCnf := &testcase.TestcaseConfig{
			Name:     caseName,
			TestFlow: make([][]testcase.TestcaseActionCnf, 1),
		}
		testcaseCnf.TestFlow[0] = make([]testcase.TestcaseActionCnf, len(cnfs))
		for j := 0; j < len(cnfs); j++ {
			actionCnf := &testcaseimp.BruteTestCnf{
				Cid:   cid,
				Index: len(cnfs) - j - 1,
			}
			actionCnf.Name = "BruteTest"
			testcaseCnf.TestFlow[0][j] = actionCnf
		}

		TESTCASE_CNF[caseName] = testcaseCnf

		accountName := fmt.Sprintf("%s%d", TEST_CNF.AccountPre, this._count+int(TEST_CNF.AccountOffset))
		robotv := Robot{}
		err := robotv.InitializeCnf(this._count, this, TEST_CNF.Server, accountName, &robotCnf, true, nil, nil)
		if err != nil {
			log.LogInfo("RobotManager Initialize robot:%s failed", accountName)
			continue
		}

		this.robotAdd(&robotv)
	}

	return nil
}

func (this *RobotManager) InitializeBrutetestTask() error {
	// 进行暴力协议测试
	log.LogInfo("RobotManager BrutetestTask %s", TEST_CNF.Brute.File)
	taskCnt, err := brutetest.BrutetestTaskCreate(TEST_CNF.Brute.File)
	if err != nil {
		return err
	}

	robotCnt := taskCnt
	if robotCnt > TEST_CNF.Brute.RobotCnt {
		robotCnt = TEST_CNF.Brute.RobotCnt
	}

	// 创建case配置
	caseName := "brutetesttask"
	testcaseCnf := &testcase.TestcaseConfig{
		Name:     caseName,
		TestFlow: make([][]testcase.TestcaseActionCnf, 1),
	}
	testcaseCnf.TestFlow[0] = make([]testcase.TestcaseActionCnf, 1)
	actionCnf := &testcaseimp.BruteTestTaskCnf{}
	actionCnf.Name = "BruteTestTask"
	testcaseCnf.TestFlow[0][0] = actionCnf
	TESTCASE_CNF[fmt.Sprintf("%s/%s", "", caseName)] = testcaseCnf

	// 创建机器人
	for i := 0; i < robotCnt; i++ {
		robotCnf := RobotConfig{
			Relogin:      true,
			File_Login:   TEST_CNF.Brute.File_Login,
			Case_Login:   TEST_CNF.Brute.Login,
			Case_Relogin: TEST_CNF.Brute.Relogin,
			Cases:        make([]*TestCaseRunnerConfig, 1),
		}

		robotCnf.Cases[0] = &TestCaseRunnerConfig{
			Do:    caseName,
			Count: 0,
		}

		accountName := fmt.Sprintf("%s%d", TEST_CNF.AccountPre, this._count+int(TEST_CNF.AccountOffset))
		robotv := Robot{}
		err := robotv.InitializeCnf(this._count, this, TEST_CNF.Server, accountName, &robotCnf, true, nil, nil)
		if err != nil {
			log.LogInfo("RobotManager Initialize robot:%s failed", accountName)
			continue
		}

		robotCnf.Name = fmt.Sprintf("brute_%d(%d)", i, robotCnt)
		this.robotAdd(&robotv)
	}

	log.LogInfo("RobotManager BrutetestTask taskcnt:%d robotcnt:%d", taskCnt, robotCnt)
	return nil
}

func (this *RobotManager) Initialize(func_msglen_get net.MsgLenGet,
	func_msgmin_get net.MsgMinGet,
	func_msg_decodeprotoid net.MsgDecodeProtoID,
	func_msg_decode net.MsgDecode,
	func_msg_encode net.MsgEncode,
	func_msg_gen protos.MsgGenerate) error {
	this.Msglen_get = func_msglen_get
	this.Msgmin_get = func_msgmin_get
	this.Msg_decode = func_msg_decode
	this.Msg_encode = func_msg_encode
	this.Msg_decode_protoid = func_msg_decodeprotoid
	protos.ProtoGeneratorInit(func_msg_gen)

	this._count = 0
	this._chan_bot_quit = make(chan co_bot_end_msg, 10)

	this._signal = make(chan os.Signal)
	Signal(this._signal)

	if TEST_CNF.Statistic.StatisticTickInterval > 0 || TEST_CNF.Statistic.StatisticTotTime > 0 {
		log.LogInfo("Statistic Start")
		statistic.Start(TEST_CNF.Statistic.StatisticTickInterval,
			TEST_CNF.Statistic.StatisticTotTime,
			TEST_CNF.Statistic.ActionTimeOver)
	}

	log.LogInfo("RobotManager Initialize Start")
	if TEST_CNF.Brute != nil {
		err := this.InitializeBrutetestTask()
		if err != nil {
			return err
		}
	}
	for i := 0; i < len(TEST_CNF.Robots); i++ {
		log.LogInfo("RobotManager Initialize robot:%s count:%d offset:%d", TEST_CNF.Robots[i].Robot, TEST_CNF.Robots[i].Count, this._count)
		var ignores map[protos.ProtoID]bool
		focus := make(map[protos.ProtoID]bool)
		for _, protoid := range TEST_CNF.Robots[i].Focus {
			log.LogDebug("Focus:%d", protoid)
			focus[protos.ProtoID(protoid)] = true
		}

		if len(focus) == 0 {
			ignores = make(map[protos.ProtoID]bool)
			for _, protoid := range TEST_CNF.Robots[i].Ignores {
				log.LogDebug("ignore:%d", protoid)
				ignores[protos.ProtoID(protoid)] = true
			}
		}

		for j := 0; j < TEST_CNF.Robots[i].Count; j++ {
			robotv := Robot{}
			accountName := fmt.Sprintf("%s%d", TEST_CNF.AccountPre, this._count+int(TEST_CNF.AccountOffset))
			err := robotv.Initialize(this._count, this, TEST_CNF.Server, accountName, TEST_CNF.Robots[i].File, TEST_CNF.Robots[i].Robot, TEST_CNF.Robots[i].Monitor, ignores, focus)
			if err != nil {
				log.LogInfo("RobotManager robot:%s intiailize err:%s", accountName, err.Error())
				continue
			}

			this.robotAdd(&robotv)
		}
	}

	return nil
}

func (this *RobotManager) Run() {
	defer func() {
		log.LogInfo("RobotManager Fin success_cnt:%d failed_cnt:%d", this._statistics_cnt_success, this._statistics_cnt_failed)
		statistic.Stop()
	}()
	defer common.PanicLog(nil)

	for _, bot := range this._robots {
		err := bot.Start()
		if err != nil {
			this._count--
			log.LogError("RobotManager robot:%s Start err:%s. robot_cnt:%d", bot.Name(), err.Error(), this._count)
		}
	}

	for this._count > 0 {
		select {
		case msg := (<-this._chan_bot_quit):
			this._count--
			if msg._err == nil {
				this._statistics_cnt_success++
				log.LogInfo("RobotManager robot:%s (%s) end success. robot_cnt left:%d success_cnt:%d failed_cnt:%d costTime:%d", msg._robot.Name(), msg._robot.CnfName(), this._count, this._statistics_cnt_success, this._statistics_cnt_failed, msg._robot._statistics_time_end-msg._robot._statistics_time_start)
			} else {
				this._statistics_cnt_failed++
				log.LogError("RobotManager robot:%s (%s) end err:%s. robot_cnt left:%d success_cnt:%d failed_cnt:%d", msg._robot.Name(), msg._robot.CnfName(), msg._err.Error(), this._count, this._statistics_cnt_success, this._statistics_cnt_failed)
			}
		case <-this._signal:
			for _, bot := range this._robots {
				bot.kill()
			}
		}
	}
}

func (this *RobotManager) RobotFinCallback(bot *Robot, err error) {
	msg := co_bot_end_msg{}
	msg._err = err
	msg._robot = bot

	if err == nil {
		statistic.Record(&statistic.StatisticEvent{
			Type: statistic.StatisticType_Robot_Success,
			Name: bot._cnfName,
		})
	} else if err.Error() == "Close from signal" {
		statistic.Record(&statistic.StatisticEvent{
			Type: statistic.StatisticType_Robot_Close,
			Name: bot._cnfName,
		})
	} else {
		statistic.Record(&statistic.StatisticEvent{
			Type: statistic.StatisticType_Robot_Fail,
			Name: bot._cnfName,
		})
	}

	this._chan_bot_quit <- msg
}