Move release related code into a consistent spot

pkg/api/parameters.go

@@ -0,0 +1,116 @@
+package api
+
+import (
+	"fmt"
+	"os"
+	"sync"
+)
+
+type DeferredParameters struct {
+	lock   sync.Mutex
+	fns    ParameterMap
+	values map[string]string
+	links  map[string][]StepLink
+}
+
+func NewDeferredParameters() *DeferredParameters {
+	return &DeferredParameters{
+		fns:    make(ParameterMap),
+		values: make(map[string]string),
+		links:  make(map[string][]StepLink),
+	}
+}
+
+func (p *DeferredParameters) Map() (map[string]string, error) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	m := make(map[string]string)
+	for k, fn := range p.fns {
+		if v, ok := p.values[k]; ok {
+			m[k] = v
+			continue
+		}
+		v, err := fn()
+		if err != nil {
+			return nil, fmt.Errorf("could not lazily evaluate deferred parameter: %v", err)
+		}
+		p.values[k] = v
+		m[k] = v
+	}
+	return m, nil
+}
+
+func (p *DeferredParameters) Set(name, value string) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	if _, ok := p.fns[name]; ok {
+		return
+	}
+	if _, ok := p.values[name]; ok {
+		return
+	}
+	p.values[name] = value
+}
+
+func (p *DeferredParameters) Add(name string, link StepLink, fn func() (string, error)) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	p.fns[name] = fn
+	if link != nil {
+		p.links[name] = []StepLink{link}
+	}
+}
+
+func (p *DeferredParameters) Has(name string) bool {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	_, ok := p.fns[name]
+	if ok {
+		return true
+	}
+	_, ok = os.LookupEnv(name)
+	return ok
+}
+
+func (p *DeferredParameters) Links(name string) []StepLink {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	if _, ok := os.LookupEnv(name); ok {
+		return nil
+	}
+	return p.links[name]
+}
+
+func (p *DeferredParameters) AllLinks() []StepLink {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	var links []StepLink
+	for name, v := range p.links {
+		if _, ok := os.LookupEnv(name); ok {
+			continue
+		}
+		links = append(links, v...)
+	}
+	return links
+}
+
+func (p *DeferredParameters) Get(name string) (string, error) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	if value, ok := p.values[name]; ok {
+		return value, nil
+	}
+	if value, ok := os.LookupEnv(name); ok {
+		p.values[name] = value
+		return value, nil
+	}
+	if fn, ok := p.fns[name]; ok {
+		value, err := fn()
+		if err != nil {
+			return "", fmt.Errorf("could not lazily evaluate deferred parameter: %v", err)
+		}
+		p.values[name] = value
+		return value, nil
+	}
+	return "", nil
+}

pkg/steps/template_test.go → pkg/api/parameters_test.go

@@ -1,14 +1,22 @@
-package steps
+package api
 
 import (
 	"reflect"
 	"testing"
 
 	"k8s.io/apimachinery/pkg/util/diff"
-
-	"github.com/openshift/ci-operator/pkg/api"
 )
 
+func someStepLink(as string) StepLink {
+	return ExternalImageLink(ImageStreamTagReference{
+		Cluster:   "cluster.com",
+		Namespace: "namespace",
+		Name:      "name",
+		Tag:       "tag",
+		As:        as,
+	})
+}
+
 func TestDeferredParametersAllLinks(t *testing.T) {
 	var testCases = []struct {
 		purpose       string
@@ -17,7 +25,7 @@ func TestDeferredParametersAllLinks(t *testing.T) {
 	}{{
 		purpose: "AllLinks should return a slice with all links for all names",
 		dp: &DeferredParameters{
-			links: map[string][]api.StepLink{
+			links: map[string][]StepLink{
 				"K1": {someStepLink("ONE"), someStepLink("TWO")},
 				"K2": {someStepLink("THREE")},
 			},
@@ -93,11 +101,11 @@ func TestDeferredParametersAddHasLinksGet(t *testing.T) {
 		dp      *DeferredParameters
 		callAdd bool
 		name    string
-		link    api.StepLink
+		link    StepLink
 		fn      func() (string, error)
 
 		expectedHas   bool
-		expectedLinks []api.StepLink
+		expectedLinks []StepLink
 		expectedGet   string
 	}{{
 		purpose: "After `Add(key, link, f)`: Has(key)->true, Links(key)->{link}, Get(key)->f()",
@@ -108,7 +116,7 @@ func TestDeferredParametersAddHasLinksGet(t *testing.T) {
 		fn:      func() (string, error) { return "value", nil },
 
 		expectedHas:   true,
-		expectedLinks: []api.StepLink{someStepLink("name")},
+		expectedLinks: []StepLink{someStepLink("name")},
 		expectedGet:   "value",
 	}, {
 		purpose: "Without Add(): Has(key)->false and Links(key)->nil",
@@ -124,17 +132,17 @@ func TestDeferredParametersAddHasLinksGet(t *testing.T) {
 	}, {
 		purpose: "After `Add(key, new-link)` when `key` already present: Has(key)->true and Links(key)->{new-link}",
 		dp: &DeferredParameters{
-			fns:    api.ParameterMap{"key": func() (string, error) { return "old", nil }},
+			fns:    ParameterMap{"key": func() (string, error) { return "old", nil }},
 			values: map[string]string{},
-			links:  map[string][]api.StepLink{"key": {someStepLink("old-link")}},
+			links:  map[string][]StepLink{"key": {someStepLink("old-link")}},
 		},
 		callAdd: true,
 		name:    "key",
 		link:    someStepLink("new-link"),
 		fn:      func() (string, error) { return "new", nil },
 
 		expectedHas:   true,
-		expectedLinks: []api.StepLink{someStepLink("new-link")},
+		expectedLinks: []StepLink{someStepLink("new-link")},
 		expectedGet:   "new",
 	}}
 	for _, tc := range testCases {
@@ -175,9 +183,9 @@ func TestDeferredParametersGetSet(t *testing.T) {
 	}, {
 		purpose: "Existing key is not overwritten",
 		dp: &DeferredParameters{
-			fns:    make(api.ParameterMap),
+			fns:    make(ParameterMap),
 			values: map[string]string{"key": "oldValue"},
-			links:  map[string][]api.StepLink{},
+			links:  map[string][]StepLink{},
 		},
 		name:     "key",
 		callSet:  true,
@@ -192,7 +200,7 @@ func TestDeferredParametersGetSet(t *testing.T) {
 				"key": func() (string, error) { return "lazyValue", nil },
 			},
 			values: map[string]string{},
-			links:  map[string][]api.StepLink{},
+			links:  map[string][]StepLink{},
 		},
 		name:     "key",
 		callSet:  true,

pkg/api/types.go

@@ -529,4 +529,6 @@ const (
 	RPMServeLocation = "/srv/repo"
 
 	StableImageStream = "stable"
+
+	ComponentFormatReplacement = "${component}"
 )

pkg/defaults/defaults.go

@@ -94,7 +94,7 @@ func FromConfig(
 		podClient = steps.NewPodClient(coreGetter, clusterConfig, coreGetter.RESTClient())
 	}
 
-	params := steps.NewDeferredParameters()
+	params := api.NewDeferredParameters()
 	params.Add("JOB_NAME", nil, func() (string, error) { return jobSpec.Job, nil })
 	params.Add("JOB_NAME_HASH", nil, func() (string, error) { return fmt.Sprintf("%x", sha256.Sum256([]byte(jobSpec.Job)))[:5], nil })
 	params.Add("JOB_NAME_SAFE", nil, func() (string, error) { return strings.Replace(jobSpec.Job, "_", "-", -1), nil })
@@ -138,7 +138,7 @@ func FromConfig(
 			if err != nil {
 				return nil, nil, fmt.Errorf("unable to access release images on remote cluster: %v", err)
 			}
-			step = steps.ReleaseImagesTagStep(*rawStep.ReleaseImagesTagStepConfiguration, srcClient, imageClient, routeGetter, configMapGetter, params, jobSpec)
+			step = release.ReleaseImagesTagStep(*rawStep.ReleaseImagesTagStepConfiguration, srcClient, imageClient, routeGetter, configMapGetter, params, jobSpec)
 			stepLinks = append(stepLinks, step.Creates()...)
 
 			releaseStep = release.AssembleReleaseStep(*rawStep.ReleaseImagesTagStepConfiguration, config.Resources, podClient, imageClient, artifactDir, jobSpec)
@@ -167,7 +167,7 @@ func FromConfig(
 		releaseStep, _ = checkForFullyQualifiedStep(releaseStep, params)
 		buildSteps = append(buildSteps, releaseStep)
 	} else {
-		buildSteps = append(buildSteps, steps.StableImagesTagStep(imageClient, jobSpec))
+		buildSteps = append(buildSteps, release.StableImagesTagStep(imageClient, jobSpec))
 	}
 
 	buildSteps = append(buildSteps, steps.ImagesReadyStep(imageStepLinks))
@@ -184,7 +184,7 @@ func FromConfig(
 				tags = append(tags, string(image.To))
 			}
 		}
-		postSteps = append(postSteps, steps.PromotionStep(*cfg, tags, imageClient, imageClient, jobSpec))
+		postSteps = append(postSteps, release.PromotionStep(*cfg, tags, imageClient, imageClient, jobSpec))
 	}
 
 	return buildSteps, postSteps, nil
@@ -193,7 +193,7 @@ func FromConfig(
 // checkForFullyQualifiedStep if all output parameters of this step are part of the
 // environment, replace the step with a shim that automatically provides those variables.
 // Returns true if the step was replaced.
-func checkForFullyQualifiedStep(step api.Step, params *steps.DeferredParameters) (api.Step, bool) {
+func checkForFullyQualifiedStep(step api.Step, params *api.DeferredParameters) (api.Step, bool) {
 	provides, link := step.Provides()
 
 	if values, ok := envHasAllParameters(provides); ok {

pkg/steps/release/create_release.go

@@ -37,12 +37,12 @@ func (s *assembleReleaseStep) Run(ctx context.Context, dry bool) error {
 	if err != nil {
 		return fmt.Errorf("could not resolve stable imagestream: %v", err)
 	}
-	cvo, ok := resolvePullSpec(stable, "cluster-version-operator")
+	cvo, ok := resolvePullSpec(stable, "cluster-version-operator", true)
 	if !ok {
 		log.Printf("No release image necessary, stable image stream does not include a cluster-version-operator image")
 		return nil
 	}
-	if _, ok := resolvePullSpec(stable, "cli"); !ok {
+	if _, ok := resolvePullSpec(stable, "cli", true); !ok {
 		return fmt.Errorf("no 'cli' image was tagged into the stable stream, that image is required for building a release")
 	}
 
@@ -148,24 +148,3 @@ func AssembleReleaseStep(config api.ReleaseTagConfiguration, resources api.Resou
 		jobSpec:     jobSpec,
 	}
 }
-
-func resolvePullSpec(is *imageapi.ImageStream, tag string) (string, bool) {
-	for _, tags := range is.Status.Tags {
-		if tags.Tag != tag {
-			continue
-		}
-		if len(tags.Items) == 0 {
-			break
-		}
-		if image := tags.Items[0].Image; len(image) > 0 {
-			if len(is.Status.PublicDockerImageRepository) > 0 {
-				return fmt.Sprintf("%s@%s", is.Status.PublicDockerImageRepository, image), true
-			}
-			if len(is.Status.DockerImageRepository) > 0 {
-				return fmt.Sprintf("%s@%s", is.Status.DockerImageRepository, image), true
-			}
-		}
-		break
-	}
-	return "", false
-}

pkg/steps/promote.go → pkg/steps/release/promote.go

@@ -1,4 +1,4 @@
-package steps
+package release
 
 import (
 	"context"