Method RunOneOffContainer

pkg/compose/run.go:44–89

(ctx context.Context, project *types.Project, opts api.RunOptions)

}

func (s *composeService) RunOneOffContainer(ctx context.Context, project *types.Project, opts api.RunOptions) (int, error) {
	result, err := s.prepareRun(ctx, project, opts)
	if err != nil {
		return 0, err
	}

	// remove cancellable context signal handler so we can forward signals to container without compose exiting
	signal.Reset()

	sigc := make(chan os.Signal, 128)
	signal.Notify(sigc)
	go cmd.ForwardAllSignals(ctx, s.apiClient(), result.containerID, sigc)
	defer signal.Stop(sigc)

	// If the service has post_start hooks, set up a goroutine that waits for
	// the container to start and then executes them. This is needed because
	// cmd.RunStart both starts and attaches to the container in one call,
	// so we can't run hooks sequentially between start and attach.
	var hookErrCh chan error
	if len(result.service.PostStart) > 0 {
		hookErrCh = make(chan error, 1)
		go func() {
			hookErrCh <- s.runPostStartHooksOnEvent(ctx, result.containerID, result.service, result.created)
		}()
	}

	err = cmd.RunStart(ctx, s.dockerCli, &cmd.StartOptions{
		OpenStdin:  !opts.Detach && opts.Interactive,
		Attach:     !opts.Detach,
		Containers: []string{result.containerID},
		DetachKeys: s.configFile().DetachKeys,
	})

	// Wait for hooks to complete if they were started
	if hookErrCh != nil {
		if hookErr := <-hookErrCh; hookErr != nil && err == nil {
			err = hookErr
		}
	}

	var stErr cli.StatusError
	if errors.As(err, &stErr) {
		return stErr.StatusCode, nil
	}
	return 0, err
}

// runPostStartHooksOnEvent listens for the container's start event and executes
// post_start lifecycle hooks once the container is running.