func TestRepositoryBlobStat(t *testing.T) {
quotaEnforcing = "aEnforcingConfig{}
ctx := context.Background()
// this driver holds all the testing blobs in memory during the whole test run
driver := inmemory.New()
// generate two images and store their blobs in the driver
testImages, err := populateTestStorage(t, driver, true, 1, map[string]int{"nm/is:latest": 1, "nm/repo:missing-layer-links": 1}, nil)
if err != nil {
t.Fatal(err)
}
// generate an image and store its blobs in the driver; the resulting image will lack managed by openshift
// annotation
testImages, err = populateTestStorage(t, driver, false, 1, map[string]int{"nm/unmanaged:missing-layer-links": 1}, testImages)
if err != nil {
t.Fatal(err)
}
// remove layer repository links from two of the above images; keep the uploaded blobs in the global
// blostore though
for _, name := range []string{"nm/repo:missing-layer-links", "nm/unmanaged:missing-layer-links"} {
repoName := strings.Split(name, ":")[0]
for _, layer := range testImages[name][0].DockerImageLayers {
dgst := digest.Digest(layer.Name)
alg, hex := dgst.Algorithm(), dgst.Hex()
err := driver.Delete(ctx, fmt.Sprintf("/docker/registry/v2/repositories/%s/_layers/%s/%s", repoName, alg, hex))
if err != nil {
t.Fatalf("failed to delete layer link %q from repository %q: %v", layer.Name, repoName, err)
}
}
}
// generate random images without storing its blobs in the driver
etcdOnlyImages := map[string]*imageapi.Image{}
for _, d := range []struct {
name string
managed bool
}{{"nm/is", true}, {"registry.org:5000/user/app", false}} {
img, err := registrytest.NewImageForManifest(d.name, registrytest.SampleImageManifestSchema1, d.managed)
if err != nil {
t.Fatal(err)
}
etcdOnlyImages[d.name] = img
}
for _, tc := range []struct {
name string
stat string
images []imageapi.Image
imageStreams []imageapi.ImageStream
pullthrough bool
skipAuth bool
deferredErrors deferredErrors
expectedDescriptor distribution.Descriptor
expectedError error
expectedActions []clientAction
}{
{
name: "local stat",
stat: "nm/is@" + testImages["nm/is:latest"][0].DockerImageLayers[0].Name,
imageStreams: []imageapi.ImageStream{{ObjectMeta: kapi.ObjectMeta{Namespace: "nm", Name: "is"}}},
expectedDescriptor: testNewDescriptorForLayer(testImages["nm/is:latest"][0].DockerImageLayers[0]),
},
{
name: "blob only tagged in image stream",
stat: "nm/repo@" + testImages["nm/repo:missing-layer-links"][0].DockerImageLayers[1].Name,
images: []imageapi.Image{*testImages["nm/repo:missing-layer-links"][0]},
imageStreams: []imageapi.ImageStream{
{
ObjectMeta: kapi.ObjectMeta{
Namespace: "nm",
Name: "repo",
},
Status: imageapi.ImageStreamStatus{
Tags: map[string]imageapi.TagEventList{
"latest": {
Items: []imageapi.TagEvent{
{
Image: testImages["nm/repo:missing-layer-links"][0].Name,
},
},
},
},
},
},
},
expectedDescriptor: testNewDescriptorForLayer(testImages["nm/repo:missing-layer-links"][0].DockerImageLayers[1]),
expectedActions: []clientAction{{"get", "imagestreams"}, {"get", "images"}},
},
{
name: "blob referenced only by not managed image with pullthrough on",
stat: "nm/unmanaged@" + testImages["nm/unmanaged:missing-layer-links"][0].DockerImageLayers[1].Name,
images: []imageapi.Image{*testImages["nm/unmanaged:missing-layer-links"][0]},
imageStreams: []imageapi.ImageStream{
{
ObjectMeta: kapi.ObjectMeta{
Namespace: "nm",
Name: "unmanaged",
},
Status: imageapi.ImageStreamStatus{
Tags: map[string]imageapi.TagEventList{
"latest": {
Items: []imageapi.TagEvent{
{
Image: testImages["nm/unmanaged:missing-layer-links"][0].Name,
},
},
},
},
},
},
},
pullthrough: true,
expectedDescriptor: testNewDescriptorForLayer(testImages["nm/unmanaged:missing-layer-links"][0].DockerImageLayers[1]),
expectedActions: []clientAction{{"get", "imagestreams"}, {"get", "images"}},
},
{
// TODO: this should err out because of missing image stream.
// Unfortunately, it's not the case. Until we start storing layer links in etcd, we depend on
// local layer links.
name: "layer link present while image stream not found",
stat: "nm/is@" + testImages["nm/is:latest"][0].DockerImageLayers[0].Name,
images: []imageapi.Image{*testImages["nm/is:latest"][0]},
expectedDescriptor: testNewDescriptorForLayer(testImages["nm/is:latest"][0].DockerImageLayers[0]),
},
{
name: "blob only tagged by not managed image with pullthrough off",
stat: "nm/repo@" + testImages["nm/unmanaged:missing-layer-links"][0].DockerImageLayers[1].Name,
images: []imageapi.Image{*testImages["nm/unmanaged:missing-layer-links"][0]},
imageStreams: []imageapi.ImageStream{
{
ObjectMeta: kapi.ObjectMeta{
Namespace: "nm",
Name: "repo",
},
Status: imageapi.ImageStreamStatus{
Tags: map[string]imageapi.TagEventList{
"latest": {
Items: []imageapi.TagEvent{
{
Image: testImages["nm/unmanaged:missing-layer-links"][0].DockerImageLayers[1].Name,
},
},
},
},
},
},
},
expectedError: distribution.ErrBlobUnknown,
expectedActions: []clientAction{{"get", "imagestreams"}, {"get", "images"}},
},
{
name: "blob not stored locally but referred in image stream",
stat: "nm/is@" + etcdOnlyImages["nm/is"].DockerImageLayers[1].Name,
images: []imageapi.Image{*etcdOnlyImages["nm/is"]},
imageStreams: []imageapi.ImageStream{
{
ObjectMeta: kapi.ObjectMeta{
Namespace: "nm",
Name: "is",
},
Status: imageapi.ImageStreamStatus{
Tags: map[string]imageapi.TagEventList{
"latest": {
Items: []imageapi.TagEvent{
{
Image: etcdOnlyImages["nm/is"].Name,
},
},
},
},
},
},
},
expectedError: distribution.ErrBlobUnknown,
},
{
name: "blob does not exist",
stat: "nm/repo@" + etcdOnlyImages["nm/is"].DockerImageLayers[0].Name,
images: []imageapi.Image{*testImages["nm/is:latest"][0]},
imageStreams: []imageapi.ImageStream{
{
ObjectMeta: kapi.ObjectMeta{
Namespace: "nm",
Name: "repo",
},
Status: imageapi.ImageStreamStatus{
Tags: map[string]imageapi.TagEventList{
"latest": {
Items: []imageapi.TagEvent{
{
Image: testImages["nm/is:latest"][0].Name,
},
},
},
},
},
},
},
expectedError: distribution.ErrBlobUnknown,
},
{
name: "auth not performed",
stat: "nm/is@" + testImages["nm/is:latest"][0].DockerImageLayers[0].Name,
imageStreams: []imageapi.ImageStream{{ObjectMeta: kapi.ObjectMeta{Namespace: "nm", Name: "is"}}},
skipAuth: true,
expectedError: fmt.Errorf("openshift.auth.completed missing from context"),
},
{
name: "deferred error",
stat: "nm/is@" + testImages["nm/is:latest"][0].DockerImageLayers[0].Name,
imageStreams: []imageapi.ImageStream{{ObjectMeta: kapi.ObjectMeta{Namespace: "nm", Name: "is"}}},
deferredErrors: deferredErrors{"nm/is": ErrOpenShiftAccessDenied},
expectedError: ErrOpenShiftAccessDenied,
},
} {
ref, err := reference.Parse(tc.stat)
if err != nil {
t.Errorf("[%s] failed to parse blob reference %q: %v", tc.name, tc.stat, err)
continue
}
canonical, ok := ref.(reference.Canonical)
if !ok {
t.Errorf("[%s] not a canonical reference %q", tc.name, ref.String())
continue
}
cachedLayers, err = newDigestToRepositoryCache(defaultDigestToRepositoryCacheSize)
if err != nil {
t.Fatal(err)
}
ctx := context.Background()
if !tc.skipAuth {
ctx = WithAuthPerformed(ctx)
}
if tc.deferredErrors != nil {
ctx = WithDeferredErrors(ctx, tc.deferredErrors)
}
client := &testclient.Fake{}
client.AddReactor("get", "imagestreams", imagetest.GetFakeImageStreamGetHandler(t, tc.imageStreams...))
client.AddReactor("get", "images", registrytest.GetFakeImageGetHandler(t, tc.images...))
reg, err := newTestRegistry(ctx, client, driver, defaultBlobRepositoryCacheTTL, tc.pullthrough, true)
if err != nil {
t.Errorf("[%s] unexpected error: %v", tc.name, err)
continue
}
repo, err := reg.Repository(ctx, canonical)
if err != nil {
t.Errorf("[%s] unexpected error: %v", tc.name, err)
continue
}
desc, err := repo.Blobs(ctx).Stat(ctx, canonical.Digest())
if err != nil && tc.expectedError == nil {
t.Errorf("[%s] got unexpected stat error: %v", tc.name, err)
continue
}
if err == nil && tc.expectedError != nil {
t.Errorf("[%s] got unexpected non-error", tc.name)
continue
}
if !reflect.DeepEqual(err, tc.expectedError) {
t.Errorf("[%s] got unexpected error: %s", tc.name, diff.ObjectGoPrintDiff(err, tc.expectedError))
continue
}
if tc.expectedError == nil && !reflect.DeepEqual(desc, tc.expectedDescriptor) {
t.Errorf("[%s] got unexpected descriptor: %s", tc.name, diff.ObjectGoPrintDiff(desc, tc.expectedDescriptor))
}
compareActions(t, tc.name, client.Actions(), tc.expectedActions)
}
}
func TestRepositoryBlobStatCacheEviction(t *testing.T) {
const blobRepoCacheTTL = time.Millisecond * 500
quotaEnforcing = "aEnforcingConfig{}
ctx := WithAuthPerformed(context.Background())
// this driver holds all the testing blobs in memory during the whole test run
driver := inmemory.New()
// generate two images and store their blobs in the driver
testImages, err := populateTestStorage(t, driver, true, 1, map[string]int{"nm/is:latest": 1}, nil)
if err != nil {
t.Fatal(err)
}
testImage := testImages["nm/is:latest"][0]
testImageStream := registrytest.TestNewImageStreamObject("nm", "is", "latest", testImage.Name, "")
blob1Desc := testNewDescriptorForLayer(testImage.DockerImageLayers[0])
blob1Dgst := blob1Desc.Digest
blob2Desc := testNewDescriptorForLayer(testImage.DockerImageLayers[1])
blob2Dgst := blob2Desc.Digest
// remove repo layer repo link of the image's second blob
alg, hex := blob2Dgst.Algorithm(), blob2Dgst.Hex()
err = driver.Delete(ctx, fmt.Sprintf("/docker/registry/v2/repositories/%s/_layers/%s/%s", "nm/is", alg, hex))
cachedLayers, err = newDigestToRepositoryCache(defaultDigestToRepositoryCacheSize)
if err != nil {
t.Fatal(err)
}
client := &testclient.Fake{}
client.AddReactor("get", "imagestreams", imagetest.GetFakeImageStreamGetHandler(t, *testImageStream))
client.AddReactor("get", "images", registrytest.GetFakeImageGetHandler(t, *testImage))
reg, err := newTestRegistry(ctx, client, driver, blobRepoCacheTTL, false, false)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
ref, err := reference.ParseNamed("nm/is")
if err != nil {
t.Errorf("failed to parse blob reference %q: %v", "nm/is", err)
}
repo, err := reg.Repository(ctx, ref)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// hit the layer repo link - cache the result
desc, err := repo.Blobs(ctx).Stat(ctx, blob1Dgst)
if err != nil {
t.Fatalf("got unexpected stat error: %v", err)
}
if !reflect.DeepEqual(desc, blob1Desc) {
t.Fatalf("got unexpected descriptor: %#+v != %#+v", desc, blob1Desc)
}
compareActions(t, "no actions expected", client.Actions(), []clientAction{})
// remove layer repo link, delete the association from cache as well
err = repo.Blobs(ctx).Delete(ctx, blob1Dgst)
if err != nil {
t.Fatalf("got unexpected error: %v", err)
}
// query etcd
desc, err = repo.Blobs(ctx).Stat(ctx, blob1Dgst)
if err != nil {
t.Fatalf("got unexpected stat error: %v", err)
}
if !reflect.DeepEqual(desc, blob1Desc) {
t.Fatalf("got unexpected descriptor: %#+v != %#+v", desc, blob1Desc)
}
expectedActions := []clientAction{{"get", "imagestreams"}, {"get", "images"}}
compareActions(t, "1st roundtrip to etcd", client.Actions(), expectedActions)
// remove the underlying blob
vacuum := storage.NewVacuum(ctx, driver)
err = vacuum.RemoveBlob(blob1Dgst.String())
if err != nil {
t.Fatalf("got unexpected error: %v", err)
}
// fail because the blob isn't stored locally
desc, err = repo.Blobs(ctx).Stat(ctx, blob1Dgst)
if err == nil {
t.Fatalf("got unexpected non error: %v", err)
}
if err != distribution.ErrBlobUnknown {
t.Fatalf("got unexpected error: %#+v", err)
}
// cache hit - don't query etcd
desc, err = repo.Blobs(ctx).Stat(ctx, blob2Dgst)
if err != nil {
t.Fatalf("got unexpected stat error: %v", err)
}
if !reflect.DeepEqual(desc, blob2Desc) {
t.Fatalf("got unexpected descriptor: %#+v != %#+v", desc, blob2Desc)
}
compareActions(t, "no etcd query", client.Actions(), expectedActions)
lastStatTimestamp := time.Now()
// hit the cache
desc, err = repo.Blobs(ctx).Stat(ctx, blob2Dgst)
if err != nil {
t.Fatalf("got unexpected stat error: %v", err)
}
if !reflect.DeepEqual(desc, blob2Desc) {
t.Fatalf("got unexpected descriptor: %#+v != %#+v", desc, blob2Desc)
}
// cache hit - no additional etcd query
compareActions(t, "no roundrip to etcd", client.Actions(), expectedActions)
t.Logf("sleeping %s while waiting for eviction of blob %q from cache", blobRepoCacheTTL.String(), blob2Dgst.String())
time.Sleep(blobRepoCacheTTL - (time.Now().Sub(lastStatTimestamp)))
desc, err = repo.Blobs(ctx).Stat(ctx, blob2Dgst)
if err != nil {
t.Fatalf("got unexpected stat error: %v", err)
}
if !reflect.DeepEqual(desc, blob2Desc) {
t.Fatalf("got unexpected descriptor: %#+v != %#+v", desc, blob2Desc)
}
expectedActions = append(expectedActions, []clientAction{{"get", "imagestreams"}, {"get", "images"}}...)
compareActions(t, "2nd roundtrip to etcd", client.Actions(), expectedActions)
err = vacuum.RemoveBlob(blob2Dgst.String())
if err != nil {
t.Fatalf("got unexpected error: %v", err)
}
// fail because the blob isn't stored locally
desc, err = repo.Blobs(ctx).Stat(ctx, blob2Dgst)
if err == nil {
t.Fatalf("got unexpected non error: %v", err)
}
if err != distribution.ErrBlobUnknown {
t.Fatalf("got unexpected error: %#+v", err)
}
}
