fix: code review alt repository (#6663)

I was not able to properly review this specific file from #6351 in time.

- Remove unnecessary second Close call to xz writer.
- Removed unused values.
- Partition packages by architecture in the first loop to reduce the
amount of iterations.
- Don't compile regex, use `path.Split`.
- Pass structs around.
- Remove usage of bytes.buffer when there's no buffering.
- Use a better data structure for building package lists.

TL;DR no functional changes.

---

Review this with "Ignore whitespace when comparing lines" enabled.

Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/6663
Reviewed-by: 0ko <0ko@noreply.codeberg.org>
Co-authored-by: Gusted <postmaster@gusted.xyz>
Co-committed-by: Gusted <postmaster@gusted.xyz>

services/packages/alt/repository.go

@@ -11,15 +11,13 @@ import (
 	"encoding/hex"
 	"fmt"
 	"io"
-	"regexp"
+	"path"
-	"slices"
-	"strconv"
-	"strings"
 	"time"
 
 	packages_model "code.gitea.io/gitea/models/packages"
 	alt_model "code.gitea.io/gitea/models/packages/alt"
 	user_model "code.gitea.io/gitea/models/user"
+	"code.gitea.io/gitea/modules/container"
 	"code.gitea.io/gitea/modules/json"
 	packages_module "code.gitea.io/gitea/modules/packages"
 	rpm_module "code.gitea.io/gitea/modules/packages/rpm"
@@ -196,32 +194,40 @@ type RPMHdrIndex struct {
 	Count  uint32
 }
 
+type indexWithData struct {
+	index *RPMHdrIndex
+	data  []any
+}
+
+type headerWithIndexes struct {
+	header  *RPMHeader
+	indexes []indexWithData
+}
+
 // https://refspecs.linuxbase.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/pkgformat.html
-func buildPackageLists(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string) (map[string][]any, error) {
+func buildPackageLists(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string) (map[string][]*repoData, error) {
-	architectures := []string{}
+	packagesByArch := map[string][]*packages_model.PackageFile{}
 
 	for _, pf := range pfs {
 		pd := c[pf]
 
-		if !slices.Contains(architectures, pd.FileMetadata.Architecture) {
+		packageArch := pd.FileMetadata.Architecture
-			architectures = append(architectures, pd.FileMetadata.Architecture)
+		if packages, ok := packagesByArch[packageArch]; ok {
+			packagesByArch[packageArch] = append(packages, pf)
+		} else {
+			packagesByArch[packageArch] = []*packages_model.PackageFile{pf}
 		}
 	}
 
-	repoDataListByArch := make(map[string][]any)
+	repoDataListByArch := make(map[string][]*repoData)
-	repoDataList := []any{}
-	orderedHeaders := []*RPMHeader{}
 
-	for i := range architectures {
+	for architecture, pfs := range packagesByArch {
-		headersWithIndexes := make(map[*RPMHeader]map[*RPMHdrIndex][]any)
+		repoDataList := []*repoData{}
-		headersWithPtrs := make(map[*RPMHeader][]*RPMHdrIndex)
+		orderedHeaders := []headerWithIndexes{}
-		indexPtrs := []*RPMHdrIndex{}
-		indexes := make(map[*RPMHdrIndex][]any)
 
 		for _, pf := range pfs {
 			pd := c[pf]
 
-			if pd.FileMetadata.Architecture == architectures[i] {
 			var requireNames []any
 			var requireVersions []any
 			var requireFlags []any
@@ -265,14 +271,12 @@ func buildPackageLists(ctx context.Context, pv *packages_model.PackageVersion, p
 
 			for _, entry := range pd.FileMetadata.Files {
 				if entry != nil {
-						re := regexp.MustCompile(`(.*?/)([^/]*)$`)
+					dir, file := path.Split(entry.Path)
-						matches := re.FindStringSubmatch(entry.Path)
+
-						if len(matches) == 3 {
+					baseNames = append(baseNames, file)
-							baseNames = append(baseNames, matches[2])
+					dirNames = append(dirNames, dir)
-							dirNames = append(dirNames, matches[1])
+					baseNamesSize += len(file) + 1
-							baseNamesSize += len(matches[2]) + 1
+					dirNamesSize += len(dir) + 1
-							dirNamesSize += len(matches[1]) + 1
-						}
 				}
 			}
 
@@ -337,189 +341,216 @@ func buildPackageLists(ctx context.Context, pv *packages_model.PackageVersion, p
 				NIndex:   binary.BigEndian.Uint32([]byte{0, 0, 0, 0}),
 				HSize:    binary.BigEndian.Uint32([]byte{0, 0, 0, 0}),
 			}
-				orderedHeaders = append(orderedHeaders, hdr)
+			orderedHeader := headerWithIndexes{hdr, []indexWithData{}}
 
 			/*Tags: */
-
 			nameInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 232}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: 0,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &nameInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&nameInd] = append(indexes[&nameInd], pd.Package.Name)
+				index: &nameInd,
+				data:  []any{pd.Package.Name},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.Package.Name) + 1)
 
 			// Индекс для версии пакета
 			versionInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 233}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &versionInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&versionInd] = append(indexes[&versionInd], pd.FileMetadata.Version)
+				index: &versionInd,
+				data:  []any{pd.FileMetadata.Version},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.FileMetadata.Version) + 1)
 
 			summaryInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 236}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 9}),
+				Type:   9,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &summaryInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&summaryInd] = append(indexes[&summaryInd], pd.VersionMetadata.Summary)
+				index: &summaryInd,
+				data:  []any{pd.VersionMetadata.Summary},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.VersionMetadata.Summary) + 1)
 
 			descriptionInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 237}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 9}),
+				Type:   9,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &descriptionInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&descriptionInd] = append(indexes[&descriptionInd], pd.VersionMetadata.Description)
+				index: &descriptionInd,
+				data:  []any{pd.VersionMetadata.Description},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.VersionMetadata.Description) + 1)
 
 			releaseInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 234}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &releaseInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&releaseInd] = append(indexes[&releaseInd], pd.FileMetadata.Release)
+				index: &releaseInd,
+				data:  []any{pd.FileMetadata.Release},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.FileMetadata.Release) + 1)
 
-				alignPadding(hdr, indexes, &releaseInd)
+			alignPadding(hdr, orderedHeader.indexes)
 
 			sizeInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 241}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 4}),
+				Type:   4,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &sizeInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&sizeInd] = append(indexes[&sizeInd], int32(pd.FileMetadata.InstalledSize))
+				index: &sizeInd,
+				data:  []any{int32(pd.FileMetadata.InstalledSize)},
+			})
 			hdr.NIndex++
 			hdr.HSize += 4
 
 			buildTimeInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 238}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 4}),
+				Type:   4,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &buildTimeInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&buildTimeInd] = append(indexes[&buildTimeInd], int32(pd.FileMetadata.BuildTime))
+				index: &buildTimeInd,
+				data:  []any{int32(pd.FileMetadata.BuildTime)},
+			})
 			hdr.NIndex++
 			hdr.HSize += 4
 
 			licenseInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 246}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &licenseInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&licenseInd] = append(indexes[&licenseInd], pd.VersionMetadata.License)
+				index: &licenseInd,
+				data:  []any{pd.VersionMetadata.License},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.VersionMetadata.License) + 1)
 
 			packagerInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 247}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &packagerInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&packagerInd] = append(indexes[&packagerInd], pd.FileMetadata.Packager)
+				index: &packagerInd,
+				data:  []any{pd.FileMetadata.Packager},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.FileMetadata.Packager) + 1)
 
 			groupInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 248}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &groupInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&groupInd] = append(indexes[&groupInd], pd.FileMetadata.Group)
+				index: &groupInd,
+				data:  []any{pd.FileMetadata.Group},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.FileMetadata.Group) + 1)
 
 			urlInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 252}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &urlInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&urlInd] = append(indexes[&urlInd], pd.VersionMetadata.ProjectURL)
+				index: &urlInd,
+				data:  []any{pd.VersionMetadata.ProjectURL},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.VersionMetadata.ProjectURL) + 1)
 
 			if len(changeLogNames) != 0 && len(changeLogTexts) != 0 && len(changeLogTimes) != 0 {
-					alignPadding(hdr, indexes, &urlInd)
+				alignPadding(hdr, orderedHeader.indexes)
 
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x38}, []byte{0, 0, 0, 4}, changeLogTimes, changeLogTimesSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x38}, 4, changeLogTimes, changeLogTimesSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x39}, []byte{0, 0, 0, 8}, changeLogNames, changeLogNamesSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x39}, 8, changeLogNames, changeLogNamesSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x3A}, []byte{0, 0, 0, 8}, changeLogTexts, changeLogTextsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x3A}, 8, changeLogTexts, changeLogTextsSize)
 			}
 
 			archInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0, 0, 3, 254}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &archInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&archInd] = append(indexes[&archInd], pd.FileMetadata.Architecture)
+				index: &archInd,
+				data:  []any{pd.FileMetadata.Architecture},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.FileMetadata.Architecture) + 1)
 
 			if len(provideNames) != 0 && len(provideVersions) != 0 && len(provideFlags) != 0 {
-					alignPadding(hdr, indexes, &archInd)
+				alignPadding(hdr, orderedHeader.indexes)
 
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x58}, []byte{0, 0, 0, 4}, provideFlags, provideFlagsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x58}, 4, provideFlags, provideFlagsSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x17}, []byte{0, 0, 0, 8}, provideNames, provideNamesSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x17}, 8, provideNames, provideNamesSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x59}, []byte{0, 0, 0, 8}, provideVersions, provideVersionsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x59}, 8, provideVersions, provideVersionsSize)
 			}
 
 			sourceRpmInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x14}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &sourceRpmInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&sourceRpmInd] = append(indexes[&sourceRpmInd], pd.FileMetadata.SourceRpm)
+				index: &sourceRpmInd,
+				data:  []any{pd.FileMetadata.SourceRpm},
+			})
 			hdr.NIndex++
 			hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(len(pd.FileMetadata.SourceRpm) + 1)})
 
 			if len(requireNames) != 0 && len(requireVersions) != 0 && len(requireFlags) != 0 {
-					alignPadding(hdr, indexes, &sourceRpmInd)
+				alignPadding(hdr, orderedHeader.indexes)
 
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x18}, []byte{0, 0, 0, 4}, requireFlags, requireFlagsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x18}, 4, requireFlags, requireFlagsSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0, 0, 4, 25}, []byte{0, 0, 0, 8}, requireNames, requireNamesSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0, 0, 4, 25}, 8, requireNames, requireNamesSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1A}, []byte{0, 0, 0, 8}, requireVersions, requireVersionsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1A}, 8, requireVersions, requireVersionsSize)
 			}
 
 			if len(baseNames) != 0 {
 				baseNamesInd := RPMHdrIndex{
 					Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x5D}),
-						Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 8}),
+					Type:   8,
 					Offset: hdr.HSize,
 					Count:  uint32(len(baseNames)),
 				}
-					indexPtrs = append(indexPtrs, &baseNamesInd)
+				orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-					indexes[&baseNamesInd] = baseNames
+					index: &baseNamesInd,
+					data:  baseNames,
+				})
 				hdr.NIndex++
 				hdr.HSize += uint32(baseNamesSize)
 			}
@@ -527,113 +558,118 @@ func buildPackageLists(ctx context.Context, pv *packages_model.PackageVersion, p
 			if len(dirNames) != 0 {
 				dirnamesInd := RPMHdrIndex{
 					Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x5E}),
-						Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 8}),
+					Type:   8,
 					Offset: hdr.HSize,
 					Count:  uint32(len(dirNames)),
 				}
-					indexPtrs = append(indexPtrs, &dirnamesInd)
+				orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-					indexes[&dirnamesInd] = dirNames
+					index: &dirnamesInd,
+					data:  dirNames,
+				})
 				hdr.NIndex++
 				hdr.HSize += uint32(dirNamesSize)
 			}
 
 			filenameInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x40}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &filenameInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&filenameInd] = append(indexes[&filenameInd], pf.Name)
+				index: &filenameInd,
+				data:  []any{pf.Name},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pf.Name) + 1)
 
-				alignPadding(hdr, indexes, &filenameInd)
+			alignPadding(hdr, orderedHeader.indexes)
 
 			filesizeInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x41}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 4}),
+				Type:   4,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &filesizeInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&filesizeInd] = append(indexes[&filesizeInd], int32(pd.Blob.Size))
+				index: &filesizeInd,
+				data:  []any{int32(pd.Blob.Size)},
+			})
 			hdr.NIndex++
 			hdr.HSize += 4
 
 			md5Ind := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x45}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &md5Ind)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&md5Ind] = append(indexes[&md5Ind], pd.Blob.HashMD5)
+				index: &md5Ind,
+				data:  []any{pd.Blob.HashMD5},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.Blob.HashMD5) + 1)
 
 			blake2bInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x49}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &blake2bInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&blake2bInd] = append(indexes[&blake2bInd], pd.Blob.HashBlake2b)
+				index: &blake2bInd,
+				data:  []any{pd.Blob.HashBlake2b},
+			})
 			hdr.NIndex++
 			hdr.HSize += uint32(len(pd.Blob.HashBlake2b) + 1)
 
 			if len(conflictNames) != 0 && len(conflictVersions) != 0 && len(conflictFlags) != 0 {
-					alignPadding(hdr, indexes, &blake2bInd)
+				alignPadding(hdr, orderedHeader.indexes)
 
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1D}, []byte{0, 0, 0, 4}, conflictFlags, conflictFlagsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1D}, 4, conflictFlags, conflictFlagsSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1E}, []byte{0, 0, 0, 8}, conflictNames, conflictNamesSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1E}, 8, conflictNames, conflictNamesSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1F}, []byte{0, 0, 0, 8}, conflictVersions, conflictVersionsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1F}, 8, conflictVersions, conflictVersionsSize)
 			}
 
 			directoryInd := RPMHdrIndex{
 				Tag:    binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x4A}),
-					Type:   binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
+				Type:   6,
 				Offset: hdr.HSize,
 				Count:  1,
 			}
-				indexPtrs = append(indexPtrs, &directoryInd)
+			orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-				indexes[&directoryInd] = append(indexes[&directoryInd], "RPMS.classic")
+				index: &directoryInd,
+				data:  []any{"RPMS.classic"},
+			})
 			hdr.NIndex++
 			hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(len("RPMS.classic") + 1)})
 
 			if len(obsoleteNames) != 0 && len(obsoleteVersions) != 0 && len(obsoleteFlags) != 0 {
-					alignPadding(hdr, indexes, &directoryInd)
+				alignPadding(hdr, orderedHeader.indexes)
 
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x5A}, []byte{0, 0, 0, 4}, obsoleteFlags, obsoleteFlagsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x5A}, 4, obsoleteFlags, obsoleteFlagsSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x42}, []byte{0, 0, 0, 8}, obsoleteNames, obsoleteNamesSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x42}, 8, obsoleteNames, obsoleteNamesSize)
-					addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x5B}, []byte{0, 0, 0, 8}, obsoleteVersions, obsoleteVersionsSize)
+				addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x5B}, 8, obsoleteVersions, obsoleteVersionsSize)
 			}
 
-				headersWithIndexes[hdr] = indexes
+			orderedHeaders = append(orderedHeaders, orderedHeader)
-				headersWithPtrs[hdr] = indexPtrs
-
-				indexPtrs = []*RPMHdrIndex{}
-				indexes = make(map[*RPMHdrIndex][]any)
-			}
 		}
 
 		files := []string{"pkglist.classic", "pkglist.classic.xz"}
 		for file := range files {
-			fileInfo, err := addPkglistAsFileToRepo(ctx, pv, files[file], headersWithIndexes, headersWithPtrs, orderedHeaders, group, architectures[i])
+			fileInfo, err := addPkglistAsFileToRepo(ctx, pv, files[file], orderedHeaders, group, architecture)
 			if err != nil {
 				return nil, err
 			}
 			repoDataList = append(repoDataList, fileInfo)
-			repoDataListByArch[architectures[i]] = repoDataList
 		}
-		repoDataList = []any{}
+		repoDataListByArch[architecture] = repoDataList
-		orderedHeaders = []*RPMHeader{}
 	}
 	return repoDataListByArch, nil
 }
 
-func alignPadding(hdr *RPMHeader, indexes map[*RPMHdrIndex][]any, lastIndex *RPMHdrIndex) {
+func alignPadding(hdr *RPMHeader, indexes []indexWithData) {
 	/* Align to 4-bytes to add a 4-byte element. */
 	padding := (4 - (hdr.HSize % 4)) % 4
 	if padding == 4 {
@@ -641,86 +677,92 @@ func alignPadding(hdr *RPMHeader, indexes map[*RPMHdrIndex][]any, lastIndex *RPM
 	}
 	hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(padding)})
 
+	lastIndex := len(indexes) - 1
 	for i := uint32(0); i < padding; i++ {
-		for _, elem := range indexes[lastIndex] {
+		for _, elem := range indexes[lastIndex].data {
 			if str, ok := elem.(string); ok {
-				indexes[lastIndex][len(indexes[lastIndex])-1] = str + "\x00"
+				indexes[lastIndex].data[len(indexes[lastIndex].data)-1] = str + "\x00"
 			}
 		}
 	}
 }
 
-func addRPMHdrIndex(hdr *RPMHeader, indexPtrs *[]*RPMHdrIndex, indexes map[*RPMHdrIndex][]any, tag, typeByte []byte, data []any, dataSize int) {
+func addRPMHdrIndex(orderedHeader *headerWithIndexes, tag []byte, typeVal uint32, data []any, dataSize int) {
 	index := RPMHdrIndex{
 		Tag:    binary.BigEndian.Uint32(tag),
-		Type:   binary.BigEndian.Uint32(typeByte),
+		Type:   typeVal,
-		Offset: hdr.HSize,
+		Offset: orderedHeader.header.HSize,
 		Count:  uint32(len(data)),
 	}
-	*indexPtrs = append(*indexPtrs, &index)
+	orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
-	indexes[&index] = data
+		index: &index,
-	hdr.NIndex++
+		data:  data,
-	hdr.HSize += uint32(dataSize)
+	})
+	orderedHeader.header.NIndex++
+	orderedHeader.header.HSize += uint32(dataSize)
 }
 
 // https://www.altlinux.org/APT_в_ALT_Linux/CreateRepository
-func buildRelease(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string, pkglist map[string][]any) error {
+func buildRelease(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string, pkglist map[string][]*repoData) error {
-	var buf bytes.Buffer
+	architectures := make(container.Set[string])
-
-	architectures := []string{}
 
 	for _, pf := range pfs {
 		pd := c[pf]
-		if !slices.Contains(architectures, pd.FileMetadata.Architecture) {
+		architectures.Add(pd.FileMetadata.Architecture)
-			architectures = append(architectures, pd.FileMetadata.Architecture)
-		}
 	}
 
-	for i := range architectures {
+	for architecture := range architectures {
-		archive := "Alt Linux Team"
+		version := time.Now().Unix()
-		component := "classic"
-		version := strconv.FormatInt(time.Now().Unix(), 10)
-		architectures := architectures[i]
-		origin := "Alt Linux Team"
 		label := setting.AppName
-		notautomatic := "false"
+		data := fmt.Sprintf(`Archive: Alt Linux Team
-		data := fmt.Sprintf("Archive: %s\nComponent: %s\nVersion: %s\nOrigin: %s\nLabel: %s\nArchitecture: %s\nNotAutomatic: %s",
+Component: classic
-			archive, component, version, origin, label, architectures, notautomatic)
+Version: %d
-		buf.WriteString(data + "\n")
+Origin: Alt Linux Team
-		fileInfo, err := addReleaseAsFileToRepo(ctx, pv, "release.classic", buf.String(), group, architectures)
+Label: %s
+Architecture: %s
+NotAutomatic: false
+`,
+			version, label, architecture)
+		fileInfo, err := addReleaseAsFileToRepo(ctx, pv, "release.classic", data, group, architecture)
 		if err != nil {
 			return err
 		}
-		buf.Reset()
 
-		origin = setting.AppName
+		origin := setting.AppName
-		suite := "Sisyphus"
+		codename := time.Now().Unix()
-		codename := strconv.FormatInt(time.Now().Unix(), 10)
 		date := time.Now().UTC().Format(time.RFC1123)
 
 		var md5Sum string
 		var blake2b string
 
-		for _, pkglistByArch := range pkglist[architectures] {
+		for _, pkglistByArch := range pkglist[architecture] {
-			md5Sum += fmt.Sprintf(" %s %s %s\n", pkglistByArch.([]string)[2], pkglistByArch.([]string)[4], "base/"+pkglistByArch.([]string)[0])
+			md5Sum += fmt.Sprintf(" %s %d %s\n", pkglistByArch.MD5Checksum.Value, pkglistByArch.Size, "base/"+pkglistByArch.Type)
-			blake2b += fmt.Sprintf(" %s %s %s\n", pkglistByArch.([]string)[3], pkglistByArch.([]string)[4], "base/"+pkglistByArch.([]string)[0])
+			blake2b += fmt.Sprintf(" %s %d %s\n", pkglistByArch.Blake2bHash.Value, pkglistByArch.Size, "base/"+pkglistByArch.Type)
 		}
-		md5Sum += fmt.Sprintf(" %s %s %s\n", fileInfo[2], fileInfo[4], "base/"+fileInfo[0])
+		md5Sum += fmt.Sprintf(" %s %d %s\n", fileInfo.MD5Checksum.Value, fileInfo.Size, "base/"+fileInfo.Type)
-		blake2b += fmt.Sprintf(" %s %s %s\n", fileInfo[3], fileInfo[4], "base/"+fileInfo[0])
+		blake2b += fmt.Sprintf(" %s %d %s\n", fileInfo.Blake2bHash.Value, fileInfo.Size, "base/"+fileInfo.Type)
 
-		data = fmt.Sprintf("Origin: %s\nLabel: %s\nSuite: %s\nCodename: %s\nDate: %s\nArchitectures: %s\nMD5Sum:\n%sBLAKE2b:\n%s\n",
+		data = fmt.Sprintf(`Origin: %s
-			origin, label, suite, codename, date, architectures, md5Sum, blake2b)
+Label: %s
-		buf.WriteString(data + "\n")
+Suite: Sisyphus
-		_, err = addReleaseAsFileToRepo(ctx, pv, "release", buf.String(), group, architectures)
+Codename: %d
+Date: %s
+Architectures: %s
+MD5Sum:
+%sBLAKE2b:
+%s
+
+`,
+			origin, label, codename, date, architecture, md5Sum, blake2b)
+		_, err = addReleaseAsFileToRepo(ctx, pv, "release", data, group, architecture)
 		if err != nil {
 			return err
 		}
-		buf.Reset()
 	}
 	return nil
 }
 
-func addReleaseAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersion, filename, obj, group, arch string) ([]string, error) {
+func addReleaseAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersion, filename, obj, group, arch string) (*repoData, error) {
 	content, _ := packages_module.NewHashedBuffer()
 	defer content.Close()
 
@@ -755,7 +797,7 @@ func addReleaseAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersi
 		group = "alt"
 	}
 
-	repoData := &repoData{
+	return &repoData{
 		Type: filename,
 		Checksum: repoChecksum{
 			Type:  "sha256",
@@ -777,20 +819,10 @@ func addReleaseAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersi
 			Href: group + ".repo/" + arch + "/base/" + filename,
 		},
 		Size: content.Size(),
-		/* Unused values:
+	}, nil
-		Timestamp: time.Now().Unix(),
-		OpenSize:  content.Size(), */
-	}
-
-	data := []string{
-		repoData.Type, repoData.Checksum.Value,
-		repoData.MD5Checksum.Value, repoData.Blake2bHash.Value, strconv.Itoa(int(repoData.Size)),
-	}
-
-	return data, nil
 }
 
-func addPkglistAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersion, filename string, headersWithIndexes map[*RPMHeader]map[*RPMHdrIndex][]any, headersWithPtrs map[*RPMHeader][]*RPMHdrIndex, orderedHeaders []*RPMHeader, group, arch string) ([]string, error) {
+func addPkglistAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersion, filename string, orderedHeaders []headerWithIndexes, group, arch string) (*repoData, error) {
 	content, _ := packages_module.NewHashedBuffer()
 	defer content.Close()
 
@@ -799,20 +831,18 @@ func addPkglistAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersi
 	buf := &bytes.Buffer{}
 
 	for _, hdr := range orderedHeaders {
-		if err := binary.Write(buf, binary.BigEndian, hdr); err != nil {
+		if err := binary.Write(buf, binary.BigEndian, *hdr.header); err != nil {
 			return nil, err
 		}
 
-		for _, indexPtr := range headersWithPtrs[hdr] {
+		for _, index := range hdr.indexes {
-			index := *indexPtr
+			if err := binary.Write(buf, binary.BigEndian, *index.index); err != nil {
-
-			if err := binary.Write(buf, binary.BigEndian, index); err != nil {
 				return nil, err
 			}
 		}
 
-		for _, indexPtr := range headersWithPtrs[hdr] {
+		for _, index := range hdr.indexes {
-			for _, indexValue := range headersWithIndexes[hdr][indexPtr] {
+			for _, indexValue := range index.data {
 				switch v := indexValue.(type) {
 				case string:
 					if _, err := buf.WriteString(v + "\x00"); err != nil {
@@ -827,9 +857,7 @@ func addPkglistAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersi
 		}
 	}
 
-	parts := strings.Split(filename, ".")
+	if path.Ext(filename) == ".xz" {
-
-	if len(parts) == 3 && parts[len(parts)-1] == "xz" {
 		xzContent, err := compressXZ(buf.Bytes())
 		if err != nil {
 			return nil, err
@@ -867,7 +895,7 @@ func addPkglistAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersi
 		group = "alt"
 	}
 
-	repoData := &repoData{
+	return &repoData{
 		Type: filename,
 		Checksum: repoChecksum{
 			Type:  "sha256",
@@ -889,17 +917,7 @@ func addPkglistAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersi
 			Href: group + ".repo/" + arch + "/base/" + filename,
 		},
 		Size: content.Size(),
-		/* Unused values:
+	}, nil
-		Timestamp: time.Now().Unix(),
-		OpenSize:  content.Size(), */
-	}
-
-	data := []string{
-		repoData.Type, repoData.Checksum.Value,
-		repoData.MD5Checksum.Value, repoData.Blake2bHash.Value, strconv.Itoa(int(repoData.Size)),
-	}
-
-	return data, nil
 }
 
 func compressXZ(data []byte) ([]byte, error) {
@@ -908,12 +926,10 @@ func compressXZ(data []byte) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	defer xzWriter.Close()
 
-	if _, err := xzWriter.Write(data); err != nil {
+	_, err = xzWriter.Write(data)
-		return nil, err
+	xzWriter.Close()
-	}
+	if err != nil {
-	if err := xzWriter.Close(); err != nil {
 		return nil, err
 	}