146 lines
3.4 KiB
Go
146 lines
3.4 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"github.com/Jguer/go-alpm/v2"
|
|
log "github.com/sirupsen/logrus"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"somegit.dev/ALHP/ALHP.GO/ent/dbpackage"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
APIBase = "https://api.alhp.dev/"
|
|
)
|
|
|
|
var (
|
|
jsonFlag = flag.Bool("j", false, "output as JSON")
|
|
debugFlag = flag.Bool("d", false, "enable debug output")
|
|
exitCodeFlag = flag.Bool("e", false, "exit with non-zero if one of your packages is in queue")
|
|
)
|
|
|
|
type JSONOut struct {
|
|
Total int `json:"total"`
|
|
Packages []string `json:"packages"`
|
|
}
|
|
|
|
func main() {
|
|
flag.Parse()
|
|
|
|
if *debugFlag {
|
|
log.SetLevel(log.DebugLevel)
|
|
}
|
|
|
|
h, er := alpm.Initialize("/", "/var/lib/pacman")
|
|
if er != nil {
|
|
log.Errorf("error initializing alpm library: %v", er)
|
|
os.Exit(1)
|
|
}
|
|
defer func(h *alpm.Handle) {
|
|
err := h.Release()
|
|
if err != nil {
|
|
log.Errorf("error releasing alpm library: %v", err)
|
|
}
|
|
}(h)
|
|
|
|
db, er := h.LocalDB()
|
|
if er != nil {
|
|
log.Errorf("error initializing alpm library: %v", er)
|
|
os.Exit(1)
|
|
}
|
|
|
|
alhpQueue, err := ALHPBuildQueuePkgbase()
|
|
if err != nil {
|
|
log.Errorf("error getting build queue from ALHP api: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
log.Debugf("alhp build queue length: %d", len(alhpQueue))
|
|
|
|
var packagesInQueue []string
|
|
for _, pkg := range db.PkgCache().Slice() {
|
|
if Find(alhpQueue, pkg.Base()) != -1 {
|
|
log.Debugf("found package in queue: %s", pkg.Name())
|
|
packagesInQueue = append(packagesInQueue, pkg.Name())
|
|
}
|
|
}
|
|
|
|
if len(packagesInQueue) > 0 {
|
|
log.Debugf("found %d of your local packages in queue", len(packagesInQueue))
|
|
if *jsonFlag {
|
|
err = json.NewEncoder(os.Stdout).Encode(JSONOut{
|
|
Total: len(packagesInQueue),
|
|
Packages: packagesInQueue,
|
|
})
|
|
if err != nil {
|
|
log.Errorf("error encoding JSON: %v", err)
|
|
os.Exit(1)
|
|
}
|
|
} else {
|
|
fmt.Println(strings.Join(packagesInQueue, "\n"))
|
|
}
|
|
|
|
if *exitCodeFlag {
|
|
os.Exit(20)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Find[T comparable](arr []T, match T) int {
|
|
for i, v := range arr {
|
|
if v == match {
|
|
return i
|
|
}
|
|
}
|
|
|
|
return -1
|
|
}
|
|
|
|
type ThinPackage struct {
|
|
Pkgbase string `json:"pkgbase"`
|
|
Repo string `json:"repo"`
|
|
SplitPackages []string `json:"split_packages"`
|
|
Status dbpackage.Status `json:"status"`
|
|
SkipReason *string `json:"skip_reason,omitempty"`
|
|
LTO dbpackage.Lto `json:"lto"`
|
|
DebugSymbols dbpackage.DebugSymbols `json:"debug_symbols"`
|
|
ArchVersion string `json:"arch_version"`
|
|
RepoVersion string `json:"repo_version"`
|
|
BuildDate *string `json:"build_date,omitempty"`
|
|
PeakMem *string `json:"peak_mem,omitempty"`
|
|
}
|
|
|
|
type PackageResponse struct {
|
|
Packages []*ThinPackage `json:"packages"`
|
|
Total int `json:"total"`
|
|
Offset int `json:"offset"`
|
|
Limit int `json:"limit"`
|
|
}
|
|
|
|
func ALHPBuildQueuePkgbase() ([]string, error) {
|
|
resp, err := http.Get(fmt.Sprintf("%spackages?status=built&status=building&status=queued&limit=0&offset=0", APIBase))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
bResp, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
jResp := new(PackageResponse)
|
|
if err = json.Unmarshal(bResp, jResp); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
respArray := make([]string, len(jResp.Packages))
|
|
for i := range jResp.Packages {
|
|
respArray[i] = jResp.Packages[i].Pkgbase
|
|
}
|
|
return respArray, nil
|
|
}
|