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

	if !pipelineFound {
		return TemplateData{}, ErrConfigNotFound
	}

	job, jobFound, err := client.Job(pipelineName, jobName)
	if err != nil {
		return TemplateData{}, err
	}

	if !jobFound {
		return TemplateData{}, ErrJobConfigNotFound
	}

	bs, pagination, _, err := client.JobBuilds(pipelineName, jobName, page)
	if err != nil {
		return TemplateData{}, err
	}

	var bsr []BuildWithInputsOutputs

	for _, build := range bs {
		buildInputsOutputs, _, err := client.BuildResources(build.ID)
		if err != nil {
			return TemplateData{}, err
		}

		bsr = append(bsr, BuildWithInputsOutputs{
			Build:     build,
			Resources: buildInputsOutputs,
		})
	}

	return TemplateData{
		PipelineName: pipelineName,
		Job:          job,

		Builds:     bsr,
		Pagination: pagination,

		GroupStates: group.States(pipeline.Groups, func(g atc.GroupConfig) bool {
			for _, groupJob := range g.Jobs {
				if groupJob == job.Name {
					return true
				}
			}

			return false
		}),

		CurrentBuild: job.FinishedBuild,
	}, nil
}
Beispiel #2
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
}