WIP

Author: Oleg Bulatov

pkg/dockerregistry/server/app.go

@@ -6,19 +6,24 @@ import (
 	"github.com/docker/distribution"
 	"github.com/docker/distribution/configuration"
 	"github.com/docker/distribution/context"
-	"github.com/docker/distribution/registry/handlers"
 	storagedriver "github.com/docker/distribution/registry/storage/driver"
 
 	"github.com/openshift/image-registry/pkg/dockerregistry/server/client"
 	registryconfig "github.com/openshift/image-registry/pkg/dockerregistry/server/configuration"
 	"github.com/openshift/image-registry/pkg/dockerregistry/server/maxconnections"
+	"github.com/openshift/image-registry/pkg/dockerregistry/server/supermiddleware"
 )
 
 const (
 	// Default values
 	defaultDigestToRepositoryCacheSize = 2048
 )
 
+// appMiddleware should be used only in tests.
+type appMiddleware interface {
+	Apply(supermiddleware.App) supermiddleware.App
+}
+
 // App is a global registry application object. Shared resources can be placed
 // on this object that will be accessible from all requests.
 type App struct {
@@ -57,6 +62,16 @@ type App struct {
 	quotaEnforcing *quotaEnforcingConfig
 }
 
+func (app *App) Storage(driver storagedriver.StorageDriver, options map[string]interface{}) (storagedriver.StorageDriver, error) {
+	app.driver = driver
+	return driver, nil
+}
+
+func (app *App) Registry(registry distribution.Namespace, options map[string]interface{}) (distribution.Namespace, error) {
+	app.registry = registry
+	return registry, nil
+}
+
 // NewApp configures the registry application and returns http.Handler for it.
 // The program will be terminated if an error happens.
 func NewApp(ctx context.Context, registryClient client.RegistryClient, dockerConfig *configuration.Configuration, extraConfig *registryconfig.Configuration, writeLimiter maxconnections.Limiter) http.Handler {
@@ -74,11 +89,9 @@ func NewApp(ctx context.Context, registryClient client.RegistryClient, dockerCon
 	}
 	app.cachedLayers = cache
 
-	weaveAppIntoConfig(app, dockerConfig)
-
 	repositoryEnabled := false
 	for _, middleware := range dockerConfig.Middleware["repository"] {
-		if middleware.Name == middlewareOpenShift {
+		if middleware.Name == "openshift" {
 			rc, err := newRepositoryConfig(ctx, extraConfig, middleware.Options)
 			if err != nil {
 				context.GetLogger(ctx).Fatalf("error configuring the repository middleware: %s", err)
@@ -89,8 +102,13 @@ func NewApp(ctx context.Context, registryClient client.RegistryClient, dockerCon
 		}
 	}
 
-	dockerApp := handlers.NewApp(ctx, dockerConfig)
+	superapp := supermiddleware.App(app)
+	if am := appMiddlewareFrom(ctx); am != nil {
+		superapp = am.Apply(superapp)
+	}
+	dockerApp := supermiddleware.NewApp(ctx, dockerConfig, superapp)
 
+	const middlewareOpenShift = "openshift"
 	if repositoryEnabled {
 		if app.driver == nil {
 			context.GetLogger(ctx).Fatalf("configuration error: the storage driver middleware %q is not activated", middlewareOpenShift)

pkg/dockerregistry/server/auth.go

@@ -89,7 +89,8 @@ var (
 	ErrUnsupportedResource = errors.New("unsupported resource")
 )
 
-func (app *App) newAccessController(authcfg *configuration.Auth) (registryauth.AccessController, error) {
+func (app *App) Auth(options map[string]interface{}) (registryauth.AccessController, error) {
+	authcfg := app.extraConfig.Auth
 	tokenRealm, err := configuration.TokenRealm(authcfg.TokenRealm)
 	if err != nil {
 		return nil, err

pkg/dockerregistry/server/auth_test.go

@@ -433,7 +433,7 @@ func TestAccessController(t *testing.T) {
 			if err := configuration.InitExtraConfig(config, app.extraConfig); err != nil {
 				t.Fatal(err)
 			}
-			accessController, err := app.newAccessController(app.extraConfig.Auth)
+			accessController, err := app.Auth(nil)
 			if err != nil {
 				t.Fatal(err)
 			}

pkg/dockerregistry/server/blobdescriptorservice.go

@@ -5,13 +5,10 @@ import (
 	"sort"
 	"time"
 
-	"github.com/Sirupsen/logrus"
 	"github.com/docker/distribution"
 	"github.com/docker/distribution/context"
 	"github.com/docker/distribution/digest"
 	"github.com/docker/distribution/manifest/schema2"
-	"github.com/docker/distribution/registry/middleware/registry"
-	"github.com/docker/distribution/registry/storage"
 
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 
@@ -34,37 +31,27 @@ func (b ByGeneration) Less(i, j int) bool { return b[i].Generation > b[j].Genera
 func (b ByGeneration) Len() int           { return len(b) }
 func (b ByGeneration) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
 
-func init() {
-	err := middleware.RegisterOptions(storage.BlobDescriptorServiceFactory(&blobDescriptorServiceFactory{}))
-	if err != nil {
-		logrus.Fatalf("Unable to register BlobDescriptorServiceFactory: %v", err)
-	}
-}
+type blobDescriptorServiceFactoryFunc func(svc distribution.BlobDescriptorService) distribution.BlobDescriptorService
 
-// blobDescriptorServiceFactory needs to be able to work with blobs
-// directly without using links. This allows us to ignore the distribution
-// of blobs between repositories.
-type blobDescriptorServiceFactory struct{}
-
-func (bf *blobDescriptorServiceFactory) BlobAccessController(svc distribution.BlobDescriptorService) distribution.BlobDescriptorService {
-	return &blobDescriptorService{svc}
+func (f blobDescriptorServiceFactoryFunc) BlobAccessController(svc distribution.BlobDescriptorService) distribution.BlobDescriptorService {
+	return f(svc)
 }
 
 type blobDescriptorService struct {
 	distribution.BlobDescriptorService
+	repo *repository
+}
+
+func (r *repository) BlobDescriptorService(svc distribution.BlobDescriptorService) distribution.BlobDescriptorService {
+	return &blobDescriptorService{svc, r}
 }
 
 // Stat returns a a blob descriptor if the given blob is either linked in repository or is referenced in
 // corresponding image stream. This method is invoked from inside of upstream's linkedBlobStore. It expects
 // a proper repository object to be set on given context by upper openshift middleware wrappers.
 func (bs *blobDescriptorService) Stat(ctx context.Context, dgst digest.Digest) (distribution.Descriptor, error) {
 	context.GetLogger(ctx).Debugf("(*blobDescriptorService).Stat: starting with digest=%s", dgst.String())
-	repo, found := repositoryFrom(ctx)
-	if !found || repo == nil {
-		err := fmt.Errorf("failed to retrieve repository from context")
-		context.GetLogger(ctx).Error(err)
-		return distribution.Descriptor{}, err
-	}
+	repo := bs.repo
 
 	// if there is a repo layer link, return its descriptor
 	desc, err := bs.BlobDescriptorService.Stat(ctx, dgst)