@@ -14,56 +14,44 @@ import (

 )

 type ImportController struct {

-	repositories client.ImageStreamsNamespacer

-	mappings     client.ImageStreamMappingsNamespacer

-	client       dockerregistry.Client

+	streams  client.ImageStreamsNamespacer

+	mappings client.ImageStreamMappingsNamespacer

+	client   dockerregistry.Client

 }

-// needsImport returns true if the provided repository should have its tags imported.

-func needsImport(repo *api.ImageStream) bool {

-	if len(repo.Spec.DockerImageRepository) == 0 {

+// needsImport returns true if the provided image stream should have its tags imported.

+func needsImport(stream *api.ImageStream) bool {

+	if len(stream.Spec.DockerImageRepository) == 0 {

 		return false

 	}

-	if repo.Annotations != nil && len(repo.Annotations[api.DockerImageRepositoryCheckAnnotation]) != 0 {

+	if stream.Annotations != nil && len(stream.Annotations[api.DockerImageRepositoryCheckAnnotation]) != 0 {

 		return false

 	}

 	return true

-	/*

-		if len(repo.Spec.Tags) == 0 {

-			return true

-		}

-		emptyTags := 0

-		for _, v := range repo.Spec.Tags {

-			if len(v.DockerImageReference) == 0 {

-				emptyTags++

-			}

-		}

-		return emptyTags > 0

-	*/

 }

 // retryCount is the number of times to retry on a conflict when updating an image stream

 const retryCount = 2

-// Next processes the given image repository, looking for repos that have DockerImageRepository

+// Next processes the given image stream, looking for streams that have DockerImageRepository

 // set but have not yet been marked as "ready". If transient errors occur, err is returned but

-// the image repository is not modified (so it will be tried again later). If a permanent

+// the image stream is not modified (so it will be tried again later). If a permanent

 // failure occurs the image is marked with an annotation. The tags of the original spec image

 // are left as is (those are updated through status).

-func (c *ImportController) Next(repo *api.ImageStream) error {

-	if !needsImport(repo) {

+func (c *ImportController) Next(stream *api.ImageStream) error {

+	if !needsImport(stream) {

 		return nil

 	}

-	name := repo.Spec.DockerImageRepository

+	name := stream.Spec.DockerImageRepository

 	ref, err := api.ParseDockerImageReference(name)

 	if err != nil {

 		err = fmt.Errorf("invalid docker image repository, cannot import data: %v", err)

 		util.HandleError(err)

-		return c.done(repo, err.Error(), retryCount)

+		return c.done(stream, err.Error(), retryCount)

 	}

-	insecure := repo.Annotations != nil && repo.Annotations[api.InsecureRepositoryAnnotation] == "true"

+	insecure := stream.Annotations != nil && stream.Annotations[api.InsecureRepositoryAnnotation] == "true"

 	conn, err := c.client.Connect(ref.Registry, insecure)

 	if err != nil {

@@ -72,56 +60,32 @@ func (c *ImportController) Next(repo *api.ImageStream) error {

 	tags, err := conn.ImageTags(ref.Namespace, ref.Name)

 	switch {

 	case dockerregistry.IsRepositoryNotFound(err), dockerregistry.IsRegistryNotFound(err):

-		return c.done(repo, err.Error(), retryCount)

+		return c.done(stream, err.Error(), retryCount)

 	case err != nil:

 		return err

 	}

-	newTags := make(map[string]string) //, len(repo.Spec.Tags))

 	imageToTag := make(map[string][]string)

-	//switch {

-	//case len(repo.Tags) == 0:

-	// copy all tags

-	for tag := range tags {

-		// TODO: switch to image when pull by ID is automatic

-		newTags[tag] = tag

-	}

 	for tag, image := range tags {

+		if specTag, ok := stream.Spec.Tags[tag]; ok && (len(specTag.DockerImageReference) != 0 || specTag.From != nil) {

+			// spec tag is set to track another tag - do not import

+			continue

+		}

+

 		imageToTag[image] = append(imageToTag[image], tag)

 	}

-	/*

-		default:

-			for tag, v := range repo.Tags {

-				if len(v) != 0 {

-					newTags[tag] = v

-					continue

-				}

-				image, ok := tags[tag]

-				if !ok {

-					// tag not found, set empty

-					continue

-				}

-				imageToTag[image] = append(imageToTag[image], tag)

-				// TODO: switch to image when pull by ID is automatic

-				newTags[tag] = tag

-			}

-		}

-	*/

-	// nothing to tag - no images in the upstream repo, or we're in sync

+	// no tags to import

 	if len(imageToTag) == 0 {

-		return c.done(repo, "", retryCount)

+		return c.done(stream, "", retryCount)

 	}

 	for id, tags := range imageToTag {

 		dockerImage, err := conn.ImageByID(ref.Namespace, ref.Name, id)

 		switch {

 		case dockerregistry.IsRepositoryNotFound(err), dockerregistry.IsRegistryNotFound(err):

-			return c.done(repo, err.Error(), retryCount)

+			return c.done(stream, err.Error(), retryCount)

 		case dockerregistry.IsImageNotFound(err):

-			for _, tag := range tags {

-				delete(newTags, tag)

-			}

 			continue

 		case err != nil:

 			return err

@@ -130,7 +94,7 @@ func (c *ImportController) Next(repo *api.ImageStream) error {

 		if err := kapi.Scheme.Convert(dockerImage, &image); err != nil {

 			err = fmt.Errorf("could not convert image: %#v", err)

 			util.HandleError(err)

-			return c.done(repo, err.Error(), retryCount)

+			return c.done(stream, err.Error(), retryCount)

 		}

 		idTagPresent := false

@@ -156,8 +120,8 @@ func (c *ImportController) Next(repo *api.ImageStream) error {

 			mapping := &api.ImageStreamMapping{

 				ObjectMeta: kapi.ObjectMeta{

-					Name:      repo.Name,

-					Namespace: repo.Namespace,

+					Name:      stream.Name,

+					Namespace: stream.Namespace,

 				},

 				Tag: tag,

 				Image: api.Image{

@@ -168,9 +132,9 @@ func (c *ImportController) Next(repo *api.ImageStream) error {

 					DockerImageMetadata:  image,

 				},

 			}

-			if err := c.mappings.ImageStreamMappings(repo.Namespace).Create(mapping); err != nil {

+			if err := c.mappings.ImageStreamMappings(stream.Namespace).Create(mapping); err != nil {

 				if errors.IsNotFound(err) {

-					return c.done(repo, err.Error(), retryCount)

+					return c.done(stream, err.Error(), retryCount)

 				}

 				return err

 			}

@@ -178,22 +142,22 @@ func (c *ImportController) Next(repo *api.ImageStream) error {

 	}

 	// we've completed our updates

-	return c.done(repo, "", retryCount)

+	return c.done(stream, "", retryCount)

 }

-// done marks the repository as being processed due to an error or failure condition

-func (c *ImportController) done(repo *api.ImageStream, reason string, retry int) error {

+// done marks the stream as being processed due to an error or failure condition

+func (c *ImportController) done(stream *api.ImageStream, reason string, retry int) error {

 	if len(reason) == 0 {

 		reason = util.Now().UTC().Format(time.RFC3339)

 	}

-	if repo.Annotations == nil {

-		repo.Annotations = make(map[string]string)

+	if stream.Annotations == nil {

+		stream.Annotations = make(map[string]string)

 	}

-	repo.Annotations[api.DockerImageRepositoryCheckAnnotation] = reason

-	if _, err := c.repositories.ImageStreams(repo.Namespace).Update(repo); err != nil && !errors.IsNotFound(err) {

+	stream.Annotations[api.DockerImageRepositoryCheckAnnotation] = reason

+	if _, err := c.streams.ImageStreams(stream.Namespace).Update(stream); err != nil && !errors.IsNotFound(err) {

 		if errors.IsConflict(err) && retry > 0 {

-			if repo, err := c.repositories.ImageStreams(repo.Namespace).Get(repo.Name); err == nil {

-				return c.done(repo, reason, retry-1)

+			if stream, err := c.streams.ImageStreams(stream.Namespace).Get(stream.Name); err == nil {

+				return c.done(stream, reason, retry-1)

 			}

 		}

 		return err

@@ -68,28 +68,28 @@ func (f *fakeDockerRegistryClient) ImageByID(namespace, name, id string) (*docke

 func TestControllerNoDockerRepo(t *testing.T) {

 	cli, fake := &fakeDockerRegistryClient{}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

+	c := ImportController{client: cli, streams: fake, mappings: fake}

-	repo := api.ImageStream{

+	stream := api.ImageStream{

 		ObjectMeta: kapi.ObjectMeta{

 			Name:      "test",

 			Namespace: "other",

 		},

 	}

-	other := repo

-	if err := c.Next(&repo); err != nil {

+	other := stream

+	if err := c.Next(&stream); err != nil {

 		t.Errorf("unexpected error: %v", err)

 	}

-	if !kapi.Semantic.DeepEqual(repo, other) {

-		t.Errorf("did not expect change to repo")

+	if !kapi.Semantic.DeepEqual(stream, other) {

+		t.Errorf("did not expect change to stream")

 	}

 }

 func TestControllerRepoHandled(t *testing.T) {

 	cli, fake := &fakeDockerRegistryClient{}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

+	c := ImportController{client: cli, streams: fake, mappings: fake}

-	repo := api.ImageStream{

+	stream := api.ImageStream{

 		ObjectMeta: kapi.ObjectMeta{

 			Name:      "test",

 			Namespace: "other",

@@ -98,11 +98,11 @@ func TestControllerRepoHandled(t *testing.T) {

 			DockerImageRepository: "foo/bar",

 		},

 	}

-	if err := c.Next(&repo); err != nil {

+	if err := c.Next(&stream); err != nil {

 		t.Errorf("unexpected error: %v", err)

 	}

-	if len(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) == 0 {

-		t.Errorf("did not set annotation: %#v", repo)

+	if len(stream.Annotations["openshift.io/image.dockerRepositoryCheck"]) == 0 {

+		t.Errorf("did not set annotation: %#v", stream)

 	}

 	if len(fake.Actions) != 1 {

 		t.Errorf("expected an update action: %#v", fake.Actions)

@@ -111,19 +111,19 @@ func TestControllerRepoHandled(t *testing.T) {

 func TestControllerTagRetrievalFails(t *testing.T) {

 	cli, fake := &fakeDockerRegistryClient{Err: fmt.Errorf("test error")}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

+	c := ImportController{client: cli, streams: fake, mappings: fake}

-	repo := api.ImageStream{

+	stream := api.ImageStream{

 		ObjectMeta: kapi.ObjectMeta{Name: "test", Namespace: "other"},

 		Spec: api.ImageStreamSpec{

 			DockerImageRepository: "foo/bar",

 		},

 	}

-	if err := c.Next(&repo); err != cli.Err {

+	if err := c.Next(&stream); err != cli.Err {

 		t.Errorf("unexpected error: %v", err)

 	}

-	if len(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) != 0 {

-		t.Errorf("should not set annotation: %#v", repo)

+	if len(stream.Annotations["openshift.io/image.dockerRepositoryCheck"]) != 0 {

+		t.Errorf("should not set annotation: %#v", stream)

 	}

 	if len(fake.Actions) != 0 {

 		t.Error("expected no actions on fake client")

@@ -132,9 +132,9 @@ func TestControllerTagRetrievalFails(t *testing.T) {

 func TestControllerRetrievesInsecure(t *testing.T) {

 	cli, fake := &fakeDockerRegistryClient{Err: fmt.Errorf("test error")}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

+	c := ImportController{client: cli, streams: fake, mappings: fake}

-	repo := api.ImageStream{

+	stream := api.ImageStream{

 		ObjectMeta: kapi.ObjectMeta{

 			Name:      "test",

 			Namespace: "other",

@@ -146,58 +146,34 @@ func TestControllerRetrievesInsecure(t *testing.T) {

 			DockerImageRepository: "foo/bar",

 		},

 	}

-	if err := c.Next(&repo); err != cli.Err {

+	if err := c.Next(&stream); err != cli.Err {

 		t.Errorf("unexpected error: %v", err)

 	}

 	if !cli.Insecure {

 		t.Errorf("expected insecure call: %#v", cli)

 	}

-	if len(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) != 0 {

-		t.Errorf("should not set annotation: %#v", repo)

+	if len(stream.Annotations["openshift.io/image.dockerRepositoryCheck"]) != 0 {

+		t.Errorf("should not set annotation: %#v", stream)

 	}

 	if len(fake.Actions) != 0 {

 		t.Error("expected no actions on fake client")

 	}

 }

-/*

-func TestControllerRepoTagsAlreadySet(t *testing.T) {

-	cli, fake := &fakeDockerRegistryClient{}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

-

-	repo := api.ImageStream{

-		ObjectMeta:            kapi.ObjectMeta{Name: "test", Namespace: "other"},

-		//DockerImageRepository: "foo/bar",

-		Tags: map[string]string{

-			"test": "",

-		},

-	}

-	if err := c.Next(&repo); err != nil {

-		t.Fatalf("unexpected error: %v", err)

-	}

-	if len(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) == 0 {

-		t.Errorf("did not set annotation: %#v", repo)

-	}

-	if len(fake.Actions) != 1 {

-		t.Errorf("expected an update action: %#v", fake.Actions)

-	}

-}

-*/

-

 func TestControllerImageNotFoundError(t *testing.T) {

 	cli, fake := &fakeDockerRegistryClient{Tags: map[string]string{api.DefaultImageTag: "not_found"}}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

-	repo := api.ImageStream{

+	c := ImportController{client: cli, streams: fake, mappings: fake}

+	stream := api.ImageStream{

 		ObjectMeta: kapi.ObjectMeta{Name: "test", Namespace: "other"},

 		Spec: api.ImageStreamSpec{

 			DockerImageRepository: "foo/bar",

 		},

 	}

-	if err := c.Next(&repo); err != nil {

+	if err := c.Next(&stream); err != nil {

 		t.Errorf("unexpected error: %v", err)

 	}

-	if len(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) == 0 {

-		t.Errorf("did not set annotation: %#v", repo)

+	if len(stream.Annotations["openshift.io/image.dockerRepositoryCheck"]) == 0 {

+		t.Errorf("did not set annotation: %#v", stream)

 	}

 	if len(fake.Actions) != 1 {

 		t.Errorf("expected an update action: %#v", fake.Actions)

@@ -214,18 +190,18 @@ func TestControllerImageWithGenericError(t *testing.T) {

 			},

 		},

 	}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

-	repo := api.ImageStream{

+	c := ImportController{client: cli, streams: fake, mappings: fake}

+	stream := api.ImageStream{

 		ObjectMeta: kapi.ObjectMeta{Name: "test", Namespace: "other"},

 		Spec: api.ImageStreamSpec{

 			DockerImageRepository: "foo/bar",

 		},

 	}

-	if err := c.Next(&repo); err != cli.Images[0].Err {

+	if err := c.Next(&stream); err != cli.Images[0].Err {

 		t.Fatalf("unexpected error: %v", err)

 	}

-	if len(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) != 0 {

-		t.Errorf("did not expect annotation: %#v", repo)

+	if len(stream.Annotations["openshift.io/image.dockerRepositoryCheck"]) != 0 {

+		t.Errorf("did not expect annotation: %#v", stream)

 	}

 	if len(fake.Actions) != 0 {

 		t.Errorf("expected no update action: %#v", fake.Actions)

@@ -245,57 +221,98 @@ func TestControllerWithImage(t *testing.T) {

 			},

 		},

 	}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

-	repo := api.ImageStream{

+	c := ImportController{client: cli, streams: fake, mappings: fake}

+	stream := api.ImageStream{

 		ObjectMeta: kapi.ObjectMeta{Name: "test", Namespace: "other"},

 		Spec: api.ImageStreamSpec{

 			DockerImageRepository: "foo/bar",

 		},

 	}

-	if err := c.Next(&repo); err != nil {

+	if err := c.Next(&stream); err != nil {

 		t.Errorf("unexpected error: %v", err)

 	}

-	if !isRFC3339(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) {

-		t.Fatalf("did not set annotation: %#v", repo)

+	if !isRFC3339(stream.Annotations["openshift.io/image.dockerRepositoryCheck"]) {

+		t.Fatalf("did not set annotation: %#v", stream)

 	}

 	if len(fake.Actions) != 2 {

 		t.Errorf("expected an update action: %#v", fake.Actions)

 	}

 }

-/*

-func TestControllerWithEmptyTag(t *testing.T) {

-	cli, fake := &fakeDockerRegistryClient{

-		Tags: map[string]string{api.DefaultImageTag: "found"},

-		Images: []expectedImage{

-			{

-				ID: "found",

-				Image: &docker.Image{

-					Comment: "foo",

-					Config:  &docker.Config{},

-				},

-			},

+func TestControllerWithSpecTags(t *testing.T) {

+	tests := map[string]struct {

+		dockerImageReference string

+		from                 *kapi.ObjectReference

+		expectUpdate         bool

+	}{

+		"no tracking": {

+			expectUpdate: true,

 		},

-	}, &client.Fake{}

-	c := ImportController{client: cli, repositories: fake, mappings: fake}

-	repo := api.ImageStream{

-		ObjectMeta:            kapi.ObjectMeta{Name: "test", Namespace: "other"},

-		//DockerImageRepository: "foo/bar",

-		Tags: map[string]string{

-			api.DefaultImageTag: "",

+		"dockerImageReference": {

+			dockerImageReference: "some/repo",

+			expectUpdate:         false,

+		},

+		"from tracking": {

+			from: &kapi.ObjectReference{

+				Kind: "ImageStreamTag",

+				Name: "2.0",

+			},

+			expectUpdate: false,

 		},

 	}

-	if err := c.Next(&repo); err != nil {

-		t.Errorf("unexpected error: %v", err)

-	}

-	if !isRFC3339(repo.Annotations["openshift.io/image.dockerRepositoryCheck"]) {

-		t.Fatalf("did not set annotation: %#v", repo)

-	}

-	if len(fake.Actions) != 2 {

-		t.Errorf("expected an update action: %#v", fake.Actions)

+

+	for name, test := range tests {

+		cli, fake := &fakeDockerRegistryClient{

+			Tags: map[string]string{api.DefaultImageTag: "found"},

+			Images: []expectedImage{

+				{

+					ID: "found",

+					Image: &docker.Image{

+						Comment: "foo",

+						Config:  &docker.Config{},

+					},

+				},

+			},

+		}, &client.Fake{}

+		c := ImportController{client: cli, streams: fake, mappings: fake}

+		stream := api.ImageStream{

+			ObjectMeta: kapi.ObjectMeta{Name: "test", Namespace: "other"},

+			Spec: api.ImageStreamSpec{

+				DockerImageRepository: "foo/bar",

+				Tags: map[string]api.TagReference{

+					api.DefaultImageTag: {

+						DockerImageReference: test.dockerImageReference,

+						From:                 test.from,

+					},

+				},

+			},

+		}

+		if err := c.Next(&stream); err != nil {

+			t.Errorf("%s: unexpected error: %v", name, err)

+		}

+		if !isRFC3339(stream.Annotations["openshift.io/image.dockerRepositoryCheck"]) {

+			t.Fatalf("%s: did not set annotation: %#v", name, stream)

+		}

+		if test.expectUpdate {

+			if len(fake.Actions) != 2 {

+				t.Errorf("%s: expected an update action: %#v", name, fake.Actions)

+			}

+			if e, a := "create-imagestream-mapping", fake.Actions[0].Action; e != a {

+				t.Errorf("%s: expected %s, got %s", name, e, a)

+			}

+			if e, a := "update-imagestream", fake.Actions[1].Action; e != a {

+				t.Errorf("%s: expected %s, got %s", name, e, a)

+			}

+		} else {

+			if len(fake.Actions) != 1 {

+				t.Errorf("%s: expected no update action: %#v", name, fake.Actions)

+			}

+			if e, a := "update-imagestream", fake.Actions[0].Action; e != a {

+				t.Errorf("%s: expected %s, got %s", name, e, a)

+			}

+		}

 	}

 }

-*/

 func isRFC3339(s string) bool {

 	_, err := time.Parse(time.RFC3339, s)

@@ -37,9 +37,9 @@ func (f *ImportControllerFactory) Create() controller.RunnableController {

 	cache.NewReflector(lw, &api.ImageStream{}, q, 2*time.Minute).Run()

 	c := &ImportController{

-		client:       dockerregistry.NewClient(),

-		repositories: f.Client,

-		mappings:     f.Client,

+		client:   dockerregistry.NewClient(),

+		streams:  f.Client,

+		mappings: f.Client,

 	}

 	return &controller.RetryController{