docker 源码分析 四（基于1.8.2版本），Docker镜像的获取和存储

前段时间一直忙些其他事情，docker源码分析的事情耽搁了，今天接着写，上一章了解了docker client 和 docker daemon（会启动一个http server）是C/S的结构，client端发出的命令由docker daemon接收并处理。

我们在运行docker的时候，可能会使用到docker run命令（当然通过Dockerfile运行docker build命令也是一样的）时，如果本地没有你需要的镜像，docker daemon首先会去下载你需要的docker镜像，然后存储在本地；另外docker 镜像其实是一个很神奇的东西，它有多个层（layer）构成，每一个层的上一层是本层的父亲层（parent layer）。最上层（top layer）是可读可写层，用户对镜像的更新在这一层起作用，top layer之下的层都是只读层；这种实现方式其实也是一种文件系统，UnionFS。

本文就从上一章的结尾，分析一下docker pull 命令的实现，就是docker 怎样下载镜像并怎样存储的；

docker run的客户端命令所在文件是api/client/pull.go 下：

func (cli *DockerCli) CmdPull(args ...string) error {

cmd := Cli.Subcmd("pull", []string{"NAME[:TAG|@DIGEST]"}, "Pull an image or a repository from a registry", true)

allTags := cmd.Bool([]string{"a", "-all-tags"}, false, "Download all tagged images in the repository")

addTrustedFlags(cmd, true)

cmd.Require(flag.Exact, 1)

cmd.ParseFlags(args, true)

remote := cmd.Arg(0)

taglessRemote, tag := parsers.ParseRepositoryTag(remote)

if tag == "" && !*allTags {

tag = tags.DefaultTag

fmt.Fprintf(cli.out, "Using default tag: %s\n", tag)

} else if tag != "" && *allTags {

return fmt.Errorf("tag can't be used with --all-tags/-a")

}

ref := registry.ParseReference(tag)

// Resolve the Repository name from fqn to RepositoryInfo

repoInfo, err := registry.ParseRepositoryInfo(taglessRemote)

if err != nil {

return err

}

if isTrusted() && !ref.HasDigest() {

// Check if tag is digest

authConfig := registry.ResolveAuthConfig(cli.configFile, repoInfo.Index)

return cli.trustedPull(repoInfo, ref, authConfig)

}

v := url.Values{}

v.Set("fromImage", ref.ImageName(taglessRemote))

_, _, err = cli.clientRequestAttemptLogin("POST", "/images/create?"+v.Encode(), nil, cli.out, repoInfo.Index, "pull")

return err

}

ParseRepositoryTag(pkg/parsers/parsers.go)的作用就是从输入的pull 后面的字符串中提取出tag名字和剩下的部分，叫taglessRemote，

举个例子：

(a) api.example.com/ubuntu:10.04 会被拆分成 api.example.com/ubuntu 和 10.04 两个部分；

(b) ubuntu:10.04 会被拆分成 ubunu 和 10.04 两个部分；

(c) api.example.com@sha256:bc8813ea7b3603864987522f02a76101c17ad122e1c46d790efc0fca78ca7bfb 还有一种digest（我理解就是对镜像生成的摘要）的形式，sha256是生成digest的方法；

这种包含@ 的形式会 分割成@左右两个部分，就是api.example.com 和 sha256：xxx...

如果分离出的tag为空 并且 alltags flag的值也为空的话（两者不能同时不为空），那么tag就会取默认值，默认值是latest；

ref := registry.ParseReference(tag) (registry/reference.go)的作用就是将分离出的tag 转成成内部的tagReference或者digestReference的形式;

repoInfo, err := registry.ParseRepositoryInfo(taglessRemote) (registry/config.go)的作用就是将taglessRemote转成RepositoryInfo的struct；

RepositoryInfo (registry/types.go)的结构如下，是用来描述一个镜像除了tag之外的部分，可能包括url路径：

type RepositoryInfo struct {

Index *IndexInfo             //registry 信息

RemoteName string         //"library/ubuntu-12.04-base"

LocalName string             //"ubuntu-12.04-base"

CanonicalName string      //"docker.io/library/ubuntu-12.04-base"

Official bool                    //像ubuntu的名字就是true，像xxx/ubuntu这种名字就是false；

}

这三种name之间的区别就如代码的注释中的一样，Index 也是一个表示registry信息的struct (registry/types.go)，里面主要包括的name（registry的名字，例如官方docker.io），mirrors表示这个registry的镜像，表现为就是一个url的list；

源码中有几个repositoryInfo的例子也许能更直观点：

// RepositoryInfo Examples:

// {

//   "Index" : {

//     "Name" : "docker.io",

//     "Mirrors" : ["https://registry-2.docker.io/v1/", "https://registry-3.docker.io/v1/"],

//     "Secure" : true,

//     "Official" : true,

//   },

//   "RemoteName" : "library/debian",

//   "LocalName" : "debian",

//   "CanonicalName" : "docker.io/debian"

//   "Official" : true,

// }

//

// {

//   "Index" : {

//     "Name" : "127.0.0.1:5000",

//     "Mirrors" : [],

//     "Secure" : false,

//     "Official" : false,

//   },

//   "RemoteName" : "user/repo",

//   "LocalName" : "127.0.0.1:5000/user/repo",

//   "CanonicalName" : "127.0.0.1:5000/user/repo",

//   "Official" : false,

// }

如果稍后docker daemon要访问的registry 需要验证，则通过 repo.Index 和 cli.configFile (api/client/cli.go) 取出对应registry的认证信息 authConfig，autoConfig在cliconfig/config.go文件中：

type AuthConfig struct {

Username      string `json:"username,omitempty"`

Password      string `json:"password,omitempty"`

Auth          string `json:"auth"`

Email         string `json:"email"`

ServerAddress string `json:"serveraddress,omitempty"`

}

接着调用trustedPull (api/client/trust.go)方法，最终trustPull方法也会通过restful API来调用

_, _, err = cli.clientRequestAttemptLogin("POST", "/images/create?"+v.Encode(), nil, cli.out, repoInfo.Index, "pull") 方法来将pull image的请求发送给docker server进行处理；

本系列文章的前两章中有介绍，docker server对应pull请求的handler是postImagesCreate (api/server/image.go)。

// Creates an image from Pull or from Import

func (s *Server) postImagesCreate(version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

.......

if image != "" { //pull

if tag == "" {

image, tag = parsers.ParseRepositoryTag(image)

}

metaHeaders := map[string][]string{}

for k, v := range r.Header {

if strings.HasPrefix(k, "X-Meta-") {

metaHeaders[k] = v

}

}

imagePullConfig := &graph.ImagePullConfig{

MetaHeaders: metaHeaders,

AuthConfig:  authConfig,

OutStream:   output,

}

err = s.daemon.Repositories().Pull(image, tag, imagePullConfig)

} else { //import

if tag == "" {

repo, tag = parsers.ParseRepositoryTag(repo)

}

src := r.Form.Get("fromSrc")

// 'err' MUST NOT be defined within this block, we need any error

// generated from the download to be available to the output

// stream processing below

var newConfig *runconfig.Config

newConfig, err = builder.BuildFromConfig(s.daemon, &runconfig.Config{}, r.Form["changes"])

if err != nil {

return err

}

err = s.daemon.Repositories().Import(src, repo, tag, message, r.Body, output, newConfig)

}

if err != nil {

if !output.Flushed() {

return err

}

sf := streamformatter.NewJSONStreamFormatter()

output.Write(sf.FormatError(err))

}

return nil

}

postImagesCreate函数只截取重要的部分，这里省略号的部分主要是从http request中提取出image名称等参数，当image不为空的时候，由于docker server也需要与 docker registry 通过http交互来下载docker网络镜像，所以首先封装了 imagePullConfig 参数，在与registry通信的时候使用。接下来调用

err = s.daemon.Repositories().Pull(image, tag, imagePullConfig)

s.daemon.Repositories() (daemon/daemon.go) 是*graph.TagStore (graph/tags.go)类型, TagStore是一个比较重要的类型: 它保存着Graph用来完成对镜像的存储，管理着各种repository，同时pullingPool 和 pushingPool 保证同一个时间段只能有一个相同的镜像被下载和上传；

type TagStore struct {

path  string

graph *Graph

// Repositories is a map of repositories, indexed by name.

Repositories map[string]Repository

trustKey     libtrust.PrivateKey

sync.Mutex

// FIXME: move push/pull-related fields

// to a helper type

pullingPool     map[string]chan struct{}

pushingPool     map[string]chan struct{}

registryService *registry.Service

eventsService   *events.Events

trustService    *trust.Store

}

接着是 TagStore的Pull()方法，

func (s *TagStore) Pull(image string, tag string, imagePullConfig *ImagePullConfig) error {

......

for _, endpoint := range endpoints {

logrus.Debugf("Trying to pull %s from %s %s", repoInfo.LocalName, endpoint.URL, endpoint.Version)

if !endpoint.Mirror && (endpoint.Official || endpoint.Version == registry.APIVersion2) {

if repoInfo.Official {

s.trustService.UpdateBase()

}

}

puller, err := NewPuller(s, endpoint, repoInfo, imagePullConfig, sf)

if err != nil {

lastErr = err

continue

}

if fallback, err := puller.Pull(tag); err != nil {

if fallback {

if _, ok := err.(registry.ErrNoSupport); !ok {

// Because we found an error that's not ErrNoSupport, discard all subsequent ErrNoSupport errors.

discardNoSupportErrors = true

// save the current error

lastErr = err

} else if !discardNoSupportErrors {

// Save the ErrNoSupport error, because it's either the first error or all encountered errors

// were also ErrNoSupport errors.

lastErr = err

}

continue

}

logrus.Debugf("Not continuing with error: %v", err)

return err

}

s.eventsService.Log("pull", logName, "")

return nil

}

......

}

还是截取主要的部分，函数最开始的部分主要是通过TagStore中的registryService，通过传入的image找到repositoryInfo，然后通过repositoryInfo找到下载镜像的endpoint；

接下来针对每一个endpoint，建立一个Puller：puller, err := NewPuller(s, endpoint, repoInfo, imagePullConfig, sf) 开始拉取镜像；sf就是个jsonformatter；

NewPuller会根据endpoint的形式（endpoint应该遵循restful api的设计，url中含有版本号），决定采用version1还是version2版本，我主要分析v2的版本，在graph/pull_v2.go中:

func (p *v2Puller) Pull(tag string) (fallback bool, err error) {

// TODO(tiborvass): was ReceiveTimeout

p.repo, err = NewV2Repository(p.repoInfo, p.endpoint, p.config.MetaHeaders, p.config.AuthConfig)

if err != nil {

logrus.Debugf("Error getting v2 registry: %v", err)

return true, err

}

p.sessionID = stringid.GenerateRandomID()

if err := p.pullV2Repository(tag); err != nil {

if registry.ContinueOnError(err) {

logrus.Debugf("Error trying v2 registry: %v", err)

return true, err

}

return false, err

}

return false, nil

}

最主要的函数是pullV2Repository()函数，同样在graph/pull_v2.go目录下：

func (p *v2Puller) pullV2Repository(tag string) (err error) {

var tags []string

taggedName := p.repoInfo.LocalName

if len(tag) > 0 {

tags = []string{tag}

taggedName = utils.ImageReference(p.repoInfo.LocalName, tag)

} else {

var err error

manSvc, err := p.repo.Manifests(context.Background())

if err != nil {

return err

}

tags, err = manSvc.Tags()

if err != nil {

return err

}

}

c, err := p.poolAdd("pull", taggedName)

if err != nil {

if c != nil {

// Another pull of the same repository is already taking place; just wait for it to finish

p.config.OutStream.Write(p.sf.FormatStatus("", "Repository %s already being pulled by another client. Waiting.", p.repoInfo.CanonicalName))

<-c

return nil

}

return err

}

defer p.poolRemove("pull", taggedName)

var layersDownloaded bool

for _, tag := range tags {

// pulledNew is true if either new layers were downloaded OR if existing images were newly tagged

// TODO(tiborvass): should we change the name of `layersDownload`? What about message in WriteStatus?

pulledNew, err := p.pullV2Tag(tag, taggedName)

if err != nil {

return err

}

layersDownloaded = layersDownloaded || pulledNew

}

writeStatus(taggedName, p.config.OutStream, p.sf, layersDownloaded)

return nil

}

首先获得tagName，通过manifest获得tags清单，一个repository可能对应着多个tag，docker的镜像呈现的是树形关系，比如ubuntu是一个repository，实际的存储情况是可能会有一个基础镜像base，这个基础镜像上，增加一些新的内容（实际上就是增加一个新的读写层，写入东西进去）就会形成新的镜像，比如：ubuntu:12.12是一个镜像，那么ubuntu:14.01是在前者基础上进行若干修改操作而形成的新的镜像；所以要下载ubuntu:14.01这个镜像的话，必须要将其父镜像完全下载下来，这样下载之后的镜像才是完整的；

看一下 c, err := p.poolAdd("pull", taggedName)  (graph/tags.go文件)这个函数：

func (store *TagStore) poolAdd(kind, key string) (chan struct{}, error) {

store.Lock()

defer store.Unlock()

if c, exists := store.pullingPool[key]; exists {

return c, fmt.Errorf("pull %s is already in progress", key)

}

if c, exists := store.pushingPool[key]; exists {

return c, fmt.Errorf("push %s is already in progress", key)

}

c := make(chan struct{})

switch kind {

case "pull":

store.pullingPool[key] = c

case "push":

store.pushingPool[key] = c

default:

return nil, fmt.Errorf("Unknown pool type")

}

return c, nil

}

这个tagStore的函数之前提到过，就是保证同一时刻，只能有一个tag在上传或者下载；当下载完成后，会调用 defer p.poolRemove("pull", taggedName) 将这个限制打开；接下来就是实际下载的函数 pullV2Tag 了，是一段很长的代码：

func (p *v2Puller) pullV2Tag(tag, taggedName string) (verified bool, err error) {

logrus.Debugf("Pulling tag from V2 registry: %q", tag)

//

out := p.config.OutStream

manSvc, err := p.repo.Manifests(context.Background())

if err != nil {

return false, err

}

manifest, err := manSvc.GetByTag(tag)

if err != nil {

return false, err

}

verified, err = p.validateManifest(manifest, tag)

if err != nil {

return false, err

}

if verified {

logrus.Printf("Image manifest for %s has been verified", taggedName)

}

pipeReader, pipeWriter := io.Pipe()

go func() {

if _, err := io.Copy(out, pipeReader); err != nil {

logrus.Errorf("error copying from layer download progress reader: %s", err)

if err := pipeReader.CloseWithError(err); err != nil {

logrus.Errorf("error closing the progress reader: %s", err)

}

}

}()

defer func() {

if err != nil {

// All operations on the pipe are synchronous. This call will wait

// until all current readers/writers are done using the pipe then

// set the error. All successive reads/writes will return with this

// error.

pipeWriter.CloseWithError(errors.New("download canceled"))

}

}()

out.Write(p.sf.FormatStatus(tag, "Pulling from %s", p.repo.Name()))

var downloads []*downloadInfo

var layerIDs []string

defer func() {

p.graph.Release(p.sessionID, layerIDs...)

}()

for i := len(manifest.FSLayers) - 1; i >= 0; i-- {

img, err := image.NewImgJSON([]byte(manifest.History[i].V1Compatibility))

if err != nil {

logrus.Debugf("error getting image v1 json: %v", err)

return false, err

}

p.graph.Retain(p.sessionID, img.ID)

layerIDs = append(layerIDs, img.ID)

// Check if exists

if p.graph.Exists(img.ID) {

logrus.Debugf("Image already exists: %s", img.ID)

out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), "Already exists", nil))

continue

}

out.Write(p.sf.FormatProgress(stringid.TruncateID(img.ID), "Pulling fs layer", nil))

d := &downloadInfo{

img:    img,

digest: manifest.FSLayers[i].BlobSum,

// TODO: seems like this chan buffer solved hanging problem in go1.5,

// this can indicate some deeper problem that somehow we never take

// error from channel in loop below

err: make(chan error, 1),

out: pipeWriter,

}

downloads = append(downloads, d)

go p.download(d)

}

// run clean for all downloads to prevent leftovers

for _, d := range downloads {

defer func(d *downloadInfo) {

if d.tmpFile != nil {

d.tmpFile.Close()

if err := os.RemoveAll(d.tmpFile.Name()); err != nil {

logrus.Errorf("Failed to remove temp file: %s", d.tmpFile.Name())

}

}

}(d)

}

var tagUpdated bool

for _, d := range downloads {

if err := <-d.err; err != nil {

return false, err

}

if d.layer == nil {

continue

}

// if tmpFile is empty assume download and extracted elsewhere

d.tmpFile.Seek(0, 0)

reader := progressreader.New(progressreader.Config{

In:        d.tmpFile,

Out:       out,

Formatter: p.sf,

Size:      d.size,

NewLines:  false,

ID:        stringid.TruncateID(d.img.ID),

Action:    "Extracting",

})

err = p.graph.Register(d.img, reader)

if err != nil {

return false, err

}

// FIXME: Pool release here for parallel tag pull (ensures any downloads block until fully extracted)

out.Write(p.sf.FormatProgress(stringid.TruncateID(d.img.ID), "Pull complete", nil))

tagUpdated = true

}

manifestDigest, _, err := digestFromManifest(manifest, p.repoInfo.LocalName)

if err != nil {

return false, err

}

// Check for new tag if no layers downloaded

if !tagUpdated {

repo, err := p.Get(p.repoInfo.LocalName)

if err != nil {

return false, err

}

if repo != nil {

if _, exists := repo[tag]; !exists {

tagUpdated = true

}

} else {

tagUpdated = true

}

}

if verified && tagUpdated {

out.Write(p.sf.FormatStatus(p.repo.Name()+":"+tag, "The image you are pulling has been verified. Important: image verification is a tech preview feature and should  not be relied on to provide security."))

}

firstID := layerIDs[len(layerIDs)-1]

if utils.DigestReference(tag) {

// TODO(stevvooe): Ideally, we should always set the digest so we can

// use the digest whether we pull by it or not. Unfortunately, the tag

// store treats the digest as a separate tag, meaning there may be an

// untagged digest image that would seem to be dangling by a user.

if err = p.SetDigest(p.repoInfo.LocalName, tag, firstID); err != nil {

return false, err

}

} else {

// only set the repository/tag -> image ID mapping when pulling by tag (i.e. not by digest)

if err = p.Tag(p.repoInfo.LocalName, tag, firstID, true); err != nil {

return false, err

}

}

if manifestDigest != "" {

out.Write(p.sf.FormatStatus("", "Digest: %s", manifestDigest))

}

return tagUpdated, nil

}

讲重点部分，先从manifest中获取(这个过程也是通过http去endpoint那里获取)出这个tag对应的所有image，我理解就是image和其所有父镜像，然后for循环进行遍历：

for i := len(manifest.FSLayers) - 1; i >= 0; i-- {

img, err := image.NewImgJSON([]byte(manifest.History[i].V1Compatibility))

if err != nil {

logrus.Debugf("error getting image v1 json: %v", err)

return false, err

}

p.graph.Retain(p.sessionID, img.ID)

layerIDs = append(layerIDs, img.ID)

......

另外附上Manifest的结构：

type Manifest struct {

Versioned

// Name is the name of the image's repository

Name string `json:"name"`

// Tag is the tag of the image specified by this manifest

Tag string `json:"tag"`

// Architecture is the host architecture on which this image is intended to

// run

Architecture string `json:"architecture"`

// FSLayers is a list of filesystem layer blobSums contained in this image

FSLayers []FSLayer `json:"fsLayers"`

// History is a list of unstructured historical data for v1 compatibility

History []History `json:"history"`

}

docker中的每一个镜像，由两部分组成，一部分是镜像的实际的数据内容，另一部分是镜像对应的json文件，json文件中有镜像的ID，同时json数据的"config"这个key中还会记录这个镜像的一些动态信息，例如：设置的环境变量，运行的命令等等。image的信息就是在image/image.go中。

接着会调用p.graph (graph/graph.go)，graph维持着不同版本的镜像文件和他们之间的关系，这里面的driver默认是aufs.go   (daemon/graphdriver/aufs/aufs.go)

type Graph struct {

root             string

idIndex          *truncindex.TruncIndex

driver           graphdriver.Driver

imageMutex       imageMutex // protect images in driver.

retained         *retainedLayers

tarSplitDisabled bool

}

下载之前先将

p.graph.Retain(p.sessionID, img.ID)

将sessionID 和 img.ID加入到 graph的数据结构

type retainedLayers struct {

layerHolders map[string]map[string]struct{} // map[layerID]map[sessionID]

sync.Mutex

}

这个结构维护着哪些imageId已经被下载过；如果if p.graph.Exists(img.ID)  为true，说明这个镜像被下载过，直接continue，否则将这个镜像加入下载的downloadInfo里面去去；然后  go p.download(d) 开始下载镜像，下载镜像的过程首先根据之前说到的TagStore判断是不是有同样的镜像在下载过程中，如果没有调用ioutil.TempFile()将镜像内容下载到临时文件；函数结束后，会defer的函数对tempfile进行清理；

最后一个主要步骤是在graph注册image的id和内容；

err = p.graph.Register(d.img, reader)   (graph/graph.go)

func (graph *Graph) Register(img *image.Image, layerData io.Reader) (err error) {

if err := image.ValidateID(img.ID); err != nil {

return err

}

graph.imageMutex.Lock(img.ID)

defer graph.imageMutex.Unlock(img.ID)

// Skip register if image is already registered

if graph.Exists(img.ID) {

return nil

}

defer func() {

// If any error occurs, remove the new dir from the driver.

// Don't check for errors since the dir might not have been created.

if err != nil {

graph.driver.Remove(img.ID)

}

}()

if err := os.RemoveAll(graph.imageRoot(img.ID)); err != nil && !os.IsNotExist(err) {

return err

}

graph.driver.Remove(img.ID)

tmp, err := graph.mktemp("")

defer os.RemoveAll(tmp)

if err != nil {

return fmt.Errorf("mktemp failed: %s", err)

}

// Create root filesystem in the driver

if err := createRootFilesystemInDriver(graph, img, layerData); err != nil {

return err

}

// Apply the diff/layer

if err := graph.storeImage(img, layerData, tmp); err != nil {

return err

}

// Commit

if err := os.Rename(tmp, graph.imageRoot(img.ID)); err != nil {

return err

}

graph.idIndex.Add(img.ID)

return nil

}

首先是验证graph是否已经注册过image，如果已经注册过image，那么直接返回nil 退出；接着删除已有的路径，稍后会说，docker存储镜像的时候会新建几个目录，

graph.imageRoot(img.ID) 这个目录是 /var/lib/docker/graph/imageID， 这个路径下每一个文件夹名称是一个imageID，在docker daemon 初始化的时候，会生成新的graph 实例，graph实例会通过restore()方法(graph/graph.go)根据目录下的内容来加载已有的镜像；

graph.driver.Remove(img.ID) graph包含driver，这里用aufs举例，文件存储在/var/lib/docker/aufs目录下，这个目录下会有三个文件夹 mnt, layers, diff。每一个目录下都会有一个以镜像ID为名称的文件，mnt下面存放的是以这个镜像为可读写层的挂载点；layers存储这以这个镜像的所有的祖先镜像的ID列表，diff存储这个镜像的实际的文件系统中的内容；

在删除了可能残留的目录后，开始建立新的目录， createRootFilesystemInDriver(graph, img, layerData)，调用driver的Create函数(daemon/graphdriver/aufs/aufs.go)，

func (a *Driver) Create(id, parent string) error {

if err := a.createDirsFor(id); err != nil {

return err

}

// Write the layers metadata

f, err := os.Create(path.Join(a.rootPath(), "layers", id))

if err != nil {

return err

}

defer f.Close()

if parent != "" {

ids, err := getParentIds(a.rootPath(), parent)

if err != nil {

return err

}

if _, err := fmt.Fprintln(f, parent); err != nil {

return err

}

for _, i := range ids {

if _, err := fmt.Fprintln(f, i); err != nil {

return err

}

}

}

return nil

}

通过createDirsFor创建mnt/imageID和diff/imageID两个文件夹，然后建立layers/imageID的文件，然后将parentID和parent的祖先ID列表写入到这个文件；

接下来对实际的镜像的实际内容进行存储，graph.storeImage(img, layerData, tmp)，storeImage函数(graph/graph.go):

func (graph *Graph) storeImage(img *image.Image, layerData io.Reader, root string) (err error) {

// Store the layer. If layerData is not nil, unpack it into the new layer

if layerData != nil {

if err := graph.disassembleAndApplyTarLayer(img, layerData, root); err != nil {

return err

}

}

if err := graph.saveSize(root, img.Size); err != nil {

return err

}

f, err := os.OpenFile(jsonPath(root), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.FileMode(0600))

if err != nil {

return err

}

defer f.Close()

return json.NewEncoder(f).Encode(img)

}

disassembleAndApplyTarLayer将下载下来的img解压到/var/lib/docker/aufs/diff/imageID中，接下来将镜像的大小也存储为一个文件，存储的地点是通过这句函数tmp, err := graph.mktemp("")建立的临时目录/var/lib/docker/graph/tmp_xxxxx中，

文件名是layersize，接下来存储image的json数据，存储的位置也是在临时目录中的文件名为json的文件；

再这些数据都存储完之后，调用os.Rename(tmp, graph.imageRoot(img.ID)) 将之前的临时目录/var/lib/docker/graph/tmp_xxxxx 改成 /var/lib/docker/graph/imageID

Register函数的最后一步是 graph.idIndex.Add(img.ID) ，将ID加入idIndex，idIndex是一个trie结构，为了方便用户根据镜像的前缀来方便的查找镜像；

docker的镜像pull就先写到这儿，下一篇趁热打铁，分析一个docker run的秘密；