We have been contacted of this error, feel free to check out status.docker.com\n to see if there is a bigger issue.
\n\n \n"}, "because the registry is temporarily unavailbe", }, } for i, test := range tests { fakeKeyring := &credentialprovider.FakeKeyring{} fakeClient := &FakeDockerClient{ Errors: map[string]error{"pull": test.err}, } puller := &dockerPuller{ client: fakeClient, keyring: fakeKeyring, } err := puller.Pull(test.imageName, []api.Secret{}) if err == nil || !strings.Contains(err.Error(), test.expectedError) { t.Errorf("%d: expect error %s, got : %s", i, test.expectedError, err) continue } } } func TestPullWithSecrets(t *testing.T) { // auth value is equivalent to: "username":"passed-user","password":"passed-password" dockerCfg := map[string]map[string]string{"index.docker.io/v1/": {"email": "passed-email", "auth": "cGFzc2VkLXVzZXI6cGFzc2VkLXBhc3N3b3Jk"}} dockercfgContent, err := json.Marshal(dockerCfg) if err != nil { t.Errorf("unexpected error: %v", err) } tests := map[string]struct { imageName string passedSecrets []api.Secret builtInDockerConfig credentialprovider.DockerConfig expectedPulls []string }{ "no matching secrets": { "ubuntu", []api.Secret{}, credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{}), []string{"ubuntu:latest using {}"}, }, "default keyring secrets": { "ubuntu", []api.Secret{}, credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{"index.docker.io/v1/": {"built-in", "password", "email"}}), []string{`ubuntu:latest using {"username":"built-in","password":"password","email":"email"}`}, }, "default keyring secrets unused": { "ubuntu", []api.Secret{}, credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{"extraneous": {"built-in", "password", "email"}}), []string{`ubuntu:latest using {}`}, }, "builtin keyring secrets, but use passed": { "ubuntu", []api.Secret{{Type: api.SecretTypeDockercfg, Data: map[string][]byte{api.DockerConfigKey: dockercfgContent}}}, credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{"index.docker.io/v1/": {"built-in", "password", "email"}}), []string{`ubuntu:latest using {"username":"passed-user","password":"passed-password","email":"passed-email"}`}, }, } for _, test := range tests { builtInKeyRing := &credentialprovider.BasicDockerKeyring{} builtInKeyRing.Add(test.builtInDockerConfig) fakeClient := &FakeDockerClient{} dp := dockerPuller{ client: fakeClient, keyring: builtInKeyRing, } err := dp.Pull(test.imageName, test.passedSecrets) if err != nil { t.Errorf("unexpected non-nil err: %s", err) continue } if e, a := 1, len(fakeClient.pulled); e != a { t.Errorf("%s: expected 1 pulled image, got %d: %v", test.imageName, a, fakeClient.pulled) continue } if e, a := test.expectedPulls, fakeClient.pulled; !reflect.DeepEqual(e, a) { t.Errorf("%s: expected pull of %v, but got %v", test.imageName, e, a) } } } func TestDockerKeyringLookupFails(t *testing.T) { fakeKeyring := &credentialprovider.FakeKeyring{} fakeClient := &FakeDockerClient{ Errors: map[string]error{"pull": fmt.Errorf("test error")}, } dp := dockerPuller{ client: fakeClient, keyring: fakeKeyring, } err := dp.Pull("host/repository/image:version", []api.Secret{}) if err == nil { t.Errorf("unexpected non-error") } msg := "image pull failed for host/repository/image:version, this may be because there are no credentials on this request. details: (test error)" if err.Error() != msg { t.Errorf("expected: %s, saw: %s", msg, err.Error()) } } func TestDockerKeyringLookup(t *testing.T) { ada := docker.AuthConfiguration{ Username: "ada", Password: "smash", Email: "ada@example.com", } grace := docker.AuthConfiguration{ Username: "grace", Password: "squash", Email: "grace@example.com", } dk := &credentialprovider.BasicDockerKeyring{} dk.Add(credentialprovider.DockerConfig{ "bar.example.com/pong": credentialprovider.DockerConfigEntry{ Username: grace.Username, Password: grace.Password, Email: grace.Email, }, "bar.example.com": credentialprovider.DockerConfigEntry{ Username: ada.Username, Password: ada.Password, Email: ada.Email, }, }) tests := []struct { image string match []docker.AuthConfiguration ok bool }{ // direct match {"bar.example.com", []docker.AuthConfiguration{ada}, true}, // direct match deeper than other possible matches {"bar.example.com/pong", []docker.AuthConfiguration{grace, ada}, true}, // no direct match, deeper path ignored {"bar.example.com/ping", []docker.AuthConfiguration{ada}, true}, // match first part of path token {"bar.example.com/pongz", []docker.AuthConfiguration{grace, ada}, true}, // match regardless of sub-path {"bar.example.com/pong/pang", []docker.AuthConfiguration{grace, ada}, true}, // no host match {"example.com", []docker.AuthConfiguration{}, false}, {"foo.example.com", []docker.AuthConfiguration{}, false}, } for i, tt := range tests { match, ok := dk.Lookup(tt.image) if tt.ok != ok { t.Errorf("case %d: expected ok=%t, got %t", i, tt.ok, ok) } if !reflect.DeepEqual(tt.match, match) { t.Errorf("case %d: expected match=%#v, got %#v", i, tt.match, match) } } } // This validates that dockercfg entries with a scheme and url path are properly matched // by images that only match the hostname. // NOTE: the above covers the case of a more specific match trumping just hostname. func TestIssue3797(t *testing.T) { rex := docker.AuthConfiguration{ Username: "rex", Password: "tiny arms", Email: "rex@example.com", } dk := &credentialprovider.BasicDockerKeyring{} dk.Add(credentialprovider.DockerConfig{ "https://quay.io/v1/": credentialprovider.DockerConfigEntry{ Username: rex.Username, Password: rex.Password, Email: rex.Email, }, }) tests := []struct { image string match []docker.AuthConfiguration ok bool }{ // direct match {"quay.io", []docker.AuthConfiguration{rex}, true}, // partial matches {"quay.io/foo", []docker.AuthConfiguration{rex}, true}, {"quay.io/foo/bar", []docker.AuthConfiguration{rex}, true}, } for i, tt := range tests { match, ok := dk.Lookup(tt.image) if tt.ok != ok { t.Errorf("case %d: expected ok=%t, got %t", i, tt.ok, ok) } if !reflect.DeepEqual(tt.match, match) { t.Errorf("case %d: expected match=%#v, got %#v", i, tt.match, match) } } } type imageTrackingDockerClient struct { *FakeDockerClient imageName string } func (f *imageTrackingDockerClient) InspectImage(name string) (image *docker.Image, err error) { image, err = f.FakeDockerClient.InspectImage(name) f.imageName = name return } func TestIsImagePresent(t *testing.T) { cl := &imageTrackingDockerClient{&FakeDockerClient{}, ""} puller := &dockerPuller{ client: cl, } _, _ = puller.IsImagePresent("abc:123") if cl.imageName != "abc:123" { t.Errorf("expected inspection of image abc:123, instead inspected image %v", cl.imageName) } } type podsByID []*kubecontainer.Pod func (b podsByID) Len() int { return len(b) } func (b podsByID) Swap(i, j int) { b[i], b[j] = b[j], b[i] } func (b podsByID) Less(i, j int) bool { return b[i].ID < b[j].ID } type containersByID []*kubecontainer.Container func (b containersByID) Len() int { return len(b) } func (b containersByID) Swap(i, j int) { b[i], b[j] = b[j], b[i] } func (b containersByID) Less(i, j int) bool { return b[i].ID < b[j].ID } func TestFindContainersByPod(t *testing.T) { tests := []struct { containerList []docker.APIContainers exitedContainerList []docker.APIContainers all bool expectedPods []*kubecontainer.Pod }{ { []docker.APIContainers{ { ID: "foobar", Names: []string{"/k8s_foobar.1234_qux_ns_1234_42"}, }, { ID: "barbar", Names: []string{"/k8s_barbar.1234_qux_ns_2343_42"}, }, { ID: "baz", Names: []string{"/k8s_baz.1234_qux_ns_1234_42"}, }, }, []docker.APIContainers{ { ID: "barfoo", Names: []string{"/k8s_barfoo.1234_qux_ns_1234_42"}, }, { ID: "bazbaz", Names: []string{"/k8s_bazbaz.1234_qux_ns_5678_42"}, }, }, false, []*kubecontainer.Pod{ { ID: "1234", Name: "qux", Namespace: "ns", Containers: []*kubecontainer.Container{ { ID: "foobar", Name: "foobar", Hash: 0x1234, }, { ID: "baz", Name: "baz", Hash: 0x1234, }, }, }, { ID: "2343", Name: "qux", Namespace: "ns", Containers: []*kubecontainer.Container{ { ID: "barbar", Name: "barbar", Hash: 0x1234, }, }, }, }, }, { []docker.APIContainers{ { ID: "foobar", Names: []string{"/k8s_foobar.1234_qux_ns_1234_42"}, }, { ID: "barbar", Names: []string{"/k8s_barbar.1234_qux_ns_2343_42"}, }, { ID: "baz", Names: []string{"/k8s_baz.1234_qux_ns_1234_42"}, }, }, []docker.APIContainers{ { ID: "barfoo", Names: []string{"/k8s_barfoo.1234_qux_ns_1234_42"}, }, { ID: "bazbaz", Names: []string{"/k8s_bazbaz.1234_qux_ns_5678_42"}, }, }, true, []*kubecontainer.Pod{ { ID: "1234", Name: "qux", Namespace: "ns", Containers: []*kubecontainer.Container{ { ID: "foobar", Name: "foobar", Hash: 0x1234, }, { ID: "barfoo", Name: "barfoo", Hash: 0x1234, }, { ID: "baz", Name: "baz", Hash: 0x1234, }, }, }, { ID: "2343", Name: "qux", Namespace: "ns", Containers: []*kubecontainer.Container{ { ID: "barbar", Name: "barbar", Hash: 0x1234, }, }, }, { ID: "5678", Name: "qux", Namespace: "ns", Containers: []*kubecontainer.Container{ { ID: "bazbaz", Name: "bazbaz", Hash: 0x1234, }, }, }, }, }, { []docker.APIContainers{}, []docker.APIContainers{}, true, nil, }, } fakeClient := &FakeDockerClient{} np, _ := network.InitNetworkPlugin([]network.NetworkPlugin{}, "", network.NewFakeHost(nil)) containerManager := NewFakeDockerManager(fakeClient, &record.FakeRecorder{}, nil, nil, PodInfraContainerImage, 0, 0, "", kubecontainer.FakeOS{}, np, nil, nil, nil) for i, test := range tests { fakeClient.ContainerList = test.containerList fakeClient.ExitedContainerList = test.exitedContainerList result, _ := containerManager.GetPods(test.all) for i := range result { sort.Sort(containersByID(result[i].Containers)) } for i := range test.expectedPods { sort.Sort(containersByID(test.expectedPods[i].Containers)) } sort.Sort(podsByID(result)) sort.Sort(podsByID(test.expectedPods)) if !reflect.DeepEqual(test.expectedPods, result) { t.Errorf("%d: expected: %#v, saw: %#v", i, test.expectedPods, result) } } } func TestMakePortsAndBindings(t *testing.T) { ports := []kubecontainer.PortMapping{ { ContainerPort: 80, HostPort: 8080, HostIP: "127.0.0.1", }, { ContainerPort: 443, HostPort: 443, Protocol: "tcp", }, { ContainerPort: 444, HostPort: 444, Protocol: "udp", }, { ContainerPort: 445, HostPort: 445, Protocol: "foobar", }, } exposedPorts, bindings := makePortsAndBindings(ports) if len(ports) != len(exposedPorts) || len(ports) != len(bindings) { t.Errorf("Unexpected ports and bindings, %#v %#v %#v", ports, exposedPorts, bindings) } for key, value := range bindings { switch value[0].HostPort { case "8080": if !reflect.DeepEqual(docker.Port("80/tcp"), key) { t.Errorf("Unexpected docker port: %#v", key) } if value[0].HostIP != "127.0.0.1" { t.Errorf("Unexpected host IP: %s", value[0].HostIP) } case "443": if !reflect.DeepEqual(docker.Port("443/tcp"), key) { t.Errorf("Unexpected docker port: %#v", key) } if value[0].HostIP != "" { t.Errorf("Unexpected host IP: %s", value[0].HostIP) } case "444": if !reflect.DeepEqual(docker.Port("444/udp"), key) { t.Errorf("Unexpected docker port: %#v", key) } if value[0].HostIP != "" { t.Errorf("Unexpected host IP: %s", value[0].HostIP) } case "445": if !reflect.DeepEqual(docker.Port("445/tcp"), key) { t.Errorf("Unexpected docker port: %#v", key) } if value[0].HostIP != "" { t.Errorf("Unexpected host IP: %s", value[0].HostIP) } } } }