func runCopy(dockerCli *client.DockerCli, opts copyOptions) error {
	srcContainer, srcPath := splitCpArg(opts.source)
	dstContainer, dstPath := splitCpArg(opts.destination)
	var direction copyDirection
	if srcContainer != "" {
		direction |= fromContainer
	}
	if dstContainer != "" {
		direction |= toContainer
	}
	cpParam := &cpConfig{
		followLink: opts.followLink,
	}
	ctx := context.Background()
	switch direction {
	case fromContainer:
		return copyFromContainer(ctx, dockerCli, srcContainer, srcPath, dstPath, cpParam)
	case toContainer:
		return copyToContainer(ctx, dockerCli, srcPath, dstContainer, dstPath, cpParam)
	case acrossContainers:
		// Copying between containers isn't supported.
		return fmt.Errorf("copying between containers is not supported")
	default:
		// User didn't specify any container.
		return fmt.Errorf("must specify at least one container source")
	}
}

func runRun(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *runOptions, copts *runconfigopts.ContainerOptions) error {
	stdout, stderr, stdin := dockerCli.Out(), dockerCli.Err(), dockerCli.In()
	client := dockerCli.Client()
	// TODO: pass this as an argument
	cmdPath := "run"
	......
	//***1.8.3中只有config, hostConfig，现在多了一个networkingConfig***//
	//***config, hostConfig和networkingConfig详见docker inspect的结果***//
	config, hostConfig, networkingConfig, err := runconfigopts.Parse(flags, copts)
	// just in case the Parse does not exit
	if err != nil {
		reportError(stderr, cmdPath, err.Error(), true)
		return cli.StatusError{StatusCode: 125}
	}
	if hostConfig.OomKillDisable != nil && *hostConfig.OomKillDisable && hostConfig.Memory == 0 {
		fmt.Fprintf(stderr, "WARNING: Disabling the OOM killer on containers without setting a '-m/--memory' limit may be dangerous.\n")
	}
	//***检测DNS是否合法***//
	if len(hostConfig.DNS) > 0 {
		// check the DNS settings passed via --dns against
		// localhost regexp to warn if they are trying to
		// set a DNS to a localhost address
		for _, dnsIP := range hostConfig.DNS {
			if dns.IsLocalhost(dnsIP) {
				fmt.Fprintf(stderr, "WARNING: Localhost DNS setting (--dns=%s) may fail in containers.\n", dnsIP)
				break
			}
		}
	}
	......
	//***WithCancel context***//
	ctx, cancelFun := context.WithCancel(context.Background())
	//***create container***//
	createResponse, err := createContainer(ctx, dockerCli, config, hostConfig, networkingConfig, hostConfig.ContainerIDFile, opts.name)
	......
	//***处理attach相关的参数***//
	attach := config.AttachStdin || config.AttachStdout || config.AttachStderr
	if attach {
		......
	}
	//***defer这种形式的用法第一次见到，可以学着用下***//
	//***如需auto remove，在defer中remove container***//
	if opts.autoRemove {
		defer func() {
			// Explicitly not sharing the context as it could be "Done" (by calling cancelFun)
			// and thus the container would not be removed.
			if err := removeContainer(dockerCli, context.Background(), createResponse.ID, true, false, true); err != nil {
				fmt.Fprintf(stderr, "%v\n", err)
			}
		}()
	}
	//start the container
	//***Fankang***//
	//***start container***//
	if err := client.ContainerStart(ctx, createResponse.ID, types.ContainerStartOptions{}); err != nil {
		......
	}
	......
}

type DockerManager struct {
	client              DockerInterface
	recorder            record.EventRecorder
	containerRefManager *kubecontainer.RefManager
	os                  kubecontainer.OSInterface
	machineInfo         *cadvisorapi.MachineInfo
	// The image name of the pod infra container.
	podInfraContainerImage string
	// (Optional) Additional environment variables to be set for the pod infra container.
	podInfraContainerEnv []api.EnvVar
	// TODO(yifan): Record the pull failure so we can eliminate the image checking?
	// Lower level docker image puller.
	dockerPuller DockerPuller
	// wrapped image puller.
	imagePuller images.ImageManager
	// Root of the Docker runtime.
	dockerRoot string
	// cgroup driver used by Docker runtime.
	cgroupDriver string
	// Directory of container logs.
	containerLogsDir string
	// Network plugin.
	networkPlugin network.NetworkPlugin
	// Health check results.
	//***livenessManager为liveness检测结果***//
	livenessManager proberesults.Manager
	// RuntimeHelper that wraps kubelet to generate runtime container options.
	runtimeHelper kubecontainer.RuntimeHelper
	// Runner of lifecycle events.
	runner kubecontainer.HandlerRunner
	// Handler used to execute commands in containers.
	//***Fankang***//
	//***在容器中执行命令***//
	execHandler ExecHandler
	// Used to set OOM scores of processes.
	oomAdjuster *oom.OOMAdjuster
	// Get information from /proc mount.
	procFs procfs.ProcFSInterface
	// If true, enforce container cpu limits with CFS quota support
	cpuCFSQuota bool
	// Container GC manager
	//***container回收器***//
	containerGC *containerGC
	// Support for gathering custom metrics.
	enableCustomMetrics bool
	// If true, the "hairpin mode" flag is set on container interfaces.
	// A false value means the kubelet just backs off from setting it,
	// it might already be true.
	configureHairpinMode bool
	// Provides image stats
	//***Fankang***//
	//***镜像信息提供者***//
	*imageStatsProvider
	// The version cache of docker daemon.
	versionCache *cache.ObjectCache
	// Directory to host local seccomp profiles.
	seccompProfileRoot string
}

type basicManager struct {
	// Protects all internal maps.
	lock sync.RWMutex
	//***UID与pod的映射***//
	// Regular pods indexed by UID.
	podByUID map[types.UID]*api.Pod
	// Mirror pods indexed by UID.
	mirrorPodByUID map[types.UID]*api.Pod
	//***FullName与pod的映射***//
	// Pods indexed by full name for easy access.
	podByFullName       map[string]*api.Pod
	mirrorPodByFullName map[string]*api.Pod
	// Mirror pod UID to pod UID map.
	translationByUID map[types.UID]types.UID
	// A mirror pod client to create/delete mirror pods.
	MirrorClient
}

type actualStateOfWorld struct {
	// nodeName is the name of this node. This value is passed to Attach/Detach
	nodeName types.NodeName
	// attachedVolumes is a map containing the set of volumes the kubelet volume
	// manager believes to be successfully attached to this node. Volume types
	// that do not implement an attacher interface are assumed to be in this
	// state by default.
	// The key in this map is the name of the volume and the value is an object
	// containing more information about the attached volume.
	//***记录volume被attached***//
	attachedVolumes map[api.UniqueVolumeName]attachedVolume
	// volumePluginMgr is the volume plugin manager used to create volume
	// plugin objects.
	volumePluginMgr *volume.VolumePluginMgr
	sync.RWMutex
}

//***此updates就是PodConfig中的updates***//
func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate) {
	......
	kl.syncLoop(updates, kl)
}