RPM-LUA(7)

NUME

rpm-lua - interpretul intern Lua al RPM

SINOPSIS

%scriptlet -p <lua>

%{lua:...}

DESCRIERE
Lua este un limbaj de programare cu scop general, conceput special pentru a fi încorporat în alte programe, iar RPM include un interpret Lua încorporat pentru utilizare în rpm-macros(7) avansate și scripturi de tranzacții.

Interpretorul Lua încorporat face posibile diverse lucruri care sunt dificile sau imposibile cu macrocomenzi simple sau scripturi shell externe, cum ar fi eliminarea buclelor de dependență din scriptlet-urile pachetelor.

MACROCOMENZI

  Accesarea macrocomenzilor
Extensia rpm are diverse funcții pentru gestionarea macrocomenzilor, dar cea mai convenabilă modalitate de a accesa rpm-macroproc(7) din mediul RPM Lua este prin intermediul tabelului global macros.

Lua nu face diferență între sintaxele indexului tabelului și ale numelui câmpului, astfel încât macros.foo și macros['foo'] sunt echivalente. Utilizați cea care se potrivește mai bine scopului.

Ca orice tabel Lua real, elementele inexistente sunt returnate ca nil, iar atribuirea poate fi utilizată pentru a defini sau a anula definiția macrocomenzilor.

Exemplu:
    if not macros.yours then
        macros.my = 'my macro'
    end

    local v = { '_libdir', '_bindir', '_xbindir' }
    for _, v in ipairs(v) do
        if not macros[v] then
            macros[v] = 'default'
        end
    end

Toate macrocomenzile împărtășesc același mediu global de execuție Lua.

  Apelarea macrocomenzilor parametrice
Macrocomenzile parametrice (inclusiv toate macrocomenzile încorporate) pot fi apelate într-un mod nativ Lua prin intermediul tabelului macros, folosind sintaxa macros.nume() sau macros[nume]().

Argumentele sunt pasate printr-un singur argument, care este fie
•   un singur șir, caz în care este extins și împărțit cu regulile native ale macrocomenzii
•   fie un tabel, caz în care conținutul tabelului este utilizat ca argumente literale care nu sunt extinse în niciun fel.

Exemplul 1:
    macros.with('foo')

Exemplul 2:
    macros.dostuff({'one', 'two', 'three'})

  Returnarea datelor
Prin definiție, orice print()'ed în Lua va ajunge în expansiunea macrocomenzii. Macrocomenzile Lua pot, de asemenea, return (să returneze) rezultatul, ceea ce face ca macrocomenzile de ajutor pentru programare să pară mai naturale.

Exemplu:
    %sum() %{lua:
       local v = 0
       for _, a in ipairs(arg) do
           v = v + tonumber(a)
       end
       return v
    }

  Opțiuni și argumente
Macrocomenzile parametrice Lua primesc opțiunile și argumentele lor sub forma a două tabele locale opt și arg, unde opt conține valorile opțiunilor procesate, indexate după caracterul opțiunii, iar arg conține argumentele indexate numeric.

Aceste tabele sunt întotdeauna prezente, indiferent dacă opțiunile sau argumentele au fost efectiv pasate pentru a simplifica utilizarea.

Exemplu:
    %foo(a:b) %{lua:
    if opt.b then
       print('fă b')
    else
       print('sau nu')
    end
    if opt.a == 's' then
       print('fă s')
    end
    if #arg == 0 then
       print('fără argumente :(')
    else
       for i = 1, #arg do
          print(arg[i])
       end
    end
    }

SCRIPTLET-uri
Lua intern poate fi utilizat ca interpret al scriptlet-urilor de tranzacții RPM, inclusiv declanșatoarele și declanșatoarele de fișiere:

Exemplu:
    %pre -p <lua>
    print('Salutare din Lua')

Deși venerabilul /bin/sh este de obicei mai convenabil pentru activitățile de scripturi legate de împachetare, interpretul Lua încorporat are câteva avantaje unice pentru scriptlet-urile de tranzacții: acestea nu adaugă dependențe suplimentare pachetelor și astfel pot ajuta la eliminarea buclelor de dependență. Aceasta poate fi o diferență crucială în setul de pachete „bootstrap” inițial dintr-o instalare inițială.

În special, un script Lua încorporat este singura opțiune general utilizabilă în scriplet-urile %pretrans în timpul instalării inițiale a unui sistem.

Lua încorporat este, de asemenea, mult mai rapid decât executarea unui interpret potențial greoi doar pentru a rula câteva linii de script shell.

Notă: scriptlet-urile care utilizează Lua intern nu trebuie să facă presupuneri cu privire la partajarea mediului de execuție cu alte scriptlet-uri.

  Argumente
Argumentele scriptlet-ului sunt accesibile dintr-un tabel de arg global.

Notă: în Lua, indexurile încep de obicei de la 1 (unu) în loc de 0 (zero) și, în bine sau în rău, implementarea RPM urmează această practică. Astfel, indexurile arg ale scriptlet-ului sunt cu unu mai mici decât se așteaptă în mod normal, pe baza argumentelor tradiționale ale scriptlet-ului. Argumentul care conține numărul de instanțe ale pachetului instalat este arg[2], iar argumentul similar pentru țintele declanșatoare este arg[3], față de $1 și $2 tradiționale din scripturile shell.

Exemplu:
    %postun -p <lua>
    if arg[2] == 0  then
        print("erasing")
    end

  Pachete realocabile
Scriptlet-urile pachetelor realocabile conțin în plus un tabel global RPM_INSTALL_PREFIX care conține toate prefixele posibile ale pachetului.

Adăugat: 4.18.0

  Starea de ieșire
Deși scriptlet-urile nu ar trebui să poată eșua în mod normal, puteți semnaliza starea de eșec a scriptlet-ului utilizând funcția Lua error(mesaj, [nivel]) dacă este necesar.

FIȘIERELE DE SPECIFICAȚII
În contextul unei analize a fișierului rpm-spec(5) cu rpmbuild(1) sau rpmspec(1), mediul RPM Lua conține următoarele tabele globale specifice specificațiilor:

patches
    Numele fișierelor corecțiilor (plasturilor) din specificație, în ordinea în care apar în specificație.

patch_nums
    Numerele corecțiilor din specificație, în ordinea în care au apărut în specificație.

sources
    Numele fișierelor surselor din specificație, în ordinea în care apar în specificație.

source_nums
    Numerele surselor din specificație, în ordinea în care apar în specificație.

Exemplu:
    for i, p in ipairs(patches) do
        print(string.format("echo %d: %sn", patch_nums[i], patches[i]))
    end

EXTENSII
În plus față de bibliotecile standard Lua (în funcție de versiunea Lua la care este legat RPM), următoarele extensii sunt disponibile în interpretul intern Lua al RPM. Acestea pot fi utilizate în toate contextele în care poate fi utilizat Lua intern.

  extensie rpm

Sunt disponibile următoarele funcții specifice RPM:

b64decode(argument)
    Efectuează decodificarea base64 pe argument. A se vedea de asemenea, b64encode().

    Exemplu:
        blob = 'binary data'
        print(blob)
        e = rpm.b64encode(blob)
        print(e)
        d = rpm.b64decode(e)
        print(d)

b64encode(argument [, lungime-linie])
    Efectuează codificarea base64 pe argument. Lungimea liniei poate fi specificată opțional prin al doilea argument. A se vedea de asemenea, b64decode().

define("nume corp")
    Definește o macrocomandă globală nume cu corp. A se vedea de asemenea, secțiunea MACROCOMENZI.

    Exemplu:
        rpm.define('foo 1')

execute(rută [, argument1 [,...])
    Execută o comandă externă. Aceasta este utilă pentru executarea comenzilor auxiliare externe fără a depinde de shell. rută este comanda de executat, urmată de un număr opțional de argumente care trebuie transmise comenzii.

    Pentru un control mai bun asupra execuției procesului și a rezultatului, consultați rpm.spawn().

    Adăugată: 4.15.0

    Exemplu:
        rpm.execute('ls', '-l', '/')
expand(argument)
    Efectuează expansiunea macrocomenzii RPM pe șirul argumentului. A se vedea de asemenea, secțiunea MACROCOMENZI.

    Exemplu:
        rpm.expand('%{_libdir}/mydir')

glob(model, [fanioane])
    Returnează un tabel cu numele de rute care corespund cu model. Dacă fanioane conține c, returnează model în cazul în care nu există coincidențe.

    Exemplu:
        for i, p in ipairs(rpm.glob('*')) do
            print(p)
        end

interactive()
    Lansează sesiunea interactivă pentru testare și depanare. Utilizați în schimb rpmlua(1).

    Exemplu:
        rpm --eval "%{lua: rpm.interactive()}"

isdefined(nume)
    Testează dacă o macrocomandă nume este definită și dacă este parametrică, returnând două valori booleene. A se vedea de asemenea, secțiunea MACROCOMENZI. (Adăugată: 4.17.0)

    Exemplu:
        if rpm.isdefined('_libdir') then
            ...
        end

load(rută)
    Încarcă un fișier de macrocomandă din ruta specificată. La fel ca macrocomanda încorporată %{load:...}.

    Exemplu:
        rpm.load('my.macros')

open(rută, [mod[.fanioane]])
    Deschide un flux de fișiere utilizând facilitățile RPM IO, cu suport pentru comprimare și decomprimare transparentă.

    rută este șirul numelui fișierului, urmat opțional de șirul mod pentru a specifica comportamentul de deschidere:
    •   a: deschide pentru adăugare
    •   w: deschide pentru scriere, trunchiere
    •   r: deschide pentru citire (implicit)
    •   +: deschide pentru citire și scriere
    •   x: eșuează dacă fișierul există

    și, opțional, urmat de rpm-payloadflags(7) pentru comprimare și decomprimare.

    Adăugată: 4.17.0

    Exemplu:
        f = rpm.open('some.txt.gz', 'r.gzdio')
        print(f:read())

    Obiectul rpm.fd returnat are următoarele metode:

    fd:close()

    Închide fluxul fișierului.

    Exemplu:
        f = rpm.open('file')
        f:close()

    fd:flush()

    Golește fluxul fișierului.

    Exemplu:
        f = rpm.open('file', 'w')
        f:write('foo')
        f:flush()
        f:close()

    fd:read([lungime])

    Citește datele din fluxul de fișiere până la lungime octeți sau, dacă nu este specificată, întregul fișier.

    Exemplu:
        f = rpm.open('/vreun/fișier')
        print(f:read())

    fd:seek(mod, poziție)

    Repoziționează poziția fișierului în flux.& mod este unul dintre set, cur și end, iar poziția este relativă la mod: absolută, relativă la curent sau relativă la sfârșit.& Nu toate fluxurile acceptă căutarea.&

    Returnează decalajul fișierului după operație.

    A se vedea de asemenea lseek(3).

    Exemplu:
        f = rpm.open('newfile', 'w')
        f:seek('set', 555)
        f:close()

    fd:write(buffer [, lungime])

    Scrie datele din buffer în fluxul de fișiere, fie în întregime, fie până la lungime octeți, dacă este specificată.

    Exemplu:
        f = rpm.open('newfile', 'w')
        f:write('data data')
        f:close()

    fd:reopen(mod)

    Redeschide un flux cu un mod nou (a se vedea rpm.open()).

    Exemplu:
        rpm.open('vreun.txt.gz')
        f = f:reopen('r.gzdio')
        print(f:read())}

redirect2null(fdno) (OBSOLETĂ)
    Redirecționează descriptorul de fișier fdno către /dev/null (înainte de 4.16, aceasta era cunoscută sub numele de posix.redirect2null())

    Această funcție este învechită și disponibilă numai pentru pachetele RPM v4, din motive de compatibilitate cu versiunile anterioare. Utilizați în schimb „rpm.spawn()” sau „rpm.execute()”.

        pid = posix.fork()
        if pid == 0 then
            posix.redirect2null(2)
            assert(posix.exec('/bin/awk'))
        elseif pid > 0 then
            posix.wait(pid)
        end

spawn({comanda} [, {acțiuni}])
    Lansează, adică execută, un program extern.

    {comanda} este un tabel format din comandă și argumentele sale. Un al doilea tabel opțional poate fi utilizat pentru a transmite diverse acțiuni legate de executarea comenzii. În prezent, sunt acceptate următoarele:

        | Acțiune  | Argument(e) | Descriere
        |----------|-------------------------
        | *stdin*  | rută        | Redirecționează intrarea standard către rută
        | *stdout* | rută        | Redirecționează ieșirea standard către rută
        | *stderr* | rută        | Redirecționează ieșirea de eroare standard către rută

    Returnează starea de ieșire a comenzii: zero în caz de succes sau un tuplet de (nil, mesaj, cod) în caz de eșec.

    Adăugată: 4.20

    Exemplu:
        rpm.spawn({'systemctl', 'restart', 'httpd'}, {stderr='/dev/null'})

undefine(nume)
    Anulează definirea unei macrocomenzi. A se vedea și secțiunea MACROCOMENZI.

    Rețineți că aceasta afișează doar cea mai recentă definiție a macrocomenzii cu numele dat din stivă, adică pot exista încă definiții ale macrocomenzii cu același nume după o operație de anulare a definiției.

    Exemplu:
        rpm.undefine('zzz')

vercmp(v1, v2)
    Efectuează compararea versiunilor RPM pe șirurile de argumente. Returnează -1, 0 sau 1 dacă v1 este mai mică, egală sau mai mare decât v2. Consultați rpm-version(7).

    Notă: în RPM < 4.16, aceasta funcționa numai pe segmente de versiune, ceea ce nu produce rezultate corecte pe șiruri EVR complete.

    Exemplu:
        rpm.vercmp('1.2-1', '2.0-1')

ver(evr), ver(e, v, r)
    Creează obiectul versiune RPM. Acesta acceptă fie un șir evr care este analizat în componentele sale, fie epoca, versiunea și lansarea în argumente separate (care pot fi șiruri sau numere). Obiectul are trei atribute: e pentru epocă, v pentru versiune și r pentru lansare, poate fi afișat în forma EVR și acceptă comparații native în Lua.

    Adăugată: 4.17.0

    Exemplu:
        v1 = rpm.ver('5:1.0-2)
        v2 = rpm.ver(3, '5a', 1)
        if v1 < v2 then
           ...
        end

        if v1.e then
           ...
        end

  extensie posix

Biblioteca standard Lua oferă un set destul de limitat de operații de In/Ieș. Extensia posix îmbunătățește considerabil posibilitățile oferite de Lua.

Următoarele funcții sunt disponibile în spațiul de nume posix, adică pentru a le apela utilizați posix.funcția(). Această documentație se concentrează pe convențiile API Lua. Pentru informații suplimentare despre apelurile de sistem corespunzătoare, consultați manualul de sistem, de exemplu access(3) pentru posix.access().

access(rută [, mod])
    Testează accesibilitatea fișierului/directorului rută. A se vedea acces(3). Dacă mod este omis, se testează existența, în caz contrar se efectuează o combinație dintre următoarele teste:
    •   r: poate fi citit
    •   w: poate fi scis
    •   x: este executabil
    •   f: există

    Exemplu:
        if posix.access('/bin/rpm', 'x') then
            ...
        end

chdir(rută)
    Schimbă directorul de lucru curent la rută. A se vedea chdir(1).

    Exemplu:
        posix.chdir('/tmp')

chmod(rută, mod)
    Modifică modul fișierului/directorului. Modul poate fi fie un număr octal, ca în cazul apelului de sistem chmod(2), fie o reprezentare sub formă de șir similară cu chmod(1).

    Exemplu:
        posix.chmod('aa', 600)
        posix.chmod('bb', 'rw-')
        posix.chmod('cc', 'u+x')

chown(rută, utilizator, grup)
    Modifică proprietarul/grupul fișierului/directorului rută. Argumentele utilizator și grup pot fi valori numerice de identificare sau nume de utilizator/grup. A se vedea chown(2) și chown(1).

    Notă: Aceasta este o operație privilegiată.

    Exemplu:
        posix.chown('aa', 0, 0)
        posix.chown('bb', 'nobody', 'nobody')

ctermid()
    Obține numele terminalului de control. Consultați ctermid(3).

    Exemplu:
        print(posix.ctermid())

dir([rută])
    Obține conținutul directorului - ca readdir(3). Dacă argumentul rută este omis, se utilizează directorul curent.

    Exemplu:
        for i,p in pairs(posix.dir('/')) do
            print(p..'n')
        end

errno()
    Obține mesajul strerror(3) și numărul corespunzător pentru ieșirea errno(3) curentă.

    Exemplu:
        f = '/zzz'
        if not posix.chmod(f, 100) then
            s, n = posix.errno()
            print(f, s)
        end

exec(rută [, argumete...]) (OBSOLETĂ)
    Execută un program. Aceasta poate fi exectuată numai după posix.fork().

    Această funcție este învechită și disponibilă numai pentru pachetele RPM v4, din motive de compatibilitate cu versiunile anterioare. Utilizați în schimb rpm.spawn() sau rpm.execute().

files([rută])
    Iterare peste conținutul directorului. Dacă ruta este omisă, se utilizează directorul curent.

    Exemplu:
        for f in posix.files('/') do
            print(f..'n')
        end

fork() (OBSOLETĂ)
    Bifurcă un nou proces (dintr-unul existent). A se vedea fork(2).

    Această funcție este învechită și disponibilă numai pentru pachetele RPM v4, din motive de compatibilitate cu versiunile anterioare. Utilizați în schimb rpm.spawn() sau rpm.execute().

    Exemplu:
        pid = posix.fork()
        if pid == 0 then
            posix.exec('/foo/bar')
        elseif pid > 0 then
            posix.wait(pid)
        end

getcwd()
    Obține directorul curent. A se vedea getenv(3).

    Exemplu:
        if posix.getcwd() ~= '/' then
            ...
        endif

getenv(nume)
    Obține o variabilă de mediu. Consultați getenv(3).

    Exemplu:
        if posix.getenv('HOME') ~= posix.getcwd() then
            print('not at home')
        end

getgroup(group)
    Obține informații grup(5) pentru un grup. grup poate fi fie un ID numeric, fie un nume de grup. Dacă este omis, se utilizează grupul curent. Returnează un tabel cu câmpurile nume și gid definite ca nume și ID de grup, respectiv, și indexuri începând de la 1 care specifică membrii grupului.

    Exemplu:
        print(posix.getgroup('wheel').gid)

getlogin()
    Obține numele de conectare. A se vedea getlogin(3).

    Exemplu:
        n = posix.getlogin()

getpasswd([utilizator [, selector]])
    Obține informații passwd(5) pentru un cont de utilizator. utilizator poate fi fie un ID numeric, fie un nume de utilizator. Dacă este omis, se utilizează utilizatorul curent. Argumentul opțional selector poate fi unul dintre următoarele:
    •   name
    •   uid
    •   gid
    •   dir
    •   shell
    •   gecos
    •   passwd

    Dacă este omis, se returnează un tabel cu toate aceste câmpuri.

    Exemplu:
        pw = posix.getpasswd(posix.getlogin(), 'shell')|

getprocessid([selector])
    Obține informații despre procesul curent. Argumentul opțional selector poate fi unul dintre
    •   egid: ID-ul grupului efectiv
    •   euid: ID-ul utilizatorului efectiv
    •   gid: ID-ul grupului
    •   uid: ID-ul utilizatorului
    •   pgrp: id-ul grupului părinte
    •   pid: ID-ul utilizatorului părinte
    •   ppid: pid-ul părinte

    Dacă este omis, se returnează un tabel cu toate aceste câmpuri.

    Exemplu:
        if posix.getprocessid('pid') == 1 then
            ...
        end

kill(pid [, semnal])
    Trimite un semnal(7) către un proces. semnal trebuie să fie o valoare numerică, de exemplu 9 pentru SIGKILL. Dacă este omis, se utilizează SIGTERM. A se vedea de asemenea, kill(2).

    Exemplu:
        posix.kill(posix.getprocessid('pid'))

link(ruta-veche, ruta-nouă)
    Creează un nou nume la ruta-nouă pentru un fișier de la ruta-veche, cunoscut și sub numele de legătură dură. A se vedea de asemenea, link(2).

    Exemplu:
        f = rpm.open('aaa', 'w')
        posix.link('aaa', 'bbb')

mkdir(rută)
    Creează un nou director la rută. A se vedea de asemenea, mkdir(2).

    Exemplu:
        posix.mkdir('/tmp')

mkfifo(rută)
    Creează o FIFO, adică o conductă cu nume, la rută. A se vedea de asemenea, mkfifo(2).

    Exemplu:
        posix.mkfifo('/tmp/loc-greșit')

pathconf(rută [, selector])
    Obține informații pathconf(3) pentru rută. Argumentul opțional selector poate fi unul dintre următoarele
    •   link_max
    •   max_canon
    •   max_input
    •   name_max
    •   path_max
    •   pipe_buf
    •   chown_restricted
    •   no_trunc
    •   vdisable.

    Dacă este omis, se returnează un tabel cu toate aceste câmpuri.

    Exemplu:
        posix.pathconf('/', 'path_max')

putenv(șir)
    Modifică sau adaugă o variabilă de mediu. A se vedea de asemenea, putenv(3).

    Exemplu:
        posix.putenv('HOME=/me')

readlink(rută)
    Citește valoarea legăturii simbolice de la rută. A se vedea de asemenea, readlink(2).

    Exemplu:
        posix.mkdir('aaa')
        posix.symlink('aaa', 'bbb')
        print(posix.readlink('bbb'))

rmdir(rută)
    Elimină un director rută. A se vedea de asemenea, rmdir(2).

    Exemplu:
        posix.rmdir('/tmp')

setgid(grup)
    Stabilește identitatea grupului. grup poate fi specificat fie ca un identificator numeric, fie ca nume de grup. A se vedea de asemenea, setgid(2).

    Notă: Aceasta este o operație privilegiată.

setuid(utilizator)
    Stabilește identitatea utilizatorului.& utilizator poate fi specificat fie ca un ID numeric, fie ca nume de utilizator.& A se vedea de asemenea, setuid(2).&

    Notă: Aceasta este o operație privilegiată.

    Exemplu:
        posix.setuid('nobody')

sleep(secunde)
    Adoarme pentru o durată de secunde. A se vedea de asemenea, sleep(3).

    Exemplu:
        posix.sleep(5)

stat(rută [, selector])
    Obține informații despre fișierul stat(3) din rută. Selectorul opțional selector poate fi unul dintre următoarele
    •   mode
    •   ino
    •   dev
    •   nlink
    •   uid
    •   gid
    •   size
    •   atime
    •   mtime
    •   ctime
    •   type.

    Dacă este omis, se returnează un tabel cu toate aceste câmpuri.

    Exemplu:
        print(posix.stat('/tmp', 'mode'))|

        s1 = posix.stat('f1')
        s2 = posix.stat('f2')
        if s1.ino == s2.ino and s1.dev == s2.dev then
            ...
        end

ssymlink(ruta-veche, ruta-nouă)
    Creează o legătură simbolică la ruta-nouă către ruta-veche. A se vedea de asemenea, symlink(2).

    Exemplu:
        posix.mkdir('aaa')
        posix.symlink('aaa', 'bbb')

sysconf([selector])
    Obține informații sysconf(3). Argumentul opțional selector poate fi unul dintre următoarele:
    •   arg_max
    •   child_max
    •   clk_tck
    •   ngroups_max
    •   stream_max
    •   tzname_max
    •   open_max
    •   job_control
    •   saved_ids
    •   version.

    Dacă este omis, se returnează un tabel cu toate aceste câmpuri.

    Exemplu:
        posix.sysconf('open_max')|

times([selector])
    Obține procesul și procesul-copil așteptat times(2). Argumentul opțional selector poate fi unul dintre
    •   utime
    •   stime
    •   cutime
    •   cstime
    •   elapsed

    Dacă este omis, se returnează un tabel cu toate aceste câmpuri.

    Exemplu:
        t = posix.times()
        print(t.utime, t.stime)

ttyname([fd])
    Obține numele unui terminal asociat cu descriptorul de fișier fd. Dacă fd este omis, se utilizează 0 (cunoscut și sub numele de stdin). A se vedea ttyname(3).

    Exemplu:
        if not posix.ttyname() then
            ...
        endif

umask([mod])
    Obține sau definește procesul umask(2). mod poate fi specificat ca număr octal sau șir de moduri similar cu posix.chmod().

    Exemplu:
        print(posix.umask())
        posix.umask(222)
        posix.umask('ug-w')
        posix.umask('rw-rw-r--')

uname(format)
    Obține informații uname(2) despre sistemul curent. Sunt acceptate următoarele directive de format:

    •   %m: Numele tipului de hardware
    •   %n: Numele acestui nod (mașini)
    •   %r: Nivelul actual de lansare al acestei implementări
    •   %s: Numele acestui sistem de operare
    •   %v: Nivelul actual al versiunii acestei implementări

    Exemplu:
        print(posix.uname('%s %r'))

utime(rută [, mtime [, ctime]])
    Modifică ora ultimei accesări și modificări. mtime și ctime sunt exprimate în secunde de la epocă. A se vedea utime(2).

    Dacă mtime sau ctime sunt omise, se utilizează ora curentă, similar cu touch(1).

    Exemplu:
        posix.mkdir('aaa')
        posix.utime('aaa', 0, 0)

wait([pid]) (DEPRECIATĂ)
    Așteaptă un proces-copil. Dacă este specificat pid, așteaptă acel proces-copil particular. A se vedea de asemenea, wait(2).

    Această funcție este învechită și disponibilă numai pentru pachetele RPM v4, din motive de compatibilitate cu versiunile anterioare. Utilizați în schimb rpm.spawn() sau rpm.execute().

    Exemplu:
        pid = posix.fork()
        if pid == 0 then
            posix.exec('/bin/ls'))
        elseif pid > 0 then
            posix.wait(pid)
        end

setenv(nume, valoare [, înlocuirea])
    Modifică sau adaugă variabila de mediu nume. Parametrul opțional înlocuirea este o valoare booleană care definește comportamentul atunci când există deja o variabilă cu același nume. A se vedea de asemenea, setenv(3).

    Exemplu:
        posix.setenv('HOME', '/me', true)

unsetenv(nume)
    Elimină variabila nume din mediu. A se vedea de asemenea, unsetenv(3).

    Exemplu:
        posix.unsetenv('HOME')

EXTINDEREA ȘI PERSONALIZAREA
La inițializare, RPM execută un script global de inițializare Lua init.lua din directorul %getconfdir, de obicei /usr/lib/rpm/init.lua. Acesta poate fi utilizat pentru a personaliza mediul Lua rpm fără a recompila RPM.

Pentru interpretul Lua încorporat, modulele încărcate cu require sunt căutate în primul rând în %{getconfdir}/lua/. %_rpmluadir este o prescurtare pentru această rută.

CONSULTAȚI ȘI
rpm-macros(7) rpm-payloadflags(7) rpmlua(1) rpm-version(7)

https://www.lua.org/

TRADUCERE
Traducerea în limba română a acestui manual a fost făcută de Remus-Gabriel Chelu <remusgabriel.chelu@disroot.org>

Această traducere este documentație gratuită; citiți Licența publică generală GNU Versiunea 3 (https://www.gnu.org/licenses/gpl-3.0.html) sau o versiune ulterioară cu privire la condiții privind drepturile de autor. NU se asumă NICIO RESPONSABILITATE.

Dacă găsiți erori în traducerea acestui manual, vă rugăm să trimiteți un e-mail la translation-team-ro@lists.sourceforge.net.