func()

in graph/task.go [249:358]
85 lines of code
27 McCabe index (conditional complexity)

func (t *Task) initialize(ctx context.Context) error {
	newDefaultNetworkName := DefaultNetworkName
	addDefaultNetworkToSteps := false

	// Default the Task's to the latest version if it's unspecified.
	if t.Version == "" {
		t.Version = currentTaskVersion
	}
	if err := validateTaskVersion(t.Version); err != nil {
		return err
	}

	// Reverse iterate the list to get the default network
	for i := len(t.Networks) - 1; i >= 0; i-- {
		network := t.Networks[i]
		if network.IsDefault {
			newDefaultNetworkName = network.Name
			addDefaultNetworkToSteps = true
			break
		}
	}

	// Add the default network if none are specified.
	// Only add the default network if we're using tasks.
	if !t.IsBuildTask && len(t.Networks) == 0 {
		defaultNetwork, err := NewNetwork(newDefaultNetworkName, false, "bridge", false, true)
		if err != nil {
			return err
		}
		if runtime.GOOS == util.WindowsOS {
			defaultNetwork.Driver = "nat"
		}
		t.Networks = append(t.Networks, defaultNetwork)
		addDefaultNetworkToSteps = true
	}

	if t.StepTimeout <= 0 {
		t.StepTimeout = defaultStepTimeoutInSeconds
	}

	for i, s := range t.Steps {
		// If individual steps don't have step timeouts specified,
		// stamp the global timeout on them.
		if s.Timeout <= 0 {
			s.Timeout = t.StepTimeout
		}

		if s.RetryDelayInSeconds <= 0 {
			s.RetryDelayInSeconds = defaultStepRetryDelayInSeconds
		}

		if addDefaultNetworkToSteps && s.Network == "" {
			s.Network = newDefaultNetworkName
		}

		newEnvs, err := mergeEnvs(s.Envs, t.Envs)
		if err != nil {
			return errors.Wrap(err, "failed to merge task and step environment variables")
		}
		s.Envs = newEnvs

		if s.ID == "" {
			s.ID = fmt.Sprintf("acb_step_%d", i)
		}

		// Override the step's working directory to be the parent's working directory.
		if s.WorkingDirectory == "" && t.WorkingDirectory != "" {
			s.WorkingDirectory = t.WorkingDirectory
		}

		// Initialize a completion channel for each step.
		if s.CompletedChan == nil {
			s.CompletedChan = make(chan bool)
		}

		// Mark the step as skipped initially
		s.StepStatus = Skipped

		if s.IsBuildStep() {
			if len(s.Tags) == 0 {
				s.Tags = util.ParseTags(s.Build)
			}
			s.BuildArgs = util.ParseBuildArgs(s.Build)

			if s.UseBuildCacheForBuildStep() {
				if runtime.GOOS == util.LinuxOS {
					if buildStepWithBuildCache, err := s.GetCmdWithCacheFlags(t.TaskName, t.Registry); err != nil {
						log.Printf("error creating build cache command %v\n", err)
					} else {
						// update the Build cmd with buildx cache flags
						s.Build = buildStepWithBuildCache
						t.InitBuildkitContainer = true
					}
				} else {
					log.Println("build cache is not supported on windows. Will use standard docker build")
				}
			}
		} else if s.IsPushStep() {
			s.Push = getNormalizedDockerImageNames(s.Push)
		}
	}
	var err error

	t.RegistryLoginCredentials, err = ResolveCustomRegistryCredentials(ctx, t.Credentials)
	if err != nil {
		return err
	}
	t.Dag, err = NewDagFromTask(t)
	return err
}