@@ -639,8 +639,10 @@ func (c *MasterConfig) GetRestStorage() map[string]rest.Storage {

 	imageStreamMappingStorage := imagestreammapping.NewREST(imageRegistry, imageStreamRegistry, c.RegistryNameFn)

 	imageStreamTagStorage := imagestreamtag.NewREST(imageRegistry, imageStreamRegistry)

 	imageStreamTagRegistry := imagestreamtag.NewRegistry(imageStreamTagStorage)

+	importerCache, err := imageimporter.NewImageStreamLayerCache(imageimporter.DefaultImageStreamLayerCacheSize)

+	checkStorageErr(err)

 	importerFn := func(r importer.RepositoryRetriever) imageimporter.Interface {

-		return imageimporter.NewImageStreamImporter(r, c.Options.ImagePolicyConfig.MaxImagesBulkImportedPerRepository, flowcontrol.NewTokenBucketRateLimiter(2.0, 3))

+		return imageimporter.NewImageStreamImporter(r, c.Options.ImagePolicyConfig.MaxImagesBulkImportedPerRepository, flowcontrol.NewTokenBucketRateLimiter(2.0, 3), &importerCache)

 	}

 	importerDockerClientFn := func() dockerregistry.Client {

 		return dockerregistry.NewClient(20*time.Second, false)

@@ -199,7 +199,7 @@ func TestDockerV1Fallback(t *testing.T) {

 	}

 	retriever := &mockRetriever{err: fmt.Errorf("does not support v2 API")}

-	im := NewImageStreamImporter(retriever, 5, nil)

+	im := NewImageStreamImporter(retriever, 5, nil, nil)

 	if err := im.Import(ctx, isi); err != nil {

 		t.Fatal(err)

 	}

@@ -52,15 +52,18 @@ type ImageStreamImporter struct {

 	digestToRepositoryCache map[gocontext.Context]map[manifestKey]*api.Image

 	// digestToLayerSizeCache maps layer digests to size.

-	digestToLayerSizeCache map[string]int64

+	digestToLayerSizeCache *ImageStreamLayerCache

 }

 // NewImageStreamImport creates an importer that will load images from a remote Docker registry into an

 // ImageStreamImport object. Limiter may be nil.

-func NewImageStreamImporter(retriever RepositoryRetriever, maximumTagsPerRepo int, limiter flowcontrol.RateLimiter) *ImageStreamImporter {

+func NewImageStreamImporter(retriever RepositoryRetriever, maximumTagsPerRepo int, limiter flowcontrol.RateLimiter, cache *ImageStreamLayerCache) *ImageStreamImporter {

 	if limiter == nil {

 		limiter = flowcontrol.NewFakeAlwaysRateLimiter()

 	}

+	if cache == nil {

+		glog.V(5).Infof("the global layer cache is disabled")

+	}

 	return &ImageStreamImporter{

 		maximumTagsPerRepo: maximumTagsPerRepo,

@@ -68,23 +71,25 @@ func NewImageStreamImporter(retriever RepositoryRetriever, maximumTagsPerRepo in

 		limiter:   limiter,

 		digestToRepositoryCache: make(map[gocontext.Context]map[manifestKey]*api.Image),

-		digestToLayerSizeCache:  make(map[string]int64),

+		digestToLayerSizeCache:  cache,

 	}

 }

-// contextImageCache initializes the image cache entry for a context and layer size cache.

-func (i *ImageStreamImporter) contextImageCache(ctx gocontext.Context) {

+// Import tries to complete the provided isi object with images loaded from remote registries.

+func (i *ImageStreamImporter) Import(ctx gocontext.Context, isi *api.ImageStreamImport) error {

+	// Initialize layer size cache if not given.

 	if i.digestToLayerSizeCache == nil {

-		i.digestToLayerSizeCache = make(map[string]int64)

+		cache, err := NewImageStreamLayerCache(DefaultImageStreamLayerCacheSize)

+		if err != nil {

+			return err

+		}

+		i.digestToLayerSizeCache = &cache

 	}

+	// Initialize the image cache entry for a context.

 	if _, ok := i.digestToRepositoryCache[ctx]; !ok {

 		i.digestToRepositoryCache[ctx] = make(map[manifestKey]*api.Image)

 	}

-}

-// Import tries to complete the provided isi object with images loaded from remote registries.

-func (i *ImageStreamImporter) Import(ctx gocontext.Context, isi *api.ImageStreamImport) error {

-	i.contextImageCache(ctx)

 	i.importImages(ctx, i.retriever, isi, i.limiter)

 	i.importFromRepository(ctx, i.retriever, isi, i.maximumTagsPerRepo, i.limiter)

 	return nil

@@ -320,8 +325,8 @@ func (isi *ImageStreamImporter) calculateImageSize(ctx gocontext.Context, repo d

 		}

 		blobSet.Insert(layer.Name)

-		if layerSize, ok := isi.digestToLayerSizeCache[layer.Name]; ok {

-			size += layerSize

+		if layerSize, ok := isi.digestToLayerSizeCache.Get(layer.Name); ok {

+			size += layerSize.(int64)

 			continue

 		}

@@ -330,7 +335,7 @@ func (isi *ImageStreamImporter) calculateImageSize(ctx gocontext.Context, repo d

 			return err

 		}

-		isi.digestToLayerSizeCache[layer.Name] = desc.Size

+		isi.digestToLayerSizeCache.Add(layer.Name, desc.Size)

 		layer.LayerSize = desc.Size

 		size += desc.Size

 	}

@@ -21,7 +21,7 @@ import (

 func TestImportNothing(t *testing.T) {

 	ctx := NewContext(http.DefaultTransport, http.DefaultTransport).WithCredentials(NoCredentials)

 	isi := &api.ImageStreamImport{}

-	i := NewImageStreamImporter(ctx, 5, nil)

+	i := NewImageStreamImporter(ctx, 5, nil, nil)

 	if err := i.Import(nil, isi); err != nil {

 		t.Fatal(err)

 	}

@@ -258,7 +258,7 @@ func TestImport(t *testing.T) {

 		},

 	}

 	for i, test := range testCases {

-		im := NewImageStreamImporter(test.retriever, 5, nil)

+		im := NewImageStreamImporter(test.retriever, 5, nil, nil)

 		if err := im.Import(nil, &test.isi); err != nil {

 			t.Errorf("%d: %v", i, err)

 		}

new file mode 100644

@@ -0,0 +1,24 @@

+package importer

+

+import (

+	"github.com/hashicorp/golang-lru"

+)

+

+const (

+	DefaultImageStreamLayerCacheSize = 2048

+)

+

+type ImageStreamLayerCache struct {

+	*lru.Cache

+}

+

+// ImageStreamLayerCache creates a new LRU cache of layer digests

+func NewImageStreamLayerCache(size int) (ImageStreamLayerCache, error) {

+	c, err := lru.New(size)

+	if err != nil {

+		return ImageStreamLayerCache{}, err

+	}

+	return ImageStreamLayerCache{

+		Cache: c,

+	}, nil

+}

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

 	kerrors "k8s.io/kubernetes/pkg/util/errors"

 	"k8s.io/kubernetes/pkg/watch"

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

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

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

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

@@ -182,6 +183,43 @@ func mockRegistryHandler(t *testing.T, requireAuth bool, count *int) http.Handle

 	})

 }

+func testImageStreamImport(t *testing.T, c *client.Client, imageSize int64, imagestreamimport *api.ImageStreamImport) {

+	imageStreams := c.ImageStreams(testutil.Namespace())

+

+	isi, err := imageStreams.Import(imagestreamimport)

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	if len(isi.Status.Images) != 1 {

+		t.Errorf("imported unexpected number of images (%d != 1)", len(isi.Status.Images))

+	}

+

+	for i, image := range isi.Status.Images {

+		if image.Status.Status != unversioned.StatusSuccess {

+			t.Errorf("unexpected status %d: %#v", i, image.Status)

+		}

+

+		if image.Image == nil {

+			t.Errorf("unexpected empty image %d", i)

+		}

+

+		// the image name is always the sha256, and size is calculated

+		if image.Image.Name != convertedDigest {

+			t.Errorf("unexpected image %d: %#v (expect %q)", i, image.Image.Name, convertedDigest)

+		}

+

+		// the image size is calculated

+		if image.Image.DockerImageMetadata.Size == 0 {

+			t.Errorf("unexpected image size %d: %#v", i, image.Image.DockerImageMetadata.Size)

+		}

+

+		if image.Image.DockerImageMetadata.Size != imageSize {

+			t.Errorf("unexpected image size %d: %#v (expect %d)", i, image.Image.DockerImageMetadata.Size, imageSize)

+		}

+	}

+}

+

 func testImageStreamImportWithPath(t *testing.T, reponame string) {

 	imageDigest := "sha256:815d06b56f4138afacd0009b8e3799fcdce79f0507bf8d0588e219b93ab6fd4d"

 	descriptors := map[string]int64{

@@ -266,9 +304,7 @@ func testImageStreamImportWithPath(t *testing.T, reponame string) {

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

 	}

-	imageStreams := c.ImageStreams(testutil.Namespace())

-

-	isi, err := imageStreams.Import(&api.ImageStreamImport{

+	testImageStreamImport(t, c, imageSize, &api.ImageStreamImport{

 		ObjectMeta: kapi.ObjectMeta{

 			Name: "test",

 		},

@@ -283,36 +319,31 @@ func testImageStreamImportWithPath(t *testing.T, reponame string) {

 			},

 		},

 	})

-	if err != nil {

-		t.Fatal(err)

-	}

-	if len(isi.Status.Images) != 1 {

-		t.Errorf("imported unexpected number of images (%d != 1)", len(isi.Status.Images))

+	if countStat != len(descriptors) {

+		t.Fatalf("unexpected number of blob stats %d (expected %d)", countStat, len(descriptors))

 	}

-	for i, image := range isi.Status.Images {

-		if image.Status.Status != unversioned.StatusSuccess {

-			t.Errorf("unexpected status %d: %#v", i, image.Status)

-		}

-

-		if image.Image == nil {

-			t.Errorf("unexpected empty image %d", i)

-		}

-

-		// the image name is always the sha256, and size is calculated

-		if image.Image.Name != convertedDigest {

-			t.Errorf("unexpected image %d: %#v (expect %q)", i, image.Image.Name, convertedDigest)

-		}

-

-		// the image size is calculated

-		if image.Image.DockerImageMetadata.Size == 0 {

-			t.Errorf("unexpected image size %d: %#v", i, image.Image.DockerImageMetadata.Size)

-		}

+	testImageStreamImport(t, c, imageSize, &api.ImageStreamImport{

+		ObjectMeta: kapi.ObjectMeta{

+			Name: "test1",

+		},

+		Spec: api.ImageStreamImportSpec{

+			Import: true,

+			Images: []api.ImageImportSpec{

+				{

+					From:         kapi.ObjectReference{Kind: "DockerImage", Name: url.Host + "/" + reponame + ":testtag"},

+					To:           &kapi.LocalObjectReference{Name: "other1"},

+					ImportPolicy: api.TagImportPolicy{Insecure: true},

+				},

+			},

+		},

+	})

-		if image.Image.DockerImageMetadata.Size != imageSize {

-			t.Errorf("unexpected image size %d: %#v (expect %d)", i, image.Image.DockerImageMetadata.Size, imageSize)

-		}

+	// Test that the global layer cache is working. The counter shouldn't change

+	// because all the information is available in the cache.

+	if countStat != len(descriptors) {

+		t.Fatalf("the global layer cache is not working: unexpected number of blob stats %d (expected %d)", countStat, len(descriptors))

 	}

 }

@@ -790,7 +821,7 @@ func TestImageStreamImportDockerHub(t *testing.T) {

 	}

 	err := retryWhenUnreachable(t, func() error {

-		i := importer.NewImageStreamImporter(importCtx, 3, nil)

+		i := importer.NewImageStreamImporter(importCtx, 3, nil, nil)

 		if err := i.Import(gocontext.Background(), imports); err != nil {

 			return err

 		}

@@ -846,7 +877,7 @@ func TestImageStreamImportQuayIO(t *testing.T) {

 	}

 	err := retryWhenUnreachable(t, func() error {

-		i := importer.NewImageStreamImporter(importCtx, 3, nil)

+		i := importer.NewImageStreamImporter(importCtx, 3, nil, nil)

 		if err := i.Import(gocontext.Background(), imports); err != nil {

 			return err

 		}

@@ -899,7 +930,7 @@ func TestImageStreamImportRedHatRegistry(t *testing.T) {

 		},

 	}

-	i := importer.NewImageStreamImporter(importCtx, 3, nil)

+	i := importer.NewImageStreamImporter(importCtx, 3, nil, nil)

 	if err := i.Import(gocontext.Background(), imports); err != nil {

 		t.Fatal(err)

 	}

@@ -926,7 +957,7 @@ func TestImageStreamImportRedHatRegistry(t *testing.T) {

 	context := gocontext.WithValue(gocontext.Background(), importer.ContextKeyV1RegistryClient, dockerregistry.NewClient(20*time.Second, false))

 	importCtx = importer.NewContext(rt, nil).WithCredentials(importer.NoCredentials)

 	err := retryWhenUnreachable(t, func() error {

-		i = importer.NewImageStreamImporter(importCtx, 3, nil)

+		i = importer.NewImageStreamImporter(importCtx, 3, nil, nil)

 		if err := i.Import(context, imports); err != nil {

 			return err

 		}