Docker-Version hängt vor Server-Info

Einführung

Ich versuche, die folgende Version von dockerauf einer Linux-VM zu verwenden ( uname -aRückkehr Linux xen 4.1.17-yocto-standard #1 SMP PREEMPT Thu Jun 2 13:29:47 PDT 2016 x86_64 GNU/Linux)aus dem docker_gitBitBake-Rezept) .

Wenn ich versuche zu laufen docker version, erhalte ich folgende Ausgabe:

Client version: 1.6.2 Client API version: 1.18 Go version (client): go1.3 Git commit (client): 7c8fca2-dirty OS/Arch (client): linux/amd64 

Dann hängt der Befehl.

Wie es aussehen soll

Ich habe versucht, docker versionauf einer funktionierenden Docker-Installation (Ubuntu 14.04) auszuführen, und erhalte folgende Ausgabe:

Client version: 1.6.2 Client API version: 1.18 Go version (client): go1.2.1 Git commit (client): 7c8fca2 OS/Arch (client): linux/amd64 Server version: 1.6.2 Server API version: 1.18 Go version (server): go1.2.1 Git commit (server): 7c8fca2 OS/Arch (server): linux/amd64 

Ich gehe also davon aus, dass beim Abrufen von Serverinformationen eine Art Fehler auftritt.

Zusätzliche Forschung

Ich bin mit Go nicht vertraut, daher könnte dieser Abschnitt erschütternd sein, während ich versuche herauszufinden, was zum Teufel hier vor sich geht.

Ich habe mir diesen Teil des api/client/version.goDocker-Quellcodes angesehen:

var versionTemplate = `Client: Version: {{.Client.Version}} API version: {{.Client.APIVersion}} Go version: {{.Client.GoVersion}} Git commit: {{.Client.GitCommit}} Built: {{.Client.BuildTime}} OS/Arch: {{.Client.Os}}/{{.Client.Arch}}{} Experimental: {{.Client.Experimental}}{}{} Server: Version: {{.Server.Version}} API version: {{.Server.APIVersion}} Go version: {{.Server.GoVersion}} Git commit: {{.Server.GitCommit}} Built: {{.Server.BuildTime}} OS/Arch: {{.Server.Os}}/{{.Server.Arch}}{} Experimental: {{.Server.Experimental}}{}{}` 

es geht weiter zu diesem Abschnitt:

vd := types.VersionResponse{ Client: &types.Version{ Version: dockerversion.Version, APIVersion: cli.client.ClientVersion(), GoVersion: runtime.Version(), GitCommit: dockerversion.GitCommit, BuildTime: dockerversion.BuildTime, Os: runtime.GOOS, Arch: runtime.GOARCH, Experimental: utils.ExperimentalBuild(), }, } 

Von engine-api/types/client.go:

// VersionResponse holds version information for the client and the server type VersionResponse struct { Client *Version Server *Version }  

Zu diesem Zeitpunkt müssen Sie also nur noch etwas dem ServerMember (vom Typ *Version) zuweisen . Dies geschieht im Abschnitt nach der vdZuweisung von oben:

serverVersion, err := cli.client.ServerVersion(context.Background()) if err == nil { vd.Server = &serverVersion } 

Die Funktionsdefinition für ServerVersionlautet wie folgt ausengine-api/client/version.go

// ServerVersion returns information of the docker client and server host. func (cli *Client) ServerVersion(ctx context.Context) (types.Version, error) { resp, err := cli.get(ctx, "/version", nil, nil) if err != nil { return types.Version{}, err }  var server types.Version err = json.NewDecoder(resp.body).Decode(&server) ensureReaderClosed(resp) return server, err } 

Aus dem, was ich entnehmen kann, weist der obige getFunktionsaufruf auf client/request.goDockers engine APIRepo hin

// getWithContext sends an http request to the docker API using the method GET with a specific go context. func (cli *Client) get(ctx context.Context, path string, query url.Values, headers map[string][]string) (*serverResponse, error) { return cli.sendRequest(ctx, "GET", path, query, nil, headers) } 

Woher:

• ctx ist context.Background()
• path ist /version
• Nein query
• Nein headers

Und diese Dokumentation für sendRequestvon vendor/src/google.golang.org/grpc/call.go:

// sendRequest writes out various information of an RPC such as Context and Message. func sendRequest(ctx context.Context, codec Codec, callHdr *transport.CallHdr, t transport.ClientTransport, args interface{}, opts *transport.Options) (_ *transport.Stream, err error) { stream, err := t.NewStream(ctx, callHdr) if err != nil { return nil, err } defer func() { if err != nil { if _, ok := err.(transport.ConnectionError); !ok { t.CloseStream(stream, err) } } }() // TODO(zhaoq): Support compression. outBuf, err := encode(codec, args, compressionNone) if err != nil { return nil, transport.StreamErrorf(codes.Internal, "grpc: %v", err) } err = t.Write(stream, outBuf, opts) if err != nil { return nil, err } // Sent successfully. return stream, nil } 

Das war eine Zeit lang Vermutung, und ich bin jetzt besorgt, dass ich vielleicht am falschen Ort suchen könnte.

Fragen

• Was verursacht docker version, docker run hello-world, docker images, docker ps, und docker infohängen und wie sie behoben werden?
• Gibt es eine effektivere Möglichkeit, die Ursache dieses Fehlers zu untersuchen?