daemon/pkg/registry: move newIndexInfo to search

It's the only user of it.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

daemon/pkg/registry/config.go

@@ -342,23 +342,6 @@ func validateHostPort(s string) error {
 	return nil
 }
 
-// newIndexInfo returns IndexInfo configuration from indexName
-func newIndexInfo(config *serviceConfig, indexName string) *registry.IndexInfo {
-	indexName = normalizeIndexName(indexName)
-
-	// Return any configured index info, first.
-	if index, ok := config.IndexConfigs[indexName]; ok {
-		return index
-	}
-
-	// Construct a non-configured index info.
-	return &registry.IndexInfo{
-		Name:    indexName,
-		Mirrors: []string{},
-		Secure:  config.isSecureIndex(indexName),
-	}
-}
-
 // getAuthConfigKey special-cases using the full index address of the official
 // index as the AuthConfig key, and uses the (host)name[:port] for private indexes.
 func getAuthConfigKey(index *registry.IndexInfo) string {

daemon/pkg/registry/registry_test.go

@@ -6,9 +6,7 @@ import (
 	"testing"
 
 	"github.com/distribution/reference"
-	"github.com/moby/moby/api/types/registry"
 	"gotest.tools/v3/assert"
-	is "gotest.tools/v3/assert/cmp"
 )
 
 // overrideLookupIP overrides net.LookupIP for testing.
@@ -34,233 +32,6 @@ func overrideLookupIP(t *testing.T) {
 	})
 }
 
-func TestNewIndexInfo(t *testing.T) {
-	overrideLookupIP(t)
-
-	// ipv6Loopback is the CIDR for the IPv6 loopback address ("::1"); "::1/128"
-	ipv6Loopback := &net.IPNet{
-		IP:   net.IPv6loopback,
-		Mask: net.CIDRMask(128, 128),
-	}
-
-	// ipv4Loopback is the CIDR for IPv4 loopback addresses ("127.0.0.0/8")
-	ipv4Loopback := &net.IPNet{
-		IP:   net.IPv4(127, 0, 0, 0),
-		Mask: net.CIDRMask(8, 32),
-	}
-
-	// emptyServiceConfig is a default service-config for situations where
-	// no config-file is available (e.g. when used in the CLI). It won't
-	// have mirrors configured, but does have the default insecure registry
-	// CIDRs for loopback interfaces configured.
-	emptyServiceConfig := &serviceConfig{
-		IndexConfigs: map[string]*registry.IndexInfo{
-			IndexName: {
-				Name:     IndexName,
-				Mirrors:  []string{},
-				Secure:   true,
-				Official: true,
-			},
-		},
-		InsecureRegistryCIDRs: []*registry.NetIPNet{
-			(*registry.NetIPNet)(ipv6Loopback),
-			(*registry.NetIPNet)(ipv4Loopback),
-		},
-	}
-
-	expectedIndexInfos := map[string]*registry.IndexInfo{
-		IndexName: {
-			Name:     IndexName,
-			Official: true,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-		"index." + IndexName: {
-			Name:     IndexName,
-			Official: true,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-		"example.com": {
-			Name:     "example.com",
-			Official: false,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-		"127.0.0.1:5000": {
-			Name:     "127.0.0.1:5000",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-	}
-	t.Run("no mirrors", func(t *testing.T) {
-		for indexName, expected := range expectedIndexInfos {
-			t.Run(indexName, func(t *testing.T) {
-				actual := newIndexInfo(emptyServiceConfig, indexName)
-				assert.Check(t, is.DeepEqual(actual, expected))
-			})
-		}
-	})
-
-	expectedIndexInfos = map[string]*registry.IndexInfo{
-		IndexName: {
-			Name:     IndexName,
-			Official: true,
-			Secure:   true,
-			Mirrors:  []string{"http://mirror1.local/", "http://mirror2.local/"},
-		},
-		"index." + IndexName: {
-			Name:     IndexName,
-			Official: true,
-			Secure:   true,
-			Mirrors:  []string{"http://mirror1.local/", "http://mirror2.local/"},
-		},
-		"example.com": {
-			Name:     "example.com",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"example.com:5000": {
-			Name:     "example.com:5000",
-			Official: false,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-		"127.0.0.1": {
-			Name:     "127.0.0.1",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"127.0.0.1:5000": {
-			Name:     "127.0.0.1:5000",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"127.255.255.255": {
-			Name:     "127.255.255.255",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"127.255.255.255:5000": {
-			Name:     "127.255.255.255:5000",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"::1": {
-			Name:     "::1",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"[::1]:5000": {
-			Name:     "[::1]:5000",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		// IPv6 only has a single loopback address, so ::2 is not a loopback,
-		// hence not marked "insecure".
-		"::2": {
-			Name:     "::2",
-			Official: false,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-		// IPv6 only has a single loopback address, so ::2 is not a loopback,
-		// hence not marked "insecure".
-		"[::2]:5000": {
-			Name:     "[::2]:5000",
-			Official: false,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-		"other.com": {
-			Name:     "other.com",
-			Official: false,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-	}
-	t.Run("mirrors", func(t *testing.T) {
-		// Note that newServiceConfig calls ValidateMirror internally, which normalizes
-		// mirror-URLs to have a trailing slash.
-		config, err := newServiceConfig(ServiceOptions{
-			Mirrors:            []string{"http://mirror1.local", "http://mirror2.local"},
-			InsecureRegistries: []string{"example.com"},
-		})
-		assert.NilError(t, err)
-		for indexName, expected := range expectedIndexInfos {
-			t.Run(indexName, func(t *testing.T) {
-				actual := newIndexInfo(config, indexName)
-				assert.Check(t, is.DeepEqual(actual, expected))
-			})
-		}
-	})
-
-	expectedIndexInfos = map[string]*registry.IndexInfo{
-		"example.com": {
-			Name:     "example.com",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"example.com:5000": {
-			Name:     "example.com:5000",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"127.0.0.1": {
-			Name:     "127.0.0.1",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"127.0.0.1:5000": {
-			Name:     "127.0.0.1:5000",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"42.42.0.1:5000": {
-			Name:     "42.42.0.1:5000",
-			Official: false,
-			Secure:   false,
-			Mirrors:  []string{},
-		},
-		"42.43.0.1:5000": {
-			Name:     "42.43.0.1:5000",
-			Official: false,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-		"other.com": {
-			Name:     "other.com",
-			Official: false,
-			Secure:   true,
-			Mirrors:  []string{},
-		},
-	}
-	t.Run("custom insecure", func(t *testing.T) {
-		config, err := newServiceConfig(ServiceOptions{
-			InsecureRegistries: []string{"42.42.0.0/16"},
-		})
-		assert.NilError(t, err)
-		for indexName, expected := range expectedIndexInfos {
-			t.Run(indexName, func(t *testing.T) {
-				actual := newIndexInfo(config, indexName)
-				assert.Check(t, is.DeepEqual(actual, expected))
-			})
-		}
-	})
-}
-
 func TestMirrorEndpointLookup(t *testing.T) {
 	containsMirror := func(endpoints []APIEndpoint) bool {
 		for _, pe := range endpoints {

daemon/pkg/registry/search.go

@@ -147,6 +147,23 @@ func splitReposSearchTerm(reposName string) (string, string) {
 	return nameParts[0], nameParts[1]
 }
 
+// newIndexInfo returns IndexInfo configuration from indexName
+func newIndexInfo(config *serviceConfig, indexName string) *registry.IndexInfo {
+	indexName = normalizeIndexName(indexName)
+
+	// Return any configured index info, first.
+	if index, ok := config.IndexConfigs[indexName]; ok {
+		return index
+	}
+
+	// Construct a non-configured index info.
+	return &registry.IndexInfo{
+		Name:    indexName,
+		Mirrors: []string{},
+		Secure:  config.isSecureIndex(indexName),
+	}
+}
+
 // defaultSearchLimit is the default value for maximum number of returned search results.
 const defaultSearchLimit = 25
 

daemon/pkg/registry/search_test.go

@@ -3,6 +3,7 @@ package registry
 import (
 	"context"
 	"encoding/json"
+	"net"
 	"net/http"
 	"net/http/httptest"
 	"net/http/httputil"
@@ -13,6 +14,7 @@ import (
 	"github.com/moby/moby/api/types/filters"
 	"github.com/moby/moby/api/types/registry"
 	"gotest.tools/v3/assert"
+	is "gotest.tools/v3/assert/cmp"
 )
 
 func spawnTestRegistrySession(t *testing.T) (*http.Client, *v1Endpoint) {
@@ -414,3 +416,230 @@ func TestSearch(t *testing.T) {
 		})
 	}
 }
+
+func TestNewIndexInfo(t *testing.T) {
+	overrideLookupIP(t)
+
+	// ipv6Loopback is the CIDR for the IPv6 loopback address ("::1"); "::1/128"
+	ipv6Loopback := &net.IPNet{
+		IP:   net.IPv6loopback,
+		Mask: net.CIDRMask(128, 128),
+	}
+
+	// ipv4Loopback is the CIDR for IPv4 loopback addresses ("127.0.0.0/8")
+	ipv4Loopback := &net.IPNet{
+		IP:   net.IPv4(127, 0, 0, 0),
+		Mask: net.CIDRMask(8, 32),
+	}
+
+	// emptyServiceConfig is a default service-config for situations where
+	// no config-file is available (e.g. when used in the CLI). It won't
+	// have mirrors configured, but does have the default insecure registry
+	// CIDRs for loopback interfaces configured.
+	emptyServiceConfig := &serviceConfig{
+		IndexConfigs: map[string]*registry.IndexInfo{
+			IndexName: {
+				Name:     IndexName,
+				Mirrors:  []string{},
+				Secure:   true,
+				Official: true,
+			},
+		},
+		InsecureRegistryCIDRs: []*registry.NetIPNet{
+			(*registry.NetIPNet)(ipv6Loopback),
+			(*registry.NetIPNet)(ipv4Loopback),
+		},
+	}
+
+	expectedIndexInfos := map[string]*registry.IndexInfo{
+		IndexName: {
+			Name:     IndexName,
+			Official: true,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+		"index." + IndexName: {
+			Name:     IndexName,
+			Official: true,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+		"example.com": {
+			Name:     "example.com",
+			Official: false,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+		"127.0.0.1:5000": {
+			Name:     "127.0.0.1:5000",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+	}
+	t.Run("no mirrors", func(t *testing.T) {
+		for indexName, expected := range expectedIndexInfos {
+			t.Run(indexName, func(t *testing.T) {
+				actual := newIndexInfo(emptyServiceConfig, indexName)
+				assert.Check(t, is.DeepEqual(actual, expected))
+			})
+		}
+	})
+
+	expectedIndexInfos = map[string]*registry.IndexInfo{
+		IndexName: {
+			Name:     IndexName,
+			Official: true,
+			Secure:   true,
+			Mirrors:  []string{"http://mirror1.local/", "http://mirror2.local/"},
+		},
+		"index." + IndexName: {
+			Name:     IndexName,
+			Official: true,
+			Secure:   true,
+			Mirrors:  []string{"http://mirror1.local/", "http://mirror2.local/"},
+		},
+		"example.com": {
+			Name:     "example.com",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"example.com:5000": {
+			Name:     "example.com:5000",
+			Official: false,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+		"127.0.0.1": {
+			Name:     "127.0.0.1",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"127.0.0.1:5000": {
+			Name:     "127.0.0.1:5000",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"127.255.255.255": {
+			Name:     "127.255.255.255",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"127.255.255.255:5000": {
+			Name:     "127.255.255.255:5000",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"::1": {
+			Name:     "::1",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"[::1]:5000": {
+			Name:     "[::1]:5000",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		// IPv6 only has a single loopback address, so ::2 is not a loopback,
+		// hence not marked "insecure".
+		"::2": {
+			Name:     "::2",
+			Official: false,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+		// IPv6 only has a single loopback address, so ::2 is not a loopback,
+		// hence not marked "insecure".
+		"[::2]:5000": {
+			Name:     "[::2]:5000",
+			Official: false,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+		"other.com": {
+			Name:     "other.com",
+			Official: false,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+	}
+	t.Run("mirrors", func(t *testing.T) {
+		// Note that newServiceConfig calls ValidateMirror internally, which normalizes
+		// mirror-URLs to have a trailing slash.
+		config, err := newServiceConfig(ServiceOptions{
+			Mirrors:            []string{"http://mirror1.local", "http://mirror2.local"},
+			InsecureRegistries: []string{"example.com"},
+		})
+		assert.NilError(t, err)
+		for indexName, expected := range expectedIndexInfos {
+			t.Run(indexName, func(t *testing.T) {
+				actual := newIndexInfo(config, indexName)
+				assert.Check(t, is.DeepEqual(actual, expected))
+			})
+		}
+	})
+
+	expectedIndexInfos = map[string]*registry.IndexInfo{
+		"example.com": {
+			Name:     "example.com",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"example.com:5000": {
+			Name:     "example.com:5000",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"127.0.0.1": {
+			Name:     "127.0.0.1",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"127.0.0.1:5000": {
+			Name:     "127.0.0.1:5000",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"42.42.0.1:5000": {
+			Name:     "42.42.0.1:5000",
+			Official: false,
+			Secure:   false,
+			Mirrors:  []string{},
+		},
+		"42.43.0.1:5000": {
+			Name:     "42.43.0.1:5000",
+			Official: false,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+		"other.com": {
+			Name:     "other.com",
+			Official: false,
+			Secure:   true,
+			Mirrors:  []string{},
+		},
+	}
+	t.Run("custom insecure", func(t *testing.T) {
+		config, err := newServiceConfig(ServiceOptions{
+			InsecureRegistries: []string{"42.42.0.0/16"},
+		})
+		assert.NilError(t, err)
+		for indexName, expected := range expectedIndexInfos {
+			t.Run(indexName, func(t *testing.T) {
+				actual := newIndexInfo(config, indexName)
+				assert.Check(t, is.DeepEqual(actual, expected))
+			})
+		}
+	})
+}