loading up the forgejo repo on tangled to test page performance
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>
authored by
Gusted
Gusted
and committed by
Earl Warren
8f8856dc
c4d8f626
+457
-441
+457
-441
services/packages/alt/repository.go
+457
-441
services/packages/alt/repository.go
···
11
11
"encoding/hex"
12
12
"fmt"
13
13
"io"
14
-
"regexp"
15
-
"slices"
16
-
"strconv"
17
-
"strings"
14
+
"path"
18
15
"time"
19
16
20
17
packages_model "code.gitea.io/gitea/models/packages"
21
18
alt_model "code.gitea.io/gitea/models/packages/alt"
22
19
user_model "code.gitea.io/gitea/models/user"
20
+
"code.gitea.io/gitea/modules/container"
23
21
"code.gitea.io/gitea/modules/json"
24
22
packages_module "code.gitea.io/gitea/modules/packages"
25
23
rpm_module "code.gitea.io/gitea/modules/packages/rpm"
···
196
194
Count uint32
197
195
}
198
196
197
+
type indexWithData struct {
198
+
index *RPMHdrIndex
199
+
data []any
200
+
}
201
+
202
+
type headerWithIndexes struct {
203
+
header *RPMHeader
204
+
indexes []indexWithData
205
+
}
206
+
199
207
// https://refspecs.linuxbase.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/pkgformat.html
200
-
func buildPackageLists(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string) (map[string][]any, error) {
201
-
architectures := []string{}
208
+
func buildPackageLists(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string) (map[string][]*repoData, error) {
209
+
packagesByArch := map[string][]*packages_model.PackageFile{}
202
210
203
211
for _, pf := range pfs {
204
212
pd := c[pf]
205
213
206
-
if !slices.Contains(architectures, pd.FileMetadata.Architecture) {
207
-
architectures = append(architectures, pd.FileMetadata.Architecture)
214
+
packageArch := pd.FileMetadata.Architecture
215
+
if packages, ok := packagesByArch[packageArch]; ok {
216
+
packagesByArch[packageArch] = append(packages, pf)
217
+
} else {
218
+
packagesByArch[packageArch] = []*packages_model.PackageFile{pf}
208
219
}
209
220
}
210
221
211
-
repoDataListByArch := make(map[string][]any)
212
-
repoDataList := []any{}
213
-
orderedHeaders := []*RPMHeader{}
222
+
repoDataListByArch := make(map[string][]*repoData)
214
223
215
-
for i := range architectures {
216
-
headersWithIndexes := make(map[*RPMHeader]map[*RPMHdrIndex][]any)
217
-
headersWithPtrs := make(map[*RPMHeader][]*RPMHdrIndex)
218
-
indexPtrs := []*RPMHdrIndex{}
219
-
indexes := make(map[*RPMHdrIndex][]any)
224
+
for architecture, pfs := range packagesByArch {
225
+
repoDataList := []*repoData{}
226
+
orderedHeaders := []headerWithIndexes{}
220
227
221
228
for _, pf := range pfs {
222
229
pd := c[pf]
223
230
224
-
if pd.FileMetadata.Architecture == architectures[i] {
225
-
var requireNames []any
226
-
var requireVersions []any
227
-
var requireFlags []any
228
-
requireNamesSize := 0
229
-
requireVersionsSize := 0
230
-
requireFlagsSize := 0
231
+
var requireNames []any
232
+
var requireVersions []any
233
+
var requireFlags []any
234
+
requireNamesSize := 0
235
+
requireVersionsSize := 0
236
+
requireFlagsSize := 0
231
237
232
-
for _, entry := range pd.FileMetadata.Requires {
233
-
if entry != nil {
234
-
requireNames = append(requireNames, entry.Name)
235
-
requireVersions = append(requireVersions, entry.Version)
236
-
requireFlags = append(requireFlags, entry.AltFlags)
237
-
requireNamesSize += len(entry.Name) + 1
238
-
requireVersionsSize += len(entry.Version) + 1
239
-
requireFlagsSize += 4
240
-
}
238
+
for _, entry := range pd.FileMetadata.Requires {
239
+
if entry != nil {
240
+
requireNames = append(requireNames, entry.Name)
241
+
requireVersions = append(requireVersions, entry.Version)
242
+
requireFlags = append(requireFlags, entry.AltFlags)
243
+
requireNamesSize += len(entry.Name) + 1
244
+
requireVersionsSize += len(entry.Version) + 1
245
+
requireFlagsSize += 4
241
246
}
247
+
}
242
248
243
-
var conflictNames []any
244
-
var conflictVersions []any
245
-
var conflictFlags []any
246
-
conflictNamesSize := 0
247
-
conflictVersionsSize := 0
248
-
conflictFlagsSize := 0
249
+
var conflictNames []any
250
+
var conflictVersions []any
251
+
var conflictFlags []any
252
+
conflictNamesSize := 0
253
+
conflictVersionsSize := 0
254
+
conflictFlagsSize := 0
249
255
250
-
for _, entry := range pd.FileMetadata.Conflicts {
251
-
if entry != nil {
252
-
conflictNames = append(conflictNames, entry.Name)
253
-
conflictVersions = append(conflictVersions, entry.Version)
254
-
conflictFlags = append(conflictFlags, entry.AltFlags)
255
-
conflictNamesSize += len(entry.Name) + 1
256
-
conflictVersionsSize += len(entry.Version) + 1
257
-
conflictFlagsSize += 4
258
-
}
256
+
for _, entry := range pd.FileMetadata.Conflicts {
257
+
if entry != nil {
258
+
conflictNames = append(conflictNames, entry.Name)
259
+
conflictVersions = append(conflictVersions, entry.Version)
260
+
conflictFlags = append(conflictFlags, entry.AltFlags)
261
+
conflictNamesSize += len(entry.Name) + 1
262
+
conflictVersionsSize += len(entry.Version) + 1
263
+
conflictFlagsSize += 4
259
264
}
265
+
}
260
266
261
-
var baseNames []any
262
-
var dirNames []any
263
-
baseNamesSize := 0
264
-
dirNamesSize := 0
267
+
var baseNames []any
268
+
var dirNames []any
269
+
baseNamesSize := 0
270
+
dirNamesSize := 0
265
271
266
-
for _, entry := range pd.FileMetadata.Files {
267
-
if entry != nil {
268
-
re := regexp.MustCompile(`(.*?/)([^/]*)$`)
269
-
matches := re.FindStringSubmatch(entry.Path)
270
-
if len(matches) == 3 {
271
-
baseNames = append(baseNames, matches[2])
272
-
dirNames = append(dirNames, matches[1])
273
-
baseNamesSize += len(matches[2]) + 1
274
-
dirNamesSize += len(matches[1]) + 1
275
-
}
276
-
}
277
-
}
278
-
279
-
var provideNames []any
280
-
var provideVersions []any
281
-
var provideFlags []any
282
-
provideNamesSize := 0
283
-
provideVersionsSize := 0
284
-
provideFlagsSize := 0
272
+
for _, entry := range pd.FileMetadata.Files {
273
+
if entry != nil {
274
+
dir, file := path.Split(entry.Path)
285
275
286
-
for _, entry := range pd.FileMetadata.Provides {
287
-
if entry != nil {
288
-
provideNames = append(provideNames, entry.Name)
289
-
provideVersions = append(provideVersions, entry.Version)
290
-
provideFlags = append(provideFlags, entry.AltFlags)
291
-
provideNamesSize += len(entry.Name) + 1
292
-
provideVersionsSize += len(entry.Version) + 1
293
-
provideFlagsSize += 4
294
-
}
276
+
baseNames = append(baseNames, file)
277
+
dirNames = append(dirNames, dir)
278
+
baseNamesSize += len(file) + 1
279
+
dirNamesSize += len(dir) + 1
295
280
}
281
+
}
296
282
297
-
var obsoleteNames []any
298
-
var obsoleteVersions []any
299
-
var obsoleteFlags []any
300
-
obsoleteNamesSize := 0
301
-
obsoleteVersionsSize := 0
302
-
obsoleteFlagsSize := 0
283
+
var provideNames []any
284
+
var provideVersions []any
285
+
var provideFlags []any
286
+
provideNamesSize := 0
287
+
provideVersionsSize := 0
288
+
provideFlagsSize := 0
303
289
304
-
for _, entry := range pd.FileMetadata.Obsoletes {
305
-
if entry != nil {
306
-
obsoleteNames = append(obsoleteNames, entry.Name)
307
-
obsoleteVersions = append(obsoleteVersions, entry.Version)
308
-
obsoleteFlags = append(obsoleteFlags, entry.AltFlags)
309
-
obsoleteNamesSize += len(entry.Name) + 1
310
-
obsoleteVersionsSize += len(entry.Version) + 1
311
-
obsoleteFlagsSize += 4
312
-
}
290
+
for _, entry := range pd.FileMetadata.Provides {
291
+
if entry != nil {
292
+
provideNames = append(provideNames, entry.Name)
293
+
provideVersions = append(provideVersions, entry.Version)
294
+
provideFlags = append(provideFlags, entry.AltFlags)
295
+
provideNamesSize += len(entry.Name) + 1
296
+
provideVersionsSize += len(entry.Version) + 1
297
+
provideFlagsSize += 4
313
298
}
299
+
}
314
300
315
-
var changeLogTimes []any
316
-
var changeLogNames []any
317
-
var changeLogTexts []any
318
-
changeLogTimesSize := 0
319
-
changeLogNamesSize := 0
320
-
changeLogTextsSize := 0
301
+
var obsoleteNames []any
302
+
var obsoleteVersions []any
303
+
var obsoleteFlags []any
304
+
obsoleteNamesSize := 0
305
+
obsoleteVersionsSize := 0
306
+
obsoleteFlagsSize := 0
321
307
322
-
for _, entry := range pd.FileMetadata.Changelogs {
323
-
if entry != nil {
324
-
changeLogNames = append(changeLogNames, entry.Author)
325
-
changeLogTexts = append(changeLogTexts, entry.Text)
326
-
changeLogTimes = append(changeLogTimes, uint32(int64(entry.Date)))
327
-
changeLogNamesSize += len(entry.Author) + 1
328
-
changeLogTextsSize += len(entry.Text) + 1
329
-
changeLogTimesSize += 4
330
-
}
308
+
for _, entry := range pd.FileMetadata.Obsoletes {
309
+
if entry != nil {
310
+
obsoleteNames = append(obsoleteNames, entry.Name)
311
+
obsoleteVersions = append(obsoleteVersions, entry.Version)
312
+
obsoleteFlags = append(obsoleteFlags, entry.AltFlags)
313
+
obsoleteNamesSize += len(entry.Name) + 1
314
+
obsoleteVersionsSize += len(entry.Version) + 1
315
+
obsoleteFlagsSize += 4
331
316
}
317
+
}
332
318
333
-
/*Header*/
334
-
hdr := &RPMHeader{
335
-
Magic: [4]byte{0x8E, 0xAD, 0xE8, 0x01},
336
-
Reserved: [4]byte{0, 0, 0, 0},
337
-
NIndex: binary.BigEndian.Uint32([]byte{0, 0, 0, 0}),
338
-
HSize: binary.BigEndian.Uint32([]byte{0, 0, 0, 0}),
339
-
}
340
-
orderedHeaders = append(orderedHeaders, hdr)
319
+
var changeLogTimes []any
320
+
var changeLogNames []any
321
+
var changeLogTexts []any
322
+
changeLogTimesSize := 0
323
+
changeLogNamesSize := 0
324
+
changeLogTextsSize := 0
341
325
342
-
/*Tags: */
343
-
344
-
nameInd := RPMHdrIndex{
345
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 232}),
346
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
347
-
Offset: 0,
348
-
Count: 1,
326
+
for _, entry := range pd.FileMetadata.Changelogs {
327
+
if entry != nil {
328
+
changeLogNames = append(changeLogNames, entry.Author)
329
+
changeLogTexts = append(changeLogTexts, entry.Text)
330
+
changeLogTimes = append(changeLogTimes, uint32(int64(entry.Date)))
331
+
changeLogNamesSize += len(entry.Author) + 1
332
+
changeLogTextsSize += len(entry.Text) + 1
333
+
changeLogTimesSize += 4
349
334
}
350
-
indexPtrs = append(indexPtrs, &nameInd)
351
-
indexes[&nameInd] = append(indexes[&nameInd], pd.Package.Name)
352
-
hdr.NIndex++
353
-
hdr.HSize += uint32(len(pd.Package.Name) + 1)
335
+
}
354
336
355
-
// Индекс для версии пакета
356
-
versionInd := RPMHdrIndex{
357
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 233}),
358
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
359
-
Offset: hdr.HSize,
360
-
Count: 1,
361
-
}
362
-
indexPtrs = append(indexPtrs, &versionInd)
363
-
indexes[&versionInd] = append(indexes[&versionInd], pd.FileMetadata.Version)
364
-
hdr.NIndex++
365
-
hdr.HSize += uint32(len(pd.FileMetadata.Version) + 1)
337
+
/*Header*/
338
+
hdr := &RPMHeader{
339
+
Magic: [4]byte{0x8E, 0xAD, 0xE8, 0x01},
340
+
Reserved: [4]byte{0, 0, 0, 0},
341
+
NIndex: binary.BigEndian.Uint32([]byte{0, 0, 0, 0}),
342
+
HSize: binary.BigEndian.Uint32([]byte{0, 0, 0, 0}),
343
+
}
344
+
orderedHeader := headerWithIndexes{hdr, []indexWithData{}}
366
345
367
-
summaryInd := RPMHdrIndex{
368
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 236}),
369
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 9}),
370
-
Offset: hdr.HSize,
371
-
Count: 1,
372
-
}
373
-
indexPtrs = append(indexPtrs, &summaryInd)
374
-
indexes[&summaryInd] = append(indexes[&summaryInd], pd.VersionMetadata.Summary)
375
-
hdr.NIndex++
376
-
hdr.HSize += uint32(len(pd.VersionMetadata.Summary) + 1)
346
+
/*Tags: */
347
+
nameInd := RPMHdrIndex{
348
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 232}),
349
+
Type: 6,
350
+
Offset: 0,
351
+
Count: 1,
352
+
}
353
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
354
+
index: &nameInd,
355
+
data: []any{pd.Package.Name},
356
+
})
357
+
hdr.NIndex++
358
+
hdr.HSize += uint32(len(pd.Package.Name) + 1)
377
359
378
-
descriptionInd := RPMHdrIndex{
379
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 237}),
380
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 9}),
381
-
Offset: hdr.HSize,
382
-
Count: 1,
383
-
}
384
-
indexPtrs = append(indexPtrs, &descriptionInd)
385
-
indexes[&descriptionInd] = append(indexes[&descriptionInd], pd.VersionMetadata.Description)
386
-
hdr.NIndex++
387
-
hdr.HSize += uint32(len(pd.VersionMetadata.Description) + 1)
360
+
// Индекс для версии пакета
361
+
versionInd := RPMHdrIndex{
362
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 233}),
363
+
Type: 6,
364
+
Offset: hdr.HSize,
365
+
Count: 1,
366
+
}
367
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
368
+
index: &versionInd,
369
+
data: []any{pd.FileMetadata.Version},
370
+
})
371
+
hdr.NIndex++
372
+
hdr.HSize += uint32(len(pd.FileMetadata.Version) + 1)
388
373
389
-
releaseInd := RPMHdrIndex{
390
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 234}),
391
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
392
-
Offset: hdr.HSize,
393
-
Count: 1,
394
-
}
395
-
indexPtrs = append(indexPtrs, &releaseInd)
396
-
indexes[&releaseInd] = append(indexes[&releaseInd], pd.FileMetadata.Release)
397
-
hdr.NIndex++
398
-
hdr.HSize += uint32(len(pd.FileMetadata.Release) + 1)
374
+
summaryInd := RPMHdrIndex{
375
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 236}),
376
+
Type: 9,
377
+
Offset: hdr.HSize,
378
+
Count: 1,
379
+
}
380
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
381
+
index: &summaryInd,
382
+
data: []any{pd.VersionMetadata.Summary},
383
+
})
384
+
hdr.NIndex++
385
+
hdr.HSize += uint32(len(pd.VersionMetadata.Summary) + 1)
399
386
400
-
alignPadding(hdr, indexes, &releaseInd)
387
+
descriptionInd := RPMHdrIndex{
388
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 237}),
389
+
Type: 9,
390
+
Offset: hdr.HSize,
391
+
Count: 1,
392
+
}
393
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
394
+
index: &descriptionInd,
395
+
data: []any{pd.VersionMetadata.Description},
396
+
})
397
+
hdr.NIndex++
398
+
hdr.HSize += uint32(len(pd.VersionMetadata.Description) + 1)
401
399
402
-
sizeInd := RPMHdrIndex{
403
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 241}),
404
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 4}),
405
-
Offset: hdr.HSize,
406
-
Count: 1,
407
-
}
408
-
indexPtrs = append(indexPtrs, &sizeInd)
409
-
indexes[&sizeInd] = append(indexes[&sizeInd], int32(pd.FileMetadata.InstalledSize))
410
-
hdr.NIndex++
411
-
hdr.HSize += 4
400
+
releaseInd := RPMHdrIndex{
401
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 234}),
402
+
Type: 6,
403
+
Offset: hdr.HSize,
404
+
Count: 1,
405
+
}
406
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
407
+
index: &releaseInd,
408
+
data: []any{pd.FileMetadata.Release},
409
+
})
410
+
hdr.NIndex++
411
+
hdr.HSize += uint32(len(pd.FileMetadata.Release) + 1)
412
412
413
-
buildTimeInd := RPMHdrIndex{
414
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 238}),
415
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 4}),
416
-
Offset: hdr.HSize,
417
-
Count: 1,
418
-
}
419
-
indexPtrs = append(indexPtrs, &buildTimeInd)
420
-
indexes[&buildTimeInd] = append(indexes[&buildTimeInd], int32(pd.FileMetadata.BuildTime))
421
-
hdr.NIndex++
422
-
hdr.HSize += 4
413
+
alignPadding(hdr, orderedHeader.indexes)
423
414
424
-
licenseInd := RPMHdrIndex{
425
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 246}),
426
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
427
-
Offset: hdr.HSize,
428
-
Count: 1,
429
-
}
430
-
indexPtrs = append(indexPtrs, &licenseInd)
431
-
indexes[&licenseInd] = append(indexes[&licenseInd], pd.VersionMetadata.License)
432
-
hdr.NIndex++
433
-
hdr.HSize += uint32(len(pd.VersionMetadata.License) + 1)
415
+
sizeInd := RPMHdrIndex{
416
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 241}),
417
+
Type: 4,
418
+
Offset: hdr.HSize,
419
+
Count: 1,
420
+
}
421
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
422
+
index: &sizeInd,
423
+
data: []any{int32(pd.FileMetadata.InstalledSize)},
424
+
})
425
+
hdr.NIndex++
426
+
hdr.HSize += 4
434
427
435
-
packagerInd := RPMHdrIndex{
436
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 247}),
437
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
438
-
Offset: hdr.HSize,
439
-
Count: 1,
440
-
}
441
-
indexPtrs = append(indexPtrs, &packagerInd)
442
-
indexes[&packagerInd] = append(indexes[&packagerInd], pd.FileMetadata.Packager)
443
-
hdr.NIndex++
444
-
hdr.HSize += uint32(len(pd.FileMetadata.Packager) + 1)
428
+
buildTimeInd := RPMHdrIndex{
429
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 238}),
430
+
Type: 4,
431
+
Offset: hdr.HSize,
432
+
Count: 1,
433
+
}
434
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
435
+
index: &buildTimeInd,
436
+
data: []any{int32(pd.FileMetadata.BuildTime)},
437
+
})
438
+
hdr.NIndex++
439
+
hdr.HSize += 4
445
440
446
-
groupInd := RPMHdrIndex{
447
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 248}),
448
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
449
-
Offset: hdr.HSize,
450
-
Count: 1,
451
-
}
452
-
indexPtrs = append(indexPtrs, &groupInd)
453
-
indexes[&groupInd] = append(indexes[&groupInd], pd.FileMetadata.Group)
454
-
hdr.NIndex++
455
-
hdr.HSize += uint32(len(pd.FileMetadata.Group) + 1)
441
+
licenseInd := RPMHdrIndex{
442
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 246}),
443
+
Type: 6,
444
+
Offset: hdr.HSize,
445
+
Count: 1,
446
+
}
447
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
448
+
index: &licenseInd,
449
+
data: []any{pd.VersionMetadata.License},
450
+
})
451
+
hdr.NIndex++
452
+
hdr.HSize += uint32(len(pd.VersionMetadata.License) + 1)
456
453
457
-
urlInd := RPMHdrIndex{
458
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 252}),
459
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
460
-
Offset: hdr.HSize,
461
-
Count: 1,
462
-
}
463
-
indexPtrs = append(indexPtrs, &urlInd)
464
-
indexes[&urlInd] = append(indexes[&urlInd], pd.VersionMetadata.ProjectURL)
465
-
hdr.NIndex++
466
-
hdr.HSize += uint32(len(pd.VersionMetadata.ProjectURL) + 1)
454
+
packagerInd := RPMHdrIndex{
455
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 247}),
456
+
Type: 6,
457
+
Offset: hdr.HSize,
458
+
Count: 1,
459
+
}
460
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
461
+
index: &packagerInd,
462
+
data: []any{pd.FileMetadata.Packager},
463
+
})
464
+
hdr.NIndex++
465
+
hdr.HSize += uint32(len(pd.FileMetadata.Packager) + 1)
467
466
468
-
if len(changeLogNames) != 0 && len(changeLogTexts) != 0 && len(changeLogTimes) != 0 {
469
-
alignPadding(hdr, indexes, &urlInd)
467
+
groupInd := RPMHdrIndex{
468
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 248}),
469
+
Type: 6,
470
+
Offset: hdr.HSize,
471
+
Count: 1,
472
+
}
473
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
474
+
index: &groupInd,
475
+
data: []any{pd.FileMetadata.Group},
476
+
})
477
+
hdr.NIndex++
478
+
hdr.HSize += uint32(len(pd.FileMetadata.Group) + 1)
470
479
471
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x38}, []byte{0, 0, 0, 4}, changeLogTimes, changeLogTimesSize)
472
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x39}, []byte{0, 0, 0, 8}, changeLogNames, changeLogNamesSize)
473
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x3A}, []byte{0, 0, 0, 8}, changeLogTexts, changeLogTextsSize)
474
-
}
480
+
urlInd := RPMHdrIndex{
481
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 252}),
482
+
Type: 6,
483
+
Offset: hdr.HSize,
484
+
Count: 1,
485
+
}
486
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
487
+
index: &urlInd,
488
+
data: []any{pd.VersionMetadata.ProjectURL},
489
+
})
490
+
hdr.NIndex++
491
+
hdr.HSize += uint32(len(pd.VersionMetadata.ProjectURL) + 1)
475
492
476
-
archInd := RPMHdrIndex{
477
-
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 254}),
478
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
479
-
Offset: hdr.HSize,
480
-
Count: 1,
481
-
}
482
-
indexPtrs = append(indexPtrs, &archInd)
483
-
indexes[&archInd] = append(indexes[&archInd], pd.FileMetadata.Architecture)
484
-
hdr.NIndex++
485
-
hdr.HSize += uint32(len(pd.FileMetadata.Architecture) + 1)
493
+
if len(changeLogNames) != 0 && len(changeLogTexts) != 0 && len(changeLogTimes) != 0 {
494
+
alignPadding(hdr, orderedHeader.indexes)
486
495
487
-
if len(provideNames) != 0 && len(provideVersions) != 0 && len(provideFlags) != 0 {
488
-
alignPadding(hdr, indexes, &archInd)
496
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x38}, 4, changeLogTimes, changeLogTimesSize)
497
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x39}, 8, changeLogNames, changeLogNamesSize)
498
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x3A}, 8, changeLogTexts, changeLogTextsSize)
499
+
}
489
500
490
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x58}, []byte{0, 0, 0, 4}, provideFlags, provideFlagsSize)
491
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x17}, []byte{0, 0, 0, 8}, provideNames, provideNamesSize)
492
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x59}, []byte{0, 0, 0, 8}, provideVersions, provideVersionsSize)
493
-
}
501
+
archInd := RPMHdrIndex{
502
+
Tag: binary.BigEndian.Uint32([]byte{0, 0, 3, 254}),
503
+
Type: 6,
504
+
Offset: hdr.HSize,
505
+
Count: 1,
506
+
}
507
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
508
+
index: &archInd,
509
+
data: []any{pd.FileMetadata.Architecture},
510
+
})
511
+
hdr.NIndex++
512
+
hdr.HSize += uint32(len(pd.FileMetadata.Architecture) + 1)
494
513
495
-
sourceRpmInd := RPMHdrIndex{
496
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x14}),
497
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
498
-
Offset: hdr.HSize,
499
-
Count: 1,
500
-
}
501
-
indexPtrs = append(indexPtrs, &sourceRpmInd)
502
-
indexes[&sourceRpmInd] = append(indexes[&sourceRpmInd], pd.FileMetadata.SourceRpm)
503
-
hdr.NIndex++
504
-
hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(len(pd.FileMetadata.SourceRpm) + 1)})
514
+
if len(provideNames) != 0 && len(provideVersions) != 0 && len(provideFlags) != 0 {
515
+
alignPadding(hdr, orderedHeader.indexes)
505
516
506
-
if len(requireNames) != 0 && len(requireVersions) != 0 && len(requireFlags) != 0 {
507
-
alignPadding(hdr, indexes, &sourceRpmInd)
517
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x58}, 4, provideFlags, provideFlagsSize)
518
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x17}, 8, provideNames, provideNamesSize)
519
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x59}, 8, provideVersions, provideVersionsSize)
520
+
}
508
521
509
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x18}, []byte{0, 0, 0, 4}, requireFlags, requireFlagsSize)
510
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0, 0, 4, 25}, []byte{0, 0, 0, 8}, requireNames, requireNamesSize)
511
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1A}, []byte{0, 0, 0, 8}, requireVersions, requireVersionsSize)
512
-
}
522
+
sourceRpmInd := RPMHdrIndex{
523
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x14}),
524
+
Type: 6,
525
+
Offset: hdr.HSize,
526
+
Count: 1,
527
+
}
528
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
529
+
index: &sourceRpmInd,
530
+
data: []any{pd.FileMetadata.SourceRpm},
531
+
})
532
+
hdr.NIndex++
533
+
hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(len(pd.FileMetadata.SourceRpm) + 1)})
513
534
514
-
if len(baseNames) != 0 {
515
-
baseNamesInd := RPMHdrIndex{
516
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x5D}),
517
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 8}),
518
-
Offset: hdr.HSize,
519
-
Count: uint32(len(baseNames)),
520
-
}
521
-
indexPtrs = append(indexPtrs, &baseNamesInd)
522
-
indexes[&baseNamesInd] = baseNames
523
-
hdr.NIndex++
524
-
hdr.HSize += uint32(baseNamesSize)
525
-
}
535
+
if len(requireNames) != 0 && len(requireVersions) != 0 && len(requireFlags) != 0 {
536
+
alignPadding(hdr, orderedHeader.indexes)
526
537
527
-
if len(dirNames) != 0 {
528
-
dirnamesInd := RPMHdrIndex{
529
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x5E}),
530
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 8}),
531
-
Offset: hdr.HSize,
532
-
Count: uint32(len(dirNames)),
533
-
}
534
-
indexPtrs = append(indexPtrs, &dirnamesInd)
535
-
indexes[&dirnamesInd] = dirNames
536
-
hdr.NIndex++
537
-
hdr.HSize += uint32(dirNamesSize)
538
-
}
538
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x18}, 4, requireFlags, requireFlagsSize)
539
+
addRPMHdrIndex(&orderedHeader, []byte{0, 0, 4, 25}, 8, requireNames, requireNamesSize)
540
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1A}, 8, requireVersions, requireVersionsSize)
541
+
}
539
542
540
-
filenameInd := RPMHdrIndex{
541
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x40}),
542
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
543
+
if len(baseNames) != 0 {
544
+
baseNamesInd := RPMHdrIndex{
545
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x5D}),
546
+
Type: 8,
543
547
Offset: hdr.HSize,
544
-
Count: 1,
548
+
Count: uint32(len(baseNames)),
545
549
}
546
-
indexPtrs = append(indexPtrs, &filenameInd)
547
-
indexes[&filenameInd] = append(indexes[&filenameInd], pf.Name)
550
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
551
+
index: &baseNamesInd,
552
+
data: baseNames,
553
+
})
548
554
hdr.NIndex++
549
-
hdr.HSize += uint32(len(pf.Name) + 1)
550
-
551
-
alignPadding(hdr, indexes, &filenameInd)
555
+
hdr.HSize += uint32(baseNamesSize)
556
+
}
552
557
553
-
filesizeInd := RPMHdrIndex{
554
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x41}),
555
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 4}),
558
+
if len(dirNames) != 0 {
559
+
dirnamesInd := RPMHdrIndex{
560
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x00, 0x04, 0x5E}),
561
+
Type: 8,
556
562
Offset: hdr.HSize,
557
-
Count: 1,
563
+
Count: uint32(len(dirNames)),
558
564
}
559
-
indexPtrs = append(indexPtrs, &filesizeInd)
560
-
indexes[&filesizeInd] = append(indexes[&filesizeInd], int32(pd.Blob.Size))
565
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
566
+
index: &dirnamesInd,
567
+
data: dirNames,
568
+
})
561
569
hdr.NIndex++
562
-
hdr.HSize += 4
570
+
hdr.HSize += uint32(dirNamesSize)
571
+
}
563
572
564
-
md5Ind := RPMHdrIndex{
565
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x45}),
566
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
567
-
Offset: hdr.HSize,
568
-
Count: 1,
569
-
}
570
-
indexPtrs = append(indexPtrs, &md5Ind)
571
-
indexes[&md5Ind] = append(indexes[&md5Ind], pd.Blob.HashMD5)
572
-
hdr.NIndex++
573
-
hdr.HSize += uint32(len(pd.Blob.HashMD5) + 1)
573
+
filenameInd := RPMHdrIndex{
574
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x40}),
575
+
Type: 6,
576
+
Offset: hdr.HSize,
577
+
Count: 1,
578
+
}
579
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
580
+
index: &filenameInd,
581
+
data: []any{pf.Name},
582
+
})
583
+
hdr.NIndex++
584
+
hdr.HSize += uint32(len(pf.Name) + 1)
574
585
575
-
blake2bInd := RPMHdrIndex{
576
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x49}),
577
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
578
-
Offset: hdr.HSize,
579
-
Count: 1,
580
-
}
581
-
indexPtrs = append(indexPtrs, &blake2bInd)
582
-
indexes[&blake2bInd] = append(indexes[&blake2bInd], pd.Blob.HashBlake2b)
583
-
hdr.NIndex++
584
-
hdr.HSize += uint32(len(pd.Blob.HashBlake2b) + 1)
586
+
alignPadding(hdr, orderedHeader.indexes)
585
587
586
-
if len(conflictNames) != 0 && len(conflictVersions) != 0 && len(conflictFlags) != 0 {
587
-
alignPadding(hdr, indexes, &blake2bInd)
588
+
filesizeInd := RPMHdrIndex{
589
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x41}),
590
+
Type: 4,
591
+
Offset: hdr.HSize,
592
+
Count: 1,
593
+
}
594
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
595
+
index: &filesizeInd,
596
+
data: []any{int32(pd.Blob.Size)},
597
+
})
598
+
hdr.NIndex++
599
+
hdr.HSize += 4
600
+
601
+
md5Ind := RPMHdrIndex{
602
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x45}),
603
+
Type: 6,
604
+
Offset: hdr.HSize,
605
+
Count: 1,
606
+
}
607
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
608
+
index: &md5Ind,
609
+
data: []any{pd.Blob.HashMD5},
610
+
})
611
+
hdr.NIndex++
612
+
hdr.HSize += uint32(len(pd.Blob.HashMD5) + 1)
588
613
589
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1D}, []byte{0, 0, 0, 4}, conflictFlags, conflictFlagsSize)
590
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1E}, []byte{0, 0, 0, 8}, conflictNames, conflictNamesSize)
591
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x1F}, []byte{0, 0, 0, 8}, conflictVersions, conflictVersionsSize)
592
-
}
614
+
blake2bInd := RPMHdrIndex{
615
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x49}),
616
+
Type: 6,
617
+
Offset: hdr.HSize,
618
+
Count: 1,
619
+
}
620
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
621
+
index: &blake2bInd,
622
+
data: []any{pd.Blob.HashBlake2b},
623
+
})
624
+
hdr.NIndex++
625
+
hdr.HSize += uint32(len(pd.Blob.HashBlake2b) + 1)
593
626
594
-
directoryInd := RPMHdrIndex{
595
-
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x4A}),
596
-
Type: binary.BigEndian.Uint32([]byte{0, 0, 0, 6}),
597
-
Offset: hdr.HSize,
598
-
Count: 1,
599
-
}
600
-
indexPtrs = append(indexPtrs, &directoryInd)
601
-
indexes[&directoryInd] = append(indexes[&directoryInd], "RPMS.classic")
602
-
hdr.NIndex++
603
-
hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(len("RPMS.classic") + 1)})
627
+
if len(conflictNames) != 0 && len(conflictVersions) != 0 && len(conflictFlags) != 0 {
628
+
alignPadding(hdr, orderedHeader.indexes)
604
629
605
-
if len(obsoleteNames) != 0 && len(obsoleteVersions) != 0 && len(obsoleteFlags) != 0 {
606
-
alignPadding(hdr, indexes, &directoryInd)
630
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1D}, 4, conflictFlags, conflictFlagsSize)
631
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1E}, 8, conflictNames, conflictNamesSize)
632
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x1F}, 8, conflictVersions, conflictVersionsSize)
633
+
}
607
634
608
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x5A}, []byte{0, 0, 0, 4}, obsoleteFlags, obsoleteFlagsSize)
609
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x42}, []byte{0, 0, 0, 8}, obsoleteNames, obsoleteNamesSize)
610
-
addRPMHdrIndex(hdr, &indexPtrs, indexes, []byte{0x00, 0x00, 0x04, 0x5B}, []byte{0, 0, 0, 8}, obsoleteVersions, obsoleteVersionsSize)
611
-
}
635
+
directoryInd := RPMHdrIndex{
636
+
Tag: binary.BigEndian.Uint32([]byte{0x00, 0x0F, 0x42, 0x4A}),
637
+
Type: 6,
638
+
Offset: hdr.HSize,
639
+
Count: 1,
640
+
}
641
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
642
+
index: &directoryInd,
643
+
data: []any{"RPMS.classic"},
644
+
})
645
+
hdr.NIndex++
646
+
hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(len("RPMS.classic") + 1)})
612
647
613
-
headersWithIndexes[hdr] = indexes
614
-
headersWithPtrs[hdr] = indexPtrs
648
+
if len(obsoleteNames) != 0 && len(obsoleteVersions) != 0 && len(obsoleteFlags) != 0 {
649
+
alignPadding(hdr, orderedHeader.indexes)
615
650
616
-
indexPtrs = []*RPMHdrIndex{}
617
-
indexes = make(map[*RPMHdrIndex][]any)
651
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x5A}, 4, obsoleteFlags, obsoleteFlagsSize)
652
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x42}, 8, obsoleteNames, obsoleteNamesSize)
653
+
addRPMHdrIndex(&orderedHeader, []byte{0x00, 0x00, 0x04, 0x5B}, 8, obsoleteVersions, obsoleteVersionsSize)
618
654
}
655
+
656
+
orderedHeaders = append(orderedHeaders, orderedHeader)
619
657
}
620
658
621
659
files := []string{"pkglist.classic", "pkglist.classic.xz"}
622
660
for file := range files {
623
-
fileInfo, err := addPkglistAsFileToRepo(ctx, pv, files[file], headersWithIndexes, headersWithPtrs, orderedHeaders, group, architectures[i])
661
+
fileInfo, err := addPkglistAsFileToRepo(ctx, pv, files[file], orderedHeaders, group, architecture)
624
662
if err != nil {
625
663
return nil, err
626
664
}
627
665
repoDataList = append(repoDataList, fileInfo)
628
-
repoDataListByArch[architectures[i]] = repoDataList
629
666
}
630
-
repoDataList = []any{}
631
-
orderedHeaders = []*RPMHeader{}
667
+
repoDataListByArch[architecture] = repoDataList
632
668
}
633
669
return repoDataListByArch, nil
634
670
}
635
671
636
-
func alignPadding(hdr *RPMHeader, indexes map[*RPMHdrIndex][]any, lastIndex *RPMHdrIndex) {
672
+
func alignPadding(hdr *RPMHeader, indexes []indexWithData) {
637
673
/* Align to 4-bytes to add a 4-byte element. */
638
674
padding := (4 - (hdr.HSize % 4)) % 4
639
675
if padding == 4 {
···
641
677
}
642
678
hdr.HSize += binary.BigEndian.Uint32([]byte{0, 0, 0, uint8(padding)})
643
679
680
+
lastIndex := len(indexes) - 1
644
681
for i := uint32(0); i < padding; i++ {
645
-
for _, elem := range indexes[lastIndex] {
682
+
for _, elem := range indexes[lastIndex].data {
646
683
if str, ok := elem.(string); ok {
647
-
indexes[lastIndex][len(indexes[lastIndex])-1] = str + "\x00"
684
+
indexes[lastIndex].data[len(indexes[lastIndex].data)-1] = str + "\x00"
648
685
}
649
686
}
650
687
}
651
688
}
652
689
653
-
func addRPMHdrIndex(hdr *RPMHeader, indexPtrs *[]*RPMHdrIndex, indexes map[*RPMHdrIndex][]any, tag, typeByte []byte, data []any, dataSize int) {
690
+
func addRPMHdrIndex(orderedHeader *headerWithIndexes, tag []byte, typeVal uint32, data []any, dataSize int) {
654
691
index := RPMHdrIndex{
655
692
Tag: binary.BigEndian.Uint32(tag),
656
-
Type: binary.BigEndian.Uint32(typeByte),
657
-
Offset: hdr.HSize,
693
+
Type: typeVal,
694
+
Offset: orderedHeader.header.HSize,
658
695
Count: uint32(len(data)),
659
696
}
660
-
*indexPtrs = append(*indexPtrs, &index)
661
-
indexes[&index] = data
662
-
hdr.NIndex++
663
-
hdr.HSize += uint32(dataSize)
697
+
orderedHeader.indexes = append(orderedHeader.indexes, indexWithData{
698
+
index: &index,
699
+
data: data,
700
+
})
701
+
orderedHeader.header.NIndex++
702
+
orderedHeader.header.HSize += uint32(dataSize)
664
703
}
665
704
666
705
// https://www.altlinux.org/APT_в_ALT_Linux/CreateRepository
667
-
func buildRelease(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string, pkglist map[string][]any) error {
668
-
var buf bytes.Buffer
669
-
670
-
architectures := []string{}
706
+
func buildRelease(ctx context.Context, pv *packages_model.PackageVersion, pfs []*packages_model.PackageFile, c packageCache, group string, pkglist map[string][]*repoData) error {
707
+
architectures := make(container.Set[string])
671
708
672
709
for _, pf := range pfs {
673
710
pd := c[pf]
674
-
if !slices.Contains(architectures, pd.FileMetadata.Architecture) {
675
-
architectures = append(architectures, pd.FileMetadata.Architecture)
676
-
}
711
+
architectures.Add(pd.FileMetadata.Architecture)
677
712
}
678
713
679
-
for i := range architectures {
680
-
archive := "Alt Linux Team"
681
-
component := "classic"
682
-
version := strconv.FormatInt(time.Now().Unix(), 10)
683
-
architectures := architectures[i]
684
-
origin := "Alt Linux Team"
714
+
for architecture := range architectures {
715
+
version := time.Now().Unix()
685
716
label := setting.AppName
686
-
notautomatic := "false"
687
-
data := fmt.Sprintf("Archive: %s\nComponent: %s\nVersion: %s\nOrigin: %s\nLabel: %s\nArchitecture: %s\nNotAutomatic: %s",
688
-
archive, component, version, origin, label, architectures, notautomatic)
689
-
buf.WriteString(data + "\n")
690
-
fileInfo, err := addReleaseAsFileToRepo(ctx, pv, "release.classic", buf.String(), group, architectures)
717
+
data := fmt.Sprintf(`Archive: Alt Linux Team
718
+
Component: classic
719
+
Version: %d
720
+
Origin: Alt Linux Team
721
+
Label: %s
722
+
Architecture: %s
723
+
NotAutomatic: false
724
+
`,
725
+
version, label, architecture)
726
+
fileInfo, err := addReleaseAsFileToRepo(ctx, pv, "release.classic", data, group, architecture)
691
727
if err != nil {
692
728
return err
693
729
}
694
-
buf.Reset()
695
730
696
-
origin = setting.AppName
697
-
suite := "Sisyphus"
698
-
codename := strconv.FormatInt(time.Now().Unix(), 10)
731
+
origin := setting.AppName
732
+
codename := time.Now().Unix()
699
733
date := time.Now().UTC().Format(time.RFC1123)
700
734
701
735
var md5Sum string
702
736
var blake2b string
703
737
704
-
for _, pkglistByArch := range pkglist[architectures] {
705
-
md5Sum += fmt.Sprintf(" %s %s %s\n", pkglistByArch.([]string)[2], pkglistByArch.([]string)[4], "base/"+pkglistByArch.([]string)[0])
706
-
blake2b += fmt.Sprintf(" %s %s %s\n", pkglistByArch.([]string)[3], pkglistByArch.([]string)[4], "base/"+pkglistByArch.([]string)[0])
738
+
for _, pkglistByArch := range pkglist[architecture] {
739
+
md5Sum += fmt.Sprintf(" %s %d %s\n", pkglistByArch.MD5Checksum.Value, pkglistByArch.Size, "base/"+pkglistByArch.Type)
740
+
blake2b += fmt.Sprintf(" %s %d %s\n", pkglistByArch.Blake2bHash.Value, pkglistByArch.Size, "base/"+pkglistByArch.Type)
707
741
}
708
-
md5Sum += fmt.Sprintf(" %s %s %s\n", fileInfo[2], fileInfo[4], "base/"+fileInfo[0])
709
-
blake2b += fmt.Sprintf(" %s %s %s\n", fileInfo[3], fileInfo[4], "base/"+fileInfo[0])
742
+
md5Sum += fmt.Sprintf(" %s %d %s\n", fileInfo.MD5Checksum.Value, fileInfo.Size, "base/"+fileInfo.Type)
743
+
blake2b += fmt.Sprintf(" %s %d %s\n", fileInfo.Blake2bHash.Value, fileInfo.Size, "base/"+fileInfo.Type)
710
744
711
-
data = fmt.Sprintf("Origin: %s\nLabel: %s\nSuite: %s\nCodename: %s\nDate: %s\nArchitectures: %s\nMD5Sum:\n%sBLAKE2b:\n%s\n",
712
-
origin, label, suite, codename, date, architectures, md5Sum, blake2b)
713
-
buf.WriteString(data + "\n")
714
-
_, err = addReleaseAsFileToRepo(ctx, pv, "release", buf.String(), group, architectures)
745
+
data = fmt.Sprintf(`Origin: %s
746
+
Label: %s
747
+
Suite: Sisyphus
748
+
Codename: %d
749
+
Date: %s
750
+
Architectures: %s
751
+
MD5Sum:
752
+
%sBLAKE2b:
753
+
%s
754
+
755
+
`,
756
+
origin, label, codename, date, architecture, md5Sum, blake2b)
757
+
_, err = addReleaseAsFileToRepo(ctx, pv, "release", data, group, architecture)
715
758
if err != nil {
716
759
return err
717
760
}
718
-
buf.Reset()
719
761
}
720
762
return nil
721
763
}
722
764
723
-
func addReleaseAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersion, filename, obj, group, arch string) ([]string, error) {
765
+
func addReleaseAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersion, filename, obj, group, arch string) (*repoData, error) {
724
766
content, _ := packages_module.NewHashedBuffer()
725
767
defer content.Close()
726
768
···
755
797
group = "alt"
756
798
}
757
799
758
-
repoData := &repoData{
800
+
return &repoData{
759
801
Type: filename,
760
802
Checksum: repoChecksum{
761
803
Type: "sha256",
···
777
819
Href: group + ".repo/" + arch + "/base/" + filename,
778
820
},
779
821
Size: content.Size(),
780
-
/* Unused values:
781
-
Timestamp: time.Now().Unix(),
782
-
OpenSize: content.Size(), */
783
-
}
784
-
785
-
data := []string{
786
-
repoData.Type, repoData.Checksum.Value,
787
-
repoData.MD5Checksum.Value, repoData.Blake2bHash.Value, strconv.Itoa(int(repoData.Size)),
788
-
}
789
-
790
-
return data, nil
822
+
}, nil
791
823
}
792
824
793
-
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) {
825
+
func addPkglistAsFileToRepo(ctx context.Context, pv *packages_model.PackageVersion, filename string, orderedHeaders []headerWithIndexes, group, arch string) (*repoData, error) {
794
826
content, _ := packages_module.NewHashedBuffer()
795
827
defer content.Close()
796
828
···
799
831
buf := &bytes.Buffer{}
800
832
801
833
for _, hdr := range orderedHeaders {
802
-
if err := binary.Write(buf, binary.BigEndian, hdr); err != nil {
834
+
if err := binary.Write(buf, binary.BigEndian, *hdr.header); err != nil {
803
835
return nil, err
804
836
}
805
837
806
-
for _, indexPtr := range headersWithPtrs[hdr] {
807
-
index := *indexPtr
808
-
809
-
if err := binary.Write(buf, binary.BigEndian, index); err != nil {
838
+
for _, index := range hdr.indexes {
839
+
if err := binary.Write(buf, binary.BigEndian, *index.index); err != nil {
810
840
return nil, err
811
841
}
812
842
}
813
843
814
-
for _, indexPtr := range headersWithPtrs[hdr] {
815
-
for _, indexValue := range headersWithIndexes[hdr][indexPtr] {
844
+
for _, index := range hdr.indexes {
845
+
for _, indexValue := range index.data {
816
846
switch v := indexValue.(type) {
817
847
case string:
818
848
if _, err := buf.WriteString(v + "\x00"); err != nil {
···
827
857
}
828
858
}
829
859
830
-
parts := strings.Split(filename, ".")
831
-
832
-
if len(parts) == 3 && parts[len(parts)-1] == "xz" {
860
+
if path.Ext(filename) == ".xz" {
833
861
xzContent, err := compressXZ(buf.Bytes())
834
862
if err != nil {
835
863
return nil, err
···
867
895
group = "alt"
868
896
}
869
897
870
-
repoData := &repoData{
898
+
return &repoData{
871
899
Type: filename,
872
900
Checksum: repoChecksum{
873
901
Type: "sha256",
···
889
917
Href: group + ".repo/" + arch + "/base/" + filename,
890
918
},
891
919
Size: content.Size(),
892
-
/* Unused values:
893
-
Timestamp: time.Now().Unix(),
894
-
OpenSize: content.Size(), */
895
-
}
896
-
897
-
data := []string{
898
-
repoData.Type, repoData.Checksum.Value,
899
-
repoData.MD5Checksum.Value, repoData.Blake2bHash.Value, strconv.Itoa(int(repoData.Size)),
900
-
}
901
-
902
-
return data, nil
920
+
}, nil
903
921
}
904
922
905
923
func compressXZ(data []byte) ([]byte, error) {
···
908
926
if err != nil {
909
927
return nil, err
910
928
}
911
-
defer xzWriter.Close()
912
929
913
-
if _, err := xzWriter.Write(data); err != nil {
914
-
return nil, err
915
-
}
916
-
if err := xzWriter.Close(); err != nil {
930
+
_, err = xzWriter.Write(data)
931
+
xzWriter.Close()
932
+
if err != nil {
917
933
return nil, err
918
934
}
919
935