func elaborate()

in cmd/hub/compose/elaborate.go [152:274]
108 lines of code
16 McCabe index (conditional complexity)

func elaborate(manifestFilename string, parametersFilenames []string, overrides map[string]string,
	wellKnown map[string]manifest.Parameter, componentsBaseDir string,
	excludedComponents []string, depth int,
	maybeExtraParameters func(manifest.Manifest) []manifest.Parameter) (*manifest.Manifest, []manifest.Manifest) {

	stackManifest := parseManifest(manifestFilename)

	order, err := manifest.GenerateLifecycleOrder(stackManifest)
	if err != nil {
		log.Fatal(err)
	}
	stackManifest.Lifecycle.Order = order

	parametersManifests, parametersFilenamesRead := parseParameters(parametersFilenames)

	stackBaseDir := util.StripDotDirs(filepath.Dir(manifestFilename))
	componentsBaseDirCurrent := componentsBaseDir
	if componentsBaseDirCurrent == "" {
		componentsBaseDirCurrent = stackBaseDir
	}
	if config.Debug {
		log.Printf("Base directory for sources is `%s`", componentsBaseDirCurrent)
	}

	componentsManifests, err := manifest.ParseComponentsManifestsWithExclusion(stackManifest.Components, excludedComponents,
		stackBaseDir, componentsBaseDirCurrent)
	if err != nil {
		log.Fatalf("Unable to load component manifest refered from `%s`: %v", manifestFilename, err)
	}

	checkComponentsNames(stackManifest.Components)
	checkLifecycle(stackManifest.Components, stackManifest.Lifecycle)

	isApplication := stackManifest.Kind == "application"

	fromStack := stackManifest.Meta.FromStack != ""
	fromStackName := ""
	fromStackManifest := &manifest.Manifest{}
	var fromStackComponentsManifests []manifest.Manifest

	if fromStack {
		if isApplication {
			log.Fatalf("Application manifest %s cannot use `fromStack`", manifestFilename)
		}
		fromStackName = filepath.Base(stackManifest.Meta.FromStack)
		fromStackFilename := filepath.Join(stackManifest.Meta.FromStack, "hub.yaml")
		fromStackParams := scanParamsFiles(stackManifest.Meta.FromStack)
		fromStackExcludedComponents := append(excludedComponents, manifest.ComponentsNamesFromRefs(stackManifest.Components)...)
		fromStackManifest, fromStackComponentsManifests = elaborate(fromStackFilename, fromStackParams, overrides,
			wellKnown, componentsBaseDir, fromStackExcludedComponents, depth+1, nil)
	}

	if config.Verbose {
		components := "with no sub-components"
		if len(stackManifest.Components) > 0 {
			components = fmt.Sprintf("with components: %s", strings.Join(stackManifest.Lifecycle.Order, ", "))
		}
		log.Printf("*** %s %s %s", cases.Title(language.Und).String(stackManifest.Kind), stackManifest.Meta.Name,
			components)
	}

	parameters := unwrapComponentsParameters(componentsManifests)
	checkParameters(parameters)
	if fromStack {
		parameters = append(parameters, fromStackManifest.Parameters) // already flat
	}
	manifestsParameters := [][]manifest.Parameter{
		manifest.FlattenParameters(stackManifest.Parameters, fmt.Sprintf("%s [%s]", stackManifest.Meta.Name, manifestFilename)),
	}
	manifestsParameters = append(manifestsParameters, unwrapManifestsParameters(parametersManifests, parametersFilenamesRead)...)
	checkParameters(manifestsParameters)

	var elaborated manifest.Manifest

	nComponents := len(componentsManifests)
	elaborated.Version = stackManifest.Version
	elaborated.Kind = stackManifest.Kind
	elaborated.Meta = stackManifest.Meta
	elaborated.Meta.FromStack = ""
	if fromStack {
		elaborated.Meta.Annotations = mergeAnnotations(fromStackManifest.Meta.Annotations, stackManifest.Meta.Annotations)
		parentBaseDir := stackManifest.Meta.FromStack
		parentComponentsBaseDir := componentsBaseDir
		if parentComponentsBaseDir == "" {
			parentComponentsBaseDir = parentBaseDir
		}
		elaborated.Components = mergeComponentsRefs(parentBaseDir, parentComponentsBaseDir,
			fromStackManifest.Components, stackManifest.Components)
		elaborated.Lifecycle = mergeLifecycle(fromStackManifest.Lifecycle, stackManifest.Lifecycle)
		elaborated.Outputs = mergeOutputs(fromStackManifest.Outputs, stackManifest.Outputs)
		componentsManifests = mergeComponentsManifests(fromStackComponentsManifests, componentsManifests)
		elaborated.Platform.Provides = util.MergeUnique(fromStackManifest.Platform.Provides, stackManifest.Platform.Provides)
	} else {
		elaborated.Components = stackManifest.Components
		elaborated.Lifecycle = stackManifest.Lifecycle
		elaborated.Outputs = stackManifest.Outputs
		elaborated.Platform.Provides = stackManifest.Platform.Provides
	}
	parametersManifestsOutputs := unwrapManifestsOutputs(parametersManifests)
	if len(parametersManifestsOutputs) > 0 {
		elaborated.Outputs = mergeOutputs(elaborated.Outputs, parametersManifestsOutputs)
	}
	if isApplication {
		elaborated.Templates = stackManifest.Templates
	}
	stackRequires := connectRequires(fromStackName, fromStackManifest.Provides,
		stackManifest.Requires, componentsManifests, stackManifest.Lifecycle.Order)
	elaborated.Requires = mergeRequires(fromStackManifest.Requires, stackRequires)
	elaborated.Provides = mergeProvides(fromStackName, fromStackManifest.Provides,
		stackManifest.Provides, componentsManifests)

	if maybeExtraParameters != nil {
		extra := maybeExtraParameters(elaborated)
		if len(extra) > 0 {
			parameters = append(parameters, extra)
		}
	}
	parameters = append(parameters, manifestsParameters...)
	elaborated.Parameters = mergeParameters(parameters, overrides, wellKnown,
		manifest.ComponentsNamesFromRefs(elaborated.Components), nComponents, isApplication)

	return &elaborated, componentsManifests
}