Jump to content

Creating packages (Magyar)

From ArchWiki
Fordítás állapota: Ez az oldal az angol Creating packages című oldal magyar nyelvre lefordított változata. Utolsó fordítás dátuma: 2026.05.16. Amennyiben a lefordítás időpontja óta az angol nyelvű oldalon történtek újabb módosítások, akkor Ön segíthet hozzászinkronizálni az angolhoz ezt a magyar nyelvű fordítást.
Arch szoftvercsomagolási irányelvek

32-bit – CLR – CMake – Cross – DKMS – Eclipse – Electron – Font – Free Pascal – GNOME – Go – Haskell – Java – KDE – Kernelmodulok – Lisp – Meson – MinGW – Node.js – Nonfree – OCaml – Perl – PHP – Python – R – Ruby – Rust - Biztonság – Shell – VCS – Web – Wine

További oldalak az adott témakörben

Ez a cikk segítséget kíván nyújtani azoknak a felhasználóknak, akik saját szoftvercsomagokat szeretnének készíteni a ports-szerű Arch build system használatával. Továbbá az Arch User Repository tárolóba történő beküldéshez is segítséget kíván nyújtani. A cikk bemutatja egy PKGBUILD(5) létrehozását — ez egy szoftvercsomaglétrehozási szkriptfájl, amelyet a makepkg segédprogram arra használ fel, hogy forráskódból binárisan futtatható programkódot tartalmazó szoftvercsomagot készítsen.

A meglévő szabályokkal és a szoftvercsomag-minőség javításának módjaival kapcsolatos utasításokért tekintse meg az Arch szoftvercsomagolási irányelvek című oldalt.

Áttekintés

Az Arch Linux szoftvercsomagjai a makepkg segédprogram használatával és egy PKGBUILD szkriptfájlban tárolt információk alapján készülnek. Amikor a makepkg fut, megkeresi a PKGBUILD szkriptfájlt az aktuális könyvtárban, és az abban található utasításokat követi a szükséges fájlok beszerzéséhez és/vagy forráskódból történő lefordításához annak érdekében, hogy azok egy pkgname.pkg.tar.zst szoftvercsomagfájlba legyenek becsomagolva. Az eredményül kapott szoftvercsomag binárisan futtatható fájlokat és telepítési utasításokat tartalmaz, amelyek készen állnak a pacman szoftvercsomag-kezelő segédprogram általi feltelepítésre.

Egy Arch szoftvercsomag gyakorlatilag nem több mint egy tar(1) archívumfájl (angolul hívják még tarball fájlnak), amely zstd(1) használatával van betömörítve, és a következő, a makepkg által létrehozott fájlokat tartalmazza:

  • Bináris kódra lefordított (ezáltal binárisan a számítógép által közvetlenül futtatható) számítógépre feltelepítendő fájlok.
  • .PKGINFO — Az összes metaadatot tartalmazza, amelyre a pacman szoftvercsomag-kezelőnek szüksége van a szoftvercsomagok, szoftvercsomag-függőségek stb. kezelése érdekében.
  • .BUILDINFO — A reprodukálható szoftvercsomag-létrehozások számára szükséges információkat tartalmazza. Részletek a BUILDINFO(5) és BUILDINFOv2(5) man súgókban.
  • .MTREE — A fájlok hash értékeit és időbélyegeit tartalmazza, amelyek bekerülnek az operációs rendszer helyi adatbázisába annak érdekében, hogy a pacman ellenőrizhesse a szoftvercsomag integritását.
  • .INSTALL — Egy opcionális fájl, amely parancsok végrehajtására szolgál a telepítés/frissítés/eltávolítás szakasz után. (Ez a fájl csak akkor van jelen, amikor a PKGBUILD szkriptfájl meghatározza.)
  • .Changelog — Egy opcionális fájl, amelyet a szoftvercsomag karbantartója vezet a szoftvercsomag változásainak dokumentálására.

Előkészületek

Előfeltételként meglévő szoftverek

Először győződjön meg arról, hogy a szükséges segédprogramok telepítve vannak: A base-devel meta szoftvercsomag elegendő kell, hogy legyen. Ez magával húzza a make(1) segédprogramot és a forráskódból történő fordításhoz szükséges további segédprogramokat.

A szoftvercsomagok létrehozásának a legfontosabb segédprogramja a makepkg (amely benne van a pacman szoftvercsomagban). Az általa végzett feladatok megtalálhatók az Arch szoftvercsomagolási útmutató#A makepkg feladatai című leírásban.

Letöltés és a feltelepített szoftver tesztelése

Töltse le a becsomagolni kívánt szoftver forráskódját tartalmazó tar archívumfájlt, tömörítse ki, és kövesse a szerző utasításait a program számítógépre történő feltelepítése érdekében. Jegyezze fel az összes parancsot és/vagy lépést, amely a programkód fordításához és feltelepítéshez szükséges. Ön pontosan ugyanezeket a parancsokat fogja majd megismételni a PKGBUILD szkriptfájlban.

A legtöbb szoftverszerző a 3 lépéses létrehozási ciklust követi: 

$ ./configure
$ make
# make install

Ez jó alkalom annak ellenőrzésére, hogy a program megfelelően működik-e.

Tiszta chroot beállítása

Ajánlott követni a Szoftvercsomag létrehozása tiszta chroot környezetben című útmutatót annak érdekében, hogy az operációs rendszer szoftvercsomagjai és a szoftvercsomag beállítása ne okozzon hibákat a PKGBUILD fájl futásakor. Ez a módszer egy robusztusabb és helyesebb módja a szoftvercsomagok létrehozásának, és gyakran felfedezi a hiányzó szoftvercsomag-függőségeket, amelyeket Ön nem vett észre, mert azok már léteztek a saját operációs rendszerén.

PKGBUILD létrehozása

Amikor fut a makepkg parancs, akkor a parancs az éppen aktuális munkakönyvtárban keresi a PKGBUILD fájlt. Ha talál egyet, akkor letölti a szoftver forráskódját, és a PKGBUILD fájlban megadott utasítások szerint fordítja azt le. Az utasításoknak teljes mértékben értelmezhetőknek kell lenniük a Bash shell számára.

A sikeres lefutást követően a létrejött binárisan futtatható fájlok és a szoftvercsomag metaadatai, azaz a szoftvercsomag verziója és szoftvercsomag-függőségek, egy szoftvercsomagneve.pkg.tar.zst fájlba kerülnek becsomagolásra. Az újonnan létrehozott szoftvercsomag egyszerűen feltelepíthető a számítógépre a makepkg --install használatával, amely a háttérben meghívja a pacman szoftvercsomag-kezelőt, vagy közvetlenül a pacman -U szoftvercsomagneve.pkg.tar.zst parancs segítségével is feltelepíthető.

Egy új szoftvercsomag létrehozásának megkezdéséhez először hozzon létre egy új könyvtárat a szoftvercsomag számára, és lépjen be ebbe a könyvtárba. Ezután Önnek létre kell hozni egy PKGBUILD fájlt: Használható egy PKGBUILD prototípusfájl, amely a /usr/share/pacman/ könyvtárban található, vagy kiindulhat egy másik szoftvercsomag PKGBUILD fájljából. Az utóbbi akkor tűnik jó választásnak amikor a számítógépen már létezik hasonló szoftvercsomag.

PKGBUILD szkriptfájl változói

Megjegyzés A fő cikk a PKGBUILD. Tekintse meg a PKGBUILD(5) § OPTIONS AND DIRECTIVES man súgót is.

A makepkg előre definiálja a következő változókat, amelyeket a szoftvercsomag-készítőknek használniuk kell a szoftvercsomag létrehozási folyamat során az ideiglenes helyek hivatkozására:

srcdir
Ez a változó arra a könyvtárra mutat, ahová a makepkg kicsomagolja vagy szimbolikusan link formájában belinkeli az összes fájlt. Ezek a forráskódfájlok mind a PKGBUILD szkriptfájl forráskódtömbjében vannak felsorolva.
pkgdir
Ez a változó arra a könyvtárra mutat, ahová a makepkg összecsomagolja a feltelepített szoftvert, amely könyvtár ezáltal a létrehozott szoftvercsomag gyökérkönyvtárává válik.

Ezek a változók abszolút elérési útvonalakat tartalmaznak, ami azt jelenti, hogy Önnek nem kell az aktuális munkakönyvtárával törődnie, amennyiben ezeket a változókat megfelelően használja.

Megjegyzés A makepkg, és így a build() és package() függvények, nem interaktív használatra vannak tervezve. Az ezekben a függvényekben meghívott interaktív segédprogramok vagy szkriptek megszakíthatják a makepkg működését, különösen amikor a függvény szoftvercsomag-létrehozási naplózással van meghívva (--log). Részletekért tekintse meg a hibával kapcsolatos FS#13214 bejegyzést.

PKGBUILD szkriptfájl függvényei

A szoftvercsomag létrehozásakor ha az alábbi őt függvény definiálva van a PKGBUILD szkriptfájlban, akkor a makepkg átlép a forráskódkönyvtárba, még mielőtt meghívná az alábbi öt függvényt. A package() függvény minden PKGBUILD szkriptfájlban kötelező, és minden esetben meghívásra kerül. Ha a többi függvény bármelyike nincs definiálva, akkor a makepkg egyszerűen kihagyja az adott függvény meghívását.

A szoftvercsomag létrehozása során a függvények abban a sorrendben vannak meghívva, ahogyan azok itt fel vannak sorolva.

További részletekért tekintse meg a PKGBUILD(5) § PACKAGING FUNCTIONS man súgót.

prepare()

A függvénnyel azok a parancsok futnak le, amelyek a forráskódok felkészítésére szolgálnak a kódfordítás számára. Például a patching. Ez a függvény a szoftvercsomag kibontása után, a pkgver() és a szoftvercsomag-létrehozás (build) funkció előtt fut le. Ha a kibontás kihagyásra kerül (makepkg --noextract), akkor a prepare() nem fut le.

Megjegyzés A PKGBUILD(5) szerint: A függvény bash -e módban fut, ami azt jelenti, hogy bármelyik parancs, amely nem nulla értékkel tér vissza, a függvény kilépését okozza.

Ha nem egyértelmű, hogy valamit a prepare() függvénybe vagy a build() függvénybe tegyünk, akkor egy íme egy ökölszabály: A prepare() függvénybe kerüljenek azok a lépések, amelyeknek pontosan egyszer kell lefutniuk a forráskódok kibontása után, míg a build() függvénybe azok a lépések kerüljenek, amelyeket érdemes újra lefuttatni a kibontott fájlok bármely kézi szerkesztése után.

pkgver()

A pkgver() függvény a forráskódok lekérése, kibontása és a prepare() függvény végrehajtódása után fut le. Tehát a pkgver változó frissíthető a makepkg során.

Ez különösen hasznos, amikor Ön git/svn/hg/stb. szoftvercsomagokat készít, ahol a szoftvercsomaglétrehozási folyamat (build folyamat) ugyanaz maradhat, de a forráskód naponta, akár óránként is frissülhet. A régi módszer az volt, hogy a dátum lett belerakva a pkgver mezőbe, ami esetén, ha a szoftver nem frissült, akkor a makepkg mégis újrafordította azt, mert azt gondolta, hogy a verzió változott. Néhány hasznos parancs ehhez: git describe, hg identify -ni, stb. Kérjük, tesztelje ezeket, mielőtt PKGBUILD fájlt küldene be, mivel a pkgver() függvény hibája a szoftvercsomaglétrehozási folyamat azonnali megszakadását okozhatja.

Megjegyzés A pkgver változó nem tartalmazhat szóközt vagy kötőjelet (-). Gyakori a sed parancs használata ennek korrigálására.

build()

Önnek most implementálnia kell a build() függvényt a PKGBUILD szkriptfájlban. Ez a függvény a Bash szintaxisban használt általános parancsokat használja a szoftver forráskódból történő automatikus lefordításához, és létrehoz egy pkg nevű könyvtárat, ahová a szoftvert telepíti. Ez lehetővé teszi, hogy a makepkg csomagolja a fájlokat anélkül, hogy Önnek a fájlrendszerben kellene böngésznie.

Az első lépés a build() függvényben az, hogy belépünk abba a könyvtárba, amelyet a forráskód tar tömörített fájl kicsomagolásával hoztunk létre. A makepkg a build() függvény végrehajtása előtt a jelenlegi könyvtárat $srcdir könyvtárra állítja rá. Ezért a legtöbb esetben, ahogyan azt a /usr/share/pacman/PKGBUILD.proto is javasolja, az első parancs így fog kinézni: 

cd "$pkgname-$pkgver"

Önnek most fel kell sorolnia ugyanazokat a parancsokat, amelyeket a szoftver kézi úton történő lefordításakor használt. A build() függvény lényegében automatizálja mindazt, amit Ön korábban kézzel elvégzett, és a szoftvert forráskódból lefordítja a fakeroot szoftvercsomag létrehozási környezetben. Ha a csomagolt szoftver beállításszkriptet használ, akkor jó gyakorlat a --prefix=/usr opció használata a pacman szoftvercsomagok létrehozásakor. Sok szoftver a fájlokat a /usr/local könyvtárhoz viszonyítva telepíti, ami csak akkor ajánlott, amikor Ön a forráskódból manuálisan hoz létre szoftvert. Minden Arch Linux szoftvercsomagnak a /usr könyvtárat kell használnia. Ahogy a /usr/share/pacman/PKGBUILD.proto fájlban látható, gyakran így néz ki a következő két sor: 

./configure --prefix=/usr
make
Megjegyzés Ha az Ön szoftverének nincs szüksége semmilyen forráskódból történő kódfordításra, akkor ne használja a build() függvényt. A build() függvény futtatása nem kötelező, de a package() függvény futtatása kötelező.

check()

Hely a make check és hasonló tesztelési rutinok meghívására. A check() függvény használata erősen ajánlott, mivel segít megbizonyosodni arról, hogy a szoftver valóban helyesen lett a forráskódból lefordítva és a szoftver a függőségeivel valóban megfelelően működik együtt.

Azok a felhasználók, akiknek erre a függvényre nincs szükségük (és alkalmanként a karbantartók, akik nem tudják a szoftvercsomagot módosítani a teszt sikeréhez), letilthatják a tesztelést a makepkg --nocheck kapcsolójának használatával.

Amennyiben Ön grafikus felhasználói felülettel rendelkező alkalmazást tesztel, akkor az alkalmazást virtuális X szerveren is futtathatja.

package()

Az utolsó lépés az, hogy a forráskódból lefordított fájlokat egy olyan könyvtárba helyezze, ahonnan a makepkg hozzáférhet a szoftvercsomag létrehozásához. Alapértelmezés szerint ez a pkg könyvtár — amely egy egyszerű fakeroot környezet. A pkg könyvtár a szoftver telepítési útvonalainak gyökérfájlrendszer-hierarchiáját másolja. Ha Önnek a fájlokat manuális úton, kézzel kell elhelyeznie a fájlrendszer gyökerében, akkor azokat a pkg könyvtárban, ugyanazon könyvtárszerkezet szerint kell telepítenie. Ha például egy fájlt Ön a /usr/bin könyvtárba szeretne telepíteni, akkor Önnek a fájlt a $pkgdir/usr/bin könyvtárba kell belehelyeznie. Nagyon kevés telepítési eljárás igényli, hogy a felhasználó több tucat fájlt manuálisan másoljon. A legtöbb szoftver esetében elegendő a make install parancs végrehajtása. A végső sor a következőképpen kell, hogy kinézzen a szoftver helyes telepítése érdekében a pkg könyvtárban: 

make DESTDIR="$pkgdir" install
Megjegyzés Előfordulhat, hogy a DESTDIR nincs használatban a Makefile fájlban. Ilyenkor szükség lehet a prefix használatára. Ha a binárisan futtatható szoftver autoconf / automake segítségével lett a forráskódból létrehozva, akkor használja a DESTDIR változót. Ez az ami a kézikönyvekben dokumentálva van. Ha a DESTDIR nem működik, akkor próbálja meg a make prefix="$pkgdir/usr" install használatával. Ha ez sem működik, akkor további vizsgálatra lesz szükség az "make <...> install" által végrehajtott telepítési parancsokkal kapcsolatban.

A makepkg --repackage csak a package() függvényt futtatja, ezáltal szoftvercsomagot készít el létrehozás (building) nélkül. Ez időt takaríthat meg, például amikor Ön csak a szoftvercsomag depends változóját módosította.

Megjegyzés A build() függvény által létrehozott fájlok (például mv használatával) $srcdir könyvtárból $pkgdir könyvtárba történő áthelyezése megszakítja a makepkg --repackage opcióját.

Tesztelés elvégzése a PKGBUILD szkriptfájlon és a szoftvercsomagon

Amikor Ön a build() függvényt írja, gyakran majd azt szeretné, hogy le legyenek tesztelve az Ön által elvégzett változtatások annak érdekében, hogy biztos legyen benne, hogy tényleg nincs benne hiba. Ezt a makepkg parancs használatával teheti meg abban a könyvtárban, amely a PKGBUILD fájlt tartalmazza. Egy megfelelően formázott PKGBUILD szkriptfájl esetén a makepkg létrehoz egy szoftvercsomagot. Egy hibás vagy befejezetlen PKGBUILD szkriptfájl esetén hibát jelez.

Ha a makepkg sikeresen lefut, akkor egy szoftvercsomagneve-szoftvercsomagverziója.pkg.tar.zst nevű fájlt helyez el az Ön munkakönyvtárában. Ezt a szoftvercsomagot a pacman -U paranccsal fel lehet telepíteni azonnal a számítógépre. Azonban az, hogy egy szoftvercsomagfájl létrejött, még nem jelenti azt, hogy teljesen működőképes. Előfordulhat, hogy csak a könyvtárat tartalmazza, fájlokat egyáltalán nem tartalmaz, például amikor a prefix helytelenül lett megadva. Ön használhatja a pacman lekérdező funkcióit a szoftvercsomagban található fájlok kilistázása érdekében a pacman -Qlp szoftvercsomagneve paranccsal, valamint a szükséges szoftvercsomag-függőségek megtekintése érdekében a pacman -Qip szoftvercsomagneve parancsot is lefuttathatja.

Ha a szoftvercsomag megfelelőnek tűnik, akkor készen van! Azonban, ha Ön tervezi a PKGBUILD fájl kiadását, akkor elengedhetetlen, hogy duplán ellenőrizze a depends tömb tartalmát.

Győződjön meg arról is, hogy a szoftvercsomag binárisan futtatható fájljai ténylegesen hibátlanul futnak! Bosszantó lenne egy olyan szoftvercsomag kiadása, amely tartalmaz minden szükséges fájlt, de egy rejtett beállítás miatt összeomlik, amely nem működik megfelelően a rendszer többi részével. Ha azonban csak az Ön saját operációs rendszerére kíván szoftvercsomagokat lefordítani a forráskódból, akkor ezen minőségellenőrzési lépés miatt nem kell túl sokat aggódnia, hiszen végül is Ön lesz az egyetlen személy, aki a hibák miatt anyázás közepette szenvedni fog.

Szoftvercsomag létrehozásának az ellenőrzése

A szoftvercsomag funkcionalitásának tesztelése után ellenőrizze le a hibák szempontjából a szoftvercsomagot a namcap segítségével: 

$ namcap PKGBUILD
$ namcap pkgname.pkg.tar.zst

A namcap a következőket végzi:

  • Ellenőrzi a PKGBUILD szkriptfájlnak a tartalmát gyakori hibák szempontjából. Továbbá, ellenőrzi a szoftvercsomag fájlszerkezetét felesleges vagy rosszul elhelyezett fájlok után kutatva.
  • Az összes ELF fájlt átvizsgálja a szoftvercsomagban az ldd(1) segítségével, automatikusan jelezve, mely szoftvercsomagok hiányoznak a szükséges megosztott függvénykönyvtárakhoz a depends tömbből, és melyek hagyhatók el mint átmeneti függőségek.
  • Heurisztikusan keresi a hiányzó és felesleges függőségeket és még sok mást.

Szokja meg, hogy az Ön szoftvercsomagjait namcap segédprogrammal ellenőrzi. Ezáltal elkerülheti, hogy a legegyszerűbb hibákat a szoftvercsomag benyújtása után kelljen kijavítania.

A pkgctl használata tiszta chroot környezetben történő szoftvercsomag-létrehozáshoz

This article or section is a candidate for merging with Arch build system#Build package.

Notes: Ez az oldal nem a szoftvercsomag-létrehozási rendszerről szól. Tekintse meg továbbá a #Tiszta chroot beállítása és a DeveloperWiki:Building in a clean chroot című szakaszokat. (Discuss in Talk:Creating packages (Magyar))

Ön használhatja a devtools szoftvercsomagból a pkgctl parancsot annak ellenőrzésére, hogy a szoftvercsomag létrehozható-e olyan környezetben, ahol még nincsenek más szoftvercsomagok feltelepítve. A PKGBUILD könyvtárban: 

$ pkgctl build

Majd a fenti parancsot kiadva ellenőrizze a kimenetet esetleges hibák vagy figyelmeztetések szempontjából. Ha a szoftvercsomag más AUR szoftvercsomagoktól függ, akkor azokat a szoftvercsomagokat előbb le kell forráskódból fordítani, és be kell vinni a chroot környezetbe: 

$ pkgctl build -I path/to/somepkg.tar.gz -I ...
Megjegyzés Ha a szoftvercsomag egy AUR segédprogrammal lett feltelepítve, akkor jó eséllyel megtalálható a tar archívumfájl a segédprogram gyorsítótár könyvtárában.

További lehetőségekért tekintse meg a pkgctl-build(1) man súgót.

Szoftvercsomagok beküldése az AUR tárolóba

Olvassa el az AUR beküldési irányelvek című oldalt, ahol megtalálható a beküldési folyamat részletes leírása.

Összefoglaló

  1. Töltse le annak a szoftvernek a betömörített forráskódfájlját amelyből Ön szoftvercsomagfájlt szeretne létrehozni.
  2. Próbálja meg a forráskódot lefordítani futtatható gépi kódra, és próbálja meg feltelepíteni a számítógépen egy tetszőleges könyvtárba.
  3. Másolja át a /usr/share/pacman/PKGBUILD.proto prototípusfájlt, és nevezze át PKGBUILD nevűre egy ideiglenes munkakönyvtárban.
  4. Szerkessze a PKGBUILD fájlt a szoftvercsomagfájl igényei szerint.
  5. Futtassa a makepkg parancsot, és ellenőrizze, hogy a szoftvercsomagfájl helyesen jön-e létre.
  6. Ha nem jön létre a szoftvercsomagfájl, akkor ismételje meg az előző két lépést.

Figyelmeztetések

  • Mielőtt Ön automatizálná a szoftvercsomaglétrehozási folyamatot, legalább egyszer manuális úton, kézzel kell elvégeznie a folyamatot, kivéve amikor nem tudja pontosan, hogy mit csinál előre. Ebben az esetben Ön eleve nem olvasná ezt az oldalt. Bár sajnos sok program szerzője ragaszkodik a 3 lépéses létrehozási ciklus művelethez (./configure; make; make install), ez nem mindig van így, és a dolgok nagyon eldurvulhatnak, amikor javításokat kell alkalmazni annak érdekében, hogy jól működjön minden. Általános szabály: Amennyiben Ön nem tudja a tömörített tar fájlból lefordítani és telepíteni a programot egy meghatározott, ideiglenes alkönyvtárba, akkor még csak próbálkozni sem érdemes a csomagolással. A makepkg nem tartalmaz varázsporokat, amelyek megoldanák a forráskódok problémáit.
  • Néhány esetben a szoftvercsomagok még forráskód formájában se nem érhetők el, és Önnek valami olyasmit kell használnia, mint az sh installer.run annak érdekében, hogy működjön. Önnek elég sok kutatómunkát kell végeznie (README fájlok, INSTALL útmutatók, man súgók, esetleg Gentoo vagy más szoftvercsomag-kezelők ebuild fájljai, esetleg maga a MAKEFILE vagy a forráskód) ahhoz, hogy működjön. Nagyon rossz esetekben a forráskódfájlokat is szerkeszteni kell, annak érdekében hogy egyáltalán működjön. Ugyanakkor a makepkg teljesen önállóan kell, hogy működjön, felhasználói beavatkozás nélkül. Ezért, ha a makefile fájlokat szerkeszteni kell, akkor előfordulhat, hogy egy egyedi javítást kell csomagolnia a PKGBUILD szkriptfájlba, és a prepare() függvényből kell feltelepítenie, vagy esetleg néhány sed parancsot kell kiadnia a prepare() függvényből.

Automatizálás

Ellenőrzőösszegek

Az új szoftververziók ellenőrzőösszegeinek frissítési folyamatát automatizálni lehet a updpkgsums segédprogrammal. Részletekért tekintse meg a Makepkg#Új ellenőrzőösszegek létrehozása című leírást.

PKGBUILD generátorok

A PKGBUILD fájlok automatikusan legenerálhatók néhány szoftvercsomaghoz.

Megjegyzés A felhasználók továbbra is felelősek azért, hogy a szoftvercsomag megfeleljen a magas minőségi követelményeknek, mielőtt a legenerált fájlokat a AUR tárolóba beküldenék.

Új upstream kiadások

A pkgctl segédprogram (a devtools szoftvercsomagból) támogatja az nvchecker integrációt .nvchecker.toml beállításfájl formájában (amelyet ugyanabba a könyvtárba kell elhelyezni, mint ahol a PKGBUILD fájl is van). Példaként tekintse meg a pacman szoftvercsomag .nvchecker.toml beállításfájlját.

Tipp A pkgctl version setup megpróbálja automatikusan létrehozni a .nvchecker.toml beállításfájlt a PKGBUILD fájlban megadott forráskódtömb elemzése alapján.

Ön ezután használhatja a pkgctl version check parancsot annak ellenőrzésére, hogy megjelent-e új upstream verzió (a PKGBUILD fájlban pkgver változóban megadotthoz képest), valamint használhatja a pkgctl version upgrade parancsot a PKGBUILD megfelelő frissítésére. További részletekért tekintse meg a pkgctl-version(1) man súgót.

További olvasnivaló a témában