Method runPreStartHook

pkg/compose/pre_start.go:75–123

(
	ctx context.Context, project *types.Project, service types.ServiceConfig,
	ctr container.Summary, index int, hook types.ServiceHook, listener api.ContainerEventListener,
)

}

func (s *composeService) runPreStartHook(
	ctx context.Context, project *types.Project, service types.ServiceConfig,
	ctr container.Summary, index int, hook types.ServiceHook, listener api.ContainerEventListener,
) error {
	created, err := s.createPreStartContainer(ctx, project, service, ctr, hook)
	if err != nil {
		return err
	}

	// Subscribe to wait before start to avoid missing the exit event for short-lived hooks.
	// WaitConditionNotRunning would match immediately because the container is still in
	// "created" state, so use WaitConditionNextExit to block until the run actually finishes.
	waitRes := s.apiClient().ContainerWait(ctx, created.ID, client.ContainerWaitOptions{
		Condition: container.WaitConditionNextExit,
	})

	// Open the log stream before ContainerStart so AutoRemove cannot race us
	// to a 404 on a fast-exiting hook. The dedicated logCtx lets us force the
	// follow stream closed once the hook has exited, so a daemon that keeps
	// the connection open cannot deadlock `<-logsDone`.
	logCtx, cancelLogs := context.WithCancel(ctx)
	defer cancelLogs()
	logsDone := s.streamPreStartLogs(logCtx, created.ID, service, index, listener)

	if _, err := s.apiClient().ContainerStart(ctx, created.ID, client.ContainerStartOptions{}); err != nil {
		// AutoRemove only fires after a successful start, so the never-started
		// container has to be dropped explicitly. A failed removal is logged
		// at warn level — without that hint the orphan is only discoverable
		// via the project/service labels.
		if _, removeErr := s.apiClient().ContainerRemove(ctx, created.ID, client.ContainerRemoveOptions{Force: true}); removeErr != nil {
			logrus.Warnf("service %q pre_start[%d]: failed to remove orphan hook container %s: %v", service.Name, index, created.ID, removeErr)
		}
		// Drain waitRes so the client's wait goroutine exits without having to
		// wait for the parent context to be canceled.
		select {
		case <-waitRes.Error:
		case <-waitRes.Result:
		case <-ctx.Done():
		}
		cancelLogs()
		<-logsDone
		return err
	}

	waitErr := waitPreStart(ctx, service.Name, index, waitRes)
	cancelLogs()
	<-logsDone
	return waitErr
}

func (s *composeService) createPreStartContainer(
	ctx context.Context, project *types.Project, service types.ServiceConfig,