func Register()

in agent/hybrid/hybrid.go [34:142]
99 lines of code
17 McCabe index (conditional complexity)

func Register(region string, code string, id string, name string, networkmode string, need_restart bool, tags []Tag) (ret bool) {
	logger := log.GetLogger().WithField("action", "register")
	logger.Infoln(region, code, id, name)

	if instance.IsHybrid() {
		fmt.Println("error, agent already register, deregister first")
		logger.Infoln("error, agent already register, deregister first")
		return
	}
	ret = false
	hostname, _ := os.Hostname()
	osType := osutil.GetOsType()

	defer func() {
		if ret {
			metrics.GetHybridRegisterEvent().ReportEventSync()
		}
	}()

	// Try to get instanceId from metaserver.
	instanceCh := make(chan string)
	go func() {
		// Default timeout in GetInstanceId() is 5 seconds. It's too long.
		instanceId, err := metaserver.GetInstanceId(logger, httpbase.WithTimeoutInSeconds(2))
		if err != nil {
			instanceId = ""
		}
		instanceCh <- instanceId
	}()

	ip, _ := osutil.ExternalIP()
	var pub, pri bytes.Buffer
	err := genRsaKey(&pub, &pri)
	if err != nil {
		fmt.Println("error, generate rsa key failed")
		return
	}
	encodeString := base64.StdEncoding.EncodeToString(pub.Bytes())
	mid, _ := instance.MachineID()
	fingerprint, err := instance.GenerateFingerprint()
	if err != nil {
		fmt.Printf("generate fingerprint failed: %v", err)
		return
	}
	info := &RegisterInfo{
		Code:            code,
		MachineId:       mid,
		Fingerprint:     fingerprint,
		RegionId:        region,
		InstanceName:    name,
		Hostname:        hostname,
		IntranetIp:      ip.String(),
		OsVersion:       osutil.GetVersion(),
		OsType:          osType,
		ClientVersion:   version.AssistVersion,
		PublicKeyBase64: encodeString,
		Id:              id,
		Tag:             tags,
	}

	headers := make(map[string]string)
	// Put instanceId into headers if it exists.
	instanceId := <-instanceCh
	if len(instanceId) > 0 && len(instanceId) <= 32 && httpguts.ValidHeaderFieldValue(instanceId) {
		headers["X-Client-Instance-ID"] = instanceId
	} else {
		logger.Info("invalid ecs instanceId: ", instanceId)
		headers["X-Client-Instance-ID"] = "unknown"
	}

	resp, err := doRegister(info, networkmode, headers)
	if err != nil {
		fmt.Println("Register failed: ", err)
		return
	}
	if resp.Code == 200 {
		instance.SaveInstanceInfo(resp.InstanceId, fingerprint, region, pub.String(), pri.String(), networkmode)
	} else if resp.ErrCode == errCodeEcsRegDisabled {
		fmt.Println("The ECS instance is forbidden from registering as a managed instance.")
		return
	} else if resp.ErrCode == errCodeFingerprintDuplicate {
		fmt.Println("Fingerprint is duplicated and needs to be regenerated")
		fingerprint, err = instance.GenerateFingerprintIgnoreSavedHash()
		if err != nil {
			fmt.Println("Regenerate fingerprint failed: ", err)
			return
		}
		info.Fingerprint = fingerprint
		resp, err = doRegister(info, networkmode, headers)
		if err == nil && resp.Code == 200 {
			instance.SaveInstanceInfo(resp.InstanceId, fingerprint, region, pub.String(), pri.String(), networkmode)
		} else {
			fmt.Println("Register failed: ", err, resp)
			return
		}
	} else {
		fmt.Println("Register failed: ", resp)
		return
	}

	fmt.Println("register ok")
	fmt.Println("instance id:", resp.InstanceId)
	if need_restart {
		serviceutil.RestartAgentService(logger)
	}
	fmt.Println("restart service")
	ret = true
	return
}