Oodata on programm, mis kooskõlas skriptiga suhtleb teiste interaktiivsete programmidega. Stsenaariumi järgi oodatakse, et teate, mida saab programmi oodata ja milline peaks olema õige vastus. Tõlgitud keel pakub dialoogi juhtimiseks hargnemist ja kõrgetasemelisi juhtimisstruktuure. Lisaks saab kasutaja võtta kontrolli ja suhelda otse soovi korral, seejärel tagastage skriptile kontroll.
Expectk on Expect ja Tk segu. See käitub nagu Expect ja Tk soov. Expect saab kasutada ka otse C või C ++ ilma Tcl-i.
Nimi "Expect" pärineb uucp, kermit ja teiste modemi kontrollprogrammide poolt populariseeritud ideede saatmis- / ootusjärjestusest. Kuid erinevalt uucpist on Expect üldistatud nii, et seda saab käivitada kasutaja taseme käsuga mis tahes programmi ja ülesande silmas pidades. Oodake saate korraga rääkida mitme programmiga.
Mida oodata saab teha
Näiteks siin on mõned asjad, mida eeldatav käsk võib teha:
- Sellepärast, et teie arvuti teid tagasi helistatakse, saate sisse logida ilma kõne tasumiseta.
- Käivitage mäng ja kui optimaalset konfiguratsiooni ei ilmu, siis taaskäivitage see uuesti ja uuesti), kuni see saabub, ja seejärel annab teile üle kontrolli.
- Käivita fsck ja vastates küsimustele vastata "jah" või "ei" või anda teile kontroll, mis põhineb eelnevalt kindlaksmääratud kriteeriumidel.
- Ühendage teise võrguga ja laadige oma kirjad automaatselt välja, nii et see kuvatakse nii, nagu oleks see algselt teie kohalikule süsteemile saadetud.
- Kandke keskkonna muutujaid, praegust kataloogi või mingit teavet rlogini, telneti, tip, su või chgrp kaudu
On mitmeid põhjuseid, miks shell ei suuda neid ülesandeid täita. Kõik on võimalikud eeldatava pakkumisega.
Üldiselt on Expect kasulik mis tahes programmi käivitamiseks, mis nõuab programmi ja kasutaja vahelist suhtlemist. Kõik, mis on vajalik, on see, et suhtlemist saab iseloomustada programmeeritult. Oodata võib ka anda kasutajale tagasi kontrolli, ilma et see piiraks programmi juhtimist. Samuti saab kasutaja igal ajal skriptile kontrolli anda.
Kasutamine
Expect loeb käskude käivitamiseks käsku cmdfile. Oodata võib kaudselt viidata süsteemidele, mis toetavad #! märgistamine, markeerides skripti käivitatavana ja skripti esimese rea tegemisel:
#! / usr / local / bin / expect-fMuidugi peab tee täpselt kirjeldama, kus oodata elu. / usr / local / bin on lihtsalt näide.
Lipp -c lisab käskluse, mis käivitatakse enne skripti mis tahes. Käsk tuleb tsiteerida, et koor seda ei saaks. Seda võimalust võib kasutada mitu korda. Mitu käsku saab täita ühe c-ga, eraldades need semikoolonidega. Käsud täidetakse nende kuvamise järjekorras. Kui kasutate Expectkit, on see võimalus määratud käsuga.
-d-lipp lubab mõnda diagnostilist väljundit, mis peamiselt annab teada käskude sisemise aktiivsuse, nagu oodata ja suhelda. Sellel lipil on Expiration skripti alguses sama efekt kui "exp_internal 1", lisaks prinditakse Expecti versiooni.
-D-tähis võimaldab interaktiivset silurit. Täisarv peab järgima. Silur võtab kontrolli enne järgmise Tcl-protseduuri, kui väärtus ei ole null või kui a ^ C on vajutatud või katkestuspunkt on tabatud, või skriptis ilmub muu sobilik käsur. Kui kasutate Expectkit, on see valik määratud - Debug.
-f tähistab faili, millelt käske lugeda. Lipp ise on vabatahtlik, kuna see on kasulik ainult #! märkus, nii et muud käsud oleksid käsureale edastatud. Kui kasutate Expectkit, on see võimalus määratud failina.
Vaikimisi loetakse käsufail mällu ja täidetakse tervikuna. Alati on soovitatav lugeda faile ühe reana korraga. Selleks, et suvalisi faile selliselt käidelda, kasutage -b-luku. Kui kasutate Expectkit, on see valik määratud -bufferiks.
Kui string "-" esitatakse failinimega, loetakse selle asemel tavaline sisend. Kasutage "./-", et lugeda failist, mille nimi on "-".
-i-lipp nõuab Expect käsku interaktiivselt käskude asemel, et neid failist lugeda. Kohvitamine lõpetatakse väljumisjuhendi või EOFi kaudu. -i lipp eeldatakse, kui ei kasutata käsufirma ega -c. Kui kasutate Expectkit, on see suvand interaktiivseks.
- võib kasutada valikute lõppu piiritlemiseks. See on kasulik, kui soovite oma skriptile anda võimaluse-sarnase argumendi ilma, et see oleks tõlgendatav eeldusega. Seda saab kasulikult panna #! et vältida Expecti mis tahes lipulist tõlgendust. Näiteks jätab välja järgmine argumendid, sealhulgas skripti nimi muutujas argv .
#! / usr / local / bin / expect -Pidage meeles, et lisades argumentide lisamisel tuleb järgida tavalisi getopti (3) ja execve (2) tavasid. rida
Faili $ exp_library / expect.rc saadakse automaatselt, kui see on olemas, välja arvatud juhul, kui kasutatakse -N-märki. (Expectk'i kasutamisel märgitakse see valik -NORC.) Vahetult pärast seda saadetakse fail ~ / .expect.rc automaatselt, välja arvatud juhul, kui kasutatakse -n-märgistust. Kui keskkonnamuutuja DOTDIR on defineeritud, käsitletakse seda kataloogina ja loetakse .expect.rc seal. Expectk'i kasutamisel märgitakse see valik -norc. See hankimine toimub alles pärast kõigi -c lippide täitmist.
-v põhjustab eeldatava printida oma versiooni numbri ja väljuda. Expectkis olev vastav lipp, mis kasutab pika lipuriigi nimesid, on -versioon.
Valikuline args loendatakse ja salvestatakse muutuja nimega argv ja. argc on initsialiseeritud argv pikkuseks.
Kui skripti ei kasutata, määratletakse argv0 kui skripti nimi või binaarne nimi. Näiteks joonistatakse välja järgmine skripti nimi ja kolm esimest argumenti:
send_user "$ argv0 [lrange $ argv 0 2] \ n"Käsud
Expect kasutab tööriista käsuviisi. Tcl pakub juhtimisvoogu (kui see katkeb), ekspressiooni hindamist ja mitmeid muid funktsioone, nagu retsirkulatsiooni ja protseduuri määratlus. Siin kasutatud, kuid määratlemata (set, if, exec) käsud on Tcl käsklused. Expect toetab täiendavaid käske. Kui pole teisiti määratud, saadavad käskud tühja stringi.
Käsud on loetletud tähestikulises järjekorras, nii et neid saab kiiresti leida. Uutele kasutajatele võib siiski olla lihtsam alustada, lugedes sellises järjekorras kudede, saata, oodata ja suhelda.
sulge [-slave] [-onexec 0 | 1] [-i spawn_id]sulgeb ühenduse praeguse protsessiga . Enamik interaktiivseid programme tuvastab EOF oma stdin ja väljumisel; Tavaliselt piisab sellest lähedusest protsessi kaotamiseks. -i-lipp deklareerib nimega spawn_id vastava sulgemise protsessi .
Mõlemad ootavad ja suudavad tuvastada, millal praegune protsess lahkub ja kaudselt lõpetab selle, kuid kui te lõpetate protsessi , ütleme näiteks, "exec kill $ pid", peate selgesõnaliselt helistama .
-onexeci lipp määrab kindlaks, kas kimbu id on suvalises uues loodud protsessis või kui protsess on kattunud. Kui kudemisnimi id on avatud, kasutage väärtust 0. Nullväärtuseta täisarv tähendab, et kimp suletakse kõigis uutes protsessides.
Suletud lipp sulgeb spawn id-ga seotud alamrühma. Kui ühendus on suletud, slaal suletakse automaatselt ka siis, kui see on veel avatud.
Sõltumata sellest, kas ühendus suletakse vaikimisi või otseselt, peate helistama ootama vastava kerneli protsessipesa puhastamiseks. Sule käsk ei kutsu ootama, sest pole mingit tagatist, et protsessiühenduse sulgemine põhjustab selle väljumise.
silumine [[-now] 0 | 1]kontrollib Tcl-silurit, mis võimaldab teil avaldusi läbi viia ja seada piirid.
Ilma argumentideta tagastatakse 1, kui silumisprogramm ei tööta, vastasel juhul tagastatakse 0.
1 argumendiga käivitatakse silur. 0 argumendiga silumine peatatakse. Kui 1 argumenti eelneb täisnimi, ilmub silumine kohe. Vastasel korral käivitatakse silumine järgmise Tcl avaldusega.
Käsu käivitamine ei muuda mingeid lõkse. Võrdle seda, kui hakkate Expect koos -D lipuga.
Katkestamise käsk katkestab terminalist läbilõikelise protsessi . Ta jätkab taustal töötamist. Protsessile on antud oma protsesside grupp. Standardne sisend / väljund suunatakse ümber / dev / null .
Järgmine fragment kasutab lahti, et taustal skripti töötada.
kui {[fork]! = 0} lõpetage lahtiühendamine. . .Järgmine skript loeb parooli ja käivitab seejärel iga tunni järel programmi, mis nõuab parooli iga kord, kui see käivitatakse. Skript varustab parooliga, nii et pead seda ainult üks kord kirjutama.
\ "expect_user -re \" (. *) \ n "jaoks {} 1 {} {if {[fork]! = 0} (unerežiim 3600; jätkata) katkestada spawn priv_prog expect Parool: saata" $ expect_out 1, string) ". . . väljumine}Koormusega asünkroonse protsessi funktsiooniga (&) katkestamise eeliseks on see, et Expect võib salvestada terminali parameetrid enne ühenduse katkestamist ja seejärel hiljem rakendada neid uutele ptys-dele. &, Expect ei saa võimalust terminali parameetrite lugemiseks, kuna terminal on juba lahti seatud kellaajaga Oodatav saab kontrollida.
väljumine [-opts] [olek]põhjustab oodata väljumist või muul viisil selle ette valmistamist.
Ainuke lipp muudab järgmise argumendi väljundi käitlejana. Ilma argumendita tagastatakse praegune väljapääsu käsitleja.
Väljaspool olev lipu põhjustab eelduse, et valmistuda väljumiseks, kuid ei peatu tegemast kontrolli operatsioonisüsteemile. Kasutaja poolt määratletud väljumisel käitleja käitab ka Expecti enda sisemisi käitlejaid. Täiendavaid ootamatuid käske pole vaja täita. See on kasulik, kui kasutate Expect koos teiste Tcl laiendustega. Praegune tõlk (ja peamine aken, kui need on Tk keskkonnas) jäävad selliselt, et teised Tcl laiendid saavad puhastada. Kui Expect väljumist kutsutakse uuesti (aga see võib juhtuda), ei käivita käitlejaid uuesti.
Väljapääsudes on kõik ühendused kudenud protsessidega suletud. Suletud protsessid tuvastatakse EOF-iga. väljumine ei võta muid meetmeid peale tavapärase _exit (2) protseduuri. Seega võivad kudenud protsessid, mis ei kontrolli EOF-i üle, jätkata. (Erinevad tingimused on olulised, et määrata näiteks, milliseid signaale tekitatakse kudenud protsess, kuid need on süsteemist sõltuvad, tavaliselt dokumenteeritakse väljumisel (3).) Endiselt käivitatavad protsessid, mis pärinevad init, päritakse.
staatus (või 0, kui see pole määratud) tagastatakse kui ooterežiimi olek. väljumine toimub vaikimisi, kui skripti lõpp on jõudnud.
exp_continue [-continue_timer]
Käsk exp_continue lubab eeldada, et ta jätkab täitmist, mitte aga tagastavad, nagu tavaliselt. Vaikimisi exp_continue lähtestab taimeri taimeri. Tähis-continue_timer takistab taimeri taaskäivitamist. (Vt oodata lisateavet.)
exp_internal [-f fail] väärtus
põhjustab täiendavaid käske, et saata diagnostikat puudutav teave sisestada eeldatavalt stderrini, kui väärtus pole null. See väljund on keelatud, kui väärtus on 0. Diagnostiline teave sisaldab iga saadud märgi ja iga katset, mis vastab praegusele väljundile mustritega.
Kui esitatakse vabatahtlik fail , siis kirjutatakse see normaalne ja silumisväljund faili (olenemata väärtuse väärtusest ). Kõik eelmised diagnostilised väljundfailid on suletud.
Infoga lipp põhjustab exp_internal, et saada uusimate mitte-info-argumentide kirjeldus.
exp_open [args] [-i spawn_id]
tagastab Tcl-faili identifikaatori, mis vastab algse kudemis-ID-le. Seejärel saab faili identifikaatorit kasutada nii, nagu see avaneks Tcl avatud käsuga. (Kärpide idi ei tohiks enam kasutada. Ootamist ei tohiks täita.
Lehevoodilipäev laseb spawn id avatud ligipääsuks läbi Expect käske. Ootamine tuleb täita spawn id-is.
exp_pid [-i spawn_id]
tagastab protsessi id, mis vastab praegu loodud protsessile. Kui -i- lipp on kasutusel, vastab peat pidama vastava kudekujutise id.
exp_send
on saatmise alias.
exp_send_error
on send_error alias.
exp_send_log
on saatmislogi alias.
exp_send_tty
on send_tty alias
exp_send_user
on saatja_ kasutajale alias.
exp_version [[-exit] versioon]
on kasulik, et tagada, et skript on praeguse Expecti versiooniga kooskõlas.
Ilma argumentideta tagastatakse praeguse Expecti versioon. See versioon võib siis teie skripti kodeerida. Kui teate tegelikult, et te ei kasuta hiljutiste versioonide funktsioone, võite määrata varasema versiooni.
Versioonid koosnevad kolmest punktist, mis on eraldatud punktidega. Esimene on suurim number. Praktika versioonide jaoks kirjutatud skriptid erineva suurusega numbritega peaaegu kindlasti ei tööta. exp_version tagastab vea, kui suured numbrid ei sobi.
Teiseks on väike number. Väiksema arvu kui praeguse versiooniga versiooniga kirjutatud skriptid võivad sõltuda mõnest uuest funktsioonist ja seda ei pruugi käivitada. exp_version tagastab vea, kui suurimad numbrid vastavad, kuid skripti väikseim number on suurem kui jooksval Expect .
Kolmas on number, mis ei ole versioonide võrdlemisel mingit osa. Siiski suurendatakse seda, kui Expiber tarkvara levitamist muul viisil muudetakse, näiteks lisadokumentide või optimeerimise abil. See lähtestatakse 0-ni igale uuele väiksemale versioonile.
Väljapanemise lippiga Expect prindib vea ja väljub, kui versioon on aegunud.
oodake [[-opts] pat1 body1] ... [-opts] patn [bodyn]
ootab, kuni üks mustritest vastab kudenud protsessi väljundile, määratud ajaperiood on möödas või on näha faili lõpp. Kui lõplik keha on tühi, võidakse see ära jätta.
Kõige uuema expect_before käsu mustrid on kaudselt kasutatud enne mis tahes muid mustreid. Viimase käsu expect_after mustreid kasutatakse kaudselt mõne muu mustri järel.
Kui kogu eeldatava avalduse argumendid nõuavad rohkem kui ühte rida, siis võib kõik argumendid olla üksteise külge kinnitatud, et vältida iga rea lõpetamist tagasilöögilangusega. Sellel juhul saab tavalisi Tcl-asendusi vaatamata traksidega.
Kui mustriga on märksõna eof , siis täidetakse vastav asutus pärast faili lõppu. Kui muster on märksõna ajastatud aeg , siis täidetakse vastav asutus pärast ooteaja lõppu. Kui pole timeout-märksõna, siis teostatakse vaikimisi tühistatud toiming pärast ooteaja lõppu. Vaikeaja ooteaeg on 10 sekundit, kuid selle võib määrata näiteks 30-ni, käsuga "set timeout 30". Lõpptulemusaja määramiseks võib olla väärtus -1. Kui muster on vaikimisi märksõna, siis täidetakse vastav asutus kehtetuks ajaks või faili lõpus.
Kui muster sobib, siis täidetakse vastav asutus. oodata tagastab keha tulemuse (või tühi string, kui mudelit ei sobi). Kui sobib mitu mustrit, kasutatakse kõigepealt esile ilmuvat keha valimist.
Iga kord, kui uus väljund saabub, võrreldakse seda iga mustriga nende järjekorras, mis need on loetletud. Seega võite proovida mängu puudumise, tehes viimase mustri, mille puhul on garanteeritud, et see ilmub, näiteks viip. Olukordades, kus kiiret ei ole, peate kasutama ajahetki (täpselt nagu siis, kui te suhtlete käsitsi).
Mustrid on määratletud kolmel viisil. Vaikimisi on mustrid määratud Tcl-i stringivõtmise käsuga. (Sellised mustrid on sarnased ka C-shell regulaaravaldistega, mida tavaliselt nimetatakse glob-mudeliteks). -gl-märgist võib kasutada mustrite kaitsmiseks, mis võivad vastasel juhul eeldada, et lipud seda teevad. Iga mustriga, mis algab tähega "-", tuleks seda kaitsta. (Kõik stringid, mis algavad tähega "-", on reserveeritud tulevastele suvanditele.)
Näiteks otsib järgmine fragment edukat sisselogimist. (Pange tähele, et katkestamist eeldatakse skripti mujal määratletud viisil).
ootama {busy {läheb kinni \ n; exp_continue} ebaõnnestunud katkestada "kehtetu salasõna" katkestuse aeg katkestatud}Neljandal musteril on vaja tsitaate, kuna see sisaldab ruumi, mis muidu võiks toimingu mustriga eraldada. Sama tegevusega mustrid (näiteks 3. ja 4.) nõuavad meetmete uuesti sisestamist. Seda saab vältida, kasutades regexp-stiilis mustreid (vt allpool). Lisateavet glob-stiilis mustrite kujundamise kohta leiate Tcl manuaalist.
Regexp -stiilis mustrid järgivad Tcl regexp-i (lühidalt "regulaaravaldise") käsuks määratud süntaksit. regexp-mustreid tutvustatakse lipuga -re . Eelmise näite saab ümber kirjutada regexp-iga järgmiselt:
ootama {busy {läheb kinni \ n; exp_continue} -re "ebaõnnestus | kehtetu salasõna" katkestuse aeg katkestatud}Mõlemat tüüpi mustrid on "ükshaaval". See tähendab, et mustrid ei pea kokku kogu stringi, vaid võib mängu alustada ja lõpetada kõikjal stringis (kui kõik muu vastab). Kasutage ^ -ga stringi algust ja $, et see vastaks lõppu. Pidage meeles, et kui te ei oota stringi lõppu, võivad teie vastused kergesti ulatuda stringi keskel, kuna need on saadud loodud protsessist. Valides õigeid tulemusi, võib väljund tunduda ebaloomulik. Seega, $ kasutamine on soovitatav, kui saate täpselt kirjeldada stringi lõpus tähemärke.
Pidage meeles, et paljudes toimetajates vastavad ^ ja $ ridade algusele ja lõpus. Kuid kuna ootus ei ole joondusliige, vastavad need märgid andmete algusele ja lõpus (erinevalt joontest), mis on hetkel eeldatavalt vastavuses puhvriga. (Vt ka allpool toodud märkus "süsteemne seedehäire".)
-ex-märge muudab mustuse sobilikuks täpseks stringiks. Tõlget ei tehta *, ^, jne. (Kuigi ikkagi tuleb järgida tavapäraseid Tcl-konventsioone). Täpne mustrid on alati üksteisele sobimatud.
Nokassi lipp põhjustab väljundi suurtähtede võrdlemiseks nii, nagu oleks need väiketähtedega. Must ei mõjuta.
Väljundi lugemisel võib rohkem kui 2000 baiti sundida varasemaid baite "unustama". Seda saab muuta funktsiooniga match_max . (Pange tähele, et ülemäära suured väärtused võivad musterimaterjali aeglustada.) Kui patlist on full_buffer , siis täidetakse vastav asutus, kui match_max- baidid on vastu võetud ja ühtegi muud mustrit pole sobitanud. Kas täis_bufferi märksõna kasutatakse või mitte, unustatud tähemärke kirjutatakse eeldatavalt (puhvri).
Kui patlist on märksõna null ja nullid on lubatud (käsu remove_nulls abil ) korral, täidetakse vastav asutus, kui ühine ASCII 0 on sobitatud. 0baite ei saa kasutada glob või regexp-mustrite järgi.
Mustri (või eof või full_buffer) sobitamisel salvestatakse kõik sobivad ja eelnevalt tasakaalustamata väljundid muutujale expect_out (buffer) . Kuni 9 regexp alamstringi vastet salvestatakse muutujate expect_out (1, string) läbi expect_out (9, string) . Kui enne mustri kasutamist kasutatakse tähist "tähised" , salvestatakse 10 stringi alguses ja lõpus olevad indeksid ( läätse jaoks sobivas vormis ) muutujades expec_out (X, start) ja expect_out (X, end), kus X on viiekordne, vastab puhvris olevale alamstringi positsioonile. 0 viitab stringidele, mis sobivad kogu mustriga ja on genereeritud glob mustritele ja regexp-mudelitele. Näiteks kui protsess on toodetud "abcdefgh \ n" väljundist, on tulemuseks:
oodake "cd"on nagu järgmiste avalduste täitmisel:
seada expec_out (0, string) cd set expec_out (buffer) abcdja "efgh \ n" jääb väljundpuhvrisse. Kui protsess toodab väljundit "abbbcabkkkka \ n", siis tulemus:
oodata -indices -re "b (b *). * (k +)"on nagu järgmiste avalduste täitmisel:
seada expec_out (0, start) 1 seada expec_out (0, lõpp) 10 seada expec_out (0, string) bbbcabkkkk seada expec_out (1, start) 2 seada expec_out (1, end) 3 seada expec_out (1, string) bb set expec_out (2, algus) 10 seatud expec_out (2, lõpp) 10 seatud expec_out (2, string) k komplekt expec_out (puhver) abbbcabkkkkja "a \ n" jääb väljundpuhvrisse. Muster "*" (ja -re ". *") Tühjendab väljundpuhvrit ilma protsessist väljundit lugedes.
Tavaliselt eemaldatakse vastav väljund Expecti sisemisest puhvrist. Seda võib vältida mustri lisamise abil -notransfer- lipuga. See lipp on eriti kasulik eksperimenteerimisel (katsetamise ajal võib seda hõlpsasti lühendada "-not").
Sobiva väljundiga (või eof või full_buffer) seotud spawn id salvestatakse expect_out (spawn_id) .
The -timeout märgis viib praeguse ootamise käsu järgmise aja väärtuse ajutine asemel ajastatud muutuja väärtuse asemel.
Vaikimisi võrreldakse mustreid praeguse protsessi väljundiga, kuid -i- lipp deklareerib, et nimega spawn_id nimekirja väljund tuleb võrrelda mis tahes järgmiste mustritega (kuni järgmisega- i ). Kataloogide spawn_id loend peaks olema kas spawn_ids tühjaks eraldatud nimekiri või spawn_ids sellise nimekirja viitav muutuja.
Näiteks ootab järgmine tunnus $ proc2-ga nimega spawn_id olevat protsessi "seotud" või "hõivatud", "ebaõnnestunud" või "ebaõige parooli".
oodata {-i $ proc2 busy {läheb kinni \ n; exp_continue} -re "ebaõnnestus | kehtetu salasõna" katkestuse aeg katkestatud}Globaalse muutuja väärtust any_spawn_id võib kasutada, et sobitada mustreid kõigi spawn_ididega, mida nimetatakse praeguse ootamise käsu kõigi teiste -i lipikutega. Spawn_id- i- lipp, millel pole seotud mustrit (st, millele järgneb kohe teine- i ), tehakse kättesaadavaks mis tahes teistele mustritele samas ootuses, mis on seotud mis tahes_spawn_id'iga.
-i- lipp võib nimetada ka globaalset muutujat, mille puhul loetakse muutuja kudede idide loendiks. Muutuja loeb uuesti, kui see muutub. See annab võimaluse muuta I / O allikat käskluse käivitamisel. Sel viisil pakutud spawn idsed nimetatakse kaudseteks spawn idsiks.
Sellised toimingud nagu katkestamine ja jätkamine põhjustavad kontrollistruktuure (st protsendi jaoks ), mis käituvad tavalisel viisil. Käsk exp_continue lubab eeldada, et ta jätkab täitmist, mitte aga tagastavad, nagu tavaliselt.
See on kasulik selgete silmuste või korduvate eeldatavate avalduste vältimiseks. Järgmine näide on osa rlogini automatiseerimiseks loodud fragmendist. Exp_continue väldib teise ootuste avalduse kirjutamist (otsima uuesti viipa), kui rlogin küsib parooli.
\ n "send_user" \ n "send" $ expec_out (1, string) \ r "stty" \ n "send_user" \ n "send" $ {{parool: {stty -echo send_user "parool ($ kasutaja jaoks) $ hostis:" expect_user -re " echo exp_continue} vale {send_user} kehtetu parool või konto \ n "exit" timeout {send_user "ühendus $ hosti aegunud \ n" exit} eof {send_user \ "ühendus hostiga ebaõnnestus: $ expec_out (buffer) exit} re $ kiireNäiteks võib järgmine fragment aidata kasutaja juhendil koostoimimist, mis on juba täielikult automatiseeritud. Sellisel juhul viiakse terminal lõpptarbimisrežiimi. Kui kasutaja vajutab "+", muutuja muutub. Kui nuppu "p" vajutatakse, saadetakse protsessile mitu tagasitõmbamist, ehkki selle abil mõni viis, ja "i" võimaldab kasutajal suhelda protsessiga, varundades stsenaariumi kontrolli. Igal juhul võimaldab exp_continue praeguse eelduse jätkata mustrite sobitamist pärast praeguse toimingu sooritamist.
stty raw - ooo expect_after {-i $ user_spawn_id "p" {send "\ r \ r \ r"; exp_continue} "+" {incr foo; exp_continue} "i" {interact; exp_continue} "quit" exit)Vaikimisi lähtestab exp_continue ajaväljundi taimer. Taimerit ei käivitu uuesti, kui exp_continue nimetatakse tähiseks -continue_timer .
ootama pärast [expec_args]
töötab identne expec_before'ga, välja arvatud juhul, kui mõlemad ootused ja ootused_aptkud võivad kokku sobida, kasutatakse eeldatavat mustrit. Lisateabe saamiseks vaadake käsku expect_before .
expect_background [expect_args]
võtab samad argumendid nagu oodata , kuid see tagastatakse kohe. Mudelit testitakse alati, kui uus sisestus saabub. Tüüpide ajastus ja vaikimisi on expec_backgroundi mõttes mõttetu ja need visatakse vaikseks . Muidu eeldab ex_background käsk expect_before ja expect_after mustreid nagu eeldada .
Kui eeldatakse, et tagasiväline toimingut hinnatakse, on sama kudevõime taustteksti töötlemine blokeeritud. Taustteabe töötlemine blokeeritakse tegevuse lõpetamisel. Kuigi tausttehnoloogia töötlemine on blokeeritud, on võimalik (esiplaanil) eeldada sama kudekujutise ID-d.
Ootuspärase ooterežiimi blokeeringut pole võimalik oodata . Eeldatav_background konkreetse kudema ID kustutatakse, deklareerides uue expect_background koos sama kudev id. Tunnustades eeldatavat_märki , mis ei sisalda ühtegi mustrit, eemaldab antud kudemisnäidiku tausta taustal olevate mudelite sobivuse.
expec_before [expect_args]
võtab samad argumendid nagu oodata , kuid see tagastatakse kohe. Kõigi järgnevate oodatavate käskude jaoks on vaikimisi lisatud ka kõige uuematest expec_before samad kudemisnimedega id-tüüpi mudelid . Kui muster sobib, käsitletakse seda nii, nagu oleks see määratud ooteseisundi käsklusega ise, ja sellega seotud asutus täidetakse eeldatava käsu kontekstis. Kui mõlemad eeldused enne ja oodat võivad sobida, kasutatakse eeldatavat mustrit.
Kui ühtegi mustrit ei ole määratud, ei kontrollita kimpude idi ühtegi mustrit.
Kui -l- lipp ei ületa seda , siis expect_before mustrid sobivad kokku käsku expect_before käivitamise ajal määratletud spawn id-ga (mitte siis, kui selle muster on sobitatud).
Infoleht tõmbab eeldatavalt enne, kui on tagastatud praegused spetsifikatsioonid selle kohta, milliste mustritega need sobivad. Vaikimisi kuvatakse aruandes praeguse kudemisnäidiku id. Selle kudeku id kohta teabe saamiseks võidakse esitada vabatahtlik spawn id-spetsifikatsioon. Näiteks
expect_before-info-i $ protsentiKõige rohkem võib anda ühe kudemisnäidiku spetsifikatsiooni. Lipu-otsesõnu pärsib otseseid spawn id-id, mis pärinevad ainult kaudsetest spetsifikatsioonidest.
Kärpide id-spetsifikatsiooni asemel annab lipp "-all" -i "-info" kõikide kirete id-ide kohta aru.
-info-lipuriigi väljundit saab kasutada argumendina expect_before.
expect_tty [expect_args]
on nagu oodata, kuid see loeb tähemärke / dev / tty (st kasutaja klahvivajutused). Vaikimisi toimub lugemine küpsetatud režiimis. Seega peavad liinid lõppema tagasitulekuga, et neid näha võiks. Seda saab muuta stty-ga (vt käsku stty ).
expect_user [expect_args]
on nagu oodata, kuid see loeb tähemärki stdinist (st kasutaja klahvivajutused). Vaikimisi toimub lugemine küpsetatud režiimis. Seega peavad liinid lõppema tagasitulekuga, et neid näha võiks. Seda saab muuta stty-ga (vt käsku stty ).
kahvlit
loob uue protsessi . Uus protsess on praeguse eeldatava protsessi täpne koopia. Edaspidi tagastab kahvl 0 uuele (lapsele) protsessile ja tagastab lapseprotsessi protsessi ID vanemale protsessile . Kui rike (alati ressursside puudumise tõttu, nt vahetusruumi, mälu tõttu), tagastab kahvlind vanemprotsessile -1 ja lapseprotsessi pole loodud.
Vallandatud protsessid väljuvad väljumise käskluse kaudu, nagu esialgne protsess . Vormitud protsessid on lubatud logifailidele kirjutada. Kui te enamate protsesside puhul keelate silumist või ei logi sisse, võib tulemuseks olla segadusse.
Mõned pty implementatsioonid võivad ajada segamini mitme lugeja ja kirjaniku poolt. Seega on enne kudemisprotsesse kõige turvalisem.
suhelda [string1 body1] ... [stringn [bodyn]]
annab kasutajale praeguse protsessi kontrolli, nii et klahvikombinatsioonid saadetakse praegusele protsessile ning praegune protsessi stdout ja stderr tagastatakse.
String-keha paarid võivad olla argumendid, millisel juhul keha täidetakse, kui vastav string on sisestatud. (Vaikimisi stringi ei saadeta praegusele protsessile .) Kui lõplik keha puudub, eeldatakse tõlkide käsklust.
Kui argumendid kogu interaktsiooni avaldusele nõuavad rohkem kui ühte rea, siis saab kõik argumendid üksteise külge kinnitada, et vältida iga rea lõpetamist tagasilöögilangusega. Sellel juhul saab tavalisi Tcl-asendusi vaatamata traksidega.
Näiteks käivitab järgmine käsk järgmiste stringi keha paaridega: Kui nuppu ^ Z on vajutatud, on ooteaeg peatatud. ( Reset- lipp taastab terminali režiimid.) Kui nuppu ^ A vajutatakse, näeb kasutaja "kirjutasite kontrolli-A" ja protsessile saadetakse ^ A. Kui nuppu $ vajutatakse, näeb kasutaja kuupäeva. Kui nuppu ^ C vajutatakse, oodata väljapääsu. Kui sisestatakse "foo", näeb kasutaja "bar". Kui ~ ~ on vajutatud, töötab Expect interpreter interaktiivselt.
määrake CTRLZ \ 032 suhelda {-reset $ CTRLZ {exec kill -STOP [pid]} \ 001 {send_user "kirjutanud kontrolli-A \ n"; saatke "\ 001") $ {send_user "Kuupäev on [kella formaat [kella sekundit]]."} \ 003 exit foo {send_user "baar"} ~~}Stringi keha paarides on stringid sobitatud järjekorras, mida nad argumentideks loevad. Ülejäänud tulemuste ootuses ei saadeta praegusele protsessile osaliselt vastavaid stringe. Kui tähemärke sisestatakse selliselt, et enam ei pruugi olla sobivus, saadetakse protsessi jaoks ainult üks osa stringist, mis ei saa alustada teise mängu. Seega võivad osalise vaste alamjooksud stringid hiljem sobida, kui originaal stringid, mis üritasid mängu olla, lõpuks ebaõnnestuvad.
Vaikimisi on stringide sobitamine täpne ilma metsikukaartideta . (Seevastu ootuste käsklus kasutab vaikimisi glob-stiilis mustreid). -ex- lipp võib kasutada mustrite kaitsmiseks, mis võivad vastasel juhul lippudega seda teha. Iga mustriga, mis algab tähega "-", tuleks seda kaitsta. (Kõik stringid, mis algavad tähega "-", on reserveeritud tulevastele suvanditele.)
-re- lipp paneb stringi tõlgendama regexp-stiilis musterina. Sellisel juhul salvestatakse vastav alamstringi väärtus muutujaga interact_out sarnaselt sellele, kuidas eeldab, et salvestatakse selle väljund muutujas expect_out . Sarnaselt toetatakse ka -indeid lippu.
Mudel eof tutvustab toimingut, mis täidetakse faili lõpus. Efi eriline mustri võib järgida ka väljundsignaali , mille puhul see vastab, kui väljundi kirjutamisel tuvastatakse eof . Vaikimisi eof- toiming on "tagasitulek", nii et suhelda lihtsalt naaseb iga EOF-i puhul.
Mustreitingu ajastust tutvustab ajahetk (sekundites) ja toiming, mis käivitatakse pärast seda, kui määratud aja jooksul pole ühtegi märki lugenud. Ajutine skeem kehtib viimati määratletud protsessi kohta . Vaikimisi aegumist pole. Erinäitaja "timeout" (mida eeldatav käsk puudutab) ei mõjuta seda ajahetki.
Näiteks võiks kasutada järgmist avaldust, et autoloogida kasutajaid, kes ei ole tund aega sisestanud, kuid kes saavad sageli süsteemseid sõnumeid:
suhelda sisend $ user_spawn_id timeout 3600 return-output \ $ spawn_idKui mustriga on märksõna null ja nullid on lubatud (käsu remove_nulls abil ) korral, täidetakse vastav asutus, kui ühine ASCII 0 on sobitatud. 0baite ei saa kasutada glob või regexp-mustrite järgi.
Mustri eelproovimine lipuriigiga põhjustab muutuja interact_out (spawn_id), mis määratakse mudelis (või eof) vastavas mudelis spawn_id.
Sellised toimingud nagu katkestamine ja jätkamine põhjustavad kontrollistruktuure (st protsendi jaoks ), mis käituvad tavalisel viisil. Kuid tagasipöördumine põhjustab vastaskäigu, et pöörduda oma helistaja poole, samas kui inter_return põhjustab vastasmõju, et põhjustada helistajale tagasipöördumine. Näiteks juhul, kui "proc foo" käskis suhelda, mis seejärel käivitas tegevuse inter_return , naaseb proc foo . (See tähendab, et kui suhelda kõnede tõlkidega, siis interaktiivselt sisestades sissetuleva reklaami, jätkab vastastikmõju, samas kui inter_return põhjustab vastasmõju, et naasta oma helistaja juurde.)
Interaktsiooni ajal kasutatakse toorrežiimi nii, et kõik märgid saaksid praegusele protsessile üle kanda. Kui praegune protsess ei taba tööjuhtimise signaale, peatub see, kui saadetakse stopp-signaal (vaikimisi ^ Z). Selle taaskäivitamiseks saatke jätkamissignaal (näiteks "tapan -CONT"). Kui soovite tõesti SIGSTOPi sellesse protsessi saata (^ Z), kaaluge esmalt cshsi loomist ja seejärel programmi käivitamist. Teisest küljest, kui soovite SIGSTOPi saata ennast ennast oodata , kasutage esimest kõne tõlki (võib-olla kasutades escape-märk) ja vajutage seejärel ^ Z.
String-keha paari saab kasutada stenografina, et vältida tõlkide sisestamist ja käskude käivitamist interaktiivselt. Eelmise terminali režiimi kasutatakse ajal, kui keerme keha paari keha täidetakse.
Kiiruse korral käituvad toimingud toores režiimis vaikimisi. Reset- lipp lähtestab terminali režiimile, mis oli enne seda interaktiivset, täideti (alati, küpsetatud režiim). Pange tähele, et režiimi sisestamisel sisestatud märgid võivad kaotsi minna (mõnedes süsteemides on terminali draiver kahetsusväärne). Ainuke põhjus -reset kasutamiseks on see, kas teie tegevus sõltub keetmise režiimis käitamisest.
The -echo lipp saadab sümbolid, mis vastavad järgmisele mustrile, protsessi juurde, mis genereerisid need, kui iga märgi loetakse. See võib olla kasulik, kui kasutaja peab nägema tagasisidet osaliselt trükitud mustritest.
Kui mustriga kajastatakse, kuid lõpuks ei sobi, saadetakse tähemärgid loodud protsessile . Kui kudenud protsess kajastab neid, näeb kasutaja märgid kaks korda. -echo sobib tõenäoliselt ainult olukordades, kus kasutaja tõenäoliselt ei täida mustrit. Näiteks järgmine väljavõte on rftp, rekursiivne ftp-skript, kus kasutajal palutakse režiimil saada, panna või loetleda praegune kataloog rekursiivselt, et sisestada ~ g, ~ p või ~ l. Need on nii kaugel tavapärastest ftp-käskudest, et kasutaja tõenäoliselt ei kirjuta ~, millele järgneb midagi muud, välja arvatud ekslikult, mille puhul nad tõenäoliselt ignoreerivad tulemust niikuinii.
suhelda {-echo ~ g (getcurdirectory 1) -echo ~ l (getcurdirectory 0) -echo ~ p (putcurdirectory}}-nobufferi lipu saadab väljundprotsessile märgid, mis vastavad järgmisele musterile, kui märgid loetakse.
See on kasulik, kui soovite, et programm jätaks muster tagasi. Näiteks võib jälgida, kui isik on helistamisel (Hayese stiilis modem), et kasutada järgmist. Iga kord, kui on näha "atd", logib skript ülejäänud rea.
% lognumber {} {suhelda -nobuffer -re "(. *)" tagastab paneb $ log "[kella formaat [kella sekundid]]: valitakse interactive_out (1, string)"} interact -nobuffer "atd" lognumberInteraktiivse interaktsiooni ajal ignoreeritakse varasemat log_user kasutamist. Täpsemalt, suhelda muudab selle väljundi logimiseks (saadetakse standardväljundisse), kuna eeldatakse, et kasutaja ei soovi pimesi suhelda.
-o- lipp põhjustab praeguse protsessi väljundile rakendamiseks järgmised võtme-keha paarid. See võib olla kasulik näiteks siis, kui tegeleb võõrustajatega, kes saadavad soovimatud tähed telneti seansi ajal.
Vaikimisi suhtlemine eeldab, et kasutaja kirjutab stdin kirjutamise ja stdout'i lugemise protsessi enda ootama . -u lipp ("kasutaja" jaoks) teeb suhtlemiseks kasutaja otsimiseks selle argumendina nime- tatud protsessi (mis peab olema loodud id).
See võimaldab kahe sõltumatu protsessi ühendada ilma selgesõnalise loopita. Selleks, et aidata silumiseks, ootate, et diagnostika läheb alati stderrile (või stdout teatud logimis- ja silumisandmete jaoks). Samal põhjusel tõlgib käsk interaktiivselt stdinist.
Näiteks loob sisselogimisprotsess järgmine fragment. Seejärel valib see kasutaja (pole näidatud) ja ühendab need lõpuks kokku. Loomulikult võib kõik sisselogimisprotsessid asendada. Näiteks kesta lubab kasutajal töötada ilma konto ja parooli varundamiseta.
spawn login set login $ spawn_id spawn tip modem # suunata tagasi kasutajale # ühenda kasutaja sisselogimiseks suhtlema -u $ loginVäljundi saatmiseks mitmele protsessile, loetlege iga kudede id nimekiri, mis on eelnevalt sisestatud väljundsignaaliga . Väljamaksekoodide rühma sisendite kudemisnimede id võib olla määratud kimbu id-loendiga, mis on eelnevalt sisestatud lipuga. (Mõlemad sisend- väljund võivad võtta loeteludena samamoodi kui -i lipu eeldatava käsuga, välja arvatud see, et any_spawn_id ei mõjuta omavahel seostatavat tähendust). Kõik järgnevad lipud ja stringid (või mustrid) kehtivad sellele sisendile, kuni teine - ilmub sisendlipp. Kui sisendit ei kuvata, tähendab väljastus "-input $ user_spawn_id -output". (Sarnaselt mustritega, millel pole sisendit .) Kui on määratud üks sisend , ignoreerib see $ user_spawn_id. Kui on määratud teine sisend , ignoreerib see $ spawn_id. Täiendavad sisendlipud võivad olla täpsustatud.
Kaks kaudset sisendprotsessi eeldavad, et nende väljundid on määratud $ spawn_id ja $ user_spawn_id (vastupidises suunas). Kui sisendfail ilmub ilma väljundsignaalita , tühistavad selle protsessi tähemärgid.
-l-lipp tutvustab praeguse spawn_id asemel asendust, kui ei kasutata teisi sisend- või väljundlippe . -l-l tähistab -o lippu.
On võimalik vahetada interaktiivseid protsesse, kasutades kaudseid spawn id-id. (Kaudsed spawn id-id kirjeldatakse oodatava käsu jaotises.) Kaudsed spawn id-id võivad olla määratletud -i, -u, -input või -väljundi lippe.
tõlk [args]
põhjustab kasutaja interaktiivse küsitluse Expect ja Tcl käsud. Iga käsu tulemus on trükitud.
Sellised toimingud nagu katkestamine ja jätkamine põhjustavad kontrollistruktuure (st protsendi jaoks ), mis käituvad tavalisel viisil. Kuid tagasipöördumine põhjustab ka helistaja pöördumiseks tõlgi , samas kui inter_return põhjustab tõlke, et ta helistajale tagastaks. Näiteks, kui "proc foo" nimetatakse tõlgendiks, mis seejärel tegi inter_returni toimingu, tagastab prots foo . Iga muu käsk põhjustab tõlkide jätkamiseks uute käskude küsimist.
Vaikimisi sisaldab viht kaks täisarvu. Esimene täisarv kirjeldab hindamispasti sügavust (st kui mitu korda on kutsutud Tcl_Eval). Teine täisarv on Tcl ajaloo identifikaator. Kiirklahvi saab määrata, määratledes protseduuri nimega "prompt1", mille tagastatav väärtus muutub järgmiseks viipuks. Kui avaldusel on avatud jutumärgid, parens, braces või sulgudes, antakse uuele reale sekundaarne viip (vaikimisi "+>"). Sekundaarpiiri saab määrata, määratledes protseduuri nimega "prompt2".
Tõlgi ajal kasutatakse keedetud režiimi, isegi kui selle helistaja kasutas toores režiimi.
Kui STDIN on suletud, läheb tõlk tagasi, kui pole kasutatud lipp-nime, millisel juhul kasutatakse järgnevat argumenti.
log_file [args] [[-a] fail]
Kui failinimi on antud, salvestab log_fail selle faili seansi ärakirja (alustades sellest hetkest). log_file lõpetab salvestamise, kui ei anta argumenti. Kõik eelmised logifailid on suletud.
Failinime asemel võib anda Tcl-faili identifikaatori, kasutades avanevaid või -valikuid avanenud lippe. See on sarnane spawn käsuga. (Lisateabe saamiseks vt kudemist .)
-l laseb jõuda väljundisse, mida logitakse log_user käsku.
Vaikimisi lisab käsk log_file vanadele failidele, mitte aga nende kärpimisele, et oleks võimalik ühe seansi ajal logimise välja lülitada ja mitu korda muuta. Failide kärpimiseks kasutage lipp- noappendat .
-info-lipp põhjustab log_file'i, et leida hiljemalt hiljutiste mitte-info-argumentide kirjeldus.
log_user -info | 0 | 1
Vaikimisi logitakse saatmise / oodatava dialoogi stdout (ja logifail kui see on avatud). Stdouti logimine keelatakse käsuga "log_user 0" ja uuesti aktiveeritud "log_user 1" abil. Logifaili logimine ei muutu.
Infoleht lipp paneb log_user, et taastada hiljutiste mitte-info-argumentide kirjelduse.
match_max [-d] [-i spawn_id] [suurus]
määrab puhvri suuruse (baitides), mida kasutatakse ootuspäraselt sisemiselt. Suuruse argumendi puudumisel tagastatakse praegune suurus.
-d- lipuga on määratud vaikimisi suurus. (Esialgne vaikimisi on 2000.) -l- lipp on määratud nimega spawn id-i jaoks, muidu on see määratud praeguse protsessi jaoks .
overlay [- # spawn_id] [- # spawn_id] [...] programm [args]
käivitab praeguse Expect programmi, mis lõpeb, "programmi args". Lahtine argumendi argumendid sunnivad käsunna ees olevat sidekriipsu, nagu oleks see sisselogimisring. Kõik spawn_ids on suletud, välja arvatud nende puhul, mida nimetatakse argumentidena. Need on kaardistatud nimega failide identifikaatoritele.
Spawn_ids on kaardistatud uue pärimisprogrammi identifikaatorite failideks. Näiteks järgib järgmine joon male ja võimaldab seda kontrollida praeguse protsessiga - näiteks, male.
overlay-0 $ spawn_id -1 $ spawn_id -2 $ spawn_id maleSee on efektiivsem kui "suhelda-u", kuid ohverdab ka programmeeritud suhtlemise võimet, sest eeldatav protsess enam ei kontrolli.
Pange tähele, et ükski juhtimistermin puudub. Seega, kui eemaldate standardset sisendit või muudate seda, siis töötavad programmid, mis teevad töökontrolli (kestad, sisselogimine jne), ei tööta korralikult.
pariteet [-d] [-i spawn_id] [väärtus]
määratleb, kas pariteet tuleks säilitada või eemaldada kudenud protsesside väljundist. Kui väärtus on null, tühjendada pariteet, vastasel juhul ei eemaldata seda. Ilma väärtuse argumendita tagastatakse praegune väärtus.
-d-lippiga määratakse vaikimisi pariteedi väärtus. (Algne vaikeväärtus on 1, st paarsus ei ole eemaldatud.) -i lipuriigiga määratakse nimega spawn id- i pariteet, vastasel juhul on see määratud praeguse protsessi jaoks .
remove_nulls [-d] [-i spawn_id] [väärtus]
määratleb, kas nullid säilitatakse või eemaldatakse kudenud protsesside väljundist enne muster sobitamist või salvestamist muutujaga expect_out või interact_out . Kui väärtus on 1, eemaldatakse nullid. Kui väärtus on 0, siis nullid ei eemaldata. Ilma väärtuse argumendita tagastatakse praegune väärtus.
-d-lippiga määratakse vaikimisi väärtus. (Esialgne vaikimisi väärtus on 1, st nullid eemaldatakse.) -i lipuga määratakse nimega spawn id, vastasel juhul on see määratud praeguse protsessi jaoks .
Kas tühimikud eemaldatakse või mitte, ootate , salvestab null baiti logi ja stdouti.
saatke [-flags] stringi
Saadab stringi praegusele protsessile . Näiteks käsk
saadab sümbolid, helloworld praegusele protsessile . (Tcl sisaldab printf- like-käsku (nimega formaat ), mis võib luua meelevaldselt keerukaid stringe.)
Tähemärgid saadetakse kohe, kuigi programmid, millel on rea puhverdatud sisend, ei loe tähemärke enne, kui saadetakse tagastatav märk. Tagastusmärk tähistatakse "\ r".
- lipp paneb järgmise argumendi tõlgendama pigem stringina kui lippuna. Igale stringile võib eelneda "-", kas see tegelikult näeb välja nagu lipu. See annab usaldusväärse mehhanismi, et määrata muutuvaid stringe, ilma et need oleksid katkestanud need, mis nägemuselt näivad lipud. (Kõik stringid, mis algavad tähega "-", on reserveeritud tulevastele suvanditele.)
-i- lipp deklareerib, et string saadetakse nimega spawn_id. Kui spawn_id on user_spawn_id ja terminal on toores režiimis, stringi uued read tõlgitakse tagasi-newline-järjestustesse, nii et need kuvatakse nii, nagu oleks terminal olnud keedetud režiimis. The -raw lipu keelab selle tõlke.
Null- lipp saadab nullmärki (0 baiti). Vaikimisi saadetakse üks null. Täisarv võib järgida -null -nuppu, et näidata, kui palju nulli saata.
Lõhkumise lipp tekitab purunemise tingimuse. See on mõttekas vaid juhul, kui kudema id viitab "spawn-open" kaudu avatud tty-seadmele. Kui teil on tekkinud selline protsess nagu näpunäide, peaksite puhkuse genereerimiseks kasutama tippkonventsiooni.
-s lipuriigid saadavad väljundit "aeglaselt", et vältida ühist olukorda, kus arvuti väljastab sisendpuhveri, mis oli kavandatud inimese jaoks, kes ei oleks kunagi samast puhvrist välja loovutanud. Seda väljundit kontrollib muutuja "send_slow" väärtus, mis võtab kahe elemendi nimekirja. Esimene element on täisarv, mis kirjeldab aatomilaienduste saatmiseks baitide arvu. Teine element on reaalne arv, mis kirjeldab aatomite eraldamise sekundite arvu. Näiteks "set send_slow" {10 .001} "sundiks" send -s "saatma stringi, mille 10 saadetava tähemärgi vahel on 1 millisekundiline.
-h lipu jõud väljastatakse saatma (mõnevõrra), nagu inimene tegelikult kirjutades. Tähemärkide vahel ilmuvad inimese jaoks sarnased viivitused. (Algoritm põhineb Weibulli levikul, selle konkreetse rakendusega kohandatud muudatustega.) Seda väljundit kontrollib muutuja "send_human" väärtus, mis võtab viie elementide nimekirja. Esimesed kaks elementi on sümbolite keskmine interarrival aeg sekundites. Esimest kasutatakse vaikimisi. Teine kasutatakse sõna lõpus, et simuleerida peent pausid, mis mõnikord sellistes üleminekutes esinevad. Kolmas parameeter on varieeruvuse mõõt, kus .1 on üsna muutlik, 1 on mõistlikult muutuv ja 10 on üsna muutumatu. Äärmuslikkus on 0 kuni lõpmatuseni. Kaks viimast parameetrit on vastavalt minimaalne ja maksimaalne vaheaeg. Minimaalset ja maksimaalset väärtust kasutatakse viimase ja "klipi" viimane aeg. Lõpp-keskmine võib antud keskmisest suhteliselt erinev, kui minimaalse ja maksimaalse klipi väärtused on piisavad.
Näiteks järgib järgmine käsk emuleerijat kiiret ja järjekindlat masinakirjutajat:
set send_human {.1 .3 1 .05 2} saatke -h "Olen näljane. Teeme lõuna."kuigi järgnevad võivad pärast pookimist paremini sobida:
set send_human {.4 .4 .2 .5 100} saatke -h "Goodd party lash night!"Pange tähele, et vigu ei simuleerita, kuigi võite ise vigade parandamise olukordi seada, sisestades saatmise argumente vigu ja parandusi.
Nullimärkide saatmise lipud pausi saatmiseks, aeglase väljundi ja inimese stiili väljundi sundimiseks on üksteist välistavad. Kasutatakse ainult viimati mainitud. Lisaks ei saa null-tähemärkide või pauside saatmiseks lipude abil määrata ühtegi stringi argumenti.
See on hea mõte enne, kui esimene saadab protsessile ootamatu . Oodata oodata protsessi alustamist, kuid saatmine ei saa. Täpsemalt, kui esimene saatmine lõpetatakse enne protsessi käivitamist, on oht, et teie andmed ignoreeritakse. Olukordades, kus interaktiivsed programmid ei paku esialgset viivitust, saate eelistada saatmist viivitusega, nagu:
# Et vältida häkkerite vihjeid sissetungimise kohta, # see süsteem ei soovita välist parooli. # Oodake 5 sekundit täieliku käivitamise lõpetamiseks telnetin väga.secure.gov magage 5 saatke paroolexp_send on saatmiseks pealkiri . Kui kasutate Expectkit või mõnda teist Expect'i varianti Tk keskkonnas, siis saatmist määrab Tk täiesti teistsugusel eesmärgil. Keskkondade ühilduvuse jaoks on ette nähtud exp_send . Sarnased aliased on ette nähtud teiste Expecti muude saatmiskäskude jaoks.
send_error [-flags] string
on nagu saatmine , välja arvatud see, et väljund saadetakse pigem stderrile kui praegusele protsessile .
send_log [-] string
on nagu saatmine , välja arvatud see, et string saadetakse ainult logifaili (vt log_file ). Kui logifail pole avatud, ignoreeritakse neid argumente.
send_tty [-flags] string
on nagu saata , välja arvatud see, et väljund saadetakse pigem / dev / tty kui praegune protsess .
send_user [-flags] string
on nagu saatmine , välja arvatud see, et väljund saadetakse pigem stdout kui praegune protsess .
magada sekundid
põhjustab skripti antud sekundi möödudes unerežiimi . Sekundid võivad olla kümnendkohani. Katkestused (ja Tk sündmused, kui kasutate Expectkit) töödeldakse, kuni oodata magab.
kudema [args] programmi [args]
loob uue protsessi, milles käivitatakse "programmi args". Selle stdin, stdout ja stderr on ühendatud Expect, nii et neid saab lugeda ja kirjutada teiste Expect käskudega. Ühendus katkeb tihedalt või kui protsess sulges mõnda faili identifikaatorit.
Kui protsess algab kudumisega , seatakse muutuja spawn_id sellele protsessile viitavasse deskriptorisse. Kataloogi spawn_id kirjeldatud protsess peetakse "praeguseks protsessiks ". spawn_id võib lugeda või kirjutada, tegelikult annab töökontrolli .
user_spawn_id on globaalne muutuja, mis sisaldab kasutaja kirjeldavat kirjeldust. Näiteks kui spawn_id on sellele väärtusele määratud, oodake käitumist nagu expect_user .
.I error_spawn_id on globaalne muutuja, mis sisaldab standardviga seotud kirjeldust. Näiteks kui spawn_id on sellele väärtusele määratud, saadab käsk nagu send_error .
tty_spawn_id on globaalne muutuja, mis sisaldab kirjeldust, mis viitab / dev / tty-le. Kui / dev / tty puudub (näiteks cron, at või partii skript), siis tty_spawn_id pole määratletud. Seda saab testida järgmiselt:
kui {[info vars tty_spawn_id]} {# / dev / tty on olemas} else {# / dev / tty ei ole olemas # tõenäoliselt cron, partii või skripti järgi}spawn tagastab UNIX-i protsessi idi. Kui protsessi ei genereerita, tagastatakse 0. Muutuja spawn_out (alam, nimi) on seatud pty-alamseadme nimele.
Vaikimisi vastab käskudele käsu nimi ja argumendid. Noecho lipu peal ei tee seda.
Konsoolimärguandel on konsooliväljund, mis suunatakse ümber loodud protsessile . Seda ei toeta kõikides süsteemides.
Sisemiselt kasutab kudemist pty, mis on initsialiseeritud samamoodi nagu kasutaja tty. See on veelgi initsialiseeritud nii, et kõik seaded on "normaalsed" (vastavalt stty (1)). Kui muutuja stty_init on defineeritud, tõlgendatakse seda stty argumentide stiilis kui täiendavat konfiguratsiooni. Näiteks, "seadistatud stty_init toores" põhjustab täiendavate kudede protsesside terminalide käivitamist toores režiimis. -nottycopy jätab initsialiseerimise luba kasutaja tty. -nottyinit jättis "mõistliku" initsialiseerimise.
Tavaliselt võtab kudemine aega, et käivitada. Kui märkate märkimisväärselt palju aega kudema, on tõenäoliselt silmatorkav ptys. Ptys'is käivitatakse mitu katset, et vältida eksitava protsessiga seostuvaid probleeme. (Need võtavad 10 sekundit kiilukujulise rühma kohta). Running Expect koos -d- valikuga näitab, kui Expect leiab palju ptysid paarituates olekutes. Kui te ei saa tappa protsesse, millele need ptys on kinnitatud, võib teie ainuke võimalus taaskäivitada.
Kui programmi ei saa edukalt genereerida, kuna exec (2) ebaõnnestub (nt kui programm puudub), saadab veateade järgmise suhtlemise või ootamise käskluse nii, nagu oleks programm käivitanud ja esitas veateate väljundina. See käitumine on looduslike tagajärgede rakendamine. Sisemiselt kerkivad kahvlid, mille järel kudenud protsessil ei ole võimalust suhelda esialgse eeldatava protsessiga, välja arvatud spawn_id kaudu toimuv suhtlemine.
Avanev lipp põhjustab järgmise argumendi tõlgendamise Tcl-faili identifikaatorina (st tagastatakse avatud .) Maske id saab seejärel kasutada nii, nagu oleks see loodud protsess . (Faili identifikaatorit ei tohiks enam kasutada.) See võimaldab teil toorainet, faile ja torujuhtmeid käsitleda kudede protsessina ilma pty. Tagastatakse 0, et näidata, et sellega ei kaasne protsessi . Kui ühendus loodud protsessiga on suletud, on ka Tcl-faili identifikaator. Valikuvõtte lipp on sarnane -open, välja arvatud see, et -leaveopen põhjustab faili identifikaatori avamise isegi pärast spawn id suletud.
-pty- lipp põhjustab pty avamise, kuid protsessi pole tekkinud. Tagastatakse 0, et näidata, et sellega ei kaasne protsessi . Spawn_id on tavapäraselt seadistatud.
Muutuja spawn_out (alam, fd) on seatud faili identifikaatorile, mis vastab pty-alamale. Seda saab suletud, kasutades "close-slave".
-ignore'i tähis tähistab signaali, mida kerkinud protsessis eiratakse. Vastasel korral saavad signaalid vaikimisi käitumise. Signaalid on nimeks trapide käsus, välja arvatud see, et iga signaal nõuab eraldi lippu.
strace tase
põhjustab enne täitmisele trükitavate avalduste tegemist. (Tcl-i jälgede käsk jälitab muutujaid). Tase näitab, kui kaugele on kõne pinu, et jälgida. Näiteks järgib järgmine käsk Expect , jälgides esimese 4 kõne taset, kuid mitte ühtegi selle all.
Infoleht tõmbab kõige uuemate mitte-info-argumentide kirjelduse tagasi.
stty args
muudab terminali reegleid sarnaselt välise stty käsklusega.
Vaikimisi on ligipääs kontrolliterminalile. Teistele terminalidele pääseb juurde, lisades käsule "Staatuse taotlused, tagastab selle käsu tulemusena. Kui staatust ei taotleta ja kontrolliterminali juurde pääseb, tagastatakse toores ja kaja atribuutide eelmine staatus vormis, mida saab hiljem käsku kasutab.
Näiteks argumendid toored või -küpsed panevad terminali toores režiimi. Argumendid -raw või küpsetatud panevad terminali keedetud režiimi. Argumendid echo ja -echo asetavad terminali vastavalt echo ja noecho režiimi.
Järgmine näide illustreerib, kuidas ajutine katkestamine ajutiselt keelatud. Seda saab kasutada muidu automaatsetes skriptidena, et vältida nende paroolide varjamist. (Vaata selle kohta täiendavat arutelu all EXPECT HINTS).
stty -echo send_user "Parool:" expect_user -re "(. *) \ n" määrata parool $ expec_out (1, string) stty echo süsteemi args
annab argsi sh (1) sisendina, justkui see oleks kirjutatud terminalist käsust. Expect ootab, kuni kestab otsa. Shi olekutäpsus käideldakse samamoodi, nagu exec käitleb oma tagasiside olekut.
Erinevalt rakendusest, mis suunab stdinile ja stdoutile skripti, ei toimi süsteem ümbersuunamist (muud kui string, mida tähistab string ise). Seega on võimalik kasutada programme, mis peavad rääkima otse / dev / tty-ga. Samal põhjusel ei salvestata süsteemi tulemusi logi.
ajatempel [args]
tagastab ajatempli. Ilma argumentideta on sekundite arv alates epohhist tagastatud.
-formaadi lipp tutvustab stringi, mis on tagastatud, kuid asenduste puhul, mis on tehtud vastavalt strtime programmi POSIX-i reeglitele. Näiteks asendatakse% a lühendatud nädalapäeva nimega (st La). Teised on:
% a lühendatud tööpäeva nimi% Täieliku tööpäeva nimi% b lühendatud kuu nimi% B täiskuu nimi% c kuupäev kellaaeg: kell 6. oktoober 11:45:56 kuu 1993% päev (01-31% H tund (00-23)% I tund (01-12)% päevas (001-366)% m kuu (01-12)% M minut (00-59)% p või pm% S sekund (00-61) % u päev (1-7, esmaspäev on esimene nädala päev)% U nädal (00-53, esimene pühapäev on esimene nädal esimesel päeval)% V nädal (01-53, ISO 8601 stiil)% päevas (0- 6)% W nädal (00-53, esimene esmaspäev on esimene nädal esimesel päeval)% x kuupäeva järgi on: Wed 6. oktoober 1993% X aeg kui: 23:59:59% y aastas (00-99) % Y aastas nagu: 1993% Z ajavööndis (või mitte midagi, kui ei ole võimalik kindlaks määrata) %% tühi protsendi märkMuud% spetsifikatsioonid on määratlemata. Muud tegelased läbivad puutumata. Toetatakse ainult C-lokaati.
-sekundi tähis tutvustab mitmeid sekundeid, kuna ajavahemikku kasutatakse vormingu allikana. Vastasel korral kasutatakse praegust kellaaega.
-gmt- lipp nõuab ajatempli väljundit, et kasutada GMT-i ajavööndit. Kui pole lippu, kasutatakse kohalikku ajavööndit.
lõksu [[käsk] signaalid]
põhjustab antud käsu täitmise mis tahes antud signaalide tulevase saamise korral. Käsk täidetakse globaalses ulatuses. Kui käsk puudus, tagastatakse signaali toiming. Kui käsk on string SIG_IGN, ignoreeritakse signaale. Kui käsk on string SIG_DFL, on signaalid tulemuseks süsteemi vaikimisi. signaalid on kas üks signaal või signaalide nimekiri. Signaalid võivad olla määratud numbriliselt või sümboolselt vastavalt signaalile (3). SIG-i eesliide võib ära jätta.
Ilma argumentideta (või argumendi -number) tagastab lukk praegu käivitatava püünise käsu signaali number.
Tippkoodi lipp kasutab käskluse tagastamise koodi selle asemel, mida Tcl hakkab käima hakkama hakkama hakkama hakkamas.
-interp- lipp paneb käsku hindama, kasutades käskluse käivitamise ajal aktiivset tõlki, mitte kui lõksu deklareeriti.
Nimekirjas olev lipp põhjustab käsku lüüa, et taastada praegu käivitatava püünise käskluse signaali nimi.
Suur- märgi lipp paneb sulgemiskäsku tagastama suurima signaalinumbri, mida saab seada.
Näiteks käsu "trap {send_user" Ouch! "} SIGINT printida" Ouch! " iga kord, kui kasutaja vajutab nuppu ^ C.
Vaikimisi on SIGINT (mida tavaliselt saab genereerida, vajutades ^ C) ja SIGTERMi põhjusel Oodata väljumiseks. See on tingitud järgmisest lõksast, mis on vaikimisi loodud, kui oodata käivitamist.
lõksu väljumine {SIGINT SIGTERM}Kui kasutate silumisprogrammi käivitamiseks -D-märgistust, on interaktiivse siluriga käivitamiseks määratud SIGINT. Selle põhjuseks on järgmine lõks:
lõks {exp_debug 1} SIGINTSiluri lõksu saab muuta, seadistades keskkonnamuutuja EXPECT_DEBUG_INIT uuele käskudele.
Loomulikult saate mõlemat neist üle kanda, lihtsalt lisades oma skriptile käske. Täpsemalt, kui sul on oma "lõksu väljumine SIGINT", siis see ületab siluri lõksu. See on kasulik, kui soovite, et kasutajad üldse ei jõua silumiseks.
Kui soovite määratleda oma lõksu SIGINT-il, kuid käivitamisel ikka veel silumisjälgi, kasutage:
kui {! [exp_debug]} {trap mystuff SIGINT}Teise võimalusena võite mõne muu signaali abil silumisseadmesse lüüa.
lõksus ei lase SIGALRM-i tegevust üle kanda, kuna seda kasutatakse ootamatult sisemiselt. Käsk lahti ühendab SIGALRMiga SIG_IGN (ignoreeri). Saate seda uuesti aktiveerida seni, kuni see keelatakse järgnevate käivitamiste käskude ajal.
Lisateabe saamiseks vaadake signaali (3).
ootama [args]
viivitused kuni kudenud protsessi (või praeguse protsessi, kui seda ei nimetata) lõpetamist.
Tavaliselt oodata tagastab nelja täisarvu. Esimene täisarv on protsess, mida oodati. Teine täisarv on vastav spawn id. Kolmas täisarv on -1, kui tekkis opsüsteemi viga või muul juhul 0. Kui kolmas täisarv oli 0, on neljas täisarv staatuse, mille tagandatud protsess on loodud. Kui kolmas täisarv oli -1, on neljas täisarv operatsioonisüsteemi määratud errno väärtus. Samuti on seatud globaalne muutuja errorCode.
Tagasisaadetava väärtuse lõpus ilmuvad ooteajal täiendavad elemendid. Vabatahtlik viies element identifitseerib teabeklassi. Praegu on selle elemendi ainus võimalik väärtus CHILDKILLED, mille puhul kaks järgmist väärtust on C-stiilis signaali nimi ja lühike tekstiline kirjeldus.
-i- lipp deklareerib, et oodatav protsess vastab nimele spawn_id (mitte protsessi ID). SIGCHLD-i käitleja sees on võimalik kudenud protsessi oodata kudevood id -1 abil.
-nowaiti märk lubab oodata, et naasta kohe eduka ootamise näitamisega. Kui protsess lahkub (hiljem), kaob see automaatselt ilma selge ootamise vajaduseta.
Ootamise käsku võib kasutada ka argumendiga "-i -1", kasutades ootamatut protsessi . Erinevalt selle kasutamisest koos loodud protsessidega saab seda käsku igal ajal täita. Protsessi ei saa kontrollida. Kuid tagasiväärtust saab kontrollida protsessi ID jaoks.
RAAMATUKOGUD
Expect automaatselt teada kahte sisseehitatud raamatukogust eeldatavate skriptide jaoks. Neid määratletakse muutujatele exp_library ja exp_exec_library nimetatute kataloogides. Mõlemad peavad sisaldama utiliidifaile, mida saavad kasutada teised skriptid.
exp_library sisaldab arhitektuuriga seotud faile. exp_exec_library sisaldab arhitektuurist sõltuvaid faile. Sõltuvalt teie süsteemist võivad mõlemad kataloogid olla täiesti tühjad. Faili $ exp_exec_library / cat-puhvrite olemasolu kirjeldab, kas teie / bin / kass puhvrid vaikimisi.
PRETTY-PRINTING
Vigrindi määratlus on saadaval ilusate trükistega Expect skriptid. Eeldusel, et eeldatava jaotusega kaasas olev vgrindi määratlus on õigesti installitud, saate seda kasutada järgmiselt:
vgrind-avatud failNÄITED
See ei näi palju, kuidas panna kõike koos, mida mees lehel kirjeldab. Soovitan teil lugeda ja proovida näiteid eeldatava levitamise näitekataloogis . Mõned neist on tõelised programmid. Teised näitavad ainult teatavaid tehnikaid, ja loomulikult on paar lihtsalt kiireid häkkimisi. INSTALL-failil on lühike ülevaade nendest programmidest.
Eeldatavad paberid (vt Vt ka) on samuti kasulikud. Kuigi mõned dokumendid kasutavad Expecti varasemate versioonidega vastavat süntaksit, on kaasnevad põhjendused endiselt kehtivad ja lähevad palju rohkem üksikasjalikumaid andmeid kui selle inimese lehelt.
CAVEATS
Laiendid võivad kokku põrkuda Expect käskude nimedega. Näiteks saatmist määratleb Tk täiesti teistsuguse eesmärgi jaoks. Sel põhjusel on enamik Expect käske saadaval ka kui exp_XXXX. Käsklustel ja muutujadel, mis algavad "exp", "inter", "spawn" ja "timeout", pole aliase. Kasutage laiendatud käsuviivalendeid, kui teil on vaja keskkondade vahelist ühilduvust.
Oodata läheb üsna liberaalselt vaate ulatusest. Eelkõige otsitakse Expect programmi spetsiifiliste käskude abil loetavaid muutujaid kõigepealt kohalikust ulatusest ja kui neid ei leita, siis globaalses ulatuses. Näiteks välistab see vajaduse panna "globaalne ajastus" kõigisse ootel kirjutatud toimingutesse. Teisest küljest on kirjutatud muutujad alati kohalikud (välja arvatud juhul, kui on antud "globaalne" käsk). Kõige sagedasem probleem, mida see põhjustab, on see, kui protseduuris täidetakse kudemist. Väljaspool protseduuri pole spawn_id enam olemas, seega pole kudenud protsess enam ligipääsetav ainult ulatusliku ulatuse tõttu. Lisage sellisele protseduurile globaalne spawn_id.
Kui te ei suuda lubada mitmeosalisi võimalusi (st teie süsteem ei toeta vali (BSD *. *), Küsitlust (SVR> 2) ega midagi samaväärset), siis oodata saab ainult ühte protsessi korraga juhtida. Sellisel juhul ärge üritage luua spawn_id , samuti ei tohiks protsesside käivitamisel protsesside kaudu käivitada exec. Lisaks sellele ei saa te korraga korraga mitme protsessi (sealhulgas kasutaja kui üks) oodata .
Terminali parameetrid võivad skriptidel suurt mõju avaldada. Näiteks kui skeem on kirjutatud echoingi otsimiseks, siis ebaõnnestub, kui echoing on välja lülitatud. Sellepärast eeldavad eeldused vaikimisi mõistlikke terminaliparameetreid. Kahjuks võib see teiste programmide jaoks asju ebameeldivaks muuta. Näiteks emacs-shell soovib muuta "tavapäraseid" seoseid: uued veerud on kaardistatud uutele reale, mitte aga veo-tagastamise uued ridad, ja kajastamine on keelatud. See võimaldab sisendjooni muutmiseks kasutada emacsi. Kahjuks ei saa Expect seda arvata.
Võite taotleda, et Expect ei võtaks üle terminali parameetrite vaikeseadistused, kuid siis peate olema väga ettevaatlik selliste keskkondade skriptide kirjutamisel. Emacsi puhul vältige sõltuvalt sellistest asjadest nagu kajastavad ja rea lõppjälgimised.
Käsud, mis aktsepteerivad argumente, mis on ühendatud ühe loendiga ( oodatavad variandid ja suhelda ), kasutavad heuristilisi otsuseid, kas loend on tegelikult üks argument või palju. Heuristiline võib ebaõnnestuda ainult juhul, kui loend tegelikult kujutab endast ühte argumenti, millel on mitu varjatud \ n-d koos mitte-tühikutega tähemärki nende vahel. See tundub olevat piisavalt ebatõenäoline, kuid argumenti "-nobrace" saab kasutada selleks, et sundida ühte argumenti käsitlema ühe argumendina. Seda võib eeldatavasti kasutada masinaga genereeritud eeldatava koodiga. Samamoodi paneb liikumine ühe argumendi, mida tuleb käsitleda kui mitu mustrit / toimingut.
VIGAD
See oli tõesti ahvatlev nimetada programmi "sex" (kas "Smart EXec" või "Send-EXpect"), kuid domineerib mõistlikkus (või isegi puritanism).
Mõnel süsteemil, kui kest on kudenud, kaebab ta, et ei saa tty-le juurdepääsu, kuid igal juhul jookseb. See tähendab, et teie süsteemil on mehhanism kontrollitüübi hankimiseks, mida Expect ei tea. Palun uurige, mis see on, ja saatke see teave mulle tagasi.
Ultrix 4.1 (vähemalt uusimad versioonid siin) arvestab, et ajahetked ületavad 1000000, mis on võrdne 0-ga.
Digitaalne UNIX 4.0A (ja arvatavasti ka muud versioonid) keeldub eraldama ptys, kui määrate SIGCHLD käitleja. Lisateabe saamiseks vaadake lehte grantpt.
IRIX 6.0 ei käivitu korrektselt õigustega ptk, nii et kui Expect proovib eraldada pty, mida keegi teine varem kasutas, siis see ebaõnnestub. Uuendage IRIX 6.1-ni.
Telnet (ainult SunOS 4.1.2-ga kontrollitud) hangub, kui TERM pole määratud. See on probleem croni, CGI-skriptide ja CGI-de puhul, mis ei määratle TERM-i. Seega peate määrama selle selgesõnaliselt - milline tüüp on ebaoluline. See tuleb lihtsalt midagi seada! Järgnevad arvatavasti piisab enamikul juhtudest.
seadista env (TERM) vt100Näpunäide (kontrollitud ainult BSDI BSD / OS 3.1 i386 all) hangub, kui SHELL ja HOME ei ole seatud. See on probleem croni , CGI- skriptide ja CGI- skriptide all, mis ei määratle neid keskkonnamuutujaid. Seega peate määrama need selgesõnaliselt - milline tüüp on ebaoluline. See tuleb lihtsalt midagi seada! Järgnevad arvatavasti piisab enamikul juhtudest.
seadista env (SHELL) / bin / sh set env (HOME) / usr / local / binMõned ptys-i rakendused on kavandatud nii, et kernel viskab ära kõik lugemata väljundid 10 kuni 15 sekundi pärast (tegelik number sõltub rakendusest) pärast protsessi failidekirjutamise lõpetamist. Seega oodake programme nagu
kudema päeva magamine 20 oodataebaõnnestub. Selle vältimiseks kasutage mitte-interaktiivseid programme, milleks on exec, mitte kudema . Kuigi sellised olukorrad on mõeldavad, ei ole ma praktikas kunagi leidnud olukorda, kus selle käitumise tõttu kaotaks tõeliselt interaktiivse programmi lõpptulemus.
Teisest küljest tühjendab Cray UNICOS välja kõik lugemata väljundid kohe pärast protsessi failide kirjelduse sulgemist. Olen teatanud sellest Cray-le ja nad töötavad probleemi lahendamisel.
Mõnikord on viivitus viivituse ja vastuse vahel nõutav, näiteks kui tty-liides muudab UART-i seadistusi või sobitatud kiirusi, otsides start / stop bitti. Tavaliselt on see kõik vaja ainult mõni teine või kaks magada. Tugevam meetod on uuesti proovida, kuni riistvara on sisendite saamiseks valmis. Järgmises näites kasutatakse mõlemat strateegiat:
saatke "kiirus 9600 \ r"; uni 1 ootavad {timeout (saatma "\ r"; exp_continue} $ kiirelõksu-kood ei tööta ühegi Tcl sündmuse silmusesse jääva käsuga, näiteks unega. Probleemiks on see, et sündmuse silmus korral eemaldab Tcl asünkeseadme käitlejate tagasiside koodid. Tööriistakomplekt on lüümiskoodis lipu seadmine. Siis kontrollige lippu kohe pärast käsku (st. Unerežiim).
Expected_background-käsk ignoreerib -maailma argumente ja üldse ei ole ajutine mõte.
& # 34; OODAT HINTS & # 34;
Expect'is on paar asja, mis võivad olla intuitiivsed. Selles osas püütakse käsitleda mõnda neist asjadest mõne soovitusega.
Tavaline ootuspärane probleem on see, kuidas shelliprobleeme ära tunda. Kuna neid teisiti kohandatakse erinevalt inimestelt ja erinevatest kestadest, võib rlogini kaasaskantav automatiseerimine olla keeruline, ilma et oleks kiiret teada. Mõistlik on see, et kasutajad salvestavad regulaaravaldist, mis kirjeldab nende kiiret (eriti selle lõppu) keskkonnamuutujat EXPECT_PROMPT. Kasutada võib järgmist koodi: Kui EXPECT_PROMPT puudub, on koodil endiselt hea võimalus korralikult toimida.
määrake kiirklahv "(% | # | \\ $) $"; # default prompt catch {set prompt $ env (EXPECT_PROMPT)} expect -re $ promptMa kutsun teid üles kirjutama eeldatavaid mustreid, mis sisaldavad lõpuks seda, mida ootate. See hoiab ära võimaluse vastata küsimusele, enne kui näete kogu asja. Lisaks sellele, kui te võite vastata küsimustele enne nende täielikku kuvamist, kui vastad varakult, võib teie vastus ilmuda ka küsimuse keskel. Teisisõnu, sellest tulenev dialoog on korrektne, kuid nägema skrambleeritud.
Enamik viipasid sisaldab tühikuid lõpus. Näiteks ftp-i käsk on 'f', 't', 'p', '>' ja 'f'. Selle viipa vastavusse viimiseks peate arvestama kõigi nende märkidega. Tavaline viga ei sisalda tühiku. Pane tühi otse.
Kui kasutate vormi X * mustrit, vastab * kogu X-i lõpust saadav väljund viimati saadud objektiga. See kõlab intuitiivselt, kuid võib mõnevõrra segi ajada, sest fraas "viimati saadud asi" võib varieeruda olenevalt arvuti kiirusest ja I / O töötlemisest nii kerneli kui ka seadme draiveri poolt.
Eelkõige näevad inimesed, et programmide väljund jõuab suurtesse tükkidesse (aatomiliselt), kui tegelikkuses toodavad enamik programme korraga ühe rea väljundi. Eeldusel on see, et eelmise lõigu muster võib * olla vastavuses ainult praeguse rea lõppu, kuigi tundub olevat rohkem, sest mängu ajal oli see kogu saadud väljund.
ole kindel, et ei ole võimalik teada, et edasine väljund on tulemas, kui teie mudel seda konkreetselt ei arvesta.
Isegi sõltuvalt joonduspõhisest puhverdamisest pole mõistlik. Programmid teevad harva mitte ainult puhvrite tüübi lubadusi, vaid ka süsteemi seedehäired võivad katkestada väljundsagedused, nii et jooned purunevad näiliselt juhuslikes kohtades. Seega, kui oskate mudeleid kirjutades väljendada viimase viie tähemärki, on mõistlik seda teha.
Kui ootate programmi viimase väljaande mustrit ja programm vallandab selle asemel midagi muud, ei saa te seda ajatemperatuuriga märksõna abil seda avastada. Põhjuseks on see, et oodata ei ole aegumist - selle asemel saab see eof- näidustust. Kasutage seda asemel. Isegi parem, kasutage mõlemat. Nii, kui seda rida kunagi liigutatakse, ei pea te seda rea ise muutma.
Uutele ridadele konverteeritakse tavaliselt terminali draiveri väljundiks vedaja tagastus, linefeedijärjestus. Seega, kui soovite mustrit, mis vastab sõnaselgelt kahele joonile, näiteks printf ("foo \ nbar"), peaksite kasutama mustrit "foo \ r \ nbar".
Sarnane tõlge tekib kasutaja lugemisel expect_user kaudu. Sellisel juhul, kui vajutate tagastamist, tõlgitakse see ümber uuele reale. Kui Expect läbib siis selle programmi, mis määrab oma terminali toores režiimi (nt telnet), tekib probleem, kuna programm eeldab tõelist tagasipöördumist. (Mõned programmid on tegelikult andestanud, kuna need tõlgivad automaatselt uuesti versioonid tagasi, kuid enamik neist ei tee seda.) Kahjuks ei ole võimalik teada saada, kas programm paneb oma terminali toores režiimi.
Selle asemel, et käsitsi redigeerida tagasitulekutega uusi reale, on lahenduseks kasutada käsku "stty raw", mis peatab tõlke. Pange tähele, et see tähendab, et te ei saa enam keedetud redigeerimisfunktsioone.
suhelda vaikimisi seab teie terminal toores režiim, et see probleem ei tekiks siis.
Sageli on kasulik salvestada paroolid (või muud isiklikud andmed) eeldatavates skriptides. Seda ei soovitata, sest kõik, mis on arvutisse salvestatud, on kergesti ligipääsetav kõigile. Seega on skriptist paroolide interaktiivne küsimine targem, kui sisestada need sõna otseses mõttes. Sellest hoolimata on mõnikord selline kinnistamine ainus võimalus.
Kahjuks ei tohiks UNIX-failisüsteem otseselt luua skripte, mis on käivitatavad, kuid loetavad. Setgid-shell skripte toetavad süsteemid võivad seda kaudselt simuleerida järgmiselt:
Loo eeldatav skript (mis sisaldab salajaseid andmeid) nagu tavaliselt. Andke oma õigused 750 (-rwxr-x ---) ja see kuulub usaldusväärsele grupile, st rühmale, kellel on seda lugeda. Vajadusel looge selleks uus rühm. Seejärel looge / bin / sh-skript koos lubadega 2751 (-rwxr-s-x), mis kuulub sama rühma kui varem.
Tulemuseks on skript, mida igaüks võib täita (ja lugeda). Kui käivitatakse, käivitub see eeldatav skript.
& # 34; VT KA "
Tcl (3), libexpect (3)
Don Libes, lk 602, ISBN 1-56592-090-2, O'Reilly ja associates, 1995, "Exploring Expect: Tcl-põhise tööriistakomplekt interaktiivsete programmide automatiseerimiseks" .
"Oodake: nende ravimite kontrollimatute interaktiivsuse puhastamist", Don Libes, USA 1990. aasta suve USENIXi konverents, Anaheim, California, 11.-15. juuni 1990.
. Don Libes, "USENIXi suurte installatsioonisüsteemide administreerimise konverentsi 1990. aasta", Colorado Springs, Colorado, 17.-19. Oktoober 1990. a. "Kasutades eeldusi, et automatiseerida süsteemi halduse ülesandeid".
. I "Tcl: Põimitav käskluskeel" John Ousterhout, USENIXi konverentsi Washington 1990, 22.-26. Jaanuaril 1990. aasta Washingtoni konverentsil. I "expect: Interaktiivsete programmide juhtimise skriptid", Don Libes, Computing Systems , Vol. 4, nr 2, California ülikooli pressiuudised, november 1991. I "Regressioonide testimine ja vastavuse testimise interaktiivsed programmid", Don Libes, 1992. aasta suve USENIXi konverents, lk. 135-144, San Antonio, TX 12.-15. Juuni 1992. I "Kibitz - Mitmete interaktiivsete programmide ühendamine üheskoos", Don Libes, tarkvara tava ja kogemus, John Wiley & Sons, West Sussex, Inglismaa, Vol.
23. november, mai 1993. I "Tkl-rakenduste silurija", Don Libes, 1993. aasta Tcl / Tk töökoda, Berkeley, CA, 10.-11. Juuni 1993.
AUTHOR
Don Libes, riiklik standardite ja tehnoloogia instituut
TUNNUSTAMINE
Tänan John Ousterhout Tcl-i ja Scott Paisley eest inspiratsiooni saamiseks. Tänu Rob Savoye'ile eeldatava autokonfiguratsioonikoodi eest.
HISTORY fail dokumenteerib suures osas ootamatu arengu. See teeb huvitavat lugemist ja võib anda teile selle tarkvara kohta täiendava ülevaate. Tänu selles mainitud inimestele, kes saatsid mulle veaparandused ja andsid muud abi.
Osaliselt on USA valitsuse poolt välja maksnud Expecti väljatöötamise ja elluviimise ning see on seega avalik. Kuid autor ja NIST tahaksid krediiti, kui seda programmi ja dokumente või nende osi kasutatakse.