Beispiel #1
0
func (factory *BuildFactory) constructPlanFromConfig(
	planConfig atc.PlanConfig,
	resources atc.ResourceConfigs,
	inputs []db.BuildInput,
	hasHooks bool,
) atc.Plan {
	var plan atc.Plan

	switch {
	case planConfig.Do != nil:
		if hasHooks {
			plan = factory.constructPlanHookBasedPlan(
				*planConfig.Do,
				resources,
				inputs,
			)
		} else {
			plan = factory.constructPlanSequenceBasedPlan(
				*planConfig.Do,
				resources,
				inputs,
			)
		}
		if plan.Location == nil {
			plan.Location = planConfig.Location
		}

	case planConfig.Put != "":
		logicalName := planConfig.Put

		resourceName := planConfig.Resource
		if resourceName == "" {
			resourceName = logicalName
		}

		resource, _ := resources.Lookup(resourceName)

		putPlan := &atc.PutPlan{
			Type:     resource.Type,
			Name:     logicalName,
			Pipeline: factory.PipelineName,
			Resource: resourceName,
			Source:   resource.Source,
			Params:   planConfig.Params,
			Tags:     planConfig.Tags,
		}

		dependentGetPlan := &atc.DependentGetPlan{
			Type:     resource.Type,
			Name:     logicalName,
			Pipeline: factory.PipelineName,
			Resource: resourceName,
			Params:   planConfig.GetParams,
			Tags:     planConfig.Tags,
			Source:   resource.Source,
		}

		stepLocation := &atc.Location{}
		nextLocation := &atc.Location{}

		if planConfig.Location != nil {
			stepLocation.ID = planConfig.Location.ID
			stepLocation.Hook = planConfig.Location.Hook

			if planConfig.Location.ParallelGroup != 0 {
				stepLocation.ParallelGroup = planConfig.Location.ParallelGroup
			} else {
				stepLocation.ParentID = planConfig.Location.ParentID
			}

			nextLocation.ID = stepLocation.ID + 1
			nextLocation.ParentID = stepLocation.ID
		}

		plan = atc.Plan{
			// Location: planConfig.Location,
			OnSuccess: &atc.OnSuccessPlan{
				Step: atc.Plan{
					Location: stepLocation,
					Put:      putPlan,
				},
				Next: atc.Plan{
					Location:     nextLocation,
					DependentGet: dependentGetPlan,
				},
			},
		}

	case planConfig.Get != "":
		resourceName := planConfig.Resource
		if resourceName == "" {
			resourceName = planConfig.Get
		}

		resource, _ := resources.Lookup(resourceName)

		name := planConfig.Get
		var version db.Version
		for _, input := range inputs {
			if input.Name == name {
				version = input.Version
				break
			}
		}

		plan = atc.Plan{
			Location: planConfig.Location,
			Get: &atc.GetPlan{
				Type:     resource.Type,
				Name:     name,
				Pipeline: factory.PipelineName,
				Resource: resourceName,
				Source:   resource.Source,
				Params:   planConfig.Params,
				Version:  atc.Version(version),
				Tags:     planConfig.Tags,
			},
		}

	case planConfig.Task != "":
		plan = atc.Plan{
			Location: planConfig.Location,
			Task: &atc.TaskPlan{
				Name:       planConfig.Task,
				Privileged: planConfig.Privileged,
				Config:     planConfig.TaskConfig,
				ConfigPath: planConfig.TaskConfigPath,
				Tags:       planConfig.Tags,
			},
		}

	case planConfig.Try != nil:
		nextStep := factory.constructPlanFromConfig(
			*planConfig.Try,
			resources,
			inputs,
			hasHooks)

		plan = atc.Plan{
			Location: planConfig.Location,
			Try: &atc.TryPlan{
				Step: nextStep,
			},
		}

	case planConfig.Aggregate != nil:
		aggregate := atc.AggregatePlan{}

		for _, planConfig := range *planConfig.Aggregate {
			nextStep := factory.constructPlanFromConfig(
				planConfig,
				resources,
				inputs,
				hasHooks)

			aggregate = append(aggregate, nextStep)
		}

		plan = atc.Plan{
			Location:  planConfig.Location,
			Aggregate: &aggregate,
		}
	}

	if planConfig.Conditions != nil {
		plan = atc.Plan{
			Conditional: &atc.ConditionalPlan{
				Conditions: *planConfig.Conditions,
				Plan:       plan,
			},
		}
	}

	if planConfig.Timeout != "" {
		plan = atc.Plan{
			Timeout: &atc.TimeoutPlan{
				Duration: planConfig.Timeout,
				Step:     plan,
			},
		}
	}

	constructionParams := factory.ensureIfPresent(factory.successIfPresent(factory.failureIfPresent(
		constructionParams{
			plan:       plan,
			planConfig: planConfig,
			resources:  resources,
			inputs:     inputs,
			hasHooks:   hasHooks,
		})),
	)

	return constructionParams.plan
}
Beispiel #2
0
func (factory *BuildFactory) constructPlanFromConfig(
	planConfig atc.PlanConfig,
	resources atc.ResourceConfigs,
	inputs []db.BuildInput,
	hasHooks bool,
) atc.Plan {
	var plan atc.Plan

	switch {
	case planConfig.Do != nil:
		if hasHooks {
			plan = factory.constructPlanHookBasedPlan(
				*planConfig.Do,
				resources,
				inputs,
			)
		} else {
			plan = factory.constructPlanSequenceBasedPlan(
				*planConfig.Do,
				resources,
				inputs,
			)
		}

	case planConfig.Put != "":
		logicalName := planConfig.Put

		resourceName := planConfig.Resource
		if resourceName == "" {
			resourceName = logicalName
		}

		resource, _ := resources.Lookup(resourceName)

		putPlan := &atc.PutPlan{
			Type:      resource.Type,
			Name:      logicalName,
			Pipeline:  factory.PipelineName,
			Resource:  resourceName,
			Source:    resource.Source,
			Params:    planConfig.Params,
			GetParams: planConfig.GetParams,
			Tags:      planConfig.Tags,
		}

		plan = atc.Plan{
			PutGet: &atc.PutGetPlan{
				Head: atc.Plan{
					Put: putPlan,
				},
				Rest: atc.Plan{},
			},
		}

	case planConfig.Get != "":
		resourceName := planConfig.Resource
		if resourceName == "" {
			resourceName = planConfig.Get
		}

		resource, _ := resources.Lookup(resourceName)

		name := planConfig.Get
		var version db.Version
		for _, input := range inputs {
			if input.Name == name {
				version = input.Version
				break
			}
		}

		plan = atc.Plan{
			Get: &atc.GetPlan{
				Type:     resource.Type,
				Name:     name,
				Pipeline: factory.PipelineName,
				Resource: resourceName,
				Source:   resource.Source,
				Params:   planConfig.Params,
				Version:  atc.Version(version),
				Tags:     planConfig.Tags,
			},
		}

	case planConfig.Task != "":
		plan = atc.Plan{
			Task: &atc.TaskPlan{
				Name:       planConfig.Task,
				Privileged: planConfig.Privileged,
				Config:     planConfig.TaskConfig,
				ConfigPath: planConfig.TaskConfigPath,
				Tags:       planConfig.Tags,
			},
		}

	case planConfig.Try != nil:
		plan = atc.Plan{
			Try: &atc.TryPlan{
				Step: factory.constructPlanFromConfig(
					*planConfig.Try,
					resources,
					inputs,
					hasHooks,
				),
			},
		}

	case planConfig.Aggregate != nil:
		aggregate := atc.AggregatePlan{}

		for _, planConfig := range *planConfig.Aggregate {
			aggregate = append(aggregate, factory.constructPlanFromConfig(
				planConfig,
				resources,
				inputs,
				hasHooks,
			))
		}

		plan = atc.Plan{
			Aggregate: &aggregate,
		}
	}

	if planConfig.Conditions != nil {
		plan = atc.Plan{
			Conditional: &atc.ConditionalPlan{
				Conditions: *planConfig.Conditions,
				Plan:       plan,
			},
		}
	}

	if planConfig.Timeout != 0 {
		plan = atc.Plan{
			Timeout: &atc.TimeoutPlan{
				Duration: planConfig.Timeout,
				Step:     plan,
			},
		}
	}

	hooks := false
	failurePlan := atc.Plan{}

	if planConfig.Failure != nil {
		hooks = true
		failurePlan = factory.constructPlanFromConfig(*planConfig.Failure, resources, inputs, hasHooks)
	}

	ensurePlan := atc.Plan{}
	if planConfig.Ensure != nil {
		hooks = true
		ensurePlan = factory.constructPlanFromConfig(*planConfig.Ensure, resources, inputs, hasHooks)
	}

	successPlan := atc.Plan{}
	if planConfig.Success != nil {
		hooks = true
		successPlan = factory.constructPlanFromConfig(*planConfig.Success, resources, inputs, hasHooks)
	}

	if hooks {
		plan = atc.Plan{
			HookedCompose: &atc.HookedComposePlan{
				Step:         plan,
				OnFailure:    failurePlan,
				OnCompletion: ensurePlan,
				OnSuccess:    successPlan,
			},
		}
	}

	return plan
}
Beispiel #3
0
func (factory *buildFactory) constructUnhookedPlan(
	planConfig atc.PlanConfig,
	resources atc.ResourceConfigs,
	resourceTypes atc.ResourceTypes,
	inputs []db.BuildInput,
) (atc.Plan, error) {
	var plan atc.Plan
	var err error

	switch {
	case planConfig.Do != nil:
		plan, err = factory.do(
			*planConfig.Do,
			resources,
			resourceTypes,
			inputs,
		)
		if err != nil {
			return atc.Plan{}, err
		}

	case planConfig.Put != "":
		logicalName := planConfig.Put

		resourceName := planConfig.Resource
		if resourceName == "" {
			resourceName = logicalName
		}

		resource, found := resources.Lookup(resourceName)
		if !found {
			return atc.Plan{}, ErrResourceNotFound
		}

		putPlan := atc.PutPlan{
			Type:          resource.Type,
			Name:          logicalName,
			PipelineID:    factory.PipelineID,
			Resource:      resourceName,
			Source:        resource.Source,
			Params:        planConfig.Params,
			Tags:          planConfig.Tags,
			ResourceTypes: resourceTypes,
		}

		dependentGetPlan := atc.DependentGetPlan{
			Type:          resource.Type,
			Name:          logicalName,
			PipelineID:    factory.PipelineID,
			Resource:      resourceName,
			Params:        planConfig.GetParams,
			Tags:          planConfig.Tags,
			Source:        resource.Source,
			ResourceTypes: resourceTypes,
		}

		plan = factory.planFactory.NewPlan(atc.OnSuccessPlan{
			Step: factory.planFactory.NewPlan(putPlan),
			Next: factory.planFactory.NewPlan(dependentGetPlan),
		})

	case planConfig.Get != "":
		resourceName := planConfig.Resource
		if resourceName == "" {
			resourceName = planConfig.Get
		}

		resource, found := resources.Lookup(resourceName)
		if !found {
			return atc.Plan{}, ErrResourceNotFound
		}

		name := planConfig.Get
		var version db.Version
		for _, input := range inputs {
			if input.Name == name {
				version = input.Version
				break
			}
		}

		plan = factory.planFactory.NewPlan(atc.GetPlan{
			Type:          resource.Type,
			Name:          name,
			PipelineID:    factory.PipelineID,
			Resource:      resourceName,
			Source:        resource.Source,
			Params:        planConfig.Params,
			Version:       atc.Version(version),
			Tags:          planConfig.Tags,
			ResourceTypes: resourceTypes,
		})

	case planConfig.Task != "":
		plan = factory.planFactory.NewPlan(atc.TaskPlan{
			Name:          planConfig.Task,
			PipelineID:    factory.PipelineID,
			Privileged:    planConfig.Privileged,
			Config:        planConfig.TaskConfig,
			ConfigPath:    planConfig.TaskConfigPath,
			Tags:          planConfig.Tags,
			ResourceTypes: resourceTypes,
			Params:        planConfig.Params,
			InputMapping:  planConfig.InputMapping,
			OutputMapping: planConfig.OutputMapping,
		})
	case planConfig.Try != nil:
		nextStep, err := factory.constructPlanFromConfig(
			*planConfig.Try,
			resources,
			resourceTypes,
			inputs,
		)
		if err != nil {
			return atc.Plan{}, err
		}

		plan = factory.planFactory.NewPlan(atc.TryPlan{
			Step: nextStep,
		})

	case planConfig.Aggregate != nil:
		aggregate := atc.AggregatePlan{}

		for _, planConfig := range *planConfig.Aggregate {
			nextStep, err := factory.constructPlanFromConfig(
				planConfig,
				resources,
				resourceTypes,
				inputs,
			)
			if err != nil {
				return atc.Plan{}, err
			}

			aggregate = append(aggregate, nextStep)
		}

		plan = factory.planFactory.NewPlan(aggregate)
	}

	if planConfig.Timeout != "" {
		plan = factory.planFactory.NewPlan(atc.TimeoutPlan{
			Duration: planConfig.Timeout,
			Step:     plan,
		})
	}

	return plan, nil
}