func()

in pkg/transformer/kubernetes/kubernetes.go [1346:1514]
130 lines of code
31 McCabe index (conditional complexity)

func (k *Kubernetes) Transform(komposeObject kobject.KomposeObject, opt kobject.ConvertOptions) ([]runtime.Object, error) {
	// this will hold all the converted data
	var allobjects []runtime.Object

	if komposeObject.Secrets != nil {
		secrets, err := k.CreateSecrets(komposeObject)
		if err != nil {
			return nil, errors.Wrapf(err, "Unable to create Secret resource")
		}
		for _, item := range secrets {
			allobjects = append(allobjects, item)
		}
	}
	if opt.ServiceGroupMode != "" {
		log.Debugf("Service group mode is: %s", opt.ServiceGroupMode)
		komposeObjectToServiceConfigGroupMapping := KomposeObjectToServiceConfigGroupMapping(&komposeObject, opt)
		for name, group := range komposeObjectToServiceConfigGroupMapping {
			var objects []runtime.Object
			podSpec := PodSpec{}

			// if using volume group, the name here will be a volume config string. reset to the first service name
			if opt.ServiceGroupMode == "volume" {
				if opt.ServiceGroupName != "" {
					name = opt.ServiceGroupName
				} else {
					var names []string
					for _, svc := range group {
						names = append(names, svc.Name)
					}
					name = strings.Join(names, "-")
				}
			}

			// added a container
			// ports conflict check between services
			portsUses := map[string]bool{}

			for _, service := range group {
				// first do ports check
				ports := ConfigPorts(service)
				for _, port := range ports {
					key := string(port.ContainerPort) + string(port.Protocol)
					if portsUses[key] {
						return nil, fmt.Errorf("detect ports conflict when group services, service: %s, port: %d", service.Name, port.ContainerPort)
					}
					portsUses[key] = true
				}

				log.Infof("Group Service %s to [%s]", service.Name, name)
				service.WithKomposeAnnotation = opt.WithKomposeAnnotation
				podSpec.Append(AddContainer(service, opt))

				if err := buildServiceImage(opt, service, service.Name); err != nil {
					return nil, err
				}
				// override..
				objects = append(objects, k.CreateWorkloadAndConfigMapObjects(name, service, opt)...)
				k.configKubeServiceAndIngressForService(service, name, &objects)

				// Configure the container volumes.
				volumesMount, volumes, pvc, cms, err := k.ConfigVolumes(name, service)
				if err != nil {
					return nil, errors.Wrap(err, "k.ConfigVolumes failed")
				}
				// Configure Tmpfs
				if len(service.TmpFs) > 0 {
					TmpVolumesMount, TmpVolumes := k.ConfigTmpfs(name, service)
					volumes = append(volumes, TmpVolumes...)
					volumesMount = append(volumesMount, TmpVolumesMount...)
				}
				podSpec.Append(
					SetVolumeMounts(volumesMount),
					SetVolumes(volumes),
				)

				if pvc != nil {
					// Looping on the slice pvc instead of `*objects = append(*objects, pvc...)`
					// because the type of objects and pvc is different, but when doing append
					// one element at a time it gets converted to runtime.Object for objects slice
					for _, p := range pvc {
						objects = append(objects, p)
					}
				}

				if cms != nil {
					for _, c := range cms {
						objects = append(objects, c)
					}
				}

				podSpec.Append(
					SetPorts(service),
					ImagePullPolicy(name, service),
					RestartPolicy(name, service),
					SecurityContext(name, service),
					HostName(service),
					DomainName(service),
					ResourcesLimits(service),
					ResourcesRequests(service),
					TerminationGracePeriodSeconds(name, service),
					TopologySpreadConstraints(service),
				)

				if serviceAccountName, ok := service.Labels[compose.LabelServiceAccountName]; ok {
					podSpec.Append(ServiceAccountName(serviceAccountName))
				}

				err = k.UpdateKubernetesObjectsMultipleContainers(name, service, &objects, podSpec)
				if err != nil {
					return nil, errors.Wrap(err, "Error transforming Kubernetes objects")
				}

				if err = k.configNetworkPolicyForService(service, service.Name, &objects); err != nil {
					return nil, err
				}
			}

			allobjects = append(allobjects, objects...)
		}
	}
	sortedKeys := SortedKeys(komposeObject)
	for _, name := range sortedKeys {
		service := komposeObject.ServiceConfigs[name]

		// if service belongs to a group, we already processed it
		if service.InGroup {
			continue
		}

		var objects []runtime.Object

		service.WithKomposeAnnotation = opt.WithKomposeAnnotation

		if err := buildServiceImage(opt, service, name); err != nil {
			return nil, err
		}

		// Generate pod only and nothing more
		if (service.Restart == "no" || service.Restart == "on-failure") && !opt.IsPodController() {
			log.Infof("Create kubernetes pod instead of pod controller due to restart policy: %s", service.Restart)
			pod := k.InitPod(name, service)
			objects = append(objects, pod)
		} else {
			objects = k.CreateWorkloadAndConfigMapObjects(name, service, opt)
		}

		if opt.Controller == StatefulStateController {
			service.ServiceType = "Headless"
		}
		k.configKubeServiceAndIngressForService(service, name, &objects)

		err := k.UpdateKubernetesObjects(name, service, opt, &objects)
		if err != nil {
			return nil, errors.Wrap(err, "Error transforming Kubernetes objects")
		}

		if err := k.configNetworkPolicyForService(service, name, &objects); err != nil {
			return nil, err
		}
		allobjects = append(allobjects, objects...)
	}

	// sort all object so Services are first
	k.SortServicesFirst(&allobjects)
	k.RemoveDupObjects(&allobjects)
	// k.FixWorkloadVersion(&allobjects)

	return allobjects, nil
}