Creating packages (Magyar) - ArchWiki

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.

További oldalak az adott témakörben

- Creating packages for other distributions (Magyar)
- Patching packages (Magyar)
- .SRCINFO (Magyar)

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.

- Haskell: cblrepo, arch-hs
- Node.js: nodejs-npm2archAUR
- Perl: perl-cpanplus-dist-archAUR
- Python: pipman-gitAUR, pip2arch-gitAUR, python-pypi2pkgbuildAUR
- Ruby: gem2archAUR, pacgemAUR
- Rust: cargo-pkgbuildAUR, cargo-aur-binAUR

### Ú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

- How to correctly create a patch file.
- Arch Linux Classroom IRC Logs of classes about creating PKGBUILDs.
- Fakeroot approach for package installation

Categories:

- About Arch (Magyar)
- Package development (Magyar)

Hidden category:

- Pages or sections flagged with Template:Merge

Creating packages (Magyar)
Add topic