@@ -9,7 +9,6 @@

         "name": "ruby-20-centos7"

       },

       "tags": {

-        "latest": "latest"

       }

     },

     {

@@ -20,7 +19,6 @@

         "name": "nodejs-010-centos7"

       },

       "tags": {

-        "latest": "latest"

       }

     },

     {

@@ -31,7 +29,6 @@

         "name": "wildfly-8-centos"

       },

       "tags": {

-        "latest": "latest"

       }

     }

   ],

@@ -39,7 +39,8 @@

       "kind": "ImageRepository",

       "metadata": {

         "name": "ruby-20-centos7"

-      }

+      },

+      "dockerImageRepository": "openshift/ruby-20-centos7"

     },

     {

       "apiVersion": "v1beta1",

@@ -39,7 +39,8 @@

       "kind": "ImageRepository",

       "metadata": {

         "name": "ruby-20-centos7"

-      }

+      },

+      "dockerImageRepository": "openshift/ruby-20-centos7"

     },

     {

       "apiVersion": "v1beta1",

@@ -225,10 +225,9 @@ osc create -f examples/image-repositories/image-repositories.json

 [ -n "$(osc get imageRepositories wildfly-8-centos -t "{{.status.dockerImageRepository}}")" ]

 osc delete imageRepositories ruby-20-centos7

 osc delete imageRepositories nodejs-010-centos7

-osc delete imageRepositories wildfly-8-centos

 [ -z "$(osc get imageRepositories ruby-20-centos7 -t "{{.status.dockerImageRepository}}")" ]

 [ -z "$(osc get imageRepositories nodejs-010-centos7 -t "{{.status.dockerImageRepository}}")" ]

-[ -z "$(osc get imageRepositories wildfly-8-centos -t "{{.status.dockerImageRepository}}")" ]

+# don't delete wildfly-8-centos

 echo "imageRepositories: ok"

 osc create -f test/integration/fixtures/test-image-repository.json

@@ -324,4 +323,8 @@ openshift ex registry --create --credentials="${OPENSHIFTCONFIG}"

 [ "$(openshift ex registry | grep 'service exists')" ]

 echo "ex registry: ok"

+# verify the image repository had its tags populated

+[ -n "$(osc get imageRepositories wildfly-8-centos -t "{{.tags.latest}}")" ]

+[ -n "$(osc get imageRepositories wildfly-8-centos -t "{{ index .metadata.annotations \"openshift.io/image.dockerRepositoryCheck\"}}")" ]

+

 osc get minions,pods

@@ -265,7 +265,7 @@ osc create -n test -f "${STI_CONFIG_FILE}"

 # Trigger build

 echo "[INFO] Starting build from ${STI_CONFIG_FILE} and streaming its logs..."

-osc start-build -n test ruby-sample-build --follow

+#osc start-build -n test ruby-sample-build --follow

 wait_for_build "test"

 wait_for_app "test"

@@ -53,6 +53,7 @@ import (

 	deployetcd "github.com/openshift/origin/pkg/deploy/registry/etcd"

 	deployrollback "github.com/openshift/origin/pkg/deploy/rollback"

 	"github.com/openshift/origin/pkg/dns"

+	imagecontroller "github.com/openshift/origin/pkg/image/controller"

 	"github.com/openshift/origin/pkg/image/registry/image"

 	imageetcd "github.com/openshift/origin/pkg/image/registry/image/etcd"

 	"github.com/openshift/origin/pkg/image/registry/imagerepository"

@@ -159,6 +160,11 @@ func (c *MasterConfig) ImageChangeControllerClient() *osclient.Client {

 	return c.OSClient

 }

+// ImageImportControllerClient returns the deployment client object

+func (c *MasterConfig) ImageImportControllerClient() *osclient.Client {

+	return c.OSClient

+}

+

 // DeploymentControllerClients returns the deployment controller client object

 func (c *MasterConfig) DeploymentControllerClients() (*osclient.Client, *kclient.Client) {

 	return c.OSClient, c.KubernetesClient

@@ -774,10 +780,7 @@ func (c *MasterConfig) RouteAllocator() *routeallocationcontroller.RouteAllocati

 		KubeClient: c.KubeClient(),

 	}

-	subdomain := os.Getenv("OPENSHIFT_ROUTE_SUBDOMAIN")

-	if len(subdomain) == 0 {

-		subdomain = OpenShiftRouteSubdomain

-	}

+	subdomain := env("OPENSHIFT_ROUTE_SUBDOMAIN", OpenShiftRouteSubdomain)

 	plugin, err := routeplugin.NewSimpleAllocationPlugin(subdomain)

 	if err != nil {

@@ -787,6 +790,15 @@ func (c *MasterConfig) RouteAllocator() *routeallocationcontroller.RouteAllocati

 	return factory.Create(plugin)

 }

+func (c *MasterConfig) RunImageImportController() {

+	osclient := c.ImageImportControllerClient()

+	factory := imagecontroller.ImportControllerFactory{

+		Client: osclient,

+	}

+	controller := factory.Create()

+	controller.Run()

+}

+

 // ensureCORSAllowedOrigins takes a string list of origins and attempts to covert them to CORS origin

 // regexes, or exits if it cannot.

 func (c *MasterConfig) ensureCORSAllowedOrigins() []*regexp.Regexp {

@@ -343,6 +343,7 @@ func StartMaster(openshiftMasterConfig *configapi.MasterConfig) error {

 	openshiftConfig.RunDeploymentConfigController()

 	openshiftConfig.RunDeploymentConfigChangeController()

 	openshiftConfig.RunDeploymentImageChangeTriggerController()

+	openshiftConfig.RunImageImportController()

 	openshiftConfig.RunProjectAuthorizationCache()

 	return nil

@@ -18,6 +18,12 @@ type Client interface {

 // Connection allows you to retrieve data from a Docker V1 registry.

 type Connection interface {

+	// ImageTags will return a map of the tags for the image by namespace (if not

+	// specified, will be "library") and name.

+	ImageTags(namespace, name string) (map[string]string, error)

+	// ImageByID will return the requested image by namespace (if not specified,

+	// will be "library"), name, and ID.

+	ImageByID(namespace, name, id string) (*docker.Image, error)

 	// ImageByTag will return the requested image by namespace (if not specified,

 	// will be "library"), name, and tag (if not specified, "latest").

 	ImageByTag(namespace, name, tag string) (*docker.Image, error)

@@ -60,12 +66,14 @@ func convertConnectionError(registry string, err error) error {

 type connection struct {

 	client *http.Client

 	host   string

+	cached map[string]*repository

 }

 func newConnection(name string) connection {

 	return connection{

 		host:   name,

 		client: http.DefaultClient,

+		cached: make(map[string]*repository),

 	}

 }

@@ -75,6 +83,41 @@ type repository struct {

 	token    string

 }

+// ImageTags returns the tags for the named Docker image repository.

+func (c connection) ImageTags(namespace, name string) (map[string]string, error) {

+	if len(namespace) == 0 {

+		namespace = "library"

+	}

+	if len(name) == 0 {

+		return nil, fmt.Errorf("image name must be specified")

+	}

+

+	repo, err := c.getCachedRepository(fmt.Sprintf("%s/%s", namespace, name))

+	if err != nil {

+		return nil, err

+	}

+

+	return c.getTags(repo)

+}

+

+// ImageByID returns the specified image within the named Docker image repository

+func (c connection) ImageByID(namespace, name, imageID string) (*docker.Image, error) {

+	if len(namespace) == 0 {

+		namespace = "library"

+	}

+	if len(name) == 0 {

+		return nil, fmt.Errorf("image name must be specified")

+	}

+

+	repo, err := c.getCachedRepository(fmt.Sprintf("%s/%s", namespace, name))

+	if err != nil {

+		return nil, err

+	}

+

+	return c.getImage(repo, imageID, "")

+}

+

+// ImageByTag returns the specified image within the named Docker image repository

 func (c connection) ImageByTag(namespace, name, tag string) (*docker.Image, error) {

 	if len(namespace) == 0 {

 		namespace = "library"

@@ -87,7 +130,7 @@ func (c connection) ImageByTag(namespace, name, tag string) (*docker.Image, erro

 		searchTag = "latest"

 	}

-	repo, err := c.getRepository(fmt.Sprintf("%s/%s", namespace, name))

+	repo, err := c.getCachedRepository(fmt.Sprintf("%s/%s", namespace, name))

 	if err != nil {

 		return nil, err

 	}

@@ -100,6 +143,18 @@ func (c connection) ImageByTag(namespace, name, tag string) (*docker.Image, erro

 	return c.getImage(repo, imageID, tag)

 }

+func (c connection) getCachedRepository(name string) (*repository, error) {

+	if cached, ok := c.cached[name]; ok {

+		return cached, nil

+	}

+	repo, err := c.getRepository(name)

+	if err != nil {

+		return nil, err

+	}

+	c.cached[name] = repo

+	return repo, nil

+}

+

 func (c connection) getRepository(name string) (*repository, error) {

 	req, err := http.NewRequest("GET", fmt.Sprintf("https://%s/v1/repositories/%s/images", c.host, name), nil)

 	if err != nil {

@@ -123,6 +178,29 @@ func (c connection) getRepository(name string) (*repository, error) {

 	}, nil

 }

+func (c connection) getTags(repo *repository) (map[string]string, error) {

+	req, err := http.NewRequest("GET", fmt.Sprintf("https://%s/v1/repositories/%s/tags", repo.endpoint, repo.name), nil)

+	if err != nil {

+		return nil, fmt.Errorf("error creating request: %v", err)

+	}

+	req.Header.Add("Authorization", "Token "+repo.token)

+	resp, err := c.client.Do(req)

+	if err != nil {

+		return nil, convertConnectionError(c.host, fmt.Errorf("error getting image tags for %s: %v", repo.name, err))

+	}

+	switch code := resp.StatusCode; {

+	case code == http.StatusNotFound:

+		return nil, errRepositoryNotFound{repo.name}

+	case code >= 300 || resp.StatusCode < 200:

+		return nil, fmt.Errorf("error retrieving tags: server returned %d", resp.StatusCode)

+	}

+	tags := make(map[string]string)

+	if err := json.NewDecoder(resp.Body).Decode(&tags); err != nil {

+		return nil, fmt.Errorf("error decoding image %s tags: %v", repo.name, err)

+	}

+	return tags, nil

+}

+

 func (c connection) getTag(repo *repository, tag, userTag string) (string, error) {

 	req, err := http.NewRequest("GET", fmt.Sprintf("https://%s/v1/repositories/%s/tags/%s", repo.endpoint, repo.name, tag), nil)

 	if err != nil {

@@ -158,7 +236,7 @@ func (c connection) getImage(repo *repository, image, userTag string) (*docker.I

 	}

 	switch code := resp.StatusCode; {

 	case code == http.StatusNotFound:

-		return nil, errImageNotFound{userTag, image, repo.name}

+		return nil, NewImageNotFoundError(repo.name, image, userTag)

 	case code >= 300 || resp.StatusCode < 200:

 		return nil, fmt.Errorf("error retrieving image %s: server returned %d", req.URL, resp.StatusCode)

 	}

@@ -197,8 +275,15 @@ type errImageNotFound struct {

 	repository string

 }

+func NewImageNotFoundError(repository, image, tag string) error {

+	return errImageNotFound{tag, image, repository}

+}

+

 func (e errImageNotFound) Error() string {

-	return fmt.Sprintf("the image %q in repository %q with tag %q was not found and may have been deleted", e.tag, e.image, e.repository)

+	if len(e.tag) == 0 {

+		return fmt.Sprintf("the image %q in repository %q was not found and may have been deleted", e.image, e.repository)

+	}

+	return fmt.Sprintf("the image %q in repository %q with tag %q was not found and may have been deleted", e.image, e.repository, e.tag)

 }

 type errRegistryNotFound struct {

new file mode 100644

@@ -0,0 +1,147 @@

+package controller

+

+import (

+	"fmt"

+	"time"

+

+	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/errors"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"

+

+	"github.com/openshift/origin/pkg/client"

+	"github.com/openshift/origin/pkg/dockerregistry"

+	"github.com/openshift/origin/pkg/image/api"

+)

+

+const dockerImageRepositoryCheckAnnotation = "openshift.io/image.dockerRepositoryCheck"

+

+type ImportController struct {

+	repositories client.ImageRepositoriesNamespacer

+	mappings     client.ImageRepositoryMappingsNamespacer

+	client       dockerregistry.Client

+}

+

+// Next processes the given image repository, looking for repos 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

+// failure occurs the image is marked with an annotation.

+func (c *ImportController) Next(repo *api.ImageRepository) error {

+	name := repo.DockerImageRepository

+	if len(name) == 0 {

+		return nil

+	}

+	if repo.Annotations == nil {

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

+	}

+	if len(repo.Annotations[dockerImageRepositoryCheckAnnotation]) != 0 {

+		return nil

+	}

+

+	registry, namespace, name, _, err := api.SplitDockerPullSpec(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())

+	}

+

+	conn, err := c.client.Connect(registry)

+	if err != nil {

+		return err

+	}

+	tags, err := conn.ImageTags(namespace, name)

+	switch {

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

+		return c.done(repo, err.Error())

+	case err != nil:

+		return err

+	}

+

+	newTags := make(map[string]string, len(repo.Tags))

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

+	switch {

+	case len(repo.Tags) == 0:

+		// copy all tags

+		for tag, _ := range tags {

+			// TODO: once pull by image is implemented, use tag = imageid

+			newTags[tag] = tag

+		}

+		for tag, image := range tags {

+			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: once pull by image is implemented, use tag = imageid

+			newTags[tag] = tag

+		}

+	}

+

+	// whether we ignore or succeed, ensure the most recent mappings are recorded

+	repo.Tags = newTags

+

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

+	if len(imageToTag) == 0 {

+		return c.done(repo, "")

+	}

+

+	for id, tags := range imageToTag {

+		dockerImage, err := conn.ImageByID(namespace, name, id)

+		switch {

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

+			return c.done(repo, err.Error())

+		case dockerregistry.IsImageNotFound(err):

+			for _, tag := range tags {

+				delete(newTags, tag)

+			}

+			continue

+		case err != nil:

+			return err

+		}

+		var image api.DockerImage

+		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())

+		}

+		mapping := &api.ImageRepositoryMapping{

+			ObjectMeta: kapi.ObjectMeta{

+				Name:      repo.Name,

+				Namespace: repo.Namespace,

+			},

+			Tag: tags[0],

+			Image: api.Image{

+				DockerImageMetadata: image,

+			},

+		}

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

+			if errors.IsNotFound(err) {

+				return c.done(repo, err.Error())

+			}

+			return err

+		}

+	}

+

+	// we've completed our updates

+	return c.done(repo, "")

+}

+

+// ignore marks the repository as being processed due to an error or failure condition

+func (c *ImportController) done(repo *api.ImageRepository, reason string) error {

+	if len(reason) == 0 {

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

+	}

+	repo.Annotations[dockerImageRepositoryCheckAnnotation] = reason

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

+		return err

+	}

+	return nil

+}

new file mode 100644

@@ -0,0 +1,257 @@

+package controller

+

+import (

+	"fmt"

+	"testing"

+	"time"

+

+	"github.com/fsouza/go-dockerclient"

+

+	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+

+	"github.com/openshift/origin/pkg/client"

+	"github.com/openshift/origin/pkg/dockerregistry"

+	"github.com/openshift/origin/pkg/image/api"

+)

+

+type expectedImage struct {

+	Tag   string

+	ID    string

+	Image *docker.Image

+	Err   error

+}

+

+type fakeDockerRegistryClient struct {

+	Registry                 string

+	Namespace, Name, Tag, ID string

+

+	Tags map[string]string

+	Err  error

+

+	Images []expectedImage

+}

+

+func (f *fakeDockerRegistryClient) Connect(registry string) (dockerregistry.Connection, error) {

+	f.Registry = registry

+	return f, nil

+}

+

+func (f *fakeDockerRegistryClient) ImageTags(namespace, name string) (map[string]string, error) {

+	f.Namespace, f.Name = namespace, name

+	return f.Tags, f.Err

+}

+

+func (f *fakeDockerRegistryClient) ImageByTag(namespace, name, tag string) (*docker.Image, error) {

+	if len(tag) == 0 {

+		tag = "latest"

+	}

+	f.Namespace, f.Name, f.Tag = namespace, name, tag

+	for _, t := range f.Images {

+		if t.Tag == tag {

+			return t.Image, t.Err

+		}

+	}

+	return nil, dockerregistry.NewImageNotFoundError(fmt.Sprintf("%s/%s", namespace, name), tag, tag)

+}

+

+func (f *fakeDockerRegistryClient) ImageByID(namespace, name, id string) (*docker.Image, error) {

+	f.Namespace, f.Name, f.ID = namespace, name, id

+	for _, t := range f.Images {

+		if t.ID == id {

+			return t.Image, t.Err

+		}

+	}

+	return nil, dockerregistry.NewImageNotFoundError(fmt.Sprintf("%s/%s", namespace, name), id, "")

+}

+

+func TestControllerNoDockerRepo(t *testing.T) {

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

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

+

+	repo := api.ImageRepository{

+		ObjectMeta: kapi.ObjectMeta{

+			Name:      "test",

+			Namespace: "other",

+		},

+	}

+	other := repo

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

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

+	}

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

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

+	}

+}

+

+func TestControllerRepoHandled(t *testing.T) {

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

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

+

+	repo := api.ImageRepository{

+		ObjectMeta: kapi.ObjectMeta{

+			Name:      "test",

+			Namespace: "other",

+		},

+		DockerImageRepository: "foo/bar",

+	}

+	if err := c.Next(&repo); 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(fake.Actions) != 1 {

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

+	}

+}

+

+func TestControllerTagRetrievalFails(t *testing.T) {

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

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

+

+	repo := api.ImageRepository{

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

+		DockerImageRepository: "foo/bar",

+	}

+	if err := c.Next(&repo); 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(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.ImageRepository{

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

+		DockerImageRepository: "foo/bar",

+		Tags: map[string]string{

+			"test": "value",

+		},

+	}

+	if err := c.Next(&repo); 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(fake.Actions) != 1 {

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

+	}

+}

+

+func TestControllerImageNotFoundError(t *testing.T) {

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

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

+	repo := api.ImageRepository{

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

+		DockerImageRepository: "foo/bar",

+	}

+	if err := c.Next(&repo); 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(fake.Actions) != 1 {

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

+	}

+}

+

+func TestControllerImageWithGenericError(t *testing.T) {

+	cli, fake := &fakeDockerRegistryClient{

+		Tags: map[string]string{"latest": "found"},

+		Images: []expectedImage{

+			{

+				ID:  "found",

+				Err: fmt.Errorf("test error"),

+			},

+		},

+	}, &client.Fake{}

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

+	repo := api.ImageRepository{

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

+		DockerImageRepository: "foo/bar",

+	}

+	if err := c.Next(&repo); 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(fake.Actions) != 0 {

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

+	}

+}

+

+func TestControllerWithImage(t *testing.T) {

+	cli, fake := &fakeDockerRegistryClient{

+		Tags: map[string]string{"latest": "found"},

+		Images: []expectedImage{

+			{

+				ID: "found",

+				Image: &docker.Image{

+					Comment: "foo",

+					Config:  &docker.Config{},

+				},

+			},

+		},

+	}, &client.Fake{}

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

+	repo := api.ImageRepository{

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

+		DockerImageRepository: "foo/bar",

+	}

+	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.Error("expected an update action: %#v", fake.Actions)

+	}

+}

+

+func TestControllerWithEmptyTag(t *testing.T) {

+	cli, fake := &fakeDockerRegistryClient{

+		Tags: map[string]string{"latest": "found"},

+		Images: []expectedImage{

+			{

+				ID: "found",

+				Image: &docker.Image{

+					Comment: "foo",

+					Config:  &docker.Config{},

+				},

+			},

+		},

+	}, &client.Fake{}

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

+	repo := api.ImageRepository{

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

+		DockerImageRepository: "foo/bar",

+		Tags: map[string]string{

+			"latest": "",

+		},

+	}

+	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.Error("expected an update action: %#v", fake.Actions)

+	}

+}

+

+func isRFC3339(s string) bool {

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

+	return err == nil

+}

new file mode 100644

@@ -0,0 +1,56 @@

+package controller

+

+import (

+	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/cache"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/watch"

+

+	"github.com/openshift/origin/pkg/client"

+	"github.com/openshift/origin/pkg/controller"

+	"github.com/openshift/origin/pkg/dockerregistry"

+	"github.com/openshift/origin/pkg/image/api"

+)

+

+// ImportControllerFactory can create an ImportController.

+type ImportControllerFactory struct {

+	Client client.Interface

+}

+

+// Create creates an ImportController.

+func (f *ImportControllerFactory) Create() controller.RunnableController {

+	lw := &cache.ListWatch{

+		ListFunc: func() (runtime.Object, error) {

+			return f.Client.ImageRepositories(kapi.NamespaceAll).List(labels.Everything(), labels.Everything())

+		},

+		WatchFunc: func(resourceVersion string) (watch.Interface, error) {

+			return f.Client.ImageRepositories(kapi.NamespaceAll).Watch(labels.Everything(), labels.Everything(), resourceVersion)

+		},

+	}

+	q := cache.NewFIFO(cache.MetaNamespaceKeyFunc)

+	cache.NewReflector(lw, &api.ImageRepository{}, q).Run()

+

+	c := &ImportController{

+		client:       dockerregistry.NewClient(),

+		repositories: f.Client,

+		mappings:     f.Client,

+	}

+

+	return &controller.RetryController{

+		Queue: q,

+		RetryManager: controller.NewQueueRetryManager(

+			q,

+			cache.MetaNamespaceKeyFunc,

+			func(obj interface{}, err error, _ int) bool {

+				util.HandleError(err)

+				return true

+			},

+		),

+		Handle: func(obj interface{}) error {

+			r := obj.(*api.ImageRepository)

+			return c.Next(r)

+		},

+	}

+}