funcmain() {var err error ...// Example: "/var/run/docker.sock", "run" conn, err := rcli.CallTCP(os.Getenv("DOCKER"), os.Args[1:]...) ... receive_stdout := future.Go(func()error { _, err := io.Copy(os.Stdout, conn)return err }) ...}

funcmain() { ...// d is the server, it will process requests made by the user d, err := New() ...gofunc() {if err := rcli.ListenAndServeHTTP(":8080", d); err != nil { log.Fatal(err) } }()if err := rcli.ListenAndServeTCP(":4242", d); err != nil { log.Fatal(err) }}

func(srv *Server)CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string)error { flags := rcli.Subcmd(stdout, "run", "[OPTIONS] IMAGE COMMAND [ARG...]", "Run a command in a new container") ...// Choose a default image if neededif name == "" { name = "base" }// Choose a default command if needediflen(cmd) == 0 { *fl_stdin = true *fl_tty = true *fl_attach = true cmd = []string{"/bin/bash", "-i"} } ...// Find the image img := srv.images.Find(name) ...// Create Container container := srv.CreateContainer(img, *fl_tty, *fl_stdin, *fl_comment, cmd[0], cmd[1:]...) ...// Start Container container.Start() ...}

type Index struct { Path string// "/var/lib/docker/images/index.json" ByName map[string]*History ById map[string]*Image}func(index *Index)Find(idOrName string) *Image { ...// Lookup by IDif image, exists := index.ById[idOrName]; exists {return image }// Lookup by nameif history, exists := index.ByName[idOrName]; exists && history.Len() > 0 {return (*history)[0] }returnnil}

container := &Container{ // Examples Id: id, // "09906fa3" Root: root, // /var/lib/docker/containers/09906fa3/" Created: time.Now(), Path: command, // "/bin/bash" Args: args, // ["-i"] Config: config,// "/var/lib/docker/containers/09906fa3/rootfs"// "/var/lib/docker/containers/09906fa3/rw" Filesystem: newFilesystem(path.Join(root, "rootfs"), path.Join(root, "rw"), layers), State: newState(),// "/var/lib/docker/containers/09906fa3/config.lxc" lxcConfigPath: path.Join(root, "config.lxc"),stdout: newWriteBroadcaster(),stderr: newWriteBroadcaster(), stdoutLog: new(bytes.Buffer), stderrLog: new(bytes.Buffer),}...// Create directoriesos.Mkdir(root, 0700);container.Filesystem.createMountPoints();...// Generate LXC Config filecontainer.generateLXCConfig();

func(container *Container)Start()error {// Mount file system if not mounted container.Filesystem.EnsureMounted(); params := []string{"-n", container.Id,"-f", container.lxcConfigPath,"--", container.Path, } params = append(params, container.Args...)// /usr/bin/lxc-start -n 09906fa3 -f /var/lib/docker/containers/09906fa3/config.lxc -- /bin/bash -i container.cmd = exec.Command("/usr/bin/lxc-start", params...) ...}

func(fs *Filesystem)Mount()error { ... rwBranch := fmt.Sprintf("%v=rw", fs.RWPath) roBranches := ""for _, layer := range fs.Layers { roBranches += fmt.Sprintf("%v=ro:", layer) } branches := fmt.Sprintf("br:%v:%v", rwBranch, roBranches)// Mount the branches onto "/var/lib/docker/containers/09906fa3/rootfs" syscall.Mount("none", fs.RootFS, "aufs", 0, branches); ...}

func(container *Container)monitor() {// Wait for the program to exit container.cmd.Wait() exitCode := container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()// Cleanup container.stdout.Close() container.stderr.Close() container.Filesystem.Umount();// Report status back container.State.setStopped(exitCode) container.save()}

dockerd is sent the run command (using the command-line application or otherwise) dockerd finds the specified image on the file system A container struct is created and stored for future use Directories on the filesystemare setup foruseby the container LXC is instructed tostart the container dockerd monitors the containeruntil completion

// Container Routesfunc(r *containerRouter)initRoutes() { r.routes = []router.Route{// HEAD router.NewHeadRoute("/containers/{name:.*}/archive", r.headContainersArchive),// GET router.NewGetRoute("/containers/json", r.getContainersJSON), router.NewGetRoute("/containers/{name:.*}/export", r.getContainersExport), router.NewGetRoute("/containers/{name:.*}/changes", r.getContainersChanges), ... }}

funcrunContainer(dockerCli command.Cli, opts *runOptions, copts *containerOptions, containerConfig *containerConfig)error { ...// Create the container createResponse = createContainer(ctx, dockerCli, containerConfig, &opts.createOptions) ...// Start the container client.ContainerStart(ctx, createResponse.ID, types.ContainerStartOptions{}); ...}

func (daemon *Daemon) create(opts createOpts) (retC *container.Container, retErr error) { ...// Find the Image img = daemon.imageService.GetImage(params.Config.Image) ...// Create container object container = daemon.newContainer(opts.params.Name, os, opts.params.Config, opts.params.HostConfig, imgID, opts.managed); ...// Set RWLayer for container after mount labels have been set rwLayer = daemon.imageService.CreateLayer(container, setupInitLayer(daemon.idMapping)) container.RWLayer = rwLayer ...// Create root directory idtools.MkdirAndChown(container.Root, 0700, rootIDs); ...// Windows or Linux specific setup daemon.createContainerOSSpecificSettings(container, opts.params.Config, opts.params.HostConfig); ...// Store in a map for future lookup daemon.Register(container); ...}

func(daemon *Daemon)containerStart(container *container.Container, checkpoint string, checkpointDir string, resetRestartManager bool)(err error) { ...// Create OCI spec for container spec = daemon.createSpec(container); ...// Call containerd to create the container according to spec daemon.containerd.Create(ctx, container.ID, spec, createOptions) ...// Call containerd to start running process inside of container pid = daemon.containerd.Start(context.Background(), container.ID, checkpointDir, container.StreamConfig.Stdin() != nil || container.Config.Tty, container.InitializeStdio); ...}

func(l *local)Create(ctx context.Context, req *api.CreateContainerRequest, _ ...grpc.CallOption)(*api.CreateContainerResponse, error) { l.withStoreUpdate(ctx, func(ctx context.Context, store containers.Store)error {// Update container data store with new container record container := containerFromProto(&req.Container) created := store.Create(ctx, container) resp.Container = containerToProto(&created)returnnil }); ...}

// Start create and start a task for the specified containerd idfunc(c *client)Start(ctx context.Context, id, checkpointDir string, withStdin bool, attachStdio libcontainerdtypes.StdioCallback)(int, error) { ctr, err := c.getContainer(ctx, id) ... t, err = ctr.NewTask(ctx, ...) ... t.Start(ctx); ...returnint(t.Pid()), nil}

func (l *local) Create(ctxcontext.Context, r *api.CreateTaskRequest, _ ...grpc.CallOption) (*api.CreateTaskResponse, error) {container := l.getContainer(ctx, r.ContainerID) ... rtime l.getRuntime(container.Runtime.Name) ... c = rtime.Create(ctx, r.ContainerID, opts) ...}

var createCommand = cli.Command{ Name: "create", Description: `The create command creates an instance of a container for a bundle. The bundleis a directory with a specification file named "` + specConfig + `" and a rootfilesystem.`, ... Action: func(context *cli.Context)error { spec := setupSpec(context) ... status := startContainer(context, spec, CT_ACT_CREATE, nil)// exit with the container's exit status so any external supervisor is// notified of the exit with the correct exit status. os.Exit(status)returnnil },

var startCommand = cli.Command{ Name: "start", Usage: "executes the user defined process in a created container", ... Action: func(context *cli.Context)error { container := getContainer(context) status := container.Status() ...switch status {case libcontainer.Created:return container.Exec()case libcontainer.Stopped:return errors.New("cannot start a container that has stopped")case libcontainer.Running:return errors.New("cannot start an already running container") } },}