Comandamentul Linux / Unix Expectați

Expect este un program care discută cu alte programe interactive conform unui scenariu. În urma scenariului, Expect știe ce poate fi așteptat de la un program și care ar trebui să fie răspunsul corect. O limbă interpretată oferă ramificații și structuri de control la nivel înalt pentru a direcționa dialogul. În plus, utilizatorul poate prelua controlul și interacționa direct atunci când se dorește, după ce întoarce controlul la scenariu.

Expectk este un amestec de Expect și Tk. Se comportă exact ca dorința lui Expect și Tk. Asteptarile pot fi de asemenea folosite direct in C sau C ++ fara Tcl.

Numele "Așteptați" vine de la ideea secvențelor de trimitere / așteptare popularizate de uucp, kermit și alte programe de control al modemului. Totuși, spre deosebire de uucp, Expect este generalizat astfel încât să poată fi rulat ca o comandă la nivel de utilizator, având în vedere orice program și sarcină. Asteptati ca puteti vorbi simultan cu mai multe programe.

Ce pot aștepta

De exemplu, aici sunt câteva lucruri pe care se poate aștepta comanda:

• Pentru ca computerul să vă apeleze înapoi, astfel încât să vă puteți conecta fără a plăti apelul.
• Începeți un joc și, dacă configurația optimă nu apare, reporniți-l din nou și din nou), până când acesta se întâmplă, apoi transferați-vă controlul.
• Rugați-vă pe fsck și, răspunzând la întrebările sale, răspundeți "da" sau "nu" sau dați controlul înapoi, bazându-vă pe criterii predeterminate.
• Conectați-vă la altă rețea și preluați automat e-mailul astfel încât să apară ca și cum ar fi fost inițial trimis la sistemul dvs. local.
• Transportați variabilele de mediu, directorul curent sau orice fel de informații în rlogin, telnet, tip, su sau chgrp

Există o varietate de motive pentru care shell - ul nu poate îndeplini aceste sarcini. Toate sunt posibile cu Expect.

În general, Expect este util pentru rularea oricărui program care necesită interacțiune între program și utilizator. Tot ceea ce este necesar este că interacțiunea poate fi caracterizată programatic. Aspectul poate, de asemenea, să dea controlul înapoi utilizatorului, fără a opri programul care este controlat. În mod similar, utilizatorul poate reveni la control în orice moment.

folosire

Se așteaptă ca citește cmdfile pentru o listă de comenzi de executat. Asteptarea poate fi invocata implicit pe sistemele care sustin #! notație marcând scriptul ca executabil și făcând prima linie în script:

#! / usr / local / bin / așteptați-f

Desigur, calea trebuie să descrie cu exactitate unde așteaptă viața. / usr / local / bin este doar un exemplu.

Parametrul -c prefațează o comandă care trebuie executată înainte de orice în script. Comanda ar trebui să fie citată pentru a împiedica ruperea de către coajă. Această opțiune poate fi utilizată de mai multe ori. Comenzile multiple pot fi executate cu un singur -c separându-le cu punct și virgulă. Comenzile sunt executate în ordinea în care apar. Când se utilizează Expectk, această opțiune este specificată ca comanda.

Parametrul -d permite o anumită ieșire de diagnosticare, care raportează în principal activitatea internă a comenzilor cum ar fi așteptarea și interacțiunea. Acest steguleț are același efect cu "exp_internal 1" la începutul unui script Expect, plus versiunea Expect este tipărită.

Parametrul -D permite un program de depanare interactiv. Trebuie să urmeze o valoare întregă. Debuggerul va prelua controlul înainte de următoarea procedură Tcl, dacă valoarea este diferită de zero sau dacă este apăsat un ^ C sau dacă un punct de întrerupere este lovit sau dacă în script apare o altă comandă de depanare corespunzătoare. Când utilizați Expectk, această opțiune este specificată ca - Debug.

Parametrul -f prefațează un fișier din care să citească comenzile. Steagul în sine este opțional deoarece este util doar atunci când se utilizează #! notație, astfel încât alte linii de comandă să poată fi furnizate pe linia de comandă. Când utilizați Expectk, această opțiune este specificată ca fișier.

În mod implicit, fișierul de comandă este citit în memorie și executat în întregime. Este uneori de dorit să citiți fișierele pe rând câte unul. Pentru a forța fișierele arbitrare să fie tratate în acest fel, utilizați pavilonul -b. Când utilizați Expectk, această opțiune este specificată ca -buffer.

Dacă șirul "-" este furnizat ca nume de fișier, se va citi intrarea standard. Utilizați "./-" pentru a citi dintr-un fișier numit "-".

Parola -i cauzează Expectați să solicitați interactiv comenzi în loc să le citiți dintr-un fișier. Solicitarea este terminată prin comanda de ieșire sau prin EOF. Parametrul -i este asumat dacă nu se utilizează nici un fișier de comandă și nici -c. Când utilizați Expectk, această opțiune este specificată ca fiind "interactivă".

- poate fi utilizat pentru a delimita capătul opțiunilor. Acest lucru este util dacă doriți să transmiteți un script ca opțiune scriptului dvs. fără a fi interpretat de către Expect. Acest lucru poate fi util plasat în #! pentru a preveni orice interpretare de către Expect. De exemplu, următoarele vor lăsa argumentele inițiale, inclusiv numele de script în variabila argv .

#! / usr / local / bin / așteptați -

Rețineți că convențiile getopt (3) și execve (2) obișnuite trebuie să fie respectate atunci când adăugați argumente către #! linia.

Fișierul $ exp_library / expect.rc este furnizat automat dacă este prezent, cu excepția cazului în care se utilizează stegulețul -N. (Când se folosește Expectk, această opțiune este specificată ca -NORC.) Imediat după aceasta, fișierul ~ / .expect.rc este furnizat automat, cu excepția cazului în care se folosește flagul -n. Dacă variabila de mediu DOTDIR este definită, este tratată ca un director și se citește .expect.rc de acolo. Când utilizați Expectk, această opțiune este specificată ca -norc. Acest aport se produce numai după executarea tuturor steagurilor -c.

-v cauzează Expect să-și imprime numărul versiunii și să iasă. Drapelul corespunzător din Expectk, care folosește nume de pavilion lung, este -versiunea.

Plăcile opționale sunt construite într-o listă și stocate în variabila denumită argv și. argc este inițializat la lungimea argv.

Argv0 este definit a fi numele scriptului sau binar dacă nu este folosit nici un script. De exemplu, următoarele afișează numele scriptului și primele trei argumente:

send_user "$ argv0 [paranteză $ argv 0 2] \ n"

comenzi

Asteptati ca se foloseste limba de comanda a instrumentului. Tcl asigură fluxul de control (dacă, pentru, pauză), evaluarea expresiei și alte câteva caracteristici, cum ar fi definirea recursului și a procedurii. Comenzile utilizate aici dar nu sunt definite (set, if, exec) sunt comenzi Tcl. Asteptati ca sunt acceptate comenzi suplimentare. Dacă nu se specifică altfel, comenzile returnează șirul gol.

Comenzile sunt listate în ordine alfabetică, astfel încât acestea să poată fi localizate rapid. Cu toate acestea, noii utilizatori ar putea fi mai ușor să înceapă prin citirea descrierilor de spawn, trimite, aștepta și interacționa în ordinea respectivă.

închide [-slave] [-onexec 0 | 1] [-i spawn_id]

închide conexiunea la procesul curent. Cele mai multe programe interactive vor detecta EOF pe stdin și pe ieșire; astfel de aproape de obicei, este suficient pentru a ucide procesul , de asemenea. Flagul -i declară procesul de închidere corespunzător spawn_id numit.

Ambele se așteaptă și interacționează când va ieși din procesul curent și se va închide implicit, dar dacă ucizi procesul prin, să zicem, "exec kill $ pid", trebuie să închizi în mod explicit apelul .

Flagul -onexec determină dacă ID-ul spawn este închis în orice proces nou introdus sau dacă procesul este suprapus. Pentru a lăsa un id spawn deschis, utilizați valoarea 0. O valoare întreagă diferită de zero determină ca spașul să fie închis în orice proces nou.

Flagul -Slave închide robul asociat cu ID-ul spawn. Când conexiunea este închisă, slave-ul este închis automat și dacă este încă deschis.

Indiferent dacă conexiunea este închisă implicit sau explicit, trebuie să apelați așteptați pentru a șterge slotul corespunzător procesului de kernel. Comanda de închidere nu apelează așteptați, deoarece nu există nicio garanție că închiderea unei conexiuni de proces va determina ieșirea.

depanare [[-în prezent] 0 | 1]

controlează un debugger Tcl care vă permite să treceți prin declarații și să setați puncte de întrerupere.

Cu nici un argument, un 1 este returnat dacă debuggerul nu rulează, în caz contrar este returnat un 0.

Cu un argument 1, debuggerul este pornit. Cu un argument 0, debuggerul este oprit. Dacă un argument 1 este precedat de flagul -now, debuggerul este pornit imediat. În caz contrar, debuggerul este pornit cu următoarea instrucțiune Tcl.

Comanda de depanare nu modifică nicio capcană. Comparați acest lucru cu începutul Așteptați cu steagul -D.

Comanda de deconectare deconectează un terminal din terminal . Continuă să ruleze în fundal. Procesul are propriul grup de procese. Standard I / O este redirecționat către / dev / null .

Următorul fragment utilizează deconectarea pentru a continua să executați scriptul în fundal.

dacă {[fork]! = 0} ieșire deconectați. . .

Următorul script citește o parolă și apoi execută un program la fiecare oră care necesită o parolă de fiecare dată când este rulată. Scriptul furnizează parola, astfel încât trebuie doar să o introduceți o singură dată.

trimite_user "parola? \" expect_user -re "(. *) \ n" pentru {} 1 {} {if {[fork]! = 0} {sleep 3600; 1, șir) \ r ". . . Ieșire }

Un avantaj al utilizării deconectării peste caracteristica procesului asincron al shell-ului (&) este faptul că Expect poate salva parametrii terminalului înainte de deconectare și apoi le poate aplica mai târziu în ptys noi. Cu &, Expect nu are nici o șansă să citească parametrii terminalului, deoarece terminalul este deja deconectat de momentul în care Expect primește controlul.

ieșiți din [-opts] [status]

Cauze Expectați să ieșiți sau să vă pregătiți în alt mod să faceți acest lucru.

Steagul -onexit determină ca următorul argument să fie folosit ca un handler de ieșire. Fără un argument, managerul de ieșire curent este returnat.

Flagul -noexit provoacă Expect să se pregătească pentru a ieși, dar nu mai este de așteptat să revină la sistemul de operare. Operatorul de ieșire definit de utilizator este rulat, precum și propriile dispozitive de lucru interne ale Expect. Nu mai trebuie executate comenzi de așteptare. Acest lucru este util dacă rulați Expect cu alte extensii Tcl. Interpretul actual (și fereastra principală dacă există în mediul Tk) rămân astfel încât alte extensii Tcl să poată curăța. Dacă ieșirea din Expect este chemată din nou (cu toate acestea, acest lucru se poate întâmpla), manipulatorii nu sunt reluați.

La ieșire, toate conexiunile la procesele generate sunt închise. Închiderea va fi detectată ca un EOF prin procese înregistrate. ieșirea nu întreprinde alte acțiuni dincolo de ceea ce face procedura normală _exit (2). Astfel, procesele spawned care nu verifică pentru EOF pot continua să ruleze. (O varietate de condiții sunt importante pentru a determina, de exemplu, ce semnale vor fi transmise unui proces înmulțit, dar acestea sunt dependente de sistem, în mod tipic documentate sub ieșire (3).) Procesele procesate care continuă să funcționeze vor fi moștenite de init.

statutul (sau 0, dacă nu este specificat) este returnat ca stat de ieșire al Expect . ieșirea este executată implicit dacă se ajunge la sfârșitul scriptului.

exp_continue [-continue_timer]
Comanda exp_continue permite să se aștepte ca ea însăși să continue să execute, mai degrabă decât să se întoarcă, așa cum ar proceda normal. În mod implicit, exp_continue resetează temporizatorul. Flagul -continue_timer împiedică reluarea temporizatorului. (Vedeți mai multe informații.)

valoarea exp_internal [-f file]
cauzează comenzi suplimentare pentru a trimite informații de diagnostic intern la Expectați la stderr dacă valoarea este diferită de zero. Această ieșire este dezactivată dacă valoarea este 0. Informațiile de diagnosticare includ fiecare caracter primit și fiecare încercare făcută pentru a se potrivi cu ieșirea curentă cu modelele.

Dacă fișierul opțional este furnizat, toate ieșirile normale și de depanare sunt scrise în acel fișier (indiferent de valoarea valorii ). Orice fișier de ieșire de diagnostic anterior este închis.

Parola -info determină exp_internal să returneze o descriere a celor mai recente argumente non-info date.

exp_open [args] [-i spawn_id]
returnează un identificator de fișier Tcl care corespunde id-ului inițial al spawn. Identificatorul de fișier poate fi folosit ca și cum ar fi fost deschis de comanda deschisă a lui Tcl. (ID-ul spawn nu trebuie să mai fie folosit.) O așteptare nu ar trebui executată.

Steagul -leaveopen părăsește id-ul spawn deschis pentru acces prin comenzile Expect. O așteptare trebuie executată pe ID-ul spawn.

exp_pid [-i spawn_id]
returnează ID-ul procesului corespunzător procesului în care a fost înregistrată. Dacă se folosește pavilionul -i , pid-ul returnat corespunde cu cel al id id-ului dat.

exp_send
este un pseudonim pentru trimitere .

exp_send_error
este un alias pentru send_error .

exp_send_log
este un alias pentru send_log .

exp_send_tty
este un alias pentru send_tty .

exp_send_user
este un alias pentru send_user .

exp_version [[-exit] versiune]
este util pentru a vă asigura că scriptul este compatibil cu versiunea curentă a Expect.

Fără argumente, versiunea curentă a Expect este returnată. Această versiune poate fi apoi codată în scriptul dvs. Dacă știți de fapt că nu utilizați funcții ale versiunilor recente, puteți specifica o versiune anterioară.

Versiunile constau din trei numere separate prin puncte. Primul este numărul major. Scripturile scrise pentru versiunile de Expect cu un alt număr major nu vor funcționa aproape sigur. exp_version returnează o eroare dacă numerele majore nu se potrivesc.

Al doilea este numărul minor. Scripturile scrise pentru o versiune cu un număr mai mic decât versiunea curentă pot depinde de unele caracteristici noi și s-ar putea să nu fie difuzate. exp_version returnează o eroare în cazul în care numerele majore se potrivesc, dar numărul minor al scriptului este mai mare decât cel al Expect .

Al treilea este un număr care nu are nici un rol în compararea versiunii. Cu toate acestea, este incrementat atunci când distribuția software-ului Expect este modificată în orice mod, cum ar fi prin documentație sau optimizare suplimentară. Se reseta la 0 la fiecare nouă versiune minoră.

Cu pavilionul -exit , Expect imprimă o eroare și se termină dacă versiunea nu este actualizată.

așteptați [[-opts] pat1 body1] ... [-opts] patn [bodyn]
așteaptă până când unul dintre modele se potrivește cu ieșirea unui proces spawned, o perioadă de timp specificată a trecut sau se vede un sfârșit de fișier. Dacă corpul final este gol, acesta poate fi omis.

Modelele de la cea mai recentă comandă expect_before sunt implicit utilizate înainte de orice alte modele. Modelele de la cea mai recentă comandă expect_after sunt implicit utilizate după orice alte modele.

Dacă argumentele pentru întreaga declarație de așteptare necesită mai mult de o linie, toate argumentele pot fi "încorporate" într-una astfel încât să se evite încheierea fiecărei linii cu o backslash. În acest caz, substituțiile obișnuite de Tcl vor avea loc în ciuda armăturilor.

Dacă un model este cuvântul cheie eof , corpul corespunzător este executat la sfârșitul fișierului. Dacă un model este termenul de expirare a cuvântului cheie, corpul corespunzător este executat după expirarea timpului. Dacă nu este utilizat niciun cuvânt cheie cu timp de expirare, o acțiune implicită este executată la expirarea timpului. Perioada de expirare implicită este de 10 secunde, dar poate fi setată, de exemplu la 30, prin comanda "set timeout 30". Un interval de timp infinit poate fi desemnat de valoarea -1. Dacă un model este implicit pentru cuvântul cheie, corpul corespunzător este executat fie la expirarea fie la sfârșitul fișierului.

Dacă se potrivește un model, atunci corpul corespunzător este executat. așteaptă returnează rezultatul corpului (sau șirul gol dacă nu se potrivește modelul). În cazul în care se potrivesc mai multe modele, cea care apare mai întâi este utilizată pentru a selecta un corp.

De fiecare dată când apare o nouă ieșire, se compară cu fiecare model în ordinea în care sunt listate. Astfel, puteți testa pentru absența unui meci, făcând ultimul model garantat să apară, cum ar fi un prompt. În situațiile în care nu există nici un prompt, trebuie să utilizați timeout (la fel ca și în cazul în care interacționați manual).

Modelele sunt specificate în trei moduri. În mod prestabilit, modelele sunt specificate ca și în cazul comenzii de potrivire a șirului Tcl. (Aceste modele sunt, de asemenea, similare cu expresiile regulate din C-shell, de obicei denumite modele globale). Steagul -gl poate fi folosit pentru a proteja modelele care ar putea altfel să se potrivească cu așteptarea unor steaguri. Orice model care începe cu un "-" ar trebui protejat în acest fel. (Toate șirurile care încep cu "-" sunt rezervate pentru opțiunile viitoare.)

De exemplu, fragmentul următor caută un login de succes. (Rețineți că anularea este presupusă a fi o procedură definită în altă parte a scriptului.)

așteptați {ocupat {pune ocupat \ n; exp_continue} nu a reușit să întrerupă "parola nevalidă" abort timeout abort conectat}

Citatele sunt necesare pe modelul al patrulea, deoarece conțin un spațiu, care altfel ar separa modelul de acțiune. Modelele cu aceeași acțiune (cum ar fi cea de-a treia și a patra) necesită afișarea din nou a acțiunilor. Acest lucru poate fi evitat prin utilizarea modelelor în stil regexp (a se vedea mai jos). Mai multe informații despre modelarea modelelor în stilul globului pot fi găsite în manualul Tcl.

Modelele în stilul Regexp urmează sintaxa definită de comanda regexp a Tcl (scurt pentru "expresie regulată"). Modelele regexp sunt introduse cu flag -re . Exemplul anterior poate fi rescris folosind un regexp ca:

așteptați {ocupat {pune ocupat \ n; exp_continue} -re "nu a reușit | parola nevalidă" abort timeout abort conectat}

Ambele tipuri de modele sunt "neanchise". Acest lucru înseamnă că modelele nu trebuie să se potrivească întregului șir, dar pot începe și încheia meciul oriunde în șir (atâta timp cât se potrivește totul). Utilizați ^ pentru a potrivi începutul unui șir și $ pentru a se potrivi cu sfârșitul. Rețineți că dacă nu așteptați sfârșitul unui șir, răspunsurile dvs. pot ajunge cu ușurință în mijlocul șirului, deoarece acestea sunt reluate de la procesul de reproducere. În timp ce produce încă rezultate corecte, producția poate să arate nefiresc. Astfel, folosirea lui $ este încurajată dacă puteți descrie exact caracterele de la sfârșitul unui șir.

Rețineți că la mulți editori, ^ și $ se potrivesc cu începutul și sfârșitul liniilor. Cu toate acestea, deoarece se așteaptă să nu fie orientată pe linie, aceste caractere se potrivesc cu începutul și sfârșitul datelor (spre deosebire de linii) aflate în așteptarea tamponului de potrivire. (De asemenea, consultați nota de mai jos despre "indigestia sistemului.")

Parametrul -ex determină ca modelul să corespundă cu un șir "exact". Nu se face nici o interpretare a *, ^, etc (deși convențiile obișnuite Tcl trebuie totuși respectate). Modelele exacte sunt întotdeauna neatinse.

Steagul -activitate provoacă transformarea caracterelor majuscule ale ieșirii ca și cum ar fi caractere minuscule. Modelul nu este afectat.

În timp ce lectură de ieșire, mai mult de 2000 de octeți pot forța bytes mai devreme să fie "uitat". Acest lucru poate fi schimbat cu funcția match_max . (Rețineți că valorile excesiv de mari pot încetini matcherul de tipare.) Dacă patch-ul este full_buffer , corpul corespunzător este executat dacă au fost primite match_max bytes și nu au fost potrivite alte modele. Indiferent dacă este utilizat sau nu cuvântul cheie full_buffer , caracterele uitate sunt scrise la expect_out (buffer).

Dacă patoul este cuvântul cheie nul și null-urile sunt permise (prin comanda remove_nulls ), corpul corespunzător este executat dacă se potrivește un singur ASCII 0. Nu este posibil să se potrivească 0 bytes prin glob sau regexp modele.

După ce se potrivește un model (sau eof sau full_buffer), orice ieșire de potrivire și de neegalat anterior este salvată în variabila expect_out (buffer) . Până la 9 potriviri de subreversare regexp sunt salvate în variabilele expect_out (1, string) prin expect_out (9, string) . În cazul în care indicatorul de indici este utilizat înaintea unui model, indiciile de început și de sfârșit (într-o formă potrivită pentru intersecție ) dintre cele 10 șiruri sunt stocate în variabilele expect_out (X, start) și expect_out (X, end) unde X este a cifră, corespunde poziției de substring din buffer. 0 se referă la șiruri de caractere care se potrivesc întregului model și sunt generate pentru modele globale, precum și modele regexp. De exemplu, dacă un proces a produs rezultatul "abcdefgh \ n", rezultatul a:

așteptați "cd"

este ca și cum ar fi executat următoarele afirmații:

set expect_out (0, șir) cd set expect_out (tampon) abcd

și "efgh \ n" este lăsat în bufferul de ieșire. Dacă un proces a produs rezultatul "abbbcabkkkka \ n", rezultatul a:

așteptați-indici -re "b (b *). * (k +)"

este ca și cum ar fi executat următoarele afirmații:

set așteptați (0, începe) 1 set expect_out (0, sfarsit) 10 set expect_out (0, sfarsit) 10 set expect_out (0, string) (2, start) 10 set expect_out (2, sfarsit) 10 set expect_out (2, string) k set expect_out (tampon) abbbcabkkkk

și "a \ n" este lăsată în bufferul de ieșire. Modelul "*" (și -re ". *") Va elimina tamponul de ieșire fără a citi mai multă ieșire din proces.

În mod normal, ieșirea corespunzătoare este eliminată din tampoanele interne ale Expect. Acest lucru poate fi prevenit prin prefixarea unui model cu pictograma -notransfer . Acest steguleț este util în special în experimentare (și poate fi abreviat la "-not" pentru confort în timpul experimentării).

ID-ul spawn asociat cu ieșirea de potrivire (sau eof sau full_buffer) este stocat în expect_out (spawn_id) .

Parametrul -timeout determină comanda curentă să aștepte să folosească următoarea valoare ca un timeout în loc să utilizeze valoarea variabilei timeout.

În mod prestabilit, modelele sunt potrivite cu ieșirea din procesul curent, cu toate acestea, flagul -i declară că ieșirea din lista spawn_id numită este potrivită cu oricare dintre următoarele modele (până la următoarea -i ). Lista spawn_id ar trebui să fie o listă separată de spawn_ids sau o variabilă care se referă la o astfel de listă de spawn_ids.

De exemplu, următorul exemplu așteaptă pentru "conectat" din procesul curent sau "ocupat", "eșuat" sau "parolă nevalidă" din spawn_id numit de $ proc2.

așteptați {-i $ proc2 ocupat {pune ocupat \ n; exp_continue} -re "nu a reușit | parola nevalidă" abort timeout abort conectat}

Valoarea variabilei globale any_spawn_id poate fi utilizată pentru a se potrivi modelelor cu orice spawn_ids care sunt denumite cu toate celelalte simboluri -i din comanda așteptare curentă. Spawn_id de la un flag-- i fără model asociat (adică, urmat imediat de alt -i ) este pus la dispoziția oricăror altor modele din aceeași comandă așteptată asociată cu any_spawn_id.

Flagul -i poate, de asemenea, să numească o variabilă globală, caz în care variabila este citită pentru o listă de ID-uri de spawn. Variabila este recitită ori de câte ori se schimbă. Aceasta oferă o modalitate de modificare a sursei I / O în timp ce comanda este în execuție. ID-urile de plantă furnizate astfel sunt denumite "indirecte".

Acțiunile, cum ar fi spargerea și continuarea cauzării structurilor de control (de exemplu, pentru proc ) pentru a se comporta în mod obișnuit. Comanda exp_continue permite să se aștepte ca ea însăși să continue să execute, mai degrabă decât să se întoarcă, așa cum ar proceda normal.

Acest lucru este util pentru evitarea buclelor explicite sau a declarațiilor de așteptare repetate. Următorul exemplu face parte dintr-un fragment pentru automatizarea rlogin. Exp_continue evită să scrie oa doua declarație așteptare (să caute din nou promptul) dacă rlogin solicită o parolă.

așteptați {password: {stty -echo send_user "pentru $ user) pe $ host:" expect_user -re "(. *) \ n" send_user "\ n" send "$ expect_out echo exp_continue} incorect {send_user "parola nevalidă sau contul \ n" ieșire} timeout {send_user "conexiune la $ host timed out \ n" ieșire} eof {send_user \ re $ prompt}

De exemplu, următorul fragment ar putea ajuta ghidul utilizatorului să interacționeze deja complet automatizat. În acest caz, terminalul este pus în modul brut. Dacă utilizatorul apasă "+", o variabilă este incrementată. Dacă "p" este apăsat, mai multe returnări sunt trimise procesului, probabil pentru a-l împinge într-un fel, iar "i" permite utilizatorului să interacționeze cu procesul, furtând efectiv controlul de la scenariu. În fiecare caz, exp_continue permite ca curentul să se aștepte la continuarea potrivirii după efectuarea acțiunii curente.

stty raw -echo expect_after {-i $ user_spawn_id "p" {trimite "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interacționează; exp_continue} "ieșire" ieșire}

Implicit, exp_continue resetează temporizatorul. Timerul nu este repornit, dacă exp_continue este apelat cu flag -continue_timer .

expect_after [expect_args]
funcționează identic cu expect_before cu excepția faptului că, dacă modelele de la ambele așteptați și expect_after se pot potrivi, se utilizează modelul așteptat . Consultați comanda expect_before pentru mai multe informații.

expect_background [expect_args]
are aceleași argumente ca se așteaptă , totuși se întoarce imediat. Modelele sunt testate de fiecare dată când sosesc noi intrări. Timpul de execuție al modelului și implicit sunt lipsite de sens la așteptările de la fața locului și sunt eliminate în tăcere. În caz contrar, comanda expect_background folosește modelele expect_before și expect_after la fel cum se așteaptă .

Atunci când acțiunile așteptate sunt evaluate, procesarea de fundal pentru același id spawn este blocată. Procesarea de fundal este deblocată când acțiunea este finalizată. În timp ce procesarea de fundal este blocată, este posibil să se aștepte la același ID de spawn.

Nu este posibilă executarea unei așteptări în timp ce un bloc expect_background este deblocat. expect_background pentru un anumit id spawn este șters prin declararea unui nou expect_background cu același id spawn. Declarația expect_background fără niciun model elimină idul spawn dat de la capacitatea de a se potrivi modelelor din fundal.

expect_before [expect_args]
are aceleași argumente ca se așteaptă , totuși se întoarce imediat. Modelele de perechi de acțiuni de la cea mai recentă așteptare înainte cu același id spawn sunt adăugate implicit în toate comenzile următoare așteptate . Dacă un model se potrivește, acesta este tratat ca și cum ar fi fost specificat în comanda așteptată în sine, iar corpul asociat este executat în contextul comenzii așteptate . Dacă modelele de la ambele așteptați înainte și așteptați se pot potrivi, se utilizează modelul expect_before .

Dacă nu este specificat niciun model, ID-ul spawn nu este verificat pentru niciun model.

Dacă nu este suprascris de un flag -i , așteptați ca modelele să se potrivească cu ID-ul spawn definit la momentul executării comenzii expect_before (nu atunci când modelul său este adaptat).

Steagul informațiilor -info așteaptă să se întoarcă specificațiile actuale cu privire la ce tipare se vor potrivi. În mod prestabilit, raportează codul de identificare al spawnului curent. Este posibil să se furnizeze o specificație opțională id spawn pentru informații despre ID-ul spawn. De exemplu

expect_before -info -i $ proc

Se poate specifica cel mult o specificație id spawn. Steagul - suprimă indirect indiciile directe ale spaților care provin doar din specificații indirecte.

În loc de o specificație id spawn, pavilionul "-all" va provoca "-info" pentru a raporta despre toate idiotul icrelor.

Ieșirea pavilionului -info poate fi reutilizată ca argument pentru a aștepta înainte.

expect_tty [expect_args]
este ca și cum se așteaptă, dar citește caracterele din / dev / tty (adică intrările de la tastatură de la utilizator). În mod prestabilit, citirea este efectuată în modul gătit. Astfel, liniile trebuie să se încheie cu o întoarcere pentru a se aștepta să le vadă. Acest lucru poate fi schimbat prin stty (vezi comanda stty de mai jos).

expect_user [expect_args]
este ca și cum se așteaptă, dar citește caractere de la stdin (adică apăsările de la tastatură de la utilizator). În mod prestabilit, citirea este efectuată în modul gătit. Astfel, liniile trebuie să se încheie cu o întoarcere pentru a se aștepta să le vadă. Acest lucru poate fi schimbat prin stty (vezi comanda stty de mai jos).

furculiţă
creează un nou proces . Noul proces este o copie exactă a procesului actual Expect . Pe succes, furculița returnează 0 la noul proces (copil) și returnează ID-ul procesului procesului copil în procesul părinte. La eșec (invariabil din cauza lipsei de resurse, de exemplu, spațiu swap, memorie), furculița returnează -1 procesului părinte și nu se creează niciun proces copil.

Procesele procesate încetează prin comanda de ieșire , la fel ca procesul inițial. Procesele procesate sunt permise să scrie în fișierele jurnal. Dacă nu dezactivați depanarea sau logarea în majoritatea proceselor, rezultatul poate fi confuz.

Unele implementări pty pot fi confundate de mai mulți cititori și scriitori, chiar și momentan. Astfel, este mai sigur să se furiseze înainte de procesele de reproducere.

interacționa [string1 body1] ... [stringn [bodyn]]
oferă controlul procesului actual către utilizator, astfel încât intrările de taste sunt trimise la procesul curent, iar stdout și stderr procesului curent sunt returnate.

Șirul de perechi de caractere pot fi specificate ca argumente, caz în care corpul este executat atunci când este introdus șirul corespunzător. (Implicit, șirul nu este trimis în procesul curent.) Comanda interpretului este presupusă, dacă corpul final lipsește.

Dacă argumentele pentru întreaga instrucțiune de interacțiune necesită mai mult de o linie, toate argumentele pot fi "încorporate" într-una astfel încât să se evite încheierea fiecărei linii cu un backslash. În acest caz, substituțiile obișnuite de Tcl vor avea loc în ciuda armăturilor.

De exemplu, următoarea comandă rulează interacționează cu următoarele perechi de string-corp definite: Când apăsați ^ Z, Expect este suspendat. (Parametrul -resetare restabilește modurile terminale.) Când se apasă tasta ^ A, utilizatorul vede "ați tastat un control-A" și procesul este trimis a ^ A. Când se apasă $, utilizatorul vede data. Atunci când apăsați ^ C, așteptați ieșirile. Dacă se introduce "foo", utilizatorul vede "bar". Atunci când apăsați ~~, interpretul Expect rulează interactiv.

setați CTRLZ \ 032 interacționați între {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "ați tastat un control-A \ n"; trimiteți "\ 001"} $ {send_user "Data este [formatul ceasului [ceas secunde]]"} \ 003 exit foo {send_user "bar"} ~~}

În perechile string-corp, șirurile sunt potrivite în ordinea în care sunt enumerate ca argumente. Stringurile care se potrivesc parțial nu sunt trimise procesului actual în așteptarea venirii restului. Dacă apoi sunt introduse caracterele astfel încât nu mai poate exista o potrivire, numai partea din șir va fi trimisă procesului care nu poate începe altul. Astfel, șirurile care sunt substringuri ale potrivirilor parțiale se pot potrivi mai târziu, dacă șirurile originale care încearcă să fie potrivite nu reușesc în cele din urmă.

În mod implicit, potrivirea șirului este exactă, fără cărți sălbatice . (În schimb, comanda așteptare folosește în mod implicit modelele în stilul globului.) Parametrul -ex poate fi utilizat pentru a proteja modele care altfel ar putea corespunde cu steagurile interacțioase . Orice model care începe cu un "-" ar trebui protejat în acest fel. (Toate șirurile care încep cu "-" sunt rezervate pentru opțiunile viitoare.)

Flagul -re forțează șirul să fie interpretat ca un model în stil regexp. În acest caz, substringurile potrivite sunt stocate în variabila interact_out similar cu modul în care se așteaptă stocarea rezultatelor în variabila expect_out . Steagul- indici este susținut în mod similar.

Modelul eof introduce o acțiune care este executată la sfârșitul fișierului. Un model eof separat poate urmări, de asemenea, pavilionul de ieșire, caz în care se potrivește dacă se detectează un eof în timp ce se scrie ieșirea. Acțiunea prestabilită este "întoarcere", astfel încât interacțiunea se întoarce pur și simplu la orice EOF.

Perioada de execuție a modelului introduce un interval de timp (în secunde) și o acțiune care este executată după ce nu s-au citit caractere pentru o anumită perioadă de timp. Modelul timeout se aplică procesului cel mai recent specificat. Nu există un interval de timp prestabilit. Variabila specială "timeout" (folosită de comanda așteptare ) nu are nici un efect asupra acestui interval de timp.

De exemplu, următoarea afirmație ar putea fi utilizată pentru autologizarea utilizatorilor care nu au tastat nimic pentru o oră, dar care primesc încă mesaje frecvente de sistem:

interacționați-introduceți $ user_spawn_id timeout 3600 return -output $ spawn_id

Dacă modelul este cuvântul cheie null și sunt permise null-uri (prin comanda remove_nulls ), corpul corespunzător este executat dacă se potrivește un singur ASCII 0. Nu este posibil să se potrivească 0 bytes prin glob sau regexp modele.

Prefabricarea unui model cu flag -write determină variabila interact_out (spawn_id) pentru a fi setată la spawn_id care corespunde modelului (sau eof).

Acțiunile, cum ar fi spargerea și continuarea cauzării structurilor de control (de exemplu, pentru proc ) pentru a se comporta în mod obișnuit. Cu toate acestea, cauzele de întoarcere interacționează pentru a reveni la apelantul său, în timp ce cauzele inter_return interacționează pentru a determina revenirea în apelul său. De exemplu, dacă "proc foo" numit interacționează, care a executat apoi acțiunea inter_return , proc foo se va întoarce. (Aceasta înseamnă că, dacă interacționează interogarea interpretului interactiv, întoarcerea prin tastare va determina interacțiunea să continue, în timp ce inter_return va determina interacțiunea să se întoarcă la apelantul său.)

În timpul interacțiunii , modul brut este utilizat astfel încât toate caracterele să poată fi transmise procesului curent. Dacă procesul actual nu capturează semnalele de control al funcției, se va opri dacă este trimis un semnal de oprire (implicit ^ Z). Pentru a reporni, trimiteți un semnal continuu (cum ar fi "ucide -CONT"). Dacă doriți cu adevărat să trimiteți un SIGSTOP la un astfel de proces (cu ^ Z), luați în considerare mai întâi cash-ul de reproducere și apoi executați programul. Pe de altă parte, dacă doriți să trimiteți un SIGSTOP să se aștepte , primul interpret de apel (poate prin utilizarea unui caracter de evacuare), apoi apăsați ^ Z.

Șirul de perechi de caractere poate fi folosit ca o scurtă durată pentru a evita intrarea în interpret și executarea comenzilor interactiv. Modul terminal anterior este utilizat în timp ce corpul unei perechi de string-corp este executat.

Pentru viteză, acțiunile se execută în modul brut în mod prestabilit. Parametrul -resetare resetează terminalul la modul pe care îl avea înainte de a interacționa a fost executat (invariabil, modul fierte). Rețineți că caracterele introduse în timpul comutării modului pot fi pierdute (o caracteristică nefericită a driverului terminalului în unele sisteme). Singurul motiv pentru care se folosește reseta este dacă acțiunea dvs. depinde de funcționarea în modul gătit.

Parola -echo trimite caractere care se potrivesc cu următorul model înapoi la procesul care le-a generat pe măsură ce fiecare caracter este citit. Acest lucru poate fi util atunci când utilizatorul trebuie să vadă feedback din modele tipărite parțial.

În cazul în care un model este în curs de ecou, ​​dar în cele din urmă nu reușește să se potrivească, caracterele sunt trimise procesului spawned. În cazul în care procesul de reproducere apoi ecou lor, utilizatorul va vedea caracterele de două ori. -echo este, probabil, numai adecvat în situațiile în care este puțin probabil ca utilizatorul să nu completeze modelul. De exemplu, următorul fragment este din rftp, scriptul recursiv-ftp, în cazul în care utilizatorul este rugat să intre, ~ p, sau ~ l, pentru a obține, a pune sau a afișa directorul curent recursiv. Acestea sunt atât de departe de comenzile obișnuite de ftp, că este puțin probabil ca utilizatorul să scrie ~ urmat de orice altceva, cu excepția greșelilor, caz în care probabil va ignora oricum rezultatul.

interacționează {-echo ~ g {getcurdirectory 1} -echo ~ l {getcurdirectory 0} -echo ~ p {putcurdirectory}}

Parola -nobuffer trimite caracterele care se potrivesc cu următorul model pe procesul de ieșire , pe măsură ce sunt citite caracterele.

Acest lucru este util atunci când doriți să permiteți unui program să redea modelul. De exemplu, următoarele ar putea fi utilizate pentru a monitoriza locația unei persoane (un modem în stil Hayes). De fiecare dată când se vede "etc", scriptul înregistrează restul liniei.

proc lognumber {} {interact -nobuffer -re "(. *) \ r" întoarcere pune $ log "[format ceas [ceas secunde]]: dialed $ interact_out (1, string)" interactiv -nobuffer "atd"

În timpul interacțiunii , utilizarea anterioară a log_user este ignorată. În special, interacționează va forța ieșirea să fie înregistrată (trimisă la ieșirea standard), deoarece se presupune că utilizatorul nu dorește să interacționeze orbește.

Parametrul -o determină aplicarea următoarelor perechi de chei-corp la ieșirea procesului curent. Acest lucru poate fi util, de exemplu, atunci când se ocupă cu gazde care transmit caractere nedorite în timpul unei sesiuni telnet.

Implicit, interacționează așteaptă ca utilizatorul să scrie stdin și să citească stdout-ul procesului Expect în sine. Flagul -u (pentru "user") face ca interogarea să fie utilizată ca proces numit de argumentul său (care trebuie să fie un id spawned).

Acest lucru permite ca două procese independente să fie îmbinate fără a utiliza o buclă explicită. Pentru a ajuta la depanare, așteptați diagnosticarea întotdeauna să mergeți la stderr (sau stdout pentru anumite informații de logare și de depanare). Din același motiv, comanda interpretului va citi interactiv de la stdin.

De exemplu, următorul fragment creează un proces de conectare. Apoi se formează utilizatorul (nu este prezentat) și, în final, leagă cele două. Desigur, orice proces poate fi înlocuit de autentificare. O cochilie, de exemplu, ar permite utilizatorului să lucreze fără a furniza un cont și o parolă.

spawn conectare set login $ spawn_id spawn vârf modem # dial înapoi la utilizator # conectare utilizator pentru conectare interacționează -u $ login

Pentru a trimite ieșirea la mai multe procese, listați fiecare listă de identificare a spawnului precedată de un semn de ieșire . Intrările pentru un grup de ID-uri de ieșire pot fi determinate de o listă cu ID-uri de tip spawn precedată de un semn de intrare . (Ambele intrări și -output pot lua liste în aceeași formă ca și flagul -i din comanda așteptare , cu excepția faptului că any_spawn_id nu are sens în interacțiune .) Toate următoarea steaguri și șiruri (sau șabloane) se aplică la această intrare până la altul - este afișat indicatorul de intrare. Dacă nu apare niciun input , -output implică "-input $ user_spawn_id -output". (În mod similar, cu modele care nu au intrare .) Dacă este specificată o intrare , ea suprascrie $ user_spawn_id. Dacă este specificată oa doua intrare , ea suprascrie $ spawn_id. Se pot specifica și alte steaguri de intrare .

Cele două procese de intrare implicite implicit au ca rezultat ieșirile specificate ca $ spawn_id și $ user_spawn_id (în sens invers). Dacă un flag de intrare apare fără pictogramă de ieșire , caracterele din acest proces sunt aruncate.

Flagul -i introduce un înlocuitor pentru spawn_id curent atunci când nu sunt folosite alte steaguri de intrare sau -output . Flagul A -i implică o pictogramă -o.

Este posibil să se schimbe procesele cu care se interacționează folosind id-uri indirecte ale spaților. (Identificările indirecte ale spaților sunt descrise în secțiunea de pe comanda așteptare.) Identificările indirecte ale spaților pot fi specificate prin intermediul semnalizatoarelor -i, -u, -inputul sau -output.

interpret [args]
determină ca utilizatorul să fie solicitat interactiv pentru comenzile Expect și Tcl. Se imprimă rezultatul fiecărei comenzi.

Acțiunile, cum ar fi spargerea și continuarea cauzării structurilor de control (de exemplu, pentru proc ) pentru a se comporta în mod obișnuit. Totuși, întoarcerea face ca interpretul să se întoarcă la apelant, în timp ce inter-returul determină ca interpretul să determine returnarea apelantului. De exemplu, dacă "proc foo" numit interpret care a executat apoi acțiunea inter_return , proc foo se va întoarce. Orice altă comandă determină ca interpretul să continue să solicite comenzi noi.

În mod implicit, promptul conține două numere întregi. Primul intreg descrie adâncimea stiva de evaluare (adică, de câte ori a fost apelată Tcl_Eval). Cel de-al doilea întreg este identificatorul istoricului Tcl. Promptul poate fi setat prin definirea unei proceduri numite "prompt1" a cărei valoare de întoarcere devine următorul prompt. Dacă o declarație are citate deschise, paranteze, brațe sau paranteze, se emite un prompt secundar (implicit "+>") la rândul nou. Instrumentul secundar poate fi setat prin definirea unei proceduri numite "prompt2".

În timpul interpretului , se utilizează modul gătit, chiar dacă apelantul său folosea modul brut.

Dacă stdin este închis, interpretul se va întoarce dacă nu se folosește flagul -eof , caz în care se invocă argumentul următor.

log_file [args] [[-a] fișier]
Dacă este furnizat un nume de fișier, log_file va înregistra o înregistrare a sesiunii (începând de la acel moment) în fișier. fișierul log_file se va opri din înregistrare dacă nu este furnizat niciun argument. Orice fișier jurnal anterior este închis.

În locul unui nume de fișier, un identificator de fișier Tcl poate fi furnizat prin utilizarea semnalizatoarelor " open- or- open" . Acest lucru este similar cu comanda spawn . (Pentru mai multe informații, consultați secțiunea Spiriduș ).

Forțele -a- flag de ieșire pentru a fi logate care a fost suprimată de comanda log_user .

Implicit, comanda log_file se anexează la fișierele vechi, mai degrabă decât la trunchierea acestora, pentru comoditatea de a putea deconecta și de mai multe ori într-o singură sesiune. Pentru a trunchia fișierele, utilizați pavilionul -noappend .

Flagul -info determină log_file pentru a returna o descriere a celor mai recente argumente non-info date.

log_user -info | 0 | 1
În mod implicit, dialogul trimitere / așteptare este înregistrat la stdout (și un jurnal dacă este deschis). Logarea la stdout este dezactivată de comanda "log_user 0" și este activată de "log_user 1". Logarea la fișierul log este neschimbată.

Parola -info determină log_user să returneze o descriere a celor mai recente argumente non-info date.

match_max [-d] [-i spawn_id] [dimensiune]
definește mărimea tamponului (în bytes) utilizat intern de așteptare . Cu nici un argument de mărime , mărimea curentă este returnată.

Cu parametrul -d , este setată dimensiunea implicită. (Valoarea implicită inițială este 2000.) Cu parametrul -i , dimensiunea este setată pentru id spawn numit, altfel este setat pentru procesul curent.

suprapunere [- # spawn_id] [- # spawn_id] [...] program [args]
execută "program args" în locul actualului program Expect , care se termină. Un argument cu cratimă goală forțează o cratimă în fața numelui comenzii ca și cum ar fi fost o coajă de conectare. Toate spawn_ids sunt închise, cu excepția celor numite ca argumente. Acestea sunt mapate pe identificatorii de fișiere numiți.

Spawn_ids sunt mapate la identificatorii de fișiere pentru ca noul program să moștenească. De exemplu, următoarea linie rulează șahul și permite să fie controlată de procesul actual - să spunem, un maestru de șah.

suprapunere -0 $ spawn_id -1 $ spawn_id -2 $ spawn_id șah

Acest lucru este mai eficient decât "interacționează-u", dar sacrifică capacitatea de a face interacțiune programată, deoarece procesul Expect nu mai este în control.

Rețineți că nu este prevăzut niciun terminal de control. Astfel, dacă deconectați sau remapați intrarea standard, programele care fac controlul funcției (shell-uri, login etc.) nu vor funcționa corect.

paritate [-d] [-i spawn_id] [valoare]
definește dacă paritatea ar trebui reținută sau eliminată de la ieșirea proceselor spawned. Dacă valoarea este zero, paritatea este dezbrăcată, altfel nu este dezbrăcată. Cu nici un argument de valoare , valoarea curentă este returnată.

Cu parametrul -d , valoarea parității implicită este setată. (Valoarea implicită inițială este 1, adică paritatea nu este dezbrăcată.) Cu parametrul -i , valoarea parității este setată pentru numele spawn numit, altfel este setat pentru procesul curent.

remove_nulls [-d] [-i spawn_id] [valoare]
definește dacă nullurile sunt reținute sau eliminate din ieșirea proceselor spawned înainte de potrivirea modelului sau stocarea în variabila expect_out sau interacțiune_out . Dacă valoarea este 1, nulls sunt eliminate. Dacă valoarea este 0, nulls nu sunt eliminate. Cu nici un argument de valoare , valoarea curentă este returnată.

Cu parametrul -d , valoarea implicită este setată. (Valoarea implicită inițială este 1, adică nulurile sunt eliminate.) Cu parametrul -i , valoarea este setată pentru numele spawn numit, altfel este setat pentru procesul curent.

Dacă nulls sunt sau nu eliminate, Expect va înregistra null bytes la jurnal și stdout.

trimiteți șirul [-flaguri]
Trimite șir la procesul curent. De exemplu, comanda

trimite "hello world \ r"

trimite caracterele, helloworld la procesul actual. (Tcl include o comandă printf (numită format ) care poate construi șiruri complexe arbitrare.)

Caracterele sunt trimise imediat, deși programele cu intrare tamponată în linie nu vor citi caracterele până când nu este trimis un caracter de retur. Un caracter de retur este notat "\ r".

Flagul - forțează ca următorul argument să fie interpretat mai degrabă ca un șir, nu ca un steag. Orice șir poate fi precedat de "-" dacă arată sau nu de fapt un steag. Acest lucru oferă un mecanism de încredere pentru a specifica șiruri variabile fără a fi împiedicat de aceia care arata în mod accidental ca steaguri. (Toate șirurile care încep cu "-" sunt rezervate pentru opțiunile viitoare.)

Flagul -i declară că șirul este trimis la spawn_id numit. Dacă spawn_id este user_spawn_id , iar terminalul este în modul brut, liniile noi din șir sunt traduse în secvențe return-newline, astfel încât să apară ca și cum terminalul era în modul fiert. Flagul -raw dezactivează această traducere.

Steagul-null trimite caractere nula (0 octeți). În mod prestabilit, este trimis un null. Un număr întreg poate să urmeze nulul pentru a indica numărul de null-uri care trebuie trimise.

Flagul-break break generează o condiție de pauză. Acest lucru are sens numai dacă ID-ul spawn se referă la un dispozitiv tty deschis prin intermediul "spawn-open". Dacă ați dat naștere unui proces, cum ar fi sfat, ar trebui să utilizați convenția tipului pentru generarea unei pauze.

Forțele de pavilion -s sunt trimise "încet", evitând astfel situația comună în care un computer depășește un tampon de intrare proiectat pentru un om care nu va depăși niciodată același tampon . Această ieșire este controlată de valoarea variabilei "send_slow" care are o listă cu două elemente. Primul element este un număr întreg care descrie numărul de octeți care se trimit în mod atomic. Cel de-al doilea element este un număr real care descrie numărul de secunde prin care atomul trimite trebuie să fie separat. De exemplu, "set send_slow {10 .001}" ar forța "send -s" să trimită șiruri cu 1 milisecundă între fiecare 10 caractere trimise.

Forțele -h de pavilion ieșesc pentru a fi trimise (oarecum) ca un om de fapt, tastând. Între personaje apar întârzieri asemănătoare omului. (Algoritmul se bazează pe o distribuție Weibull, cu modificări care se potrivesc acestei aplicații particulare.) Această ieșire este controlată de valoarea variabilei "send_human" care are o listă cu cinci elemente. Primele două elemente sunt durata medie a caracterelor în secunde. Primul este utilizat în mod implicit. Al doilea este folosit la terminațiile cuvintelor, pentru a simula pauzele subtile care apar ocazional la astfel de tranziții. Al treilea parametru este o măsură de variabilitate unde .1 este destul de variabilă, 1 variabilă în mod rezonabil, iar 10 este invariabil. Extremele sunt de la 0 la infinit. Ultimii doi parametri sunt, respectiv, un interval minim și maxim interarrival. Valoarea minimă și maximă sunt folosite ultima dată și "clip" ultima dată. Media maximă poate fi destul de diferită de media dată dacă valorile minime și maxime ale clipului sunt suficiente.

De exemplu, următoarea comandă emula un dactilograf rapid și consistent:

set send_human {.1 .3 1 .05 2} trimite -h "Îmi este foame, hai să luăm prânzul."

în timp ce următoarele ar putea fi mai potrivite după o mahmureală:

set trimite_human {.4 .4 .2 .5 100} trimite -h "Goodd petrecere noapte barbati!"

Rețineți că erorile nu sunt simulate, deși puteți să vă configurați singur situațiile de corectare a erorilor prin încorporarea greșelilor și corecțiilor într-un argument de trimitere.

Steagurile pentru trimiterea de caractere nulă, pentru trimiterea pauzelor, pentru forțarea ieșirii lente și pentru ieșirea în stil uman se exclud reciproc. Se va utiliza numai cea specificată ultima dată. În plus, nu poate fi specificat niciun argument string cu steagurile pentru trimiterea de caractere sau pauze nul.

Este o idee bună să precedeți prima trimitere unui proces de la un așteptat . așteaptă să aștepte procesul să înceapă, în timp ce trimite nu poate. În special, dacă prima trimitere este finalizată înainte ca procesul să înceapă, există riscul ca datele dvs. să fie ignorate. În situațiile în care programele interactive nu oferă nici un prompt inițial, puteți preceda trimiterea cu o întârziere, ca în:

# Pentru a evita să oferi hackerilor sfaturi despre cum să pătrundă, # acest sistem nu solicită o parolă externă. # Așteptați 5 secunde pentru exec pentru a finaliza spawn telnet very.secure.gov somn 5 trimite parola \ r

exp_send este un pseudonim pentru trimitere. Dacă utilizați Expectk sau altă variantă de Expect în mediul Tk, trimiterea este definită de Tk pentru un scop cu totul diferit. exp_send este furnizat pentru compatibilitatea între medii. Alije similare sunt furnizate și altor comenzi de trimitere ale celorlalte Expect.

șirul send_error [-flags]
este ca trimite , cu excepția faptului că ieșirea este trimisă la stderr mai degrabă decât procesul curent.

send_log [-] șir
este ca trimite , cu excepția faptului că șirul este trimis numai la fișierul jurnal (a se vedea log_file .) Argumentele sunt ignorate dacă nici un fișier jurnal nu este deschis.

send_tty [-flags] șir
este ca trimite , cu excepția faptului că ieșirea este trimisă la / dev / tty mai degrabă decât procesul curent.

send_user [-flags] șir
este ca trimite , cu excepția faptului că ieșirea este trimisă mai degrabă la stdout decât la procesul curent.

dormi secunde
determină scenariul să doarmă pentru numărul dat de secunde. Secundele pot fi un număr zecimal. Întreruperile (și evenimentele Tk dacă utilizați Expectk) sunt procesate în timp ce Expect dormește.

spawn [args] program [args]
creează un proces nou care rulează "program args". Stdin, stdout și stderr sunt conectate la Expect, astfel încât acestea să poată fi citite și scrise de alte comenzi Expect . Conexiunea este întreruptă prin închidere sau dacă procesul însuși închide oricare dintre identificatorii de fișiere.

Atunci când un proces este inițiat de spawn , variabila spawn_id este setată la un descriptor referitor la acel proces . Procesul descris de spawn_id este considerat " procesul actual ". spawn_id pot fi citite sau scrise, în practică oferind controlul locului de muncă.

user_spawn_id este o variabilă globală care conține un descriptor care se referă la utilizator. De exemplu, atunci când spawn_id este setat la această valoare, așteptați să se comporte ca expect_user .

.I error_spawn_id este o variabilă globală care conține un descriptor care se referă la eroarea standard. De exemplu, atunci când spawn_id este setat la această valoare, trimite se comportă ca send_error .

tty_spawn_id este o variabilă globală care conține un descriptor care se referă la / dev / tty. Dacă / dev / tty nu există (cum ar fi într-un script cron, la sau batch), atunci tty_spawn_id nu este definit. Acest lucru poate fi testat ca:

dacă {[info vars tty_spawn_id]} {# / dev / tty există} altceva {# / dev / tty nu există # probabil în cron, lot sau la script}

spawn returnează ID-ul procesului UNIX. Dacă nu apare niciun proces , 0 este returnat. Variabila spawn_out (slave, name) este setată la numele dispozitivului pty slave.

În mod implicit, spawn echoaza numele comenzii și argumentele. Flagul -noecho se oprește din acest lucru.

Steagul-console determină ca ieșirea consolei să fie redirecționată către procesul procesat . Acest lucru nu este acceptat pe toate sistemele.

Pe plan intern, spawn utilizează un pty, inițializat în același mod ca și tty al utilizatorului. Aceasta este inițializată astfel încât toate setările să fie "sane" (conform stty (1)). Dacă variabila stty_init este definită, ea este interpretată în stilul argumentelor stty ca și configurație ulterioară. De exemplu, "setul stty_init raw" va determina terminalele proceselor suplimentare generate pentru a porni în modul brut. -nottycopy ignoră inițializarea pe baza tty a utilizatorului. -nottyinit ignoră inițializarea "sănătoasă".

În mod normal, spawn-ul are nevoie de puțin timp pentru a executa. Dacă observați că spawnul consumă o cantitate semnificativă de timp, este probabil să întâlniți ptys care sunt înclinate. O serie de teste sunt efectuate pe ptys pentru a evita incursiunile cu procese errant. (Acestea durează 10 secunde pe pty.) Rularea Expect cu opțiunea -d va arăta dacă Expect întâlnește multe ptys în stări ciudate. Dacă nu puteți ucide procesele la care sunt atașate aceste ptys, singurul dvs. recurs ar fi restabilirea.

Dacă programul nu poate fi lansat cu succes, deoarece exec (2) nu reușește (de exemplu, atunci când programul nu există), un mesaj de eroare va fi returnat de următoarea comandă de interacțiune sau așteptare ca și cum programul ar fi rulat și a produs mesajul de eroare ca ieșire. Acest comportament este o consecință firească a implementării hamsterului . În interior, furculițele spawn, după care procesul procesat nu are cum să comunice cu procesul inițial Expect , cu excepția comunicării prin spawn_id.

Flagul -open determină ca următorul argument să fie interpretat ca un identificator de fișier Tcl (adică, returnat prin deschidere .) ID-ul spawn poate fi folosit ca și cum ar fi un proces care a dat naștere. (Identificatorul de fișiere nu mai trebuie utilizat.) Acest lucru vă permite să tratați dispozitivele, fișierele și conductele brute ca procese care au dat naștere, fără a utiliza un pty. 0 este returnat pentru a indica că nu există niciun proces asociat. Când conexiunea la procesul spawned este închisă, la fel este și identificatorul de fișier Tcl. Steagul -leaveopen este asemănător cu -openul, cu excepția faptului că -leaveopen determină ca identificatorul fișierului să rămână deschis chiar și după ce ID-ul spawn este închis.

Flagul -45 determină deschiderea unui pty, dar nu sa produs niciun proces . 0 este returnat pentru a indica că nu există niciun proces asociat. Spawn_id este setat ca de obicei.

Variabila spawn_out (slave, fd) este setată la un identificator de fișier corespunzător pty slave. Poate fi închisă folosind "aproape-roșu".

Steagul -ignore numește un semnal care trebuie ignorat în procesul provocat. În caz contrar, semnalele primesc comportamentul implicit. Semnalele sunt denumite ca în comanda trap , cu excepția faptului că fiecare semnal necesită un drapel separat.

nivel de nivel
face ca următoarele afirmații să fie tipărite înainte de a fi executate. (Comanda urmăririi lui Tcl urmărește variabilele.) Nivelul indică cât de departe în stivă de apeluri pentru a urmări. De exemplu, următoarea comandă rulează Așteptați în timp ce urmăriți primele 4 nivele de apeluri, dar nici unul sub acesta.

așteptați-c "strace 4" script.exp

Steagul -info determină ca strace să returneze o descriere a celor mai recente argumente non-info date.

stty args
modifică modurile terminale în mod similar cu comanda stty externă.

În mod implicit, terminalul de control este accesat. Alte terminale pot fi accesate prin adăugarea "Solicitări de stare returnați ca urmare a comenzii. Dacă nu este solicitată nicio stare și terminalul de control este accesat, starea anterioară a atributelor prime și echo sunt returnate într-o formă care poate fi ulterior utilizate de comandă.

De exemplu, argumentele crude sau cookie - urile au pus terminalul în modul brut. Argumentele - rasă sau gătită au pus terminalul în modul gătit. Argumentele ecou și - i-au pus terminalul în mod ecou și noecho respectiv.

Următorul exemplu ilustrează cum să dezactivați temporar ecourile. Acest lucru ar putea fi folosit în scripturi altfel-automate pentru a evita încorporarea parolelor în ele. (Vedeți mai multe discuții despre acest subiect sub EXPUNERILE HÂRTIE de mai jos.)

stty -echo send_user "Parola:" expect_user -re "(. *) \ n" setare parola $ expect_out (1, șir) stty echo

sistem arges
dă args la sh (1) ca intrare, ca și cum ar fi fost tastat ca o comandă de la un terminal. Asteptati asteptati pana cand shell-ul se termina. Starea de returnare de la sh este tratată în același mod în care exec gestionează starea de returnare.

Spre deosebire de exec, care redirecționează stdin și stdout la script, sistemul nu efectuează nici o redirecționare (alta decât cea indicată de șirul propriu-zis). Astfel, este posibil să folosiți programe care trebuie să vorbească direct cu / dev / tty. Din același motiv, rezultatele sistemului nu sunt înregistrate în jurnal.

marcajul temporal [args]
returnează o marcă de timp. Fără argumente, numărul de secunde de la revenirea epocii.

Steagul -format introduce un șir care este returnat, dar cu substituții făcute în conformitate cu regulile POSIX pentru strftime. De exemplu,% a este înlocuit cu un nume abreviat de săptămână (adică Sat). Altele sunt:

% a un nume săptămânal abreviat% Un nume de săptămână întreg% b abreviere nume lună% B nume lună completă% c data-dată ca în: Mie Oct 6 11:45:56 1993% d zi a lunii (01-31% H oră (00-23)% I ora (01-12)% j zi (001-366)% m luna (01-12)% M minut (00-59)% p am sau pm% S secunda (00-61) % u zi (1-7, luni este prima zi a săptămânii)% U săptămână (00-53, prima duminică este prima zi a săptămânii 1)% săptămâna săptămânală (01-53, stilul ISO 8601) 6)% săptămâna W (00-53, prima zi de luni este prima zi a săptămânii 1)% x data-dată ca în: Mie Oct 6 1993% X timp ca în: 23:59:59% y an (00-99) % Y an ca în: 1993% Z fusul orar (sau nimic dacă nu este determinabil) %% un semn procentaj gol

Alte specificații% sunt nedefinite. Alte caractere vor fi trecute prin neatins. Este acceptată numai locația C.

Steagul-secunde introduce un număr de secunde de la epoca care urmează să fie utilizată ca sursă din care să se formateze. În caz contrar, se folosește ora curentă.

Parametrul -gmt forțează ieșirea de timp pentru utilizarea zonei de fus orar GMT . Fără pavilion, este utilizată fusul orar local.

capcana [[comandă] semnale]
determină executarea comenzii date la recepționarea viitoare a oricărui semnal dat. Comanda este executată în domeniul global. Dacă comanda este absentă, acțiunea de semnal este returnată. Dacă comanda este șirul SIG_IGN, semnalele sunt ignorate. Dacă comanda este șirul SIG_DFL, semnalele sunt rezultatul sistemului implicit. semnalele sunt fie un singur semnal, fie o listă de semnale. Semnalele pot fi specificate numeric sau simbolic ca pe semnal (3). Prefixul "SIG" poate fi omis.

Fără argumente (sau argumentul -number), capcana returnează numărul de semnal al comenzii capcană care se execută în prezent.

Fișierul- cod de cod utilizează codul de returnare al comenzii în locul oricărui cod Tcl care urma să se întoarcă atunci când comanda a început inițial să fie difuzată.

Steagul -interp face ca comanda să fie evaluată utilizând interpretul activ la momentul când comanda a început să fie difuzată mai degrabă decât atunci când a fost declarată capcana.

Flagul -name determină comanda capcanei să returneze numele semnalului comenzii capcană care se execută în prezent.

Flagul -max provoacă comanda capcană să returneze cel mai mare număr de semnal care poate fi setat.

De exemplu, comanda "trap {send_user" Ouch! "} SIGINT" va imprima "Ouch!" de fiecare dată când utilizatorul apasă ^ C.

În mod implicit, SIGINT (care poate fi generat de obicei apăsând tasta C) și SIGTERM provoacă Expect să iasă. Acest lucru se datorează următoarei capcane, create în mod implicit când începe Expect.

ieșire de capcană {SIGINT SIGTERM}

Dacă utilizați pavilionul -D pentru a porni programul de depanare, SIGINT este redefinit pentru a porni programul de depanare interactiv. Acest lucru se datorează următoarei capcane:

capcana {exp_debug 1} SIGINT

Capcana de depanare poate fi modificată prin setarea variabilei de mediu EXPECT_DEBUG_INIT la o nouă comandă de trap.

Puteți, bineînțeles, să suprascrieți ambele aceste lucruri doar prin adăugarea de comenzi de capcane către scenariul dvs. În special, dacă aveți propriul "capăt de ieșire SIGINT", aceasta va suprascrie capcana de depanare. Acest lucru este util dacă doriți să împiedicați utilizatorii să ajungă deloc la depanator.

Dacă doriți să definiți capcana proprie pe SIGINT, dar încă capcana la depanator atunci când rulează, utilizați:

dacă {! [exp_debug]} {trap mystuff SIGINT}

Alternativ, puteți să prindeți depanatorul utilizând un alt semnal.

capcana nu vă va lăsa să înlocuiți acțiunea pentru SIGALRM deoarece aceasta este utilizată intern pentru a aștepta . Comanda de deconectare stabilește SIGALRM la SIG_IGN (ignorare). Puteți reîncuvi acest lucru atâta timp cât îl dezactivați în timpul comenzilor ulterioare.

Consultați semnalul (3) pentru mai multe informații.

așteptați [args]
întârzieri până la terminarea procesului (sau a procesului actual , dacă nici unul nu este denumit).

așteptați în mod normal returnează o listă cu patru numere întregi. Primul întreg este pidul procesului care a fost așteptat. Cel de-al doilea întreg este ID-ul corespunzător. Cel de-al treilea întreg este -1 dacă a apărut o eroare de sistem de operare sau altfel. Dacă cel de-al treilea număr întreg a fost 0, cel de-al patrulea întreg este starea returnată de procesul provocat. Dacă al treilea intreg a fost -1, cel de-al patrulea întreg este valoarea errno setată de sistemul de operare. De asemenea, este setată și eroarea globală errorCode.

Elementele suplimentare pot să apară de la așteptare la sfârșitul valorii returnate. Un al cincilea element opțional identifică o clasă de informații. În prezent, singura valoare posibilă pentru acest element este CHILDKILLED, caz în care următoarele două valori sunt numele semnalului în stil C și o scurtă descriere textuală.

Flagul -i declară procesul de așteptare corespunzător spawn_id numit (NOT ID-ul procesului ). În interiorul unui manipulator SIGCHLD, este posibil să așteptați orice proces provocat , utilizând id-ul spawn -1.

Steagul -nowait determină așteptarea să se întoarcă imediat cu indicarea unei așteptare reușită. Când procesul iese (mai târziu), acesta va dispărea automat fără a fi nevoie de o așteptare explicită.

De asemenea, comanda de așteptare poate fi folosită pentru a aștepta un proces forked folosind argumentele "-i -1". Spre deosebire de utilizarea sa cu procese spawned, această comandă poate fi executată în orice moment. Nu există control asupra procesului care se obține. Cu toate acestea, valoarea returnată poate fi verificată pentru ID-ul procesului .

BIBLIOTECI

Se așteaptă automat să știe despre două biblioteci încorporate pentru Scripturile de așteptare. Acestea sunt definite de directoarele numite în variabilele exp_library și exp_exec_library. Ambele sunt menite să conțină fișiere utilitare care pot fi utilizate de alte scripturi.

exp_library conține fișiere independente de arhitectură. exp_exec_library conține fișiere dependente de arhitectură. În funcție de sistemul dvs., ambele directoare pot fi complet goale. Existența fișierului $ exp_exec_library / buffers-cat descrie dacă tampoanele dvs. / bin / pisică sunt implicite.

Pretty-IMPRIMARE

O definiție vgrind este disponibilă pentru scripturile Expect . Presupunând că definiția vgrind furnizată împreună cu distribuția Expect este instalată corect, o puteți folosi ca:

fișier vgrind -lexpect

EXEMPLE

Mulți nu știu cum să pună totul împreună, așa cum descrie pagina manului. Vă încurajez să citiți și să încercați exemplele din directorul de exemplu al distribuției Expect . Unele dintre ele sunt programe reale. Altele sunt pur și simplu ilustrative ale anumitor tehnici, și, desigur, un cuplu sunt doar hacks rapid. Fișierul INSTALL are o prezentare rapidă a acestor programe.

Documentele Expect (a se vedea de asemenea) sunt, de asemenea, utile. În timp ce unele lucrări utilizează o sintaxă care corespunde versiunilor anterioare ale Expect, rațiunile de însoțire sunt încă valide și sunt mult mai detaliate decât această pagină man.

caveats

Extensiile pot intra în coliziune cu numele de comandă al Expect. De exemplu, trimiterea este definită de Tk pentru un scop cu totul diferit. Din acest motiv, majoritatea comenzilor Expect sunt de asemenea disponibile ca "exp_XXXX". Comenzile și variabilele care încep cu "exp", "inter", "spawn" și "timeout" nu au pseudonime. Utilizați numele comenzilor extinse dacă aveți nevoie de această compatibilitate între medii.

Asteptarile au o viziune mai degraba liberala asupra scopului. În special, variabilele citite de comenzile specifice programului Expect vor fi căutate mai întâi din domeniul de aplicare local și dacă nu vor fi găsite în domeniul global. De exemplu, acest lucru evită necesitatea de a plasa "timeout-ul global" în fiecare procedură pe care o scrieți pe care se așteaptă utilizările. Pe de altă parte, variabilele scrise sunt întotdeauna în domeniul de aplicare local (cu excepția cazului în care a fost emisă o comandă "globală"). Cea mai obișnuită problemă cauzată de aceasta este atunci când spawnul este executat într-o procedură. În afară de procedură, spawn_id nu mai există, astfel încât procesul spawned nu mai este accesibil doar din cauza scopului. Adăugați un "spawn_id global" la o astfel de procedură.

Dacă nu puteți să activați capacitatea multispot (sistemul dvs. nu acceptă nici selectați (BSD *. *), Sondaj (SVR> 2), nici ceva echivalent), Expect va putea controla un singur proces la un moment dat. În acest caz, nu încercați să setați spawn_id , nici nu trebuie să executați procese prin exec în timp ce se execută un proces născut. În plus, nu veți putea aștepta de la mai multe procese (inclusiv utilizatorul ca atare) în același timp.

Parametrii terminalelor pot avea un efect mare asupra scripturilor. De exemplu, dacă un script este scris pentru a căuta o ecou, ​​va fi greșit dacă ecoul este oprit. Din acest motiv, așteptați parametrii terminalului forțelor normale în mod implicit. Din păcate, acest lucru poate face lucrurile neplăcute pentru alte programe. De exemplu, shell-ul emacs dorește să schimbe mapările "obișnuite": linii noi sunt cartografiate pe linii noi în loc de linii noi de retur de transport și ecou este dezactivat. Aceasta permite folosirea emacs pentru a edita linia de intrare. Din nefericire, Asteptam ca nu putem ghici asta.

Puteți solicita ca Expect să nu suprascrie setarea implicită a parametrilor terminalului, dar trebuie să fiți foarte atenți când scrieți scripturi pentru astfel de medii. În cazul emacs, evitați în funcție de lucruri cum ar fi ecou și cartografiere la sfârșitul liniei.

Comenzile care acceptă argumente încorporate într-o singură listă (variantele așteaptă și interacționează ) folosesc un euristic pentru a decide dacă lista este de fapt un argument sau multe. Euristica poate eșua numai în cazul în care lista de fapt nu reprezintă un singur argument care are mai multe caractere \ n încorporate, cu caractere care nu se află în spațiu între ele. Acest lucru pare destul de improbabil, totuși argumentul "-nobrace" poate fi folosit pentru a forța un singur argument să fie tratat ca un singur argument. Acest lucru ar putea fi folosit cu ajutorul codului Expect generat de mașină. În mod similar, forța forțează un singur argument care trebuie tratat ca mai multe modele / acțiuni.

GANDACI

A fost cu adevărat tentant să numim programul "sex" (pentru "Smart EXec" sau "Send-Expect"), dar bunul simț (sau puritanismul pur și simplu) a predominat.

La unele sisteme, când se produce o cochilie, se plânge că nu poate accesa tty, dar oricum se execută. Acest lucru înseamnă că sistemul dvs. are un mecanism de a câștiga controlul pe care Expect nu-l cunoaște. Aflați ce este și trimiteți-mi această informație.

Ultrix 4.1 (cel puțin cele mai recente versiuni în jurul valorii de aici) consideră că depășirile de 1000000 sunt echivalente cu 0.

Digital UNIX 4.0A (și probabil alte versiuni) refuză să aloce ptys dacă definiți un handler SIGCHLD. Consultați pagina de grant pentru mai multe informații.

IRIX 6.0 nu se ocupă corect de permisiunile pty, astfel încât dacă așteaptă încercări de alocare a unui pty utilizat anterior de altcineva, acesta nu reușește. Treceți la IRIX 6.1.

Telnet (verificat numai în SunOS 4.1.2) se blochează dacă TERM nu este setat. Aceasta este o problemă sub cron, la și în script-urile cgi, care nu definesc TERM. Astfel, trebuie să o setați în mod explicit - la ce tip este de obicei irelevant. Trebuie doar să fie pus la ceva! Următoarele sunt, probabil, suficiente pentru majoritatea cazurilor.

setați env (TERM) vt100

Sfat (verificat numai în BSDI BSD / OS 3.1 i386) se blochează dacă SHELL și HOME nu sunt setate. Aceasta este o problemă în cadrul scripturilor cron , at și cgi , care nu definesc aceste variabile de mediu. Astfel, trebuie să le setați în mod explicit - la ce tip este de obicei irelevant. Trebuie doar să fie pus la ceva! Următoarele sunt, probabil, suficiente pentru majoritatea cazurilor.

setați env (SHELL) / bin / sh set env (HOME) / usr / local / bin

Unele implementări ale ptys sunt proiectate astfel încât kernelul să elimine orice ieșire necitită după 10-15 secunde (numărul real este dependent de implementare) după ce procesul a închis descriptorul fișierului. Așteptați astfel programe cum ar fi

spawn date somn 20 aștepta

va eșua. Pentru a evita acest lucru, invoca programele non-interactive cu exec, mai degrabă decât spawn . În timp ce astfel de situații sunt concepute, în practică nu am întâlnit niciodată o situație în care rezultatul final al unui program cu adevărat interactiv ar fi pierdut din cauza acestui comportament.

Pe de altă parte, Cray UNICOS ptys aruncă orice ieșire necitită imediat după ce procesul a închis descriptorul fișierului. Am raportat asta lui Cray și ei lucrează la un remediu.

Uneori este necesară o întârziere între un prompt și un răspuns, cum ar fi atunci când o interfață tty schimbă setările UART sau ratele de transfer ale frecvenței prin căutarea biților de start / stop. De obicei, toate acestea sunt necesare pentru a dormi pentru o secundă sau două. O tehnică mai robustă este să reîncercați până când hardware-ul este gata să primească intrare. Următorul exemplu folosește ambele strategii:

trimite "viteza 9600 \ r"; somn 1 așteptați {timeout {trimite "\ r"; exp_continue} $ prompt}

codul de trap nu va funcționa cu nici o comandă care se află în bucla evenimentului Tcl, cum ar fi somnul. Problema este că în buclă eveniment, Tcl elimină codurile de returnare de la agenții de asincronizare a evenimentelor. O soluție este să setați un drapel în codul de trap. Apoi, verificați steagul imediat după comandă (de exemplu, somnul).

Comanda expect_background ignoră argumentele -timeout și nu are niciun concept de timeouts în general.

CHESTIUNILE EXPUNERE & # 34;

Există câteva lucruri despre Așteptați, care pot fi non-intuitive. Această secțiune încearcă să abordeze unele dintre aceste lucruri cu câteva sugestii.

O problemă comună a așteptărilor este cum să recunoașteți instrucțiunile shell. Deoarece acestea sunt personalizate diferit de către oameni diferit și cochilii diferite, portabil automatizarea rlogin poate fi dificil, fără a cunoaște promptul. O convenție rezonabilă este ca utilizatorii să stocheze o expresie regulată care să descrie promptul lor (în special sfârșitul acestuia) în variabila de mediu EXPECT_PROMPT. Pot fi utilizate coduri precum cele de mai jos. Dacă EXPECT_PROMPT nu există, codul are încă o bună șansă de a funcționa corect.

set prompt prompt (setare prompt $ env (EXPECT_PROMPT)} expect -rere prompt (% | # | \\ $) $;

Vă încurajez să scrieți modele de așteptare care includ sfârșitul a ceea ce vă așteptați să vedeți. Acest lucru evită posibilitatea de a răspunde la o întrebare înainte de a vedea totul. În plus, în timp ce este posibil să răspundeți la întrebări înainte de a le vedea în totalitate, dacă răspundeți mai devreme, răspunsul dvs. poate apărea reluat înapoi în mijlocul întrebării. Cu alte cuvinte, dialogul care rezultă va fi corect, dar va fi încurcat.

Cele mai multe solicitări includ un caracter spațial la final. De exemplu, promptul de la ftp este 'f', 't', 'p', '>' și. Pentru a corespunde acestei solicitări, trebuie să contabilizați fiecare dintre aceste caractere. Este o greșeală obișnuită să nu includeți martorul. Puneți martorul în mod explicit.

Dacă utilizați un model al formularului X *, * va corespunde tuturor rezultatelor primite de la sfârșitul lui X la ultimul lucru primit. Acest lucru pare intuitiv, dar poate fi oarecum confuz, deoarece expresia "ultimul lucru primit" poate varia în funcție de viteza calculatorului și de procesarea I / O atât de kernel, cât și de driverul dispozitivului.

În special, oamenii au tendința de a vedea ieșirea programului care sosesc în bucăți imense (atomic) atunci când, în realitate, majoritatea programelor produc ieșiri pe rând. Presupunând că acesta este cazul, modelul * din modelul paragrafului precedent se poate potrivi doar la sfârșitul liniei curente, chiar dacă pare să existe mai mult, deoarece la momentul meciului a fost tot rezultatul primit.

se asteapta ca nu exista nici o modalitate de a sti ca productia ulterioara va veni daca modelul nu conteaza in mod special pentru ea.

Chiar și în funcție de tamponarea orientată pe linie nu este înțeleaptă. Nu numai că programele rareori fac promisiuni cu privire la tipul de tamponare pe care îl fac, dar sistemul de indigestie poate rupe liniile de ieșire, astfel încât liniile să se rupă în locuri aparent aleatoare. Astfel, dacă puteți exprima ultimele caractere ale unui prompt atunci când scrieți modele, este înțelept să faceți acest lucru.

Dacă așteptați un șablon în ultima ieșire a unui program și programul emite altceva în locul dvs., nu veți putea detecta acest lucru cu cuvântul cheie cu expirare . Motivul este că se așteaptă că nu va termina - în schimb, va primi o indicație eof . Folosește-o în schimb. Chiar mai bine, folosiți ambele. În acest fel, dacă acea linie este mutată vreodată, nu va trebui să editați linia însăși.

Noile linii sunt, de obicei, convertite în retur de carriage, secvențe de alimentare cu linie atunci când ieșirea de la driver-ul terminalului. Astfel, dacă doriți un model care să corespundă în mod explicit celor două linii, de la, de exemplu, printf ("foo \ nbar"), ar trebui să utilizați modelul "foo \ r \ nbar".

O traducere similară apare atunci când citiți de la utilizator, prin expect_user . În acest caz, când apăsați retur, va fi tradus la o linie nouă. Dacă se așteaptă, atunci se va trece la un program care își stabilește terminalul la modul brut (cum ar fi telnet), va exista o problemă, deoarece programul așteaptă o adevărată întoarcere. (Unele programe sunt, de fapt, iertând prin faptul că vor traduce în mod automat linii noi către returnări, dar cele mai multe nu.) Din păcate, nu există nici o modalitate de a afla că un program și-a pus terminalul în modul brut.

Mai degrabă decât înlocuirea manuală a liniilor noi cu returnări, soluția este de a folosi comanda "stty raw", care va opri traducerea. Rețineți, totuși, că aceasta înseamnă că nu veți mai avea funcțiile de editare a liniei fierte.

interacționează implicit setarea terminalului la modul brut, astfel încât această problemă nu va apărea atunci.

Este adesea util să stocați parole (sau alte informații private) în Scenariile de așteptare . Acest lucru nu este recomandat deoarece orice lucru care este stocat pe un computer este susceptibil de a fi accesat de oricine. Astfel, solicitarea interactivă de parole dintr-un scenariu este o idee mai inteligentă decât încorporarea literală. Cu toate acestea, uneori astfel de încorporare este singura posibilitate.

Din păcate, sistemul de fișiere UNIX nu are un mod direct de a crea scripturi care sunt executabile, dar nu pot fi citite. Sistemele care suportă scripturile shell-ului setgid pot simula indirect acest lucru după cum urmează:

Creați scriptul Expect (care conține datele secrete) ca de obicei. Faceți permisiunile să fie 750 (-rwxr-x ---) și să fie deținute de un grup de încredere, adică un grup care are permisiunea să o citească. Dacă este necesar, creați un nou grup în acest scop. Apoi, creați un script a / bin / sh cu permisiuni 2751 (-rwxr-s - x) deținute de același grup ca înainte.

Rezultatul este un script care poate fi executat (și citit) de oricine. Când este invocată, rulează scriptul Expect .

& # 34;

Tcl (3), libexpect (3)
"Explorarea așteptării: Un set de instrumente Tcl pentru automatizarea programelor interactive" de Don Libes, pp. 602, ISBN 1-56592-090-2, O'Reilly and Associates, 1995.
"așteptăm: Tratarea acelor aspecte incontrolabile ale interactivității" de Don Libes, Proceedings of the US 1990 Conferința USENIX, Anaheim, California, 11-15 iunie 1990.
.I "Utilizarea se așteaptă la Automatizarea sarcinilor de administrare a sistemului" de Don Libes, Proceedings of the USENIX Large Conference Systems Administration Conference, Colorado Springs, Colorado, 17-19 octombrie 1990.
. "Tcl: Un limbaj de comandă încorporabil" de John Ousterhout, Proceedings of the Winter 1990 USENIX Conference, Washington, DC, 22-26 ianuarie 1990. "Mă aștept: Scripturi pentru controlul programelor interactive" de Don Libes, , Vol. 4, No. 2, University of California Journal Press, noiembrie 1991. I "Testarea regresiei și testarea conformității programelor interactive", de Don Libes, Proceedings of the US 1992 Conference USENIX, pp. 135-144, San Antonio, TX, Iunie 12-15, 1992. "Kibitz - Conectarea mai multor programe interactive împreună", de Don Libes, Software - Practică și Experiență, John Wiley & Sons, West Sussex, Anglia, vol.

23, No. 5, May, 1993. "Un debugger pentru aplicații Tcl", de Don Libes, Proceedings of the Workshop Tcl / Tk 1993, Berkeley, CA, 10-11 iunie 1993.

AUTOR

Don Libes, Institutul Național de Standarde și Tehnologie

MULȚUMIRI

Mulțumită lui John Ousterhout pentru Tcl și Scott Paisley pentru inspirație. Mulțumită lui Rob Savoye pentru codul de autoconfigurare Expect.

Fișierul ISTORIE documentează o mare parte din evoluția așteptărilor . Este o citire interesantă și vă poate oferi informații suplimentare despre acest software. Mulțumită persoanelor menționate în el, care mi-au trimis corecții de erori și am dat o altă asistență.

Proiectarea și implementarea programului Expect au fost plătite în parte de guvernul Statelor Unite și, prin urmare, se află în domeniul public. Cu toate acestea, autorul și NIST ar dori credit dacă acest program și documentația sau porțiuni din ele sunt utilizate.