Beispiel #1
0
func FetchTemplateData(pipelineName string, resourceName string, client concourse.Client, page concourse.Page) (TemplateData, error) {
	pipeline, pipelineFound, err := client.Pipeline(pipelineName)
	if err != nil {
		return TemplateData{}, err
	}

	if !pipelineFound {
		return TemplateData{}, ErrConfigNotFound
	}

	resource, resourceFound, err := client.Resource(pipelineName, resourceName)
	if err != nil {
		return TemplateData{}, err
	}

	if !resourceFound {
		return TemplateData{}, ErrResourceNotFound
	}

	versionedResources, pagination, resourceVersionsFound, err := client.ResourceVersions(pipelineName, resourceName, page)
	if err != nil {
		return TemplateData{}, err
	}

	if !resourceVersionsFound {
		return TemplateData{}, ErrResourceNotFound
	}

	versions := []VersionedResourceWithInputsAndOutputs{}
	for _, versionedResource := range versionedResources {
		inputs, _, err := client.BuildsWithVersionAsInput(pipelineName, resourceName, versionedResource.ID)
		if err != nil {
			return TemplateData{}, err
		}

		outputs, _, err := client.BuildsWithVersionAsOutput(pipelineName, resourceName, versionedResource.ID)
		if err != nil {
			return TemplateData{}, err
		}

		inputsTo := map[string][]atc.Build{}
		outputsOf := map[string][]atc.Build{}

		for _, input := range inputs {
			if _, ok := inputsTo[input.JobName]; !ok {
				inputsTo[input.JobName] = []atc.Build{}
			}

			inputsTo[input.JobName] = append(inputsTo[input.JobName], input)
		}

		for _, output := range outputs {
			if _, ok := outputsOf[output.JobName]; !ok {
				outputsOf[output.JobName] = []atc.Build{}
			}

			outputsOf[output.JobName] = append(outputsOf[output.JobName], output)
		}

		versions = append(versions, VersionedResourceWithInputsAndOutputs{
			VersionedResource: versionedResource,
			InputsTo:          inputsTo,
			OutputsOf:         outputsOf,
		})
	}

	return TemplateData{
		Resource:     resource,
		Versions:     versions,
		PipelineName: pipelineName,
		Pagination:   pagination,
		GroupStates: group.States(pipeline.Groups, func(g atc.GroupConfig) bool {
			for _, groupResource := range g.Resources {
				if groupResource == resource.Name {
					return true
				}
			}

			return false
		}),
	}, nil
}