func ConvertPodSpecToTaskConfig()

in pkg/common/api/api_converter.go [1233:1351]
103 lines of code
17 McCabe index (conditional complexity)

func ConvertPodSpecToTaskConfig(spec *pod.PodSpec) (*task.TaskConfig, error) {
	if len(spec.GetContainers()) > 1 {
		return nil,
			yarpcerrors.UnimplementedErrorf("configuration of more than one container per pod is not supported")
	}

	if len(spec.GetInitContainers()) > 0 {
		return nil,
			yarpcerrors.UnimplementedErrorf("init containers are not supported")
	}

	result := &task.TaskConfig{
		Controller:             spec.GetController(),
		KillGracePeriodSeconds: spec.GetKillGracePeriodSeconds(),
		Revocable:              spec.GetRevocable(),
	}

	var mainContainer *pod.ContainerSpec
	if len(spec.GetContainers()) > 0 {
		mainContainer = spec.GetContainers()[0]
		result.Container = ConvertPodSpecToMesosContainer(spec)
		result.Command = ConvertPodSpecToMesosCommand(spec)
		result.Executor = ConvertPodSpecToMesosExecutorInfo(spec)
	}

	result.Name = mainContainer.GetName()

	if spec.GetLabels() != nil {
		var labels []*peloton.Label
		for _, label := range spec.GetLabels() {
			labels = append(labels, &peloton.Label{
				Key: label.GetKey(), Value: label.GetValue(),
			})
		}
		result.Labels = labels
	}

	if mainContainer.GetResource() != nil {
		result.Resource = &task.ResourceConfig{
			CpuLimit:    mainContainer.GetResource().GetCpuLimit(),
			MemLimitMb:  mainContainer.GetResource().GetMemLimitMb(),
			DiskLimitMb: mainContainer.GetResource().GetDiskLimitMb(),
			FdLimit:     mainContainer.GetResource().GetFdLimit(),
			GpuLimit:    mainContainer.GetResource().GetGpuLimit(),
		}
	}

	if mainContainer.GetLivenessCheck() != nil {
		healthCheck := &task.HealthCheckConfig{
			Enabled:                mainContainer.GetLivenessCheck().GetEnabled(),
			InitialIntervalSecs:    mainContainer.GetLivenessCheck().GetInitialIntervalSecs(),
			IntervalSecs:           mainContainer.GetLivenessCheck().GetIntervalSecs(),
			MaxConsecutiveFailures: mainContainer.GetLivenessCheck().GetMaxConsecutiveFailures(),
			TimeoutSecs:            mainContainer.GetLivenessCheck().GetTimeoutSecs(),
			Type:                   task.HealthCheckConfig_Type(mainContainer.GetLivenessCheck().GetType()),
		}

		if mainContainer.GetLivenessCheck().GetCommandCheck() != nil {
			healthCheck.CommandCheck = &task.HealthCheckConfig_CommandCheck{
				Command:             mainContainer.GetLivenessCheck().GetCommandCheck().GetCommand(),
				UnshareEnvironments: mainContainer.GetLivenessCheck().GetCommandCheck().GetUnshareEnvironments(),
			}
		}

		if mainContainer.GetLivenessCheck().GetHttpCheck() != nil {
			healthCheck.HttpCheck = &task.HealthCheckConfig_HTTPCheck{
				Scheme: mainContainer.GetLivenessCheck().GetHttpCheck().GetScheme(),
				Port:   mainContainer.GetLivenessCheck().GetHttpCheck().GetPort(),
				Path:   mainContainer.GetLivenessCheck().GetHttpCheck().GetPath(),
			}
		}

		result.HealthCheck = healthCheck
	}

	if len(mainContainer.GetPorts()) != 0 {
		var portConfigs []*task.PortConfig
		for _, port := range mainContainer.GetPorts() {
			portConfigs = append(portConfigs, &task.PortConfig{
				Name:    port.GetName(),
				Value:   port.GetValue(),
				EnvName: port.GetEnvName(),
			})
		}
		result.Ports = portConfigs
	}

	if spec.GetConstraint() != nil {
		result.Constraint = ConvertPodConstraintsToTaskConstraints(
			[]*pod.Constraint{spec.GetConstraint()},
		)[0]
	}

	if spec.GetRestartPolicy() != nil {
		result.RestartPolicy = &task.RestartPolicy{
			MaxFailures: spec.GetRestartPolicy().GetMaxFailures(),
		}
	}

	if spec.GetVolume() != nil {
		result.Volume = &task.PersistentVolumeConfig{
			ContainerPath: spec.GetVolume().GetContainerPath(),
			SizeMB:        spec.GetVolume().GetSizeMb(),
		}
	}

	if spec.GetPreemptionPolicy() != nil {
		result.PreemptionPolicy = &task.PreemptionPolicy{
			KillOnPreempt: spec.GetPreemptionPolicy().GetKillOnPreempt(),
		}
		if result.GetPreemptionPolicy().GetKillOnPreempt() {
			result.PreemptionPolicy.Type = task.PreemptionPolicy_TYPE_PREEMPTIBLE
		} else {
			result.PreemptionPolicy.Type = task.PreemptionPolicy_TYPE_NON_PREEMPTIBLE
		}
	}

	return result, nil
}