func updateWorkspaceRule()

in deb_packages/tools/update_deb_packages/src/update_deb_packages.go [455:550]
81 lines of code
13 McCabe index (conditional complexity)

func updateWorkspaceRule(workspaceContents []byte, rule string) string {
	arch := getStringField("arch", "-", rule, workspaceContents)
	distroType := getStringField("distro_type", "-", rule, workspaceContents)
	distro := getStringField("distro", "-", rule, workspaceContents)
	mirrors := getListField("mirrors", "-", rule, workspaceContents)
	components := getListField("components", "-", rule, workspaceContents)
	packages := getMapField("packages", "-", rule, workspaceContents)
	packagesSha256 := getMapField("packages_sha256", "-", rule, workspaceContents)
	pgpKeyRuleName := getStringField("pgp_key", "-", rule, workspaceContents)

	packageNames := make([]string, 0, len(packages))
	for p := range packages {
		packageNames = append(packageNames, p)
	}
	sort.Strings(packageNames)

	packageShaNames := make([]string, 0, len(packagesSha256))
	for p := range packages {
		packageShaNames = append(packageShaNames, p)
	}
	sort.Strings(packageShaNames)
	if reflect.DeepEqual(packageNames, packageShaNames) == false {
		log.Fatalf("Mismatch between package names in packages and packages_sha256 in rule %s.\npackages: %s\npackages_sha256: %s", rule, packageNames, packageShaNames)
	}

	wd, err := os.Getwd()
	projectName := path.Base(wd)
	pgpKeyname := path.Join("bazel-"+projectName, "external", pgpKeyRuleName, "file", "downloaded")

	allPackages := getPackages(arch, distroType, distro, mirrors, components, pgpKeyname)

	newPackages := make(map[string]string)
	newPackagesSha256 := make(map[string]string)

	for _, pack := range packageNames {
		packlist := strings.Split(pack, "=")
		var packname string
		var packversion string
		var targetVersion version.Version
		if len(packlist) > 1 && packlist[1] != "latest" {
			packname = packlist[0]
			packversion = packlist[1]
			var err error
			targetVersion, err = version.NewVersion(packlist[1])
			logFatalErr(err)
		} else {
			packname = packlist[0]
			packversion = "latest"
			var err error
			targetVersion, err = version.NewVersion("0")
			logFatalErr(err)
		}

		done := false
		for _, pkg := range allPackages {
			if pkg["Package"] == packname {
				currentVersion, err := version.NewVersion(pkg["Version"])
				logFatalErr(err)
				if packversion == "latest" {
					// iterate over all packages and keep the highest version
					if targetVersion.LessThan(currentVersion) {
						newPackages[pack] = pkg["Filename"]
						newPackagesSha256[pack] = pkg["SHA256"]
						targetVersion = currentVersion
						done = true
					}
				} else {
					// version is fixed, break once found
					if targetVersion.Equal(currentVersion) {
						newPackages[pack] = pkg["Filename"]
						newPackagesSha256[pack] = pkg["SHA256"]
						done = true
						break
					}
				}
			}
		}
		if done == false {
			log.Fatalf("Package %s isn't available in %s (rule: %s)", pack, distro, rule)
		}
	}

	pkgstring, err := json.Marshal(newPackages)
	logFatalErr(err)
	pkgshastring, err := json.Marshal(newPackagesSha256)
	logFatalErr(err)

	// set packages
	workspaceContents = []byte(setStringField("packages", string(pkgstring), "-", rule, workspaceContents, &FORCE_PACKAGE_IDENT))
	// set packages_sha256
	workspaceContents = []byte(setStringField("packages_sha256", string(pkgshastring), "-", rule, workspaceContents, nil))
	// final run that just replaces a known value with itself to make sure the output is prettyfied
	workspaceContents = []byte(setStringField("distro", "\""+distro+"\"", "-", rule, workspaceContents, nil))

	return string(workspaceContents)
}