func aptChanges()

in policies/apt.go [193:281]
75 lines of code
21 McCabe index (conditional complexity)

func aptChanges(ctx context.Context, aptInstalled, aptRemoved, aptUpdated []*agentendpointpb.Package) error {
	var err error
	var errs []string

	var installed []*packages.PkgInfo
	if len(aptInstalled) > 0 || len(aptUpdated) > 0 || len(aptRemoved) > 0 {
		installed, err = packages.InstalledDebPackages(ctx)
		if err != nil {
			return err
		}
	}

	var updates []*packages.PkgInfo
	if len(aptUpdated) > 0 {
		updates, err = packages.AptUpdates(ctx, packages.AptGetUpgradeType(packages.AptGetDistUpgrade), packages.AptGetUpgradeShowNew(false))
		if err != nil {
			return err
		}
	}

	changes := getNecessaryChanges(installed, updates, aptInstalled, aptRemoved, aptUpdated)

	if changes.packagesToInstall != nil {
		// run apt-get update to update to latest changes.
		if _, err := packages.AptUpdate(ctx); err != nil {
			clog.Errorf(ctx, "Error running apt-get update")
		}
		clog.Infof(ctx, "Installing packages %s", changes.packagesToInstall)
		if err := packages.InstallAptPackages(ctx, changes.packagesToInstall); err != nil {
			clog.Errorf(ctx, "Error installing apt packages: %v", err)

			// Try fallback logic to install the packages individually.
			clog.Infof(ctx, "Trying to install packages individually")
			var installPkgErrs []string
			for _, pkg := range changes.packagesToInstall {
				if err = packages.InstallAptPackages(ctx, []string{pkg}); err != nil {
					installPkgErrs = append(installPkgErrs, fmt.Sprintf("Error installing apt package: %v. Error details: %v", pkg, err))
				}
			}

			if len(installPkgErrs) > 0 {
				errorString := strings.Join(installPkgErrs, "\n")
				clog.Errorf(ctx, "Error installing apt packages individually: %v", errorString)
				errs = append(errs, fmt.Sprintf("error installing apt packages: %v", errorString))
			}
		}
	} else {
		clog.Debugf(ctx, "No packages to install.")
	}

	if changes.packagesToUpgrade != nil {
		clog.Infof(ctx, "Upgrading packages %s", changes.packagesToUpgrade)
		if err := packages.InstallAptPackages(ctx, changes.packagesToUpgrade); err != nil {
			clog.Errorf(ctx, "Error upgrading apt packages: %v", err)
			errs = append(errs, fmt.Sprintf("error upgrading apt packages: %v", err))
		}
	} else {
		clog.Debugf(ctx, "No packages to upgrade.")
	}

	if changes.packagesToRemove != nil {
		clog.Infof(ctx, "Removing packages %s", changes.packagesToRemove)
		if err := packages.RemoveAptPackages(ctx, changes.packagesToRemove); err != nil {
			clog.Errorf(ctx, "Error removing apt packages: %v", err)

			// Try fallback logic to remove the packages individually.
			clog.Infof(ctx, "Trying to remove packages individually")
			var removePkgErrs []string
			for _, pkg := range changes.packagesToRemove {
				if err = packages.RemoveAptPackages(ctx, []string{pkg}); err != nil {
					removePkgErrs = append(removePkgErrs, fmt.Sprintf("Error removing apt package: %v. Error details: %v", pkg, err))
				}
			}

			if len(removePkgErrs) > 0 {
				errorString := strings.Join(removePkgErrs, "\n")
				clog.Errorf(ctx, "Error removing apt packages individually: %v", errorString)
				errs = append(errs, fmt.Sprintf("error removing apt packages: %v", errorString))
			}
		}
	} else {
		clog.Debugf(ctx, "No packages to remove.")
	}

	if errs == nil {
		return nil
	}
	return errors.New(strings.Join(errs, ",\n"))
}