func getDockerOptions()

in internal/core/container.go [284:436]
141 lines of code
17 McCabe index (conditional complexity)

func getDockerOptions(c corescan.Context, image string) *backend.ContainerCreateConfig {
	cmdOpts := GetIdeArgs(c)

	updateScanContextEnv := func(key string, value string) { c = c.WithEnvExtractedFromOsEnv(key, value) }
	qdenv.ExtractQodanaEnvironment(updateScanContextEnv)

	dockerEnv := c.Env()
	qodanaCloudUploadToken := c.QodanaUploadToken()
	if qodanaCloudUploadToken != "" {
		dockerEnv = append(dockerEnv, fmt.Sprintf("%s=%s", qdenv.QodanaToken, qodanaCloudUploadToken))
	}
	qodanaLicenseOnlyToken := os.Getenv(qdenv.QodanaLicenseOnlyToken)
	if qodanaLicenseOnlyToken != "" && qodanaCloudUploadToken == "" {
		dockerEnv = append(dockerEnv, fmt.Sprintf("%s=%s", qdenv.QodanaLicenseOnlyToken, qodanaLicenseOnlyToken))
	}

	cachePath, err := filepath.Abs(c.CacheDir())
	if err != nil {
		log.Fatal("couldn't get abs path for cache", err)
	}
	repositoryRootPath, err := filepath.Abs(c.RepositoryRoot())
	if err != nil {
		log.Fatal("couldn't get abs path for project", err)
	}
	resultsPath, err := filepath.Abs(c.ResultsDir())
	if err != nil {
		log.Fatal("couldn't get abs path for results", err)
	}
	reportPath, err := filepath.Abs(c.ReportDir())
	if err != nil {
		log.Fatal("couldn't get abs path for report", err)
	}
	containerName = os.Getenv(qdenv.QodanaCliContainerName)
	if containerName == "" {
		containerName = fmt.Sprintf("qodana-cli-%s", c.Id())
	}
	volumes := []mount.Mount{
		{
			Type:   mount.TypeBind,
			Source: cachePath,
			Target: qdcontainer.DataCacheDir,
		},
		{
			Type:   mount.TypeBind,
			Source: repositoryRootPath,
			Target: qdcontainer.MountDir,
		},
		{
			Type:   mount.TypeBind,
			Source: resultsPath,
			Target: qdcontainer.DataResultsDir,
		},
		{
			Type:   mount.TypeBind,
			Source: reportPath,
			Target: qdcontainer.DataResultsReportDir,
		},
	}
	if c.GlobalConfigurationsDir() != "" {
		globalConfigDirAbsPath, err := filepath.Abs(c.GlobalConfigurationsDir())
		if err != nil {
			log.Fatalf(
				"Failed to get absolute path for global configurations file %s: %s",
				c.GlobalConfigurationsDir(),
				err,
			)
		}
		volumes = append(
			volumes, mount.Mount{
				Type:   mount.TypeBind,
				Source: globalConfigDirAbsPath,
				Target: qdcontainer.DataGlobalConfigDir,
			},
		)
	}
	for _, volume := range c.Volumes() {
		source, target := extractDockerVolumes(volume)
		if source != "" && target != "" {
			volumes = append(
				volumes, mount.Mount{
					Type:   mount.TypeBind,
					Source: source,
					Target: target,
				},
			)
		} else {
			log.Fatal("couldn't parse volume ", volume)
		}
	}
	log.Debugf("image: %s", image)
	log.Debugf("container name: %s", containerName)
	log.Debugf("user: %s", c.User())
	log.Debugf("volumes: %v", volumes)
	log.Debugf("cmd: %v", cmdOpts)

	portBindings := make(nat.PortMap)
	exposedPorts := make(nat.PortSet)

	if c.JvmDebugPort() > 0 {
		log.Infof("Enabling JVM debug on port %d", c.JvmDebugPort())
		portBindings = nat.PortMap{
			containerJvmDebugPort: []nat.PortBinding{
				{
					HostIP:   "0.0.0.0",
					HostPort: strconv.Itoa(c.JvmDebugPort()),
				},
			},
		}
		exposedPorts = nat.PortSet{
			containerJvmDebugPort: struct{}{},
		}
	}

	var capAdd []string
	var securityOpt []string
	var networkMode container.NetworkMode

	if strings.Contains(image, "dotnet") {
		capAdd = []string{"SYS_PTRACE"}
		securityOpt = []string{"seccomp=unconfined"}
	}

	// See QD-11584 for reasoning
	//goland:noinspection HttpUrlsUsage
	isLocalHttpCloud := strings.HasPrefix(cloud.GetCloudRootEndpoint().Url, "http://")
	if isLocalHttpCloud {
		networkMode = network.NetworkHost
	}

	var hostConfig = &container.HostConfig{
		AutoRemove:   os.Getenv(qdenv.QodanaCliContainerKeep) == "",
		Mounts:       volumes,
		CapAdd:       capAdd,
		SecurityOpt:  securityOpt,
		PortBindings: portBindings,
		NetworkMode:  networkMode,
	}

	return &backend.ContainerCreateConfig{
		Name: containerName,
		Config: &container.Config{
			Image:        image,
			Cmd:          cmdOpts,
			Tty:          msg.IsInteractive(),
			AttachStdout: true,
			AttachStderr: true,
			Env:          dockerEnv,
			User:         selectUser(image, c.User()),
			ExposedPorts: exposedPorts,
		},
		HostConfig: hostConfig,
	}
}