[shell script linux] aprire nuova finestra X

[andrea86re]

Ciao a tutti,

Non avendo praticamente mai lavorato su linux non ho mai dovuto scriverne uno script.
Mi trovo a dover aprire un tunnel ssh tramite script (chiamato da un listato in C#) che presuppone il ritorno di una finestra X con immagine dal server.

Il codice è il seguente:

#!/bin/bash/

VAR=$(expect -c "
spawn ssh #### server 1 -X
expect \"password:\"
send \"password1\r\"
expect \"\\\\$\"
spawn ssh #### server 2 -X

expect \"password:\"
send \"password2\r\"
expect \"\\\\$\"
send \"command\r\"
expect \"\\\\$\"
"
)
echo "$VAR"

Dico subito che il codice l'ho scritto partendo da esempi online e non conosco a fondo le specifiche dei vari comandi.
Lo script funziona, nel senso che mi ritorna l'immagine voluta dal server. Ci sono però 2 problemi:

1) il comando "command" funziona se non contiene "" all'interno. Nel mio caso dovrebbe essere del tipo: camera freq=1 cmd="image get all".
cioè esegue il comando cmd="..." con frequenza di 1 secondo.
Il problema è che inserendo le "" all'interno delle virgolette della funzione send \".....\" non funziona niente.
Soluzioni?

2) La finestra con l'immagine viene visualizzata nella stessa finestra della shell, salvo poi scomparire alla pressione di qualsiasi tasto per ridare posto alla command line.
Se io eseguo lo script manualmente comando per comando da shell, invece, l'immagine viene rappresentata in una nuova finestra, e questo è il risultato che vorrei ottenere anche da script.

Se qualcuno è pratico di script su linux e potesse darmi un rapido commento gli sarei molto grato!
grazie a tutti

[Gimli[2BV!2B]]

Quello script conviene srotolarlo un attimo:

1. invochi bash con lo shabang (#!/bin/bash/)
2. questa invoca un'altra bash con $()
3. in quest'ultima bash viene invocato expect (altro interprete di comandi concettualmente simile a bash)
4. expect fa il lavoro che ti interessa

Questo ti costringe all'escape dei doppi apici nello script che passi come parametro ad expect dandoti il problema di cui ti lamenti.

#!/usr/bin/expect

set SERVER01 192.168.1.1
set SERVER02 192.168.1.2
set USER01 user01
set USER02 user02
set PWD01 "Segretissima"
set PWD02 "_ImPoSsIb1l3_"
set CMD "command -con -parametri blah"

spawn ssh $SERVER01 -l$USER01 -X
expect "password:"
send "$PWD01\r"
expect "\$"
spawn ssh $SERVER02 -l$USER02 -X

expect "password:"
send "$PWD02\r"
expect "\$"
send "$CMD\r"
expect "\$"

Avvertenze:

• non testato, potrei aver scritto fastidiosi errori su apici/escape ridotti
• basato su vecchi ricordi
• l'echo $VAR finale del tuo script dovrebbe corrispondere al ritorno dell'esecuzione dello script expect
• mi spiace ma non ho capito bene cosa succede nel tuo punto 2

[andrea86re]

ciao Gimli, grazie mille per l'aiuto

Così lo script è un tantino più chiaro e leggibile! Domani lo provo, se riesco a far funzionare il command il punto 1 è risolto.

riguardo al punto 2,

La situazione è questa: tramite tunnell ssh io con il "command" nello script chiedo al server di restituirmi una immagine presa da una camera in remoto ogni tot secondi.
Quando inserisco manualmente il command da script, il sistema mi apre automaticamente una finestra X con l'immagine richiesta.
Se invece lancio lo script riportato sopra, la stessa immagine viene visualizzata all'interno della stessa finestra di shell in cui lo script viene eseguito, per poi scomparire e tornare alla command line dopo un paio di secondi.

La cosa mi pare molto strana, e me la riesco a spiegare solo con il fatto che il comando eseguito in quel modo da script è in qualche modo diverso dello stesso comando lanciato manualmente.

per completezza, il comando è:

cam push t=1 cmd="poolget img all"

[Gimli[2BV!2B]]

Visto che hai riportato il comando (avevo dimenticato la questione degli apici) e che ora ho pure cenato ti riporto lo script riveduto:

#!/usr/bin/expect

# Resta in esecuzione indefinitamente
# Default 10 secondi dopo ultimo match expect
set timeout -1

set SERVER01 192.168.1.1
set SERVER02 192.168.1.2
set USER01 user01
set USER02 user02
set PWD01 "Segretissima"
set PWD02 "_ImPoSsIb1l3_"
set CMD "cam push t=1 cmd=\"poolget img all\""

spawn ssh $SERVER01 -l$USER01 -X
expect "password:"
send "$PWD01\r"
expect ".*\$ *"

spawn ssh $SERVER02 -l$USER02 -X
expect "password:"
send "$PWD02\r"
expect ".*\$ *"

send "$CMD\r"
expect ".*\$ *"

Il problema dell'esecuzione che termina dopo poco dovrebbe essere dovuto al comportamento standard di expect: trascorsi 10 secondi dall'ultimo match del comando expect l'esecuzione viene terminata. Per questo ho aggiunto il set timeout a -1 (cioè aspetta all'infinito).
Osservazione fondamentale: se l'espressione regolare di expect fallisce l'esecuzione dello script rimarrà bloccata finché non se ne forzerà la chiusura.
Non ho modo di immaginare come gestirai la chiusura, se il comando remoto non gradisca la chiusura forzata o altro.

Avendo creato un piccolo script per testare l'esecuzione ho irrobustito l'espressione regolare per intercettare il prompt: ".*\$ *"
Dovrebbe comunque funzionarti: ho mantenuto il $ come elemento chiave.

[andrea86re]

Grazie di nuovo per la disponibilità.
Ho provato il codice da te suggerito, ma invocando all'inizio direttamente expect anzichè bash, alla prima istruzione "proprietaria" di expect, e cioè spawn, mi ritorna un errore di command not found.
E così per tutte le righe con spawn ed expect.

Non ho idea del perchè, ma posso comunque risolvere integrando il metodo che avevo utilizzato all'inizio con i tuoi utilissimi consigli sul timeout e il CMD.

[Gimli[2BV!2B]]

Come lanci lo script?
Lanciandolo con sh si ottiene quel che dici:

gimli@kwankey ~$ sh expect.tcl
expect.tcl: line 11: spawn: command not found
couldn't read file "password:": no such file or directory
expect.tcl: line 13: send: command not found
[...]

Il modo giusto per invocare un qualsiasi script in modo tale che venga eseguito l'interprete impostato nello shabang (in questo caso /usr/bin/expect) è lanciarne direttamente l'esecuzione dopo avergli attribuito il diritto di esecuzione.
Esempio, presupponendo che la shell si trovi già nella cartella contenente lo script e che lo script si chiami expect.tcl:

gimli@kwankey ~$ chmod +x expect.tcl
gimli@kwankey ~$ ./expect.tcl

Il primo comando aggiunge l'attributo eseguibile al file.

Il secondo lo esegue, come se si trattasse di un eseguibile. Questo è possibile invocando il file con il suo percorso completo.

È possibile specificare il percorso completo in 3 modi principali:

1. nell'esempio utilizzo il percorso relativo ./ che significa "la cartella in cui si trova la shell ora" seguito dal nome del file (altro esempio di percorso relativo con risalita di un livello: ../projects/expect.tcl)
2. altrimenti si può specificare il percorso completo (per esempio /home/gimli/expect.tcl)
3. per finire si può copiare lo script in una delle cartelle presenti nella variabile d'ambiente PATH, rendendolo invocabile con il solo nome come un qualsiasi altro comando shell (di solito metto i miei script in /usr/local/bin o /usr/local/sbin se sono per scopi amministrativi)

Per finire (dimenticavo!) è anche possibile invocarlo esplicitamente con il suo interprete:

gimli@kwankey ~$ expect expect.tcl

[andrea86re]

Chiarissimo e completo.

Il tutto funziona bene, ma purtroppo il comando famoso da script non parte.

A questo punto penso che abbandonerò l'idea dello script e farò l'accesso manualmente prima di mandare il codice; soluzione meno elegante ma a quanto pare il problema di visualizzare una immagine in una nuova finestra e aggiornarla ogni tot è un task complesso da eseguire da bash.

In ogni caso Gimli mi sei stato utilissimo, se non altro per capire qualcosa di più di come funziona lo scripting su linux, il che tornerà sicuramente utile! grazie.