Golang golog.Error函數代碼示例

func (b *Broker) HandleTaskResult(uuid string) (*task.Reply, error) {
	if len(uuid) == 0 {
		return nil, errors.ErrInvalidArgument
	}
	key := fmt.Sprintf("r_%s", uuid)
	result, err := b.redisClient.HMGet(key,
		"is_success",
		"result",
	).Result()
	if err != nil {
		golog.Error("Broker", "HandleFailTask", err.Error(), 0, "key", key)
		return nil, err
	}

	//key不存在
	if result[0] == nil {
		return nil, errors.ErrResultNotExist
	}
	isSuccess, err := strconv.Atoi(result[0].(string))
	if err != nil {
		return nil, err
	}
	ret := result[1].(string)
	return &task.Reply{
		IsResultExist: 1,
		IsSuccess:     isSuccess,
		Result:        ret,
	}, nil
}

func (b *Broker) resetTaskRequest(args []interface{}) error {
	var err error
	if len(args) == 0 || len(args) != config.TaskRequestItemCount {
		return errors.ErrInvalidArgument
	}
	request := new(task.TaskRequest)
	request.Uuid = args[0].(string)
	request.BinName = args[1].(string)
	request.Args = args[2].(string)
	request.StartTime, err = strconv.ParseInt(args[3].(string), 10, 64)
	if err != nil {
		return err
	}
	request.TimeInterval = args[4].(string)
	request.Index, err = strconv.Atoi(args[5].(string))
	if err != nil {
		return err
	}
	vec := strings.Split(request.TimeInterval, " ")
	request.Index++
	if request.Index < len(vec) {
		timeLater, err := strconv.Atoi(vec[request.Index])
		if err != nil {
			return err
		}
		afterTime := time.Second * time.Duration(timeLater)
		b.timer.NewTimer(afterTime, b.AddRequestToRedis, request)
	} else {
		golog.Error("Broker", "HandleFailTask", "retry max time", 0,
			"key", fmt.Sprintf("t_%s", request.Uuid))
		return errors.ErrTryMaxTimes
	}
	return nil
}

func NewWorker(cfg *config.WorkerConfig) (*Worker, error) {
	var err error
	w := new(Worker)
	w.cfg = cfg

	vec := strings.SplitN(cfg.RedisAddr, "/", 2)
	if len(vec) == 2 {
		w.redisAddr = vec[0]
		w.redisDB, err = strconv.Atoi(vec[1])
		if err != nil {
			return nil, err
		}
	} else {
		w.redisAddr = vec[0]
		w.redisDB = config.DefaultRedisDB
	}

	w.redisClient = redis.NewClient(
		&redis.Options{
			Addr:     w.redisAddr,
			Password: "", // no password set
			DB:       int64(w.redisDB),
		},
	)
	_, err = w.redisClient.Ping().Result()
	if err != nil {
		golog.Error("worker", "NewWorker", "ping redis fail", 0, "err", err.Error())
		return nil, err
	}

	return w, nil
}

func (w *Worker) DoScriptTaskRequest(req *task.TaskRequest) (string, error) {
	var output string
	var err error
	var maxRunTime int64

	binPath := path.Clean(w.cfg.BinPath + "/" + req.BinName)
	_, err = os.Stat(binPath)
	if err != nil && os.IsNotExist(err) {
		golog.Error("worker", "DoScrpitTaskRequest", "File not exist", 0,
			"key", fmt.Sprintf("t_%s", req.Uuid),
			"bin_path", binPath,
		)
		return "", errors.ErrFileNotExist
	}
	if req.MaxRunTime == 0 {
		maxRunTime = w.cfg.TaskRunTime
	} else {
		maxRunTime = req.MaxRunTime
	}
	if len(req.Args) == 0 {
		output, err = w.ExecBin(binPath, nil, maxRunTime)
	} else {
		argsVec := strings.Split(req.Args, " ")
		output, err = w.ExecBin(binPath, argsVec, maxRunTime)
	}
	return output, err
}

func (w *Worker) CmdRunWithTimeout(cmd *exec.Cmd, timeout time.Duration) (error, bool) {
	done := make(chan error)
	go func() {
		done <- cmd.Wait()
	}()

	var err error
	select {
	case <-time.After(timeout):
		// timeout
		if err = cmd.Process.Kill(); err != nil {
			golog.Error("worker", "CmdRunTimeout", "kill error", 0,
				"path", cmd.Path,
				"error", err.Error(),
			)
		}
		golog.Info("worker", "CmdRunWithTimeout", "kill process", 0,
			"path", cmd.Path,
			"error", errors.ErrExecTimeout.Error(),
		)
		go func() {
			<-done // allow goroutine to exit
		}()
		return errors.ErrExecTimeout, true
	case err = <-done:
		return err, false
	}
}

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	flag.Parse()

	if len(*configFile) == 0 {
		fmt.Println("must use a config file")
		return
	}

	cfg, err := config.ParseWorkerConfigFile(*configFile)
	if err != nil {
		fmt.Printf("parse config file error:%v\n", err.Error())
		return
	}

	//when the log file size greater than 1GB, kingtask will generate a new file
	if len(cfg.LogPath) != 0 {
		sysFilePath := path.Join(cfg.LogPath, sysLogName)
		sysFile, err := golog.NewRotatingFileHandler(sysFilePath, MaxLogSize, 1)
		if err != nil {
			fmt.Printf("new log file error:%v\n", err.Error())
			return
		}
		golog.GlobalLogger = golog.New(sysFile, golog.Lfile|golog.Ltime|golog.Llevel)
	}

	if *logLevel != "" {
		setLogLevel(*logLevel)
	} else {
		setLogLevel(cfg.LogLevel)
	}

	var w *worker.Worker
	w, err = worker.NewWorker(cfg)
	if err != nil {
		golog.Error("main", "main", err.Error(), 0)
		golog.GlobalLogger.Close()
		w.Close()
		return
	}

	sc := make(chan os.Signal, 1)
	signal.Notify(sc,
		syscall.SIGHUP,
		syscall.SIGINT,
		syscall.SIGTERM,
		syscall.SIGQUIT)

	go func() {
		sig := <-sc
		golog.Info("main", "main", "Got signal", 0, "signal", sig)
		golog.GlobalLogger.Close()
		w.Close()
	}()
	golog.Info("main", "main", "Worker start!", 0)
	w.Run()
}

func (b *Broker) handleConn(c net.Conn) error {
	defer func() {
		r := recover()
		if err, ok := r.(error); ok {
			const size = 4096
			buf := make([]byte, size)
			buf = buf[:runtime.Stack(buf, false)]

			golog.Error("Broker", "handleConn",
				err.Error(), 0,
				"stack", string(buf))
		}
		c.Close()
	}()

	var CloseConn bool
	reader := bufio.NewReaderSize(c, 1024)
	for {
		msgType := []byte{0}
		if _, err := io.ReadFull(reader, msgType); err != nil {
			return errors.ErrBadConn
		}

		switch msgType[0] {
		case config.TypeRequestTask:
			b.HandleRequest(reader, c)
		case config.TypeGetTaskResult:
			b.HandleTaskResult(reader, c)
		case config.TypeCloseConn:
			CloseConn = true
		default:
			golog.Error("Broker", "handleConn", "msgType error", 0, "msg_type", msgType[0])
			CloseConn = true
		}
		if CloseConn {
			break
		}
	}
	return nil
}

//處理失敗的任務
func (b *Broker) HandleFailTask() error {
	var uuid string
	var err error
	for b.running {
		uuid, err = b.redisClient.SPop(config.FailResultUuidSet).Result()
		//沒有結果，直接返回
		if err == redis.Nil {
			time.Sleep(time.Second)
			continue
		}
		if err != nil {
			golog.Error("Broker", "HandleFailTask", "spop error", 0, "error", err.Error())
			continue
		}

		key := fmt.Sprintf("r_%s", uuid)
		timeInterval, err := b.redisClient.HGet(key, "time_interval").Result()
		if err != nil {
			golog.Error("Broker", "HandleFailTask", err.Error(), 0, "key", key)
			continue
		}
		//沒有超時重試機製
		if len(timeInterval) == 0 {
			b.SetFailTaskCount(fmt.Sprintf("t_%s", uuid))
			continue
		}
		//獲取結果中所有值,改為逐個獲取
		results, err := b.redisClient.HMGet(key,
			"uuid",
			"bin_name",
			"args",
			"start_time",
			"time_interval",
			"index",
			"max_run_time",
			"task_type",
		).Result()
		if err != nil {
			golog.Error("Broker", "HandleFailTask", err.Error(), 0, "key", key)
			continue
		}
		//key已經過期
		if results[0] == nil {
			golog.Error("Broker", "HandleFailTask", "result expired", 0, "key", key)
			continue
		}
		//刪除結果
		_, err = b.redisClient.Del(key).Result()
		if err != nil {
			golog.Error("Broker", "HandleFailTask", "delete result failed", 0, "key", key)
		}
		err = b.resetTaskRequest(results)
		if err != nil {
			golog.Error("Broker", "HandleFailTask", err.Error(), 0, "key", key)
			b.SetFailTaskCount(fmt.Sprintf("t_%s", uuid))
		}
	}

	return nil
}

func (w *Worker) SetSuccessTaskCount(reqKey string) error {
	successTaskKey := fmt.Sprintf(config.SuccessTaskKey,
		time.Now().Format(config.TimeFormat))
	count, err := w.redisClient.Incr(successTaskKey).Result()
	if err != nil {
		golog.Error("Worker", "SetSuccessTaskCount", "Incr", 0, "err", err.Error(),
			"req_key", reqKey)
		return err
	}
	//第一次設置該key
	if count == 1 {
		//保存一個月
		expireTime := time.Second * time.Duration(60*60*24*30)
		_, err = w.redisClient.Expire(successTaskKey, expireTime).Result()
		if err != nil {
			golog.Error("Worker", "SetSuccessTaskCount", "Expire", 0, "err", err.Error(),
				"req_key", reqKey)
			return err
		}
	}
	return nil
}

func (w *Worker) Run() error {
	w.running = true
	for w.running {
		uuid, err := w.redisClient.SPop(config.RequestUuidSet).Result()
		//沒有請求
		if err == redis.Nil {
			time.Sleep(time.Second)
			continue
		}
		if err != nil {
			golog.Error("Worker", "run", "spop error", 0, "error", err.Error())
			continue
		}
		reqKey := fmt.Sprintf("t_%s", uuid)

		//獲取請求中所有值
		request, err := w.redisClient.HMGet(reqKey,
			"uuid",
			"bin_name",
			"args",
			"start_time",
			"time_interval",
			"index",
		).Result()
		if err != nil {
			golog.Error("Worker", "run", err.Error(), 0, "req_key", reqKey)
			continue
		}
		//key不存在
		if request[0] == nil {
			golog.Error("Worker", "run", "Key is not exist", 0, "req_key", reqKey)
			continue
		}
		_, err = w.redisClient.Del(reqKey).Result()
		if err != nil {
			golog.Error("Worker", "run", "delete result failed", 0, "req_key", reqKey)
		}
		taskResult, err := w.DoTaskRequest(request)
		if err != nil {
			golog.Error("Worker", "run", "DoTaskRequest", 0, "err", err.Error(),
				"req_key", reqKey)
		}

		if taskResult != nil {
			err = w.SetTaskResult(taskResult)
			if err != nil {
				golog.Error("Worker", "run", "DoTaskRequest", 0,
					"err", err.Error(), "req_key", reqKey)
			}
			golog.Info("worker", "run", "do task success", 0, "req_key", reqKey,
				"result", taskResult.Result)
		}

		if w.cfg.Peroid != 0 {
			time.Sleep(time.Second * time.Duration(w.cfg.Peroid))
		}
	}
	return nil
}

func (b *Broker) AddRequestToRedis(tr interface{}) error {
	r, ok := tr.(*task.TaskRequest)
	if !ok {
		return errors.ErrInvalidArgument
	}
	key := fmt.Sprintf("t_%s", r.Uuid)
	setCmd := b.redisClient.HMSet(key,
		"uuid", r.Uuid,
		"bin_name", r.BinName,
		"args", r.Args,
		"start_time", strconv.FormatInt(r.StartTime, 10),
		"time_interval", r.TimeInterval,
		"index", strconv.Itoa(r.Index),
		"max_run_time", strconv.FormatInt(r.MaxRunTime, 10),
		"task_type", strconv.Itoa(r.TaskType),
	)
	err := setCmd.Err()
	if err != nil {
		golog.Error("Broker", "AddRequestToRedis", "HMSET error", 0,
			"set", config.RequestUuidSet,
			"uuid", r.Uuid,
			"err", err.Error(),
		)
		return err
	}
	saddCmd := b.redisClient.SAdd(config.RequestUuidSet, r.Uuid)
	err = saddCmd.Err()
	if err != nil {
		golog.Error("Broker", "AddRequestToRedis", "SADD error", 0,
			"set", config.RequestUuidSet,
			"uuid", r.Uuid,
			"err", err.Error(),
		)
		return err
	}

	return nil
}

func (w *Worker) DoTaskRequest(args []interface{}) (*task.TaskResult, error) {
	var err error
	var output string

	req := new(task.TaskRequest)
	ret := new(task.TaskResult)

	req.Uuid = args[0].(string)
	req.BinName = args[1].(string)
	req.Args = args[2].(string)
	req.StartTime, err = strconv.ParseInt(args[3].(string), 10, 64)
	if err != nil {
		return nil, err
	}
	req.TimeInterval = args[4].(string)
	req.Index, err = strconv.Atoi(args[5].(string))
	if err != nil {
		return nil, err
	}
	req.MaxRunTime, err = strconv.ParseInt(args[6].(string), 10, 64)
	if err != nil {
		return nil, err
	}
	req.TaskType, err = strconv.Atoi(args[7].(string))
	if err != nil {
		return nil, err
	}
	switch req.TaskType {
	case task.ScriptTask:
		output, err = w.DoScriptTaskRequest(req)
	case task.RpcTaskGET, task.RpcTaskPOST, task.RpcTaskPUT, task.RpcTaskDELETE:
		output, err = w.DoRpcTaskRequest(req)
	default:
		err = errors.ErrInvalidArgument
		golog.Error("Worker", "DoTaskRequest", "task type error", 0, "task_type", req.TaskType)
	}
	ret.TaskRequest = *req
	//執行任務失敗，
	if err != nil {
		ret.IsSuccess = int64(0)
		ret.Result = err.Error()
		return ret, nil
	}
	ret.IsSuccess = int64(1)
	ret.Result = output

	return ret, nil
}

func (b *Broker) Run() error {
	b.running = true

	go b.HandleFailTask()
	for b.running {
		conn, err := b.listener.Accept()
		if err != nil {
			golog.Error("server", "Run", err.Error(), 0)
			continue
		}
		//處理客戶端請求
		go b.handleConn(conn)
	}

	return nil
}

func (w *Worker) DoTaskRequest(args []interface{}) (*task.TaskResult, error) {
	var err error
	var output string
	req := new(task.TaskRequest)
	ret := new(task.TaskResult)

	req.Uuid = args[0].(string)
	req.BinName = args[1].(string)
	req.Args = args[2].(string)
	req.StartTime, err = strconv.ParseInt(args[3].(string), 10, 64)
	if err != nil {
		return nil, err
	}
	req.TimeInterval = args[4].(string)
	req.Index, err = strconv.Atoi(args[5].(string))
	if err != nil {
		return nil, err
	}
	binPath := path.Clean(w.cfg.BinPath + "/" + req.BinName)
	_, err = os.Stat(binPath)
	if err != nil && os.IsNotExist(err) {
		golog.Error("worker", "DoTaskRequest", "File not exist", 0,
			"key", fmt.Sprintf("t_%s", req.Uuid),
			"bin_path", binPath,
		)
		return nil, errors.ErrFileNotExist
	}
	if len(req.Args) == 0 {
		output, err = w.ExecBin(binPath, nil)
	} else {
		argsVec := strings.Split(req.Args, " ")
		output, err = w.ExecBin(binPath, argsVec)
	}

	ret.TaskRequest = *req
	//執行任務失敗
	if err != nil {
		ret.IsSuccess = int64(0)
		ret.Result = err.Error()
		return ret, nil
	}
	ret.IsSuccess = int64(1)
	ret.Result = output

	return ret, nil
}

func NewBroker(cfg *config.BrokerConfig) (*Broker, error) {
	var err error

	broker := new(Broker)
	broker.cfg = cfg
	broker.addr = cfg.Addr
	if len(broker.addr) == 0 {
		return nil, errors.ErrInvalidArgument
	}

	vec := strings.SplitN(cfg.RedisAddr, "/", 2)
	if len(vec) == 2 {
		broker.redisAddr = vec[0]
		broker.redisDB, err = strconv.Atoi(vec[1])
		if err != nil {
			return nil, err
		}
	} else {
		broker.redisAddr = vec[0]
		broker.redisDB = config.DefaultRedisDB
	}

	broker.web = echo.New()

	broker.timer = timer.New(time.Millisecond * 10)
	go broker.timer.Start()

	broker.redisClient = redis.NewClient(
		&redis.Options{
			Addr:     broker.redisAddr,
			Password: "", // no password set
			DB:       int64(broker.redisDB),
		},
	)
	_, err = broker.redisClient.Ping().Result()
	if err != nil {
		golog.Error("broker", "NewBroker", "ping redis fail", 0, "err", err.Error())
		return nil, err
	}

	return broker, nil
}