Исправлена повторная сборка подпакетов мультипакета

При установке пакета с зависимостями на другие подпакеты того же
мультипакета теперь каждый подпакет собирается только один раз.

internal/build/build.go

@@ -45,6 +45,7 @@ type BuildInput struct {
 	script           string
 	repository       string
 	packages         []string
+	skipDepsBuilding bool // Пропустить сборку зависимостей (используется при вызове из BuildALRDeps)
 }
 
 func (bi *BuildInput) GobEncode() ([]byte, error) {
@@ -245,6 +246,7 @@ type BuildArgs struct {
 	Opts             *types.BuildOpts
 	Info             *distro.OSRelease
 	PkgFormat_       string
+	SkipDepsBuilding bool // Пропустить сборку зависимостей (используется при вызове из BuildALRDeps)
 }
 
 func (b *BuildArgs) BuildOpts() *types.BuildOpts {
@@ -284,6 +286,7 @@ func (b *Builder) BuildPackageFromDb(
 		pkgFormat:        args.PkgFormat(),
 		opts:             args.Opts,
 		info:             args.Info,
+		skipDepsBuilding: args.SkipDepsBuilding,
 	})
 }
 
@@ -409,9 +412,10 @@ func (b *Builder) BuildPackage(
 	var filteredDepends []string
 
 	// Создаем набор подпакетов текущего мультипакета для исключения циклических зависимостей
+	// Используем имена из varsOfPackages, так как input.packages может быть пустым
 	currentPackageNames := make(map[string]struct{})
-	for _, pkg := range input.packages {
+	for _, vars := range varsOfPackages {
-		currentPackageNames[pkg] = struct{}{}
+		currentPackageNames[vars.Name] = struct{}{}
 	}
 
 	for _, d := range depends {
@@ -423,11 +427,17 @@ func (b *Builder) BuildPackage(
 		}
 	}
 
+	var newBuiltDeps []*BuiltDep
+	var repoDeps []string
+
+	// Пропускаем сборку зависимостей если флаг установлен (вызов из BuildALRDeps)
+	if !input.skipDepsBuilding {
 		slog.Debug("BuildALRDeps")
-	newBuiltDeps, repoDeps, err := b.BuildALRDeps(ctx, input, filteredDepends)
+		newBuiltDeps, repoDeps, err = b.BuildALRDeps(ctx, input, filteredDepends)
 		if err != nil {
 			return nil, err
 		}
+	}
 
 	slog.Debug("PrepareDirs")
 	err = b.scriptExecutor.PrepareDirs(ctx, input, basePkg)
@@ -580,65 +590,68 @@ func (b *Builder) BuildALRDeps(
 	// Системные зависимости возвращаем как repoDeps
 	repoDeps = systemDeps
 
-	// Шаг 2: Собираем список всех пакетов из дерева для топологической сортировки
+	// Шаг 2: Топологическая сортировка (от корней к листьям)
-	allFound := make(map[string][]alrsh.Package)
+	sortedPkgs, err := TopologicalSort(depTree)
-	for baseName, node := range depTree {
-		allFound[baseName] = []alrsh.Package{*node.Package}
-	}
-
-	// Шаг 3: Топологическая сортировка (от корней к листьям)
-	sortedPkgs, err := TopologicalSort(depTree, allFound)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to sort dependencies: %w", err)
 	}
 
+	// Шаг 3: Группируем подпакеты по basePkgName для оптимизации сборки
+	// Если несколько подпакетов из одного мультипакета, собираем их вместе
+	builtBasePkgs := make(map[string]bool) // Уже собранные базовые пакеты
+
 	// Шаг 4: Собираем пакеты в правильном порядке, проверяя кеш
-	for _, basePkgName := range sortedPkgs {
+	for _, pkgName := range sortedPkgs {
-		node := depTree[basePkgName]
+		node := depTree[pkgName]
 		if node == nil {
 			continue
 		}
 
 		pkg := node.Package
+		basePkgName := node.BasePkgName
 
-		// Находим ВСЕ подпакеты с этим BasePkgName
+		// Если базовый пакет уже собран, пропускаем
-		allSubpkgs, err := b.findAllSubpackages(ctx, basePkgName, pkg.Repository)
+		if builtBasePkgs[basePkgName] {
-		if err != nil {
+			continue
-			return nil, nil, fmt.Errorf("failed to find subpackages for %s: %w", basePkgName, err)
 		}
 
-		// Проверяем кеш для ВСЕХ подпакетов
+		// Собираем только запрошенный подпакет (или все, если запрошен basePkgName)
+		packagesToBuilt := []string{pkgName}
+
+		// Проверяем кеш для запрошенного подпакета
 		scriptInfo := b.scriptResolver.ResolveScript(ctx, pkg)
 		buildInput := &BuildInput{
 			script:     scriptInfo.Script,
 			repository: scriptInfo.Repository,
-			packages:   allSubpkgs,
+			packages:   packagesToBuilt,
 			pkgFormat:  input.PkgFormat(),
 			opts:       input.BuildOpts(),
 			info:       input.OSRelease(),
 		}
 
-		cachedDeps, allInCache, err := b.checkCacheForAllSubpackages(ctx, buildInput, basePkgName, allSubpkgs)
+		cachedDeps, allInCache, err := b.checkCacheForAllSubpackages(ctx, buildInput, basePkgName, packagesToBuilt)
 		if err != nil {
 			return nil, nil, err
 		}
 
 		if allInCache {
-			// Все подпакеты в кеше, используем их
+			// Подпакет в кеше, используем его
 			buildDeps = append(buildDeps, cachedDeps...)
 			continue
 		}
 
-		// Собираем пакет (без рекурсивной сборки зависимостей, так как они уже собраны)
+		// Собираем только запрошенный подпакет
+		// SkipDepsBuilding: true предотвращает рекурсивный вызов BuildALRDeps
 		res, err := b.BuildPackageFromDb(
 			ctx,
 			&BuildPackageFromDbArgs{
 				Package:  pkg,
-				Packages: allSubpkgs,
+				Packages: packagesToBuilt,
 				BuildArgs: BuildArgs{
 					Opts:             input.BuildOpts(),
 					Info:             input.OSRelease(),
 					PkgFormat_:       input.PkgFormat(),
+					SkipDepsBuilding: true,
 				},
 			},
 		)
@@ -647,6 +660,7 @@ func (b *Builder) BuildALRDeps(
 		}
 
 		buildDeps = append(buildDeps, res...)
+		builtBasePkgs[basePkgName] = true
 	}
 
 	buildDeps = removeDuplicates(buildDeps)

internal/build/dependency_tree.go

@@ -27,6 +27,7 @@ import (
 type DependencyNode struct {
 	Package      *alrsh.Package
 	BasePkgName  string
+	PkgName      string   // Имя конкретного подпакета (может отличаться от BasePkgName)
 	Dependencies []string // Имена зависимостей
 }
 
@@ -82,8 +83,9 @@ func (b *Builder) ResolveDependencyTree(
 				baseName = pkg.Name
 			}
 
-			// Если уже обработали этот базовый пакет, пропускаем
+			// Используем имя конкретного подпакета как ключ (не basePkgName)
-			if resolved[baseName] != nil {
+			// Это позволяет собирать только запрошенный подпакет, а не весь мультипакет
+			if resolved[pkgName] != nil {
 				continue
 			}
 
@@ -96,10 +98,11 @@ func (b *Builder) ResolveDependencyTree(
 			allDeps := append([]string{}, deps...)
 			allDeps = append(allDeps, buildDeps...)
 
-			// Добавляем узел в resolved
+			// Добавляем узел в resolved с ключом = имя подпакета
-			resolved[baseName] = &DependencyNode{
+			resolved[pkgName] = &DependencyNode{
 				Package:      &pkg,
 				BasePkgName:  baseName,
+				PkgName:      pkgName,
 				Dependencies: allDeps,
 			}
 
@@ -129,8 +132,8 @@ func (b *Builder) ResolveDependencyTree(
 }
 
 // TopologicalSort выполняет топологическую сортировку пакетов по зависимостям
-// Возвращает список базовых имен пакетов в порядке сборки (от корней к листьям)
+// Возвращает список имен подпакетов в порядке сборки (от корней к листьям)
-func TopologicalSort(nodes map[string]*DependencyNode, allPkgs map[string][]alrsh.Package) ([]string, error) {
+func TopologicalSort(nodes map[string]*DependencyNode) ([]string, error) {
 	// Список для результата
 	var result []string
 
@@ -140,51 +143,42 @@ func TopologicalSort(nodes map[string]*DependencyNode, allPkgs map[string][]alrs
 	// Множество узлов в текущем пути (для обнаружения циклов)
 	inStack := make(map[string]bool)
 
-	var visit func(basePkgName string) error
+	var visit func(pkgName string) error
-	visit = func(basePkgName string) error {
+	visit = func(pkgName string) error {
-		if visited[basePkgName] {
+		if visited[pkgName] {
 			return nil
 		}
 
-		if inStack[basePkgName] {
+		if inStack[pkgName] {
-			return fmt.Errorf("circular dependency detected: %s", basePkgName)
+			return fmt.Errorf("circular dependency detected: %s", pkgName)
 		}
 
-		node := nodes[basePkgName]
+		node := nodes[pkgName]
 		if node == nil {
-			// Это системный пакет, игнорируем
+			// Это системный пакет или пакет не в дереве, игнорируем
 			return nil
 		}
 
-		inStack[basePkgName] = true
+		inStack[pkgName] = true
 
 		// Посещаем все зависимости
 		for _, dep := range node.Dependencies {
-			// Находим базовое имя для зависимости
+			// Используем имя зависимости напрямую (это имя подпакета)
-			depBaseName := dep
+			if err := visit(dep); err != nil {
-
-			// Проверяем, есть ли этот пакет в allPkgs
-			if pkgs, ok := allPkgs[dep]; ok && len(pkgs) > 0 {
-				if pkgs[0].BasePkgName != "" {
-					depBaseName = pkgs[0].BasePkgName
-				}
-			}
-
-			if err := visit(depBaseName); err != nil {
 				return err
 			}
 		}
 
-		inStack[basePkgName] = false
+		inStack[pkgName] = false
-		visited[basePkgName] = true
+		visited[pkgName] = true
-		result = append(result, basePkgName)
+		result = append(result, pkgName)
 
 		return nil
 	}
 
 	// Посещаем все узлы
-	for basePkgName := range nodes {
+	for pkgName := range nodes {
-		if err := visit(basePkgName); err != nil {
+		if err := visit(pkgName); err != nil {
 			return nil, err
 		}
 	}