docker命令之rmi

1 man docker-rmi

NAME

       docker-rmi - Remove one or more images.

SYNOPSIS
       docker rmi [-f|--force[=false] IMAGE [IMAGE...]

DESCRIPTION
       This  will  remove  one  or  more  images from the host node.  This does not remove images from a registry.  You cannot
       remove an image of a running container unless you use the -f option.  To see all images on a host use the docker images
       command.

OPTIONS

       -f, --force=true|false When set to true, force the removal of the image.  The default is false.

2 代码分析

docker rmi 

CmdRmi(api/client/command.go) ---> deleteImages(api/server/server.go) --->  srv.ImageDelete (server/server.go)

CmdRmi和deleteImages省略，主要分析srv.ImageDelete部分

在srv.ImageDelete中调用server的方法srv.DeleteImage完成镜像的删除工作。

创建一张表，用于存储删除镜像的信息，将这些信息显示在标准输出上

imgs := engine.NewTable("", 0)

支持具体删除任务的方法

if err := srv.DeleteImage(job.Args[0], imgs, true, job.GetenvBool("force"), job.GetenvBool("noprune")); err != nil {
		return job.Error(err)
	}

将删除镜像的信息显示在标准输出上

if _, err := imgs.WriteListTo(job.Stdout); err != nil {
		return job.Error(err)
	}

srv.DeleteImage(server/server.go)分析

参数：

job.Args[0]:删除镜像名

imgs:删除结果信息

true（first）：

job.GetenvBool("force")：参数 -f|--force

job.GetenvBool("noprune")：参数 

本地变量初始化

var (
		repoName, tag string
		tags          = []string{}
		tagDeleted    bool
	)

从镜像名name中解析出repo名和tag信息，如果name中没有tag信息，使用默认的latest tag

repoName, tag = utils.ParseRepositoryTag(name)
	if tag == "" {
		tag = graph.DEFAULTTAG
	}

在graph中查找此name的镜像是否存在，如果没有查到，说明 此name的镜像不存在。

img, err := srv.daemon.Repositories().LookupImage(name)
	if err != nil {
		if r, _ := srv.daemon.Repositories().Get(repoName); r != nil {
			return fmt.Errorf("No such image: %s:%s", repoName, tag)
		}
		return fmt.Errorf("No such image: %s", name)
	}

如果镜像的ID中包含了name，说明是按镜像的ID删除，就不是用repoName和tag删除，所以将repoName和tag清空。

if strings.Contains(img.ID, name) {
		repoName = ""
		tag = ""
	}

找到此镜像的所有父镜像

byParents, err := srv.daemon.Graph().ByParent()
	if err != nil {
		return err
	}

如果是安装镜像ID删除，要对镜像的镜像树中的进行是否只属于此name的镜像做判断，如果镜像树中的镜像不只属于此镜像，

并且不是强制删除，报错。如果repoName不空，将此镜像所有tag加入到tags列表中。

if repoName == "" {
		for _, repoAndTag := range srv.daemon.Repositories().ByID()[img.ID] {
			parsedRepo, parsedTag := utils.ParseRepositoryTag(repoAndTag)
			if repoName == "" || repoName == parsedRepo {
				repoName = parsedRepo
				if parsedTag != "" {
					tags = append(tags, parsedTag)
				}
			} else if repoName != parsedRepo && !force {
				// the id belongs to multiple repos, like base:latest and user:test,
				// in that case return conflict
				return fmt.Errorf("Conflict, cannot delete image %s because it is tagged in multiple repositories, use -f to force", name)
			}
		}
	} else {
		tags = append(tags, tag)
	}

？？？？？？？？

if !first && len(tags) > 0 {
		return nil
	}

删除tags列表中镜像的tag

for _, tag := range tags {
		tagDeleted, err = srv.daemon.Repositories().Delete(repoName, tag)
		if err != nil {
			return err
		}
		if tagDeleted {
			out := &engine.Env{}
			out.Set("Untagged", repoName+":"+tag)
			imgs.Add(out)
			srv.LogEvent("untag", img.ID, "")
		}
	}

如果有Container在使用镜像，则不能删除，否则可以删除。由于记录镜像信息分布在registry和graph中，需要在这两部分都做删除相应的信息。

如果镜像有父镜像，对父镜像做删除操作。

if (len(tags) <= 1 && repoName == "") || len(tags) == 0 {
		if len(byParents[img.ID]) == 0 {
			if err := srv.canDeleteImage(img.ID, force, tagDeleted); err != nil {
				return err
			}
			if err := srv.daemon.Repositories().DeleteAll(img.ID); err != nil {
				return err
			}
			if err := srv.daemon.Graph().Delete(img.ID); err != nil {
				return err
			}
			out := &engine.Env{}
			out.Set("Deleted", img.ID)
			imgs.Add(out)
			srv.LogEvent("delete", img.ID, "")
			if img.Parent != "" && !noprune {
				err := srv.DeleteImage(img.Parent, imgs, false, force, noprune)
				if first {
					return err
				}

			}

		}
	}

/var/lib/docker/
├── aufs                                       # Storage area for AUFS driver
│   ├── diff                                   # Branch directory of layer
│   ├── layers                                 # Infomation about docker layer
│   └── mnt                                    # Mount point of aufs, root of containers
├── containers                                 # Container configurations
│                                                (both LXC and Docker-specific)
├── graph                                      # Storage for the images
├── init
│   └── dockerinit-0.7.3                       # Used as /sbin/init in containers
├── linkgraph.db                               # SQLite database storing links
│                                                and names.
├── lxc-start-unconfined -> /usr/bin/lxc-start # When starting a privileged
│                                                container, this is used in
│                                                lieu of lxc-start, to evade
│                                                AppArmor confinement (which
│                                                matches by exact path).
├── repositories-aufs                          # repository infomation
└── volumes                                    # Storage for "anonymous" volumes
                                                 (those which are not bind-mounts)