delete.go#Action

  1.     Action: func(context *cli.Context) error {
  2.         if err := checkArgs(context, 1, exactArgs); err != nil {
  3.             return err
  4.         }
  6.         id := context.Args().First()
  7.         force := context.Bool("force")
  8.         container, err := getContainer(context)
  9.         if err != nil {
  10.             if lerr, ok := err.(libcontainer.Error); ok && lerr.Code() == libcontainer.ContainerNotExists {
  11.                 // if there was an aborted start or something of the sort then the container's directory could exist but
  12.                 // libcontainer does not see it because the state.json file inside that directory was never created.
  13.                 path := filepath.Join(context.GlobalString("root"), id)
  14.                 if e := os.RemoveAll(path); e != nil {
  15.                     fmt.Fprintf(os.Stderr, "remove %s: %v\n", path, e)
  16.                 }
  17.                 if force {
  18.                     return nil
  19.                 }
  20.             }
  21.             return err
  22.         }
  23.         s, err := container.Status()
  24.         if err != nil {
  25.             return err
  26.         }
  27.         switch s {
  28.         case libcontainer.Stopped:
  29.             destroy(container)
  30.         case libcontainer.Created:
  31.             return killContainer(container)
  32.         default:
  33.             if force {
  34.                 return killContainer(container)
  35.             }
  36.             return fmt.Errorf("cannot delete container %s that is not stopped: %s\n", id, s)
  37.         }
  39.         return nil
  40.     },

A) Stopped

1) utils_linux.go#destroy

  2. func destroy(container libcontainer.Container) {
  3.     if err := container.Destroy(); err != nil {
  4.         logrus.Error(err)
  5.     }
  6. }

1.1) libcontainer/container_linux.go#Destroy

  1. func (c *linuxContainer) Destroy() error {
  2.     c.m.Lock()
  3.     defer c.m.Unlock()
  4.     return c.state.destroy()
  5. }
  7. type containerState interface {
  8.     transition(containerState) error
  9.     destroy() error
  10.     status() Status
  11. }

1.1.1) libcontainer/state_linux.go#stoppedState.destroy

  1. func (b *stoppedState) destroy() error {
  2.     return destroy(b.c)
  3. }

1.1.1.1) libcontainer/state_linux.go#destroy

  1. func destroy(c *linuxContainer) error {
  2.     if !c.config.Namespaces.Contains(configs.NEWPID) {
  3.         if err := signalAllProcesses(c.cgroupManager, unix.SIGKILL); err != nil {
  4.             logrus.Warn(err)
  5.         }
  6.     }
  7.     err := c.cgroupManager.Destroy()
  8.     if c.intelRdtManager != nil {
  9.         if ierr := c.intelRdtManager.Destroy(); err == nil {
  10.             err = ierr
  11.         }
  12.     }
  13.     if rerr := os.RemoveAll(c.root); err == nil {
  14.         err = rerr
  15.     }
  16.     c.initProcess = nil
  17.     if herr := runPoststopHooks(c); err == nil {
  18.         err = herr
  19.     }
  20.     c.state = &stoppedState{c: c}
  21.     return err
  22. }

B) Created

1) delete.go#killContainer

  1. func killContainer(container libcontainer.Container) error {
  2.     _ = container.Signal(unix.SIGKILL, false)
  3.     for i := 0; i < 100; i++ {
  4.         time.Sleep(100 * time.Millisecond)
  5.         if err := container.Signal(syscall.Signal(0), false); err != nil {
  6.             destroy(container)
  7.             return nil
  8.         }
  9.     }
  10.     return fmt.Errorf("container init still running")
  11. }

1.1) libcontainer/container_linux.go#Destroy

  1. func (c *linuxContainer) Destroy() error {
  2.     c.m.Lock()
  3.     defer c.m.Unlock()
  4.     return c.state.destroy()
  5. }
  7. type containerState interface {
  8.     transition(containerState) error
  9.     destroy() error
  10.     status() Status
  11. }

1.1.1) libcontainer/state_linux.go#createdState.destroy

  1. func (i *createdState) destroy() error {
  2.     i.c.initProcess.signal(unix.SIGKILL)
  3.     return destroy(i.c)
  4. }