enabled housekeeping; almost complete

refactoring

main.go

@@ -61,7 +61,7 @@ func (b *BuildManager) buildWorker(id int) {
 
 			log.Infof("[%s/%s] Build starting", pkg.FullRepo, pkg.Pkgbase)
 
-			dbPkg := getDbPackage(pkg)
+			dbPkg := pkg.toDbPackage(true)
 			dbPkg = dbPkg.Update().SetStatus(dbpackage.StatusBuilding).ClearSkipReason().SaveX(context.Background())
 
 			err := importKeys(pkg)
@@ -69,7 +69,7 @@ func (b *BuildManager) buildWorker(id int) {
 				log.Warningf("[%s/%s] Failed to import pgp keys: %v", pkg.FullRepo, pkg.Pkgbase, err)
 			}
 
-			err = increasePkgRel(pkg)
+			err = pkg.increasePkgRel()
 			if err != nil {
 				log.Errorf("[%s/%s] Failed to increase pkgrel: %v", pkg.FullRepo, pkg.Pkgbase, err)
 				b.buildWG.Done()
@@ -133,7 +133,6 @@ func (b *BuildManager) buildWorker(id int) {
 
 			pkgFiles, err := filepath.Glob(filepath.Join(filepath.Dir(pkg.Pkgbuild), "*.pkg.tar.zst"))
 			check(err)
-			log.Debug(pkgFiles)
 
 			if len(pkgFiles) == 0 {
 				log.Warningf("No packages found after building %s. Abort build.", pkg.Pkgbase)
@@ -195,38 +194,36 @@ func (b *BuildManager) parseWorker() {
 		}
 		select {
 		case pkg := <-b.parse:
-			info, err := genSRCINFO(pkg.Pkgbuild)
+			if err := pkg.genSrcinfo(); err != nil {
-			if err != nil {
 				log.Warningf("Failed to generate SRCINFO for %s: %v", pkg.Pkgbase, err)
 				b.parseWG.Done()
 				continue
 			}
-			pkg.Srcinfo = info
 			pkg.Version = constructVersion(pkg.Srcinfo.Pkgver, pkg.Srcinfo.Pkgrel, pkg.Srcinfo.Epoch)
 
-			dbPkg := getDbPackage(pkg)
+			dbPkg := pkg.toDbPackage(true)
 
 			skipping := false
-			if contains(info.Arch, "any") {
+			if contains(pkg.Srcinfo.Arch, "any") {
-				log.Debugf("Skipped %s: any-Package", info.Pkgbase)
+				log.Debugf("Skipped %s: any-Package", pkg.Srcinfo.Pkgbase)
 				dbPkg.SkipReason = "arch = any"
 				dbPkg.Status = dbpackage.StatusSkipped
 				skipping = true
-			} else if contains(conf.Blacklist.Packages, info.Pkgbase) {
+			} else if contains(conf.Blacklist.Packages, pkg.Srcinfo.Pkgbase) {
-				log.Debugf("Skipped %s: blacklisted package", info.Pkgbase)
+				log.Debugf("Skipped %s: blacklisted package", pkg.Srcinfo.Pkgbase)
 				dbPkg.SkipReason = "blacklisted"
 				dbPkg.Status = dbpackage.StatusSkipped
 				skipping = true
-			} else if contains(info.MakeDepends, "ghc") || contains(info.MakeDepends, "haskell-ghc") || contains(info.Depends, "ghc") || contains(info.Depends, "haskell-ghc") {
+			} else if contains(pkg.Srcinfo.MakeDepends, "ghc") || contains(pkg.Srcinfo.MakeDepends, "haskell-ghc") || contains(pkg.Srcinfo.Depends, "ghc") || contains(pkg.Srcinfo.Depends, "haskell-ghc") {
 				// Skip Haskell packages for now, as we are facing linking problems with them,
 				// most likely caused by not having a dependency check implemented yet and building at random.
 				// https://git.harting.dev/anonfunc/ALHP.GO/issues/11
-				log.Debugf("Skipped %s: haskell package", info.Pkgbase)
+				log.Debugf("Skipped %s: haskell package", pkg.Srcinfo.Pkgbase)
 				dbPkg.SkipReason = "blacklisted (haskell)"
 				dbPkg.Status = dbpackage.StatusSkipped
 				skipping = true
 			} else if isPkgFailed(pkg, dbPkg) {
-				log.Debugf("Skipped %s: failed build", info.Pkgbase)
+				log.Debugf("Skipped %s: failed build", pkg.Srcinfo.Pkgbase)
 				skipping = true
 			}
 
@@ -239,29 +236,29 @@ func (b *BuildManager) parseWorker() {
 				dbPkg = dbPkg.Update().SetUpdated(time.Now()).SetVersion(pkg.Version).SaveX(context.Background())
 			}
 
-			repoVer, err := getVersionFromRepo(pkg)
+			repoVer, err := pkg.repoVersion()
 			if err != nil {
 				dbPkg = dbPkg.Update().ClearRepoVersion().SaveX(context.Background())
 			} else if err == nil && alpm.VerCmp(repoVer, pkg.Version) > 0 {
-				log.Debugf("Skipped %s: Version in repo higher than in PKGBUILD (%s < %s)", info.Pkgbase, pkg.Version, repoVer)
+				log.Debugf("Skipped %s: Version in repo higher than in PKGBUILD (%s < %s)", pkg.Srcinfo.Pkgbase, pkg.Version, repoVer)
 				dbPkg = dbPkg.Update().SetStatus(dbpackage.StatusLatest).ClearSkipReason().SetHash(pkg.Hash).SaveX(context.Background())
 				b.parseWG.Done()
 				continue
 			}
 
-			isLatest, local, syncVersion, err := isMirrorLatest(alpmHandle, pkg)
+			isLatest, local, syncVersion, err := pkg.isMirrorLatest(alpmHandle)
 			if err != nil {
 				switch err.(type) {
 				default:
-					log.Warningf("[%s/%s] Problem solving dependencies: %v", pkg.FullRepo, info.Pkgbase, err)
+					log.Warningf("[%s/%s] Problem solving dependencies: %v", pkg.FullRepo, pkg.Srcinfo.Pkgbase, err)
 				case MultiplePKGBUILDError:
-					log.Infof("Skipped %s: Multiple PKGBUILDs for dependency found: %v", info.Pkgbase, err)
+					log.Infof("Skipped %s: Multiple PKGBUILDs for dependency found: %v", pkg.Srcinfo.Pkgbase, err)
 					dbPkg = dbPkg.Update().SetStatus(dbpackage.StatusSkipped).SetSkipReason("multiple PKGBUILD for dep. found").SaveX(context.Background())
 					b.repoPurge[pkg.FullRepo] <- pkg
 					b.parseWG.Done()
 					continue
 				case UnableToSatisfyError:
-					log.Infof("Skipped %s: unable to resolve dependencies: %v", info.Pkgbase, err)
+					log.Infof("Skipped %s: unable to resolve dependencies: %v", pkg.Srcinfo.Pkgbase, err)
 					dbPkg = dbPkg.Update().SetStatus(dbpackage.StatusSkipped).SetSkipReason("unable to resolve dependencies").SaveX(context.Background())
 					b.repoPurge[pkg.FullRepo] <- pkg
 					b.parseWG.Done()
@@ -273,10 +270,10 @@ func (b *BuildManager) parseWorker() {
 
 			if !isLatest {
 				if local != nil {
-					log.Infof("Delayed %s: not all dependencies are up to date (local: %s==%s, sync: %s==%s)", info.Pkgbase, local.Name(), local.Version(), local.Name(), syncVersion)
+					log.Infof("Delayed %s: not all dependencies are up to date (local: %s==%s, sync: %s==%s)", pkg.Srcinfo.Pkgbase, local.Name(), local.Version(), local.Name(), syncVersion)
 					dbPkg.Update().SetSkipReason(fmt.Sprintf("waiting for %s==%s", local.Name(), syncVersion)).ExecX(context.Background())
 				} else {
-					log.Infof("Delayed %s: not all dependencies are up to date or resolvable", info.Pkgbase)
+					log.Infof("Delayed %s: not all dependencies are up to date or resolvable", pkg.Srcinfo.Pkgbase)
 					dbPkg.Update().SetSkipReason("waiting for mirror").ExecX(context.Background())
 				}
 
@@ -372,7 +369,9 @@ func (b *BuildManager) htmlWorker() {
 
 					switch pkg.Lto {
 					case dbpackage.LtoUnknown:
-						addPkg.LTOUnknown = true
+						if pkg.Status != dbpackage.StatusSkipped {
+							addPkg.LTOUnknown = true
+						}
 					case dbpackage.LtoEnabled:
 						addPkg.LTO = true
 					case dbpackage.LtoDisabled:
@@ -412,7 +411,7 @@ func (b *BuildManager) repoWorker(repo string) {
 				log.Panicf("%s while repo-add: %v", string(res), err)
 			}
 
-			dbPkg := getDbPackage(pkg)
+			dbPkg := pkg.toDbPackage(true)
 			dbPkg = dbPkg.Update().SetStatus(dbpackage.StatusLatest).ClearSkipReason().SetRepoVersion(pkg.Version).SetHash(pkg.Hash).SaveX(context.Background())
 
 			cmd = exec.Command("paccache",
@@ -428,8 +427,10 @@ func (b *BuildManager) repoWorker(repo string) {
 				continue
 			}
 			if len(pkg.PkgFiles) == 0 {
-				findPkgFiles(pkg)
+				if err := pkg.findPkgFiles(); err != nil {
-				if len(pkg.PkgFiles) == 0 {
+					log.Warningf("[%s/%s] Unable to find files: %v", pkg.FullRepo, pkg.Pkgbase, err)
+					continue
+				} else if len(pkg.PkgFiles) == 0 {
 					continue
 				}
 			}
@@ -451,8 +452,10 @@ func (b *BuildManager) repoWorker(repo string) {
 				continue
 			}
 
-			dbPkg := getDbPackage(pkg)
+			dbPkg := pkg.toDbPackage(false)
-			dbPkg = dbPkg.Update().ClearRepoVersion().SaveX(context.Background())
+			if dbPkg != nil {
+				dbPkg = dbPkg.Update().ClearRepoVersion().SaveX(context.Background())
+			}
 
 			for _, file := range pkg.PkgFiles {
 				check(os.Remove(file))
@@ -506,10 +509,16 @@ func (b *BuildManager) syncWorker() {
 			}
 		}
 
+		// housekeeping
+		err := housekeeping()
+		if err != nil {
+			log.Warningf("Housekeeping failed: %v", err)
+		}
+
 		// fetch updates between sync runs
 		b.alpmMutex.Lock()
 		check(alpmHandle.Release())
-		err := setupChroot()
+		err = setupChroot()
 		for err != nil {
 			log.Warningf("Unable to upgrade chroot, trying again later.")
 			time.Sleep(time.Minute)

utils.go

@@ -87,6 +87,7 @@ type Conf struct {
 }
 
 type Globs []string
+type PKGFile string
 
 type MultiplePKGBUILDError struct {
 	error
@@ -149,14 +150,17 @@ func statusId2string(s dbpackage.Status) (string, string) {
 	}
 }
 
-func getVersionFromRepo(pkg *BuildPackage) (string, error) {
+func (p *BuildPackage) repoVersion() (string, error) {
-	findPkgFiles(pkg)
+	err := p.findPkgFiles()
+	if err != nil {
+		return "", err
+	}
 
-	if len(pkg.PkgFiles) == 0 {
+	if len(p.PkgFiles) == 0 {
 		return "", fmt.Errorf("not found")
 	}
 
-	fNameSplit := strings.Split(pkg.PkgFiles[0], "-")
+	fNameSplit := strings.Split(p.PkgFiles[0], "-")
 	return fNameSplit[len(fNameSplit)-3] + "-" + fNameSplit[len(fNameSplit)-2], nil
 }
 
@@ -170,8 +174,8 @@ func gitClean(pkg *BuildPackage) {
 	}
 }
 
-func increasePkgRel(pkg *BuildPackage) error {
+func (p *BuildPackage) increasePkgRel() error {
-	f, err := os.OpenFile(pkg.Pkgbuild, os.O_RDWR, 0644)
+	f, err := os.OpenFile(p.Pkgbuild, os.O_RDWR, 0644)
 	if err != nil {
 		return err
 	}
@@ -188,7 +192,7 @@ func increasePkgRel(pkg *BuildPackage) error {
 		return err
 	}
 
-	nStr := rePkgRel.ReplaceAllLiteralString(string(fStr), "pkgrel="+pkg.Srcinfo.Pkgrel+".1")
+	nStr := rePkgRel.ReplaceAllLiteralString(string(fStr), "pkgrel="+p.Srcinfo.Pkgrel+".1")
 	_, err = f.Seek(0, 0)
 	if err != nil {
 		return err
@@ -203,7 +207,7 @@ func increasePkgRel(pkg *BuildPackage) error {
 		return err
 	}
 
-	pkg.Version = pkg.Version + ".1"
+	p.Version += ".1"
 	return nil
 }
 
@@ -288,13 +292,13 @@ func initALPM(root string, dbpath string) (*alpm.Handle, error) {
 	return h, nil
 }
 
-func getSVN2GITVersion(pkg *BuildPackage, h *alpm.Handle) (string, error) {
+func (p *BuildPackage) SVN2GITVersion(h *alpm.Handle) (string, error) {
-	if pkg.Pkgbuild == "" && pkg.Pkgbase == "" {
+	if p.Pkgbuild == "" && p.Pkgbase == "" {
 		return "", fmt.Errorf("invalid arguments")
 	}
 
 	// upstream/upstream-core-extra/extra-cmake-modules/repos/extra-any/PKGBUILD
-	pkgBuilds, _ := Glob(filepath.Join(conf.Basedir.Upstream, "**/"+pkg.Pkgbase+"/repos/*/PKGBUILD"))
+	pkgBuilds, _ := Glob(filepath.Join(conf.Basedir.Upstream, "**/"+p.Pkgbase+"/repos/*/PKGBUILD"))
 
 	var fPkgbuilds []string
 	for _, pkgbuild := range pkgBuilds {
@@ -311,13 +315,13 @@ func getSVN2GITVersion(pkg *BuildPackage, h *alpm.Handle) (string, error) {
 	}
 
 	if len(fPkgbuilds) > 1 {
-		log.Infof("%s: multiple PKGBUILD found, try resolving from mirror", pkg.Pkgbase)
+		log.Infof("%s: multiple PKGBUILD found, try resolving from mirror", p.Pkgbase)
 		dbs, err := h.SyncDBs()
 		if err != nil {
 			return "", err
 		}
 
-		iPackage, err := dbs.FindSatisfier(pkg.Pkgbase)
+		iPackage, err := dbs.FindSatisfier(p.Pkgbase)
 		if err != nil {
 			return "", err
 		}
@@ -343,11 +347,11 @@ func getSVN2GITVersion(pkg *BuildPackage, h *alpm.Handle) (string, error) {
 		}
 
 		if len(fPkgbuilds) > 1 {
-			return "", MultiplePKGBUILDError{fmt.Errorf("%s: multiple PKGBUILD found: %s", pkg.Pkgbase, fPkgbuilds)}
+			return "", MultiplePKGBUILDError{fmt.Errorf("%s: multiple PKGBUILD found: %s", p.Pkgbase, fPkgbuilds)}
 		}
-		log.Infof("%s: resolving successful: MirrorRepo=%s; PKGBUILD chosen: %s", pkg.Pkgbase, iPackage.DB().Name(), fPkgbuilds[0])
+		log.Infof("%s: resolving successful: MirrorRepo=%s; PKGBUILD chosen: %s", p.Pkgbase, iPackage.DB().Name(), fPkgbuilds[0])
 	} else if len(fPkgbuilds) == 0 {
-		return "", fmt.Errorf("%s: no matching PKGBUILD found (searched: %s, canidates: %s)", pkg.Pkgbase, filepath.Join(conf.Basedir.Upstream, "**/"+pkg.Pkgbase+"/repos/*/PKGBUILD"), pkgBuilds)
+		return "", fmt.Errorf("%s: no matching PKGBUILD found (searched: %s, canidates: %s)", p.Pkgbase, filepath.Join(conf.Basedir.Upstream, "**/"+p.Pkgbase+"/repos/*/PKGBUILD"), pkgBuilds)
 	}
 
 	cmd := exec.Command("sh", "-c", "cd "+filepath.Dir(fPkgbuilds[0])+"&&"+"makepkg --printsrcinfo")
@@ -369,6 +373,10 @@ func isPkgFailed(pkg *BuildPackage, dbPkg *ent.DbPackage) bool {
 		return false
 	}
 
+	if err := pkg.genSrcinfo(); err != nil {
+		return false
+	}
+
 	if pkg.Version == "" {
 		pkg.Version = constructVersion(pkg.Srcinfo.Pkgver, pkg.Srcinfo.Pkgrel, pkg.Srcinfo.Epoch)
 	}
@@ -380,19 +388,24 @@ func isPkgFailed(pkg *BuildPackage, dbPkg *ent.DbPackage) bool {
 	}
 }
 
-func genSRCINFO(pkgbuild string) (*srcinfo.Srcinfo, error) {
+func (p *BuildPackage) genSrcinfo() error {
-	cmd := exec.Command("sh", "-c", "cd "+filepath.Dir(pkgbuild)+"&&"+"makepkg --printsrcinfo")
+	if p.Srcinfo != nil {
+		return nil
+	}
+
+	cmd := exec.Command("sh", "-c", "cd "+filepath.Dir(p.Pkgbuild)+"&&"+"makepkg --printsrcinfo")
 	res, err := cmd.Output()
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	info, err := srcinfo.Parse(string(res))
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	return info, nil
+	p.Srcinfo = info
+	return nil
 }
 
 func setupChroot() error {
@@ -420,9 +433,9 @@ func setupChroot() error {
 	return nil
 }
 
-func getDBPkgFromPkgfile(pkg string) (*ent.DbPackage, error) {
+func (path PKGFile) DBPackage() (*ent.DbPackage, error) {
-	fNameSplit := strings.Split(pkg, "-")
+	fNameSplit := strings.Split(filepath.Base(string(path)), "-")
-	pkgname := strings.Join(fNameSplit[0:len(fNameSplit)-3], "-")
+	pkgname := strings.Join(fNameSplit[:len(fNameSplit)-3], "-")
 
 	dbPkgs, err := db.DbPackage.Query().Where(dbpackage.PackagesNotNil()).All(context.Background())
 	if err != nil {
@@ -431,11 +444,13 @@ func getDBPkgFromPkgfile(pkg string) (*ent.DbPackage, error) {
 			log.Debugf("Not found in database: %s", pkgname)
 			return nil, fmt.Errorf("package not found in DB: %s", pkgname)
 		default:
-			log.Errorf("Problem querying db for package %s: %v", pkgname, err)
+			return nil, err
 		}
+	} else if len(dbPkgs) == 0 {
+		return nil, fmt.Errorf("package not found in DB: %s", pkgname)
 	} else {
 		for _, dbPkg := range dbPkgs {
-			if contains(dbPkg.Packages, pkg) {
+			if contains(dbPkg.Packages, pkgname) {
 				return dbPkg, nil
 			}
 		}
@@ -444,11 +459,11 @@ func getDBPkgFromPkgfile(pkg string) (*ent.DbPackage, error) {
 	return nil, fmt.Errorf("package not found in DB: %s", pkgname)
 }
 
-func isSignatureValid(pkg string) (bool, error) {
+func (path PKGFile) isSignatureValid() (bool, error) {
-	cmd := exec.Command("gpg", "--verify", pkg)
+	cmd := exec.Command("gpg", "--verify", string(path)+".sig")
 	res, err := cmd.CombinedOutput()
 	log.Debug(string(res))
-	if cmd.ProcessState.ExitCode() == 2 {
+	if cmd.ProcessState.ExitCode() == 2 || cmd.ProcessState.ExitCode() == 1 {
 		return false, nil
 	} else if cmd.ProcessState.ExitCode() == 0 {
 		return true, nil
@@ -460,85 +475,123 @@ func isSignatureValid(pkg string) (bool, error) {
 }
 
 func housekeeping() error {
+	log.Debugf("Start housekeeping")
 	for _, repo := range repos {
 		packages, err := Glob(filepath.Join(conf.Basedir.Repo, repo, "/**/*.pkg.tar.zst"))
-		check(err)
+		if err != nil {
+			return err
+		}
+
+		for _, path := range packages {
+			pkgfile := PKGFile(path)
+			dbPkg, err := pkgfile.DBPackage()
+			if err != nil {
+				log.Warningf("[HK] Unable to find entry for %s in db: %v", filepath.Base(path), err)
+				// TODO: remove orphan file not tracked by db (WTF kmod-debug!)
+				continue
+			}
 
-		for _, pkgfile := range packages {
-			dbPkg, err := getDBPkgFromPkgfile(pkgfile)
 			pkg := &BuildPackage{
 				Pkgbase:  dbPkg.Pkgbase,
 				Repo:     dbPkg.Repository,
 				FullRepo: dbPkg.Repository.String() + "-" + dbPkg.March,
 			}
 
-			// check if pkg signature is valid
+			var upstream string
-			valid, err := isSignatureValid(pkgfile)
+			switch dbPkg.Repository {
-			check(err)
+			case dbpackage.RepositoryCore, dbpackage.RepositoryExtra:
-			if !valid {
+				upstream = "upstream-core-extra"
-				// TODO: purge pkg to trigger rebuild -> need srcinfo
+			case dbpackage.RepositoryCommunity:
-				if err != nil {
+				upstream = "upstream-community"
-					return err
-				}
-
-				var upstream string
-				switch dbPkg.Repository {
-				case dbpackage.RepositoryCore, dbpackage.RepositoryExtra:
-					upstream = "upstream-core-extra"
-				case dbpackage.RepositoryCommunity:
-					upstream = "upstream-community"
-				}
-
-				pkg.Srcinfo, err = genSRCINFO(filepath.Join(conf.Basedir.Upstream, upstream, dbPkg.Pkgbase, "repos", dbPkg.Repository.String()+"-"+conf.Arch, "PKGBUILD"))
-				if err != nil {
-					return err
-				}
-
-				buildManager.repoPurge[pkg.FullRepo] <- pkg
 			}
 
-			// TODO: compare db-version with repo version
+			pkg.Pkgbuild = filepath.Join(conf.Basedir.Upstream, upstream, dbPkg.Pkgbase, "repos", dbPkg.Repository.String()+"-"+conf.Arch, "PKGBUILD")
+			if err = pkg.genSrcinfo(); err != nil {
+				return err
+			}
+
+			// check if pkg signature is valid
+			valid, err := pkgfile.isSignatureValid()
+			if err != nil {
+				return err
+			}
+			if !valid {
+				log.Infof("[HK/%s/%s] invalid package signature", pkg.FullRepo, pkg.Pkgbase)
+				buildManager.repoPurge[pkg.FullRepo] <- pkg
+				continue
+			}
+
+			// compare db-version with repo version
+			repoVer, err := pkg.repoVersion()
+			if err != nil {
+				log.Infof("[HK/%s/%s] package not present on disk", pkg.FullRepo, pkg.Pkgbase)
+				// error means package was not found -> delete version & hash from db so rebuild can happen
+				err := dbPkg.Update().ClearHash().ClearRepoVersion().Exec(context.Background())
+				if err != nil {
+					return err
+				}
+			} else if alpm.VerCmp(repoVer, dbPkg.RepoVersion) != 0 {
+				log.Infof("[HK/%s/%s] update %s->%s in db", pkg.FullRepo, pkg.Pkgbase, dbPkg.RepoVersion, repoVer)
+				dbPkg, err = dbPkg.Update().SetRepoVersion(repoVer).Save(context.Background())
+				if err != nil {
+					return err
+				}
+			}
 
 			// TODO: check split packages
 
-			/* TODO: check if package is still part of repo
+			// check if package is still part of repo
-			   maybe we need to query ArchWeb here, since svn2git is not an absolute source
+			dbs, err := alpmHandle.SyncDBs()
-			   see https://git.harting.dev/anonfunc/ALHP.GO/issues/16#issuecomment-208
+			if err != nil {
-			   or https://git.harting.dev/anonfunc/ALHP.GO/issues/43#issuecomment-371
+				return err
-			*/
+			}
+			pkgResolved, err := dbs.FindSatisfier(pkg.Srcinfo.Packages[0].Pkgname)
+			if err != nil || pkgResolved.DB().Name() != dbPkg.Repository.String() {
+				// package not found on mirror/db -> not part of any repo anymore
+				log.Infof("[HK/%s/%s] not part of repo", pkg.FullRepo, pkg.Pkgbase)
+				buildManager.repoPurge[pkg.FullRepo] <- pkg
+				err = db.DbPackage.DeleteOne(dbPkg).Exec(context.Background())
+				if err != nil {
+					return err
+				}
+				continue
+			}
 		}
 	}
 
 	return nil
 }
 
-func findPkgFiles(pkg *BuildPackage) {
+func (p *BuildPackage) findPkgFiles() error {
-	pkgs, err := os.ReadDir(filepath.Join(conf.Basedir.Repo, pkg.FullRepo, "os", conf.Arch))
+	pkgs, err := os.ReadDir(filepath.Join(conf.Basedir.Repo, p.FullRepo, "os", conf.Arch))
-	check(err)
+	if err != nil {
+		return err
+	}
+
+	var realPkgs []string
+	for _, realPkg := range p.Srcinfo.Packages {
+		realPkgs = append(realPkgs, realPkg.Pkgname)
+	}
 
 	var fPkg []string
 	for _, file := range pkgs {
 		if !file.IsDir() && !strings.HasSuffix(file.Name(), ".sig") {
 			matches := rePkgFile.FindStringSubmatch(file.Name())
 
-			var realPkgs []string
-			for _, realPkg := range pkg.Srcinfo.Packages {
-				realPkgs = append(realPkgs, realPkg.Pkgname)
-			}
-
 			if len(matches) > 1 && contains(realPkgs, matches[1]) {
-				fPkg = append(fPkg, filepath.Join(conf.Basedir.Repo, pkg.FullRepo, "os", conf.Arch, file.Name()))
+				fPkg = append(fPkg, filepath.Join(conf.Basedir.Repo, p.FullRepo, "os", conf.Arch, file.Name()))
 			}
 		}
 	}
 
-	pkg.PkgFiles = fPkg
+	p.PkgFiles = fPkg
+	return nil
 }
 
-func getDbPackage(pkg *BuildPackage) *ent.DbPackage {
+func (p *BuildPackage) toDbPackage(create bool) *ent.DbPackage {
-	dbPkg, err := db.DbPackage.Query().Where(dbpackage.Pkgbase(pkg.Pkgbase)).Only(context.Background())
+	dbPkg, err := db.DbPackage.Query().Where(dbpackage.Pkgbase(p.Pkgbase)).Only(context.Background())
-	if err != nil {
+	if err != nil && create {
-		dbPkg = db.DbPackage.Create().SetPkgbase(pkg.Pkgbase).SetMarch(pkg.March).SetPackages(packages2slice(pkg.Srcinfo.Packages)).SetRepository(pkg.Repo).SaveX(context.Background())
+		dbPkg = db.DbPackage.Create().SetPkgbase(p.Pkgbase).SetMarch(p.March).SetPackages(packages2slice(p.Srcinfo.Packages)).SetRepository(p.Repo).SaveX(context.Background())
 	}
 
 	return dbPkg
@@ -630,14 +683,14 @@ func setupMakepkg(march string) error {
 	return nil
 }
 
-func isMirrorLatest(h *alpm.Handle, buildPkg *BuildPackage) (bool, alpm.IPackage, string, error) {
+func (p *BuildPackage) isMirrorLatest(h *alpm.Handle) (bool, alpm.IPackage, string, error) {
 	dbs, err := h.SyncDBs()
 	if err != nil {
 		return false, nil, "", err
 	}
 
-	allDepends := buildPkg.Srcinfo.Depends
+	allDepends := p.Srcinfo.Depends
-	allDepends = append(allDepends, buildPkg.Srcinfo.MakeDepends...)
+	allDepends = append(allDepends, p.Srcinfo.MakeDepends...)
 
 	for _, dep := range allDepends {
 		buildManager.alpmMutex.Lock()
@@ -647,9 +700,9 @@ func isMirrorLatest(h *alpm.Handle, buildPkg *BuildPackage) (bool, alpm.IPackage
 			return false, nil, "", UnableToSatisfyError{err}
 		}
 
-		svn2gitVer, err := getSVN2GITVersion(&BuildPackage{
+		svn2gitVer, err := (&BuildPackage{
 			Pkgbase: pkg.Base(),
-		}, h)
+		}).SVN2GITVersion(h)
 		if err != nil {
 			return false, nil, "", err
 		}