Method Create

core/runtime/v2/task_manager.go:159–275

Create launches new shim instance and creates new task

(ctx context.Context, taskID string, opts runtime.CreateOpts)

// Create launches new shim instance and creates new task
func (m *TaskManager) Create(ctx context.Context, taskID string, opts runtime.CreateOpts) (_ runtime.Task, retErr error) {
	bundle, err := NewBundle(ctx, m.root, m.state, taskID, opts.Spec)
	if err != nil {
		return nil, err
	}
	defer func() {
		if retErr != nil {
			bundle.Delete()
		}
	}()

	log.G(ctx).WithFields(log.Fields{
		"id":      taskID,
		"runtime": opts.Runtime,
	}).Debug("creating task")

	activateOpts := []mount.ActivateOpt{
		mount.WithLabels(map[string]string{
			"containerd.io/gc.bref.container": taskID,
		}),
	}
	if info, err := m.manager.loadShimInfo(ctx, opts.Runtime); err == nil {
		for _, t := range info.handledMounts {
			activateOpts = append(activateOpts, mount.WithAllowMountType(t))
		}
	} else {
		log.G(ctx).WithError(err).WithField("runtime", opts.Runtime).Error("failed to load runtime info")
	}

	// Add options based on runtime
	if ai, err := m.mounts.Activate(ctx, taskID, opts.Rootfs, activateOpts...); err == nil {
		opts.Rootfs = ai.System
		defer func() {
			if retErr != nil {
				dctx, cancel := timeout.WithContext(context.WithoutCancel(ctx), cleanupTimeout)
				defer cancel()
				if err := m.mounts.Deactivate(dctx, taskID); err != nil {
					log.G(ctx).WithError(err).WithField("task", taskID).Errorf("failed to deactivate mounts")
				}
			}
		}()
	} else if errdefs.IsAlreadyExists(err) {
		// If creation of task with same identifier, use existing mount rather than forcing
		// deactivation of the old one. The back reference will prevent racing between
		// deactivation and re-use, as the container with the same ID would still exist.
		ai, err = m.mounts.Info(ctx, taskID)
		if err != nil {
			return nil, fmt.Errorf("failed to get info on already active mount: %w", err)
		}
		opts.Rootfs = ai.System
	} else if !errdefs.IsNotImplemented(err) {
		return nil, err
	}

	shim, err := m.manager.Start(ctx, taskID, bundle, opts)
	if err != nil {
		return nil, fmt.Errorf("failed to start shim: %w", err)
	}