func()

in common/apiserver/fromexe.go [174:258]
79 lines of code
20 McCabe index (conditional complexity)

func (p *ExternalExecutableProvider) unsafeProvision(logger logrus.FieldLogger) {
	configDir, err := pathutil.GetConfigPath()
	if err != nil {
		configDir = ""
		logger.WithError(err).Error("Get config path failed")
	}

	crossVersionConfigDir, err := pathutil.GetCrossVersionConfigPath()
	if err != nil {
		crossVersionConfigDir = ""
		logger.WithError(err).Error("Get cross version config path failed")
	}
	if configDir == "" && crossVersionConfigDir == "" {
		return
	}

	for _, candidateName := range candidateExternalExecutableProviderNames {
		candidatePath := filepath.Join(configDir, candidateName)
		if _, err := os.Stat(candidatePath); !os.IsNotExist(err) {
			p.executablePath = &candidatePath
			break
		}
	}
	if p.executablePath == nil {
		for _, candidateName := range candidateExternalExecutableProviderNames {
			candidatePath := filepath.Join(crossVersionConfigDir, candidateName)
			if _, err := os.Stat(candidatePath); !os.IsNotExist(err) {
				p.executablePath = &candidatePath
				break
			}
		}
	}
	if p.executablePath == nil {
		noExecutablePath := ""
		p.executablePath = &noExecutablePath
		return
	}

	stdout, stderr, err := runExternalProvider(*p.executablePath)
	logger = logger.WithFields(logrus.Fields{
		"path":   *p.executablePath,
		"stdout": stdout,
		"stderr": stderr,
	})
	if err != nil {
		logger.WithError(err).Error("Failed to run external API server provider")
		return
	}

	var provision model.ProvisionOutputV1
	if err := json.Unmarshal([]byte(stdout), &provision); err != nil {
		logger.WithError(err).Error("Mal-formatted stdout from external provider")
		return
	}
	if provision.SchemaVersion != "1.0" {
		logger.WithError(errors.New("unknown schema version")).Errorf("Failed to parse provider stdout of schema version %s", provision.SchemaVersion)
		return
	}

	var provisionErr model.ErrorOutputV1
	if err := json.Unmarshal([]byte(stderr), &provisionErr); err != nil {
		logger.WithError(err).Error("Mal-formatted stderr from external provider")
	}
	if provisionErr.SchemaVersion != "1.0" {
		logger.WithError(errors.New("unknown schema version")).Errorf("Failed to parse provider stderr of schema version %s", provisionErr.SchemaVersion)
		return
	}

	pemCerts := []byte(provision.Result.CACertificate)
	p.pemCerts = &pemCerts
	p.serverDomain = &provision.Result.ServerDomain
	p.extraHTTPheaders = &provision.Result.ExtraHTTPHeaders
	p.regionId = &provision.Result.RegionId
	for _, errmsg := range provisionErr.Error {
		switch errmsg.Code {
		case model.CodeGetServerDomainError:
			p.serverDomainError = errmsg.Message
		case model.CodeGetCACertificateError:
			p.pemCertsError = errmsg.Message
		case model.CodeRegionIdError:
			p.regionIdError = errmsg.Message
		}
	}
	logger.WithField("provision", p).Info("Provisioned API server information with external provider")
}