Add pkg/image/registryclient/v2

This is a separate module that is compatible with
pkg/image/registryclient, but uses distribution/[email protected].

Since distribution/[email protected] has removed the client package being used
by library-go currently, or rather moved it into internal, this patch
includes copying the packages from distribution/v3/internal/client into
registryclient/v2/internal. Some of the logic is exported as required
to make oc work as that is where this patch has been tested.

So the approach taken was to copy registryclient into registryclient/v2,
then copy distribution/v3/internal/client into
registryclient/v2/internal, then keep exporting functionality so that oc
can be ported to distributions/[email protected] and registryclient/v2.

Generally when a project importing library-go wants to migrate to
the current distribution/v3, they can just import this module instead of
using pkg/image/registryclient. The interface is compatible with
pkg/image/registryclient and all that is needed is changing the import
path.

Author: tchap

pkg/image/registryclient/v2/auth/api_version.go

@@ -0,0 +1,20 @@
+package auth
+
+import (
+	"net/http"
+	"strings"
+)
+
+// APIVersions gets the API versions out of an HTTP response using the provided
+// version header as the key for the HTTP header.
+func APIVersions(resp *http.Response, versionHeader string) []string {
+	var versions []string
+	if versionHeader != "" {
+		for _, supportedVersions := range resp.Header[http.CanonicalHeaderKey(versionHeader)] {
+			for _, version := range strings.Fields(supportedVersions) {
+				versions = append(versions, version)
+			}
+		}
+	}
+	return versions
+}

pkg/image/registryclient/v2/auth/api_version_test.go

@@ -0,0 +1,56 @@
+package auth
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestAPIVersions(t *testing.T) {
+	const header = "Docker-Distribution-API-Version"
+
+	tests := []struct {
+		name             string
+		headerName       string
+		headerValue      string
+		expectedVersions []string
+	}{{
+		name:             "HeaderPresentExactName",
+		headerName:       header,
+		headerValue:      "registry/2.0",
+		expectedVersions: []string{"registry/2.0"},
+	}, {
+		name:             "HeaderPresentLowerCaseName",
+		headerName:       strings.ToLower(header),
+		headerValue:      "registry/2.0",
+		expectedVersions: []string{"registry/2.0"},
+	}, {
+		name:             "HeaderPresentMultipleValues",
+		headerName:       header,
+		headerValue:      "registry/2.0 registry/3.0",
+		expectedVersions: []string{"registry/2.0", "registry/3.0"},
+	}, {
+		name:             "HeaderMissing",
+		headerName:       header,
+		headerValue:      "",
+		expectedVersions: nil,
+	}}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			resp := http.Response{
+				Header: make(map[string][]string),
+			}
+			if test.headerValue != "" {
+				resp.Header.Set(test.headerName, test.headerValue)
+			}
+
+			versions := APIVersions(&resp, header)
+			if !cmp.Equal(test.expectedVersions, versions) {
+				t.Error("Unexpected versions slice:\n", cmp.Diff(test.expectedVersions, versions))
+			}
+		})
+	}
+}

pkg/image/registryclient/v2/auth/credential_store.go

@@ -0,0 +1,17 @@
+package auth
+
+import "net/url"
+
+// CredentialStore is an interface for getting credentials for a given URL.
+type CredentialStore interface {
+	// Basic returns basic auth for the given URL
+	Basic(*url.URL) (string, string)
+
+	// RefreshToken returns a refresh token for the
+	// given URL and service
+	RefreshToken(*url.URL, string) string
+
+	// SetRefreshToken sets the refresh token if none
+	// is provided for the given url and service
+	SetRefreshToken(realm *url.URL, service, token string)
+}

pkg/image/registryclient/v2/auth/session.go

@@ -0,0 +1,32 @@
+package auth
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Scope is a type which is serializable to a string
+// using the allow scope grammar.
+type Scope interface {
+	String() string
+}
+
+// RepositoryScope represents a token scope for access
+// to a repository.
+type RepositoryScope struct {
+	Repository string
+	Class      string
+	Actions    []string
+}
+
+// String returns the string representation of the repository
+// using the scope grammar
+func (rs RepositoryScope) String() string {
+	repoType := "repository"
+	// Keep existing format for image class to maintain backwards compatibility
+	// with authorization servers which do not support the expanded grammar.
+	if rs.Class != "" && rs.Class != "image" {
+		repoType = fmt.Sprintf("%s(%s)", repoType, rs.Class)
+	}
+	return fmt.Sprintf("%s:%s:%s", repoType, rs.Repository, strings.Join(rs.Actions, ","))
+}