func processIntegration()

in internal/cmd/integrations/apply.go [541:646]
87 lines of code
21 McCabe index (conditional complexity)

func processIntegration(overridesFile string, integrationFolder string, testsFolder string,
	configVarsFolder string, testConfigFolder string, pipeline string, userLabel string, grantPermission bool,
	runTests bool,
) (err error) {
	rJSONFiles := regexp.MustCompile(`(\S*)\.json$`)

	var integrationNames []string
	var overridesBytes []byte

	javascriptFolder := path.Join(integrationFolder, "javascript")
	jsonnetFolder := path.Join(integrationFolder, "datatransformer")

	if _, err = os.Stat(overridesFile); err == nil {
		overridesBytes, err = utils.ReadFile(overridesFile)
		if err != nil {
			return err
		}
	}

	if len(overridesBytes) > 0 {
		clilog.Info.Printf("Found overrides file %s\n", overridesFile)
	}

	// get the integration file
	_ = filepath.Walk(integrationFolder, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			integrationFile := filepath.Base(path)
			if rJSONFiles.MatchString(integrationFile) {
				clilog.Info.Printf("Found configuration for integration: %s\n", integrationFile)
				integrationNames = append(integrationNames, integrationFile)
			}
		}
		return nil
	})

	if len(integrationNames) > 0 {
		// get only the first file
		integrationBytes, err := utils.ReadFile(path.Join(integrationFolder, integrationNames[0]))
		if err != nil {
			return err
		}
		// check for code files
		codeMap, err := processCodeFolders(javascriptFolder, jsonnetFolder)
		if err != nil {
			return err
		}

		if len(codeMap) > 0 {
			integrationBytes, err = integrations.SetCode(integrationBytes, codeMap)
			if err != nil {
				return err
			}
		}

		clilog.Info.Printf("Create integration %s\n", getFilenameWithoutExtension(integrationNames[0]))
		respBody, err := integrations.CreateVersion(getFilenameWithoutExtension(integrationNames[0]),
			integrationBytes, overridesBytes, "", userLabel, grantPermission, false)
		if err != nil {
			return err
		}
		version, err := getVersion(respBody)
		if err != nil {
			return err
		}

		// create  test cases for integration
		if err = processTestCases(testsFolder, getFilenameWithoutExtension(integrationNames[0]), version); err != nil {
			return err
		}

		// publish the integration
		clilog.Info.Printf("Publish integration %s with version %s\n",
			getFilenameWithoutExtension(integrationNames[0]), version)
		// read any config variables
		configVarsFile := path.Join(configVarsFolder, getFilenameWithoutExtension(integrationNames[0])+"-config.json")
		var configVarBytes []byte
		if _, err = os.Stat(configVarsFile); err == nil {
			configVarBytes, err = utils.ReadFile(configVarsFile)
			if err != nil {
				return err
			}
		}
		_, err = integrations.Publish(getFilenameWithoutExtension(integrationNames[0]), version, configVarBytes)
		if err != nil {
			return err
		}

		// Execute test cases
		if runTests {
			err = executeAllTestCases(testConfigFolder, getFilenameWithoutExtension(integrationNames[0]), version)
			if err != nil {
				return err
			}
		}

		if pipeline != "" {
			err = apiclient.WriteResultsFile(outputGCSPath, "SUCCEEDED")
		}
		return err
	}
	clilog.Warning.Printf("No integration files were found\n")
	return nil
}