Stdin bir terminal olmadığı için sözde terminal ayrılmayacak

Uzak bir sunucuda bazı dizinler oluşturur ve daha sonra uzaktan yerel makinemden dosyaları kopyalamak için scp kullanan bir kabuk komut dosyası yazmaya çalışıyorum. Şimdiye kadar sahip olduğum şey:

ssh -t user@server<<EOT
DEP_ROOT='/home/matthewr/releases'
datestamp=$(date +%Y%m%d%H%M%S)
REL_DIR=$DEP_ROOT"/"$datestamp
if [ ! -d "$DEP_ROOT" ]; then
    echo "creating the root directory"
    mkdir $DEP_ROOT
fi
mkdir $REL_DIR
exit
EOT

scp ./dir1 user@server:$REL_DIR
scp ./dir2 user@server:$REL_DIR

Ne zaman çalıştırsam şu mesajı alıyorum:

Pseudo-terminal will not be allocated because stdin is not a terminal.

Ve senaryo sonsuza dek asılı.

Ortak anahtarım sunucuda güveniliyor ve komut dosyasının dışındaki tüm komutları gayet iyi çalıştırabiliyorum. Herhangi bir fikir?

Stdin bir terminal olmasa bile sahte tty tahsisini zorlamaya çalışın ssh -t -t(veya ssh -ttkısaca).

Ayrıca bkz: bash betiği tarafından yürütülen SSH oturumunu sonlandırma

Ssh manpage'den:

-T      Disable pseudo-tty allocation.

-t      Force pseudo-tty allocation.  This can be used to execute arbitrary 
        screen-based programs on a remote machine, which can be very useful,
        e.g. when implementing menu services.  Multiple -t options force tty
        allocation, even if ssh has no local tty.

Ayrıca seçeneğiyle -Tgelen manuel

Yalancı tty ayırmayı devre dışı bırak

Başına zanco cevabı , size uzak bir komut veren değil sshkabuk komut satırını ayrıştırır nasıl verilir. Bu sorunu çözmek için, sshkomut çağrınızın sözdizimini , uzak komut sözdizimsel olarak doğru, çok satırlı bir dizeden oluşacak şekilde değiştirin.

Kullanılabilecek çeşitli sözdizimleri vardır. Örneğin, komutlar bashve shve muhtemelen diğer kabuklara da dahil edilebildiğinden, en basit çözüm sshkabuk kabartmasını yorumlu metinlerle birleştirmektir :

ssh user@server /bin/bash <<'EOT'
echo "These commands will be run on: $( uname -a )"
echo "They are executed by: $( whoami )"
EOT

Yukarıdakilerin olmadan çalıştırmanın /bin/bashuyarıya neden olacağını unutmayın Pseudo-terminal will not be allocated because stdin is not a terminal. Ayrıca not o EOTki, tek tırnak ile çevrilidir bashbir şekilde yorumlu metin tanır Yorumlu metin komut metin için olduğu gibi geçilecek ve böylece yerel değişken interpolasyon kapatarak, ssh.

Bir boru hayranı iseniz, yukarıdakileri aşağıdaki gibi yeniden yazabilirsiniz:

cat <<'EOT' | ssh user@server /bin/bash
echo "These commands will be run on: $( uname -a )"
echo "They are executed by: $( whoami )"
EOT

Aynı uyarı /bin/bashyukarıdaki hususlar için de geçerlidir.

Bir başka geçerli yaklaşım, çok satırlı uzaktan komutun, bashdeğişken enterpolasyonun çoklu katmanlarını aşağıdaki gibi kullanarak tek bir dize olarak geçirmektir :

ssh user@server "$( cat <<'EOT'
echo "These commands will be run on: $( uname -a )"
echo "They are executed by: $( whoami )"
EOT
)"

Yukarıdaki çözüm bu sorunu aşağıdaki şekilde giderir:

1. ssh user@serverBash tarafından ayrıştırılır ve olduğu yorumlanır sshkomutu, ardından bir bağımsız değişken user@servergeçirilecek sshkomutu

2. "tamamlandığında sshkomuta iletilecek bir argüman içerecek enterpolasyonlu bir dize başlatır ; bu durumda, sshyürütmek için uzaktan komut olarak yorumlanır.user@server

3. $( çıktı, çevreleyen enterpolasyonlu dize tarafından yakalanacak şekilde yürütülecek bir komutu başlatır

4. cattakip eden dosyanın içeriğini çıktılamak için kullanılan bir komuttur. Çıkışı catyakalanan enterpolasyonlu dizeye geri aktarılacaktır

5. <<bash heredoc başlar

6. 'EOT'yorumlu metin adının EOT olduğunu belirtir. 'EOT'yi çevreleyen tek alıntılar , yorumlu yazının, içeriğin bash tarafından enterpole edilmediği, daha ziyade değişmez biçimde aktarıldığı özel bir yorumlu metin olan nowdoc olarak ayrıştırılması gerektiğini belirtir.

7. Karşılaşılan <<'EOT've <newline>EOT<newline>nowdoc çıktısına eklenecek herhangi bir içerik

8. EOTnowdoc öğesini sonlandırır, bu nedenle nowdoc geçici dosyası oluşturulur ve çağrı catkomutuna iletilir . catnowdoc çıktısını alır ve çıktıyı yakalanan enterpolasyonlu dizeye geri aktarır

9. ) yürütülecek komutu sonlandırır

10. "yakalanan enterpolasyonlu dizgiyi sonlandırır. Enterpolasyonlu dizenin içeriği, sshtek bir komut satırı bağımsız değişkeni olarak iletilir sshve bu komut, yürütmek için uzaktan komut olarak yorumlanıruser@server

Gibi harici araçlar kullanmaktan kaçınmanız gerekiyorsa catve bir yerine iki ifade readalmayı düşünmüyorsanız, SSH komutunu oluşturmak için yerleşik bir yorumlu metinle kullanın:

IFS='' read -r -d '' SSH_COMMAND <<'EOT'
echo "These commands will be run on: $( uname -a )"
echo "They are executed by: $( whoami )"
EOT

ssh user@server "${SSH_COMMAND}"

Bu yanıtı ekliyorum çünkü aynı hata mesajıyla ilgili bir sorunu çözdüm.

Sorun : Cygwin'i Windows altında yükledim ve şu hatayı alıyordum:Pseudo-terminal will not be allocated because stdin is not a terminal

çözüm : Ben vardı çıkıyor değil openssh istemci programı ve yardımcı programları yüklü. Bu nedenle cygwin, cygwin sürümünü değil, ssh'nin Windows uygulamasını kullanıyordu. Çözüm, openssh cygwin paketini kurmaktı.

Uyarı mesajı Pseudo-terminal will not be allocated because stdin is not a terminal., için komut belirtilmediğinden kaynaklanırssh stdin bu belgeden yeniden yönlendirilirken kaynaklanmaktadır. Bağımsız değişken olarak belirtilen bir komutun bulunmaması nedeniyle, sshilk önce etkileşimli bir giriş oturumu bekler (bu, uzak ana bilgisayarda bir pty'nin tahsis edilmesini gerektirir), ancak daha sonra yerel stdin'in tty / pty olmadığını fark etmelidir. Bu sshbelgeden stdin yönlendirmesi normalde /bin/shbağımsız değişken olarak bir komutun (örneğin ) belirtilmesini gerektirir ssh- ve bu durumda varsayılan olarak uzak ana makineye pty atanmaz.

sshBir tty / pty ( vimveya gibi top) varlığını gerektiren herhangi bir komut olmadığından-t geçiş anahtarı sshgereksizdir. Sadece ssh -T user@server <<EOT ...veyassh user@server /bin/bash <<EOT ... ve uyarı kaybolacaktır.

Eğer <<EOF belgeden kaçan veya tek tırnaklı (yani <<\EOTveya <<'EOT') değişkenler yürütülmeden önce yerel kabuk tarafından genişletilir ssh .... Sonuç, bu belgedeki değişkenlerin yalnızca uzak kabukta tanımlandıkları için boş kalacağıdır.

Bu nedenle, $REL_DIRhem yerel kabuk tarafından erişilebilir olmalı hem de uzak kabukta $REL_DIRtanımlanmışsa, sshkomuttan önce bu belgenin dışında tanımlanmalıdır ( aşağıdaki sürüm 1 ); veya, <<\EOTveya <<'EOT'kullanılırsa, sshkomutun REL_DIRçıktısı,ssh stdout komutununecho "$REL_DIR" burada kaçan / tek tırnaklı belgenin ( sürüm 2) içinde üretiliyorsa komutun aşağıdaki ) .

Üçüncü seçenek, burada belgeyi bir değişkende saklamak ve ardından bu değişkeni komut argümanı olarak ssh -t user@server "$heredoc" ( aşağıdaki sürüm 3) iletmektir.

Son olarak, uzak ana bilgisayardaki dizinlerin başarılı bir şekilde oluşturulup oluşturulmadığını kontrol etmek kötü bir fikir değildir (bakınız: ssh ile uzak ana bilgisayarda dosya olup olmadığını kontrol edin ).

# version 1

unset DEP_ROOT REL_DIR
DEP_ROOT='/tmp'
datestamp=$(date +%Y%m%d%H%M%S)
REL_DIR="${DEP_ROOT}/${datestamp}"

ssh localhost /bin/bash <<EOF
if [ ! -d "$DEP_ROOT" ] && [ ! -e "$DEP_ROOT" ]; then
   echo "creating the root directory" 1>&2
   mkdir "$DEP_ROOT"
fi
mkdir "$REL_DIR"
#echo "$REL_DIR"
exit
EOF

scp -r ./dir1 user@server:"$REL_DIR"
scp -r ./dir2 user@server:"$REL_DIR"


# version 2

REL_DIR="$(
ssh localhost /bin/bash <<\EOF
DEP_ROOT='/tmp'
datestamp=$(date +%Y%m%d%H%M%S)
REL_DIR="${DEP_ROOT}/${datestamp}"
if [ ! -d "$DEP_ROOT" ] && [ ! -e "$DEP_ROOT" ]; then
   echo "creating the root directory" 1>&2
   mkdir "$DEP_ROOT"
fi
mkdir "$REL_DIR"
echo "$REL_DIR"
exit
EOF
)"

scp -r ./dir1 user@server:"$REL_DIR"
scp -r ./dir2 user@server:"$REL_DIR"


# version 3

heredoc="$(cat <<'EOF'
# -onlcr: prevent the terminal from converting bare line feeds to carriage return/line feed pairs
stty -echo -onlcr
DEP_ROOT='/tmp'
datestamp="$(date +%Y%m%d%H%M%S)"
REL_DIR="${DEP_ROOT}/${datestamp}"
if [ ! -d "$DEP_ROOT" ] && [ ! -e "$DEP_ROOT" ]; then
   echo "creating the root directory" 1>&2
   mkdir "$DEP_ROOT"
fi
mkdir "$REL_DIR"
echo "$REL_DIR"
stty echo onlcr
exit
EOF
)"

REL_DIR="$(ssh -t localhost "$heredoc")"

scp -r ./dir1 user@server:"$REL_DIR"
scp -r ./dir2 user@server:"$REL_DIR"

İlgili tüm bilgiler mevcut yanıtlardadır, ancak pragmatik bir özet sunmaya çalışalım :

tl; dr:

• Bir komut satırı argümanı kullanarak çalıştırmak için komutları iletmek :
  ssh jdoe@server '...'

  • '...' dizeler birden çok satıra yayılabilir, bu nedenle burada bir belge kullanmadan bile kodunuzu okunabilir tutabilirsiniz:
    ssh jdoe@server ' ... '

• Burada bir belge kullandığınızda olduğu gibi, komutları stdin üzerinden GEÇMEYİN :
  ssh jdoe@server <<'EOF' # Do NOT do this ... EOF

Komutları bağımsız değişken olarak iletmek olduğu gibi çalışır ve:

• sözde terminaldeki problem bile ortaya çıkmaz.
• exitkomutların sonunda bir ifadeye ihtiyacınız olmayacaktır , çünkü komutlar işlendikten sonra oturum otomatik olarak çıkacaktır.

Kısacası, komutları stdin ile iletmek , sshtasarımıyla çelişen ve daha sonra çözülmesi gereken sorunlara neden olan bir mekanizmadır .
Daha fazla bilgi edinmek için okumaya devam edin.

İsteğe bağlı arka plan bilgileri:

sshhedef sunucuda çalıştırılacak komutları kabul etme mekanizması komut satırı bağımsız değişkenidir : son işlenen (seçenek olmayan bağımsız değişken) bir veya daha fazla kabuk komutu içeren bir dizeyi kabul eder.

• Varsayılan olarak, bu komutlar etkileşimli olmayan bir ortamda katılımsız olarak çalışır kabukta (bir sözde) terminal kullanılmadan (seçenek -Tima edilir) ve son komutun işlenmesi bittiğinde oturum otomatik olarak sona erer .

• Komutlarınızın etkileşimli bir isteme yanıt vermek gibi kullanıcı etkileşimi gerektirmesi durumunda , seçeneği kullanarak uzak oturumla etkileşime izin veren bir sahte terminal (ptyudo-tty) oluşturulmasını açıkça isteyebilirsiniz -t; Örneğin:

  • ssh -t jdoe@server 'read -p "Enter something: "; echo "Entered: [$REPLY]"'

  • İnteraktif olduğunu unutmayın read istemin yalnızca bir pty ile doğru çalıştığını , bu nedenle -tseçenek gereklidir.

  • Bir pty kullanmanın dikkate değer bir yan etkisi vardır: stdout ve stderr birleştirilir ve her ikisi de stdout yoluyla rapor edilir ; diğer bir deyişle: normal ve hata çıktıları arasındaki farkı kaybedersiniz; Örneğin:

    • ssh jdoe@server 'echo out; echo err >&2' # OK - stdout and stderr separate

    • ssh -t jdoe@server 'echo out; echo err >&2' # !! stdout + stderr -> stdout

Bu argümanın yokluğunda, sshstdin aracılığıyla komutlar gönderdiğinizde , sorunun başladığı yer de dahil olmak üzere etkileşimli bir kabuk oluşturur :

• Bir için etkileşimli kabuk, sshnormal olarak, varsayılan bir PTY (psödo-terminali) ayırır dışında kendi Stdin terminali (gerçek) bağlı değil ise.

  • Bu araçlar, stdin'i üzerinden komutlar göndermek sshböylece bireyin Stdin artık, bir uç bağlanan bir Pty oluşturulur vessh uyarıyor buna göre size :
    Pseudo-terminal will not be allocated because stdin is not a terminal.

  • Açık -tamacı bir pty yaratmayı istemek olan seçenek bile bu durumda yeterli değildir : aynı uyarıyı alırsınız.

    • Biraz merakla, daha sonra gereken çift-t seçeneği bir pty kuvvet yaratılmasına:ssh -t -t ... veya ssh -tt ...bunu gösterir gerçekten, gerçekten ciddiyim .

    • Belki de bu çok kasıtlı adımı atmanın gerekçesi, işlerin beklendiği gibi çalışmayabileceğidir . Örneğin, MacOS 10.12 yukarıdaki komutun belirgin eşdeğer, standart girdiden üzerinden komutlar veren ve kullanımında -tt, yok değil düzgün çalışması; oturum readistemine yanıt verdikten sonra takılır :
      ssh -tt jdoe@server <<<'read -p "Enter something: "; echo "Entered: [$REPLY]"'

Bağımsız değişken olarak iletmek istediğiniz komutların, komut satırını sisteminiz için çok uzun hale getirmesi olası değilse (uzunluğu yaklaşıyorsa getconf ARG_MAX- bu makaleye bakın ), kodu önce uzak sisteme bir komut dosyası biçiminde kopyalamayı düşünün ( kullanarak, örneğin,scp ) yazın ve ardından bu komut dosyasını yürütmek için bir komut gönderin.

Bir tutam, Kullanımda -Tve üzeri komutları sağlayan Stdin , bir eğik ile exitde kullanarak, interaktif özellikler gerekiyorsa o komutun, ancak not -ttyerine -Tçalışma olmayabilir.

Asmak nereden geliyor bilmiyorum, ama etkileşimli bir ssh içine yönlendirme (veya boru) komutları genellikle sorunlar için bir reçete. Son bağımsız değişken olarak çalıştır komutunu kullanmak ve komut dosyasını ssh komut satırına iletmek daha sağlamdır:

ssh user@server 'DEP_ROOT="/home/matthewr/releases"
datestamp=$(date +%Y%m%d%H%M%S)
REL_DIR=$DEP_ROOT"/"$datestamp
if [ ! -d "$DEP_ROOT" ]; then
    echo "creating the root directory"
    mkdir $DEP_ROOT
fi
mkdir $REL_DIR'

(Hepsi bir devde ' ayrılmış çok satırlı komut satırı bağımsız değişkeni).

Sözde terminal mesajı, -tssh'den uzak makinede çalıştırdığı ortamı orada çalışan programlara gerçek bir terminal gibi göstermesini istemenizi ister. Ssh istemciniz kendi standart girişi bir terminal olmadığı için bunu yapmayı reddediyor , bu nedenle özel terminal API'lerini uzak makineden yerel uçtaki gerçek terminalinize iletmenin bir yolu yok.

-tZaten ne elde etmeye çalışıyordun ?

Bu cevapların çoğunu okuduktan sonra ortaya çıkan çözümü paylaşacağımı düşündüm. Tüm eklediğim/bin/bash heredoc'tan önce ve artık hata vermiyor.

Bunu kullan:

ssh user@machine /bin/bash <<'ENDSSH'
   hostname
ENDSSH

Bunun yerine (hata verir):

ssh user@machine <<'ENDSSH'
   hostname
ENDSSH

Veya bunu kullanın:

ssh user@machine /bin/bash < run-command.sh

Bunun yerine (hata verir):

ssh user@machine < run-command.sh

EKSTRA :

Yine de uzaktan etkileşimli bir bilgi istemi istiyorsanız, örneğin çalıştırdığınız komut dosyası sizden bir parola veya başka bir bilgi isterse, çünkü önceki çözümler bilgi istemlerine yazmanıza izin vermez.

ssh -t user@machine "$(<run-command.sh)"

Ayrıca tüm oturumu bir dosyaya kaydetmek istiyorsanız logfile.log:

ssh -t user@machine "$(<run-command.sh)" | tee -a logfile.log

/ Ssh: user @ host üzerinden bazı şirket sunucularına bağlanmak için emacs 24.5.1 kullanarak Windows altında aynı hatayı alıyordum. Benim sorunum ne çözdü "tramp-default-method" değişkeni "plink" olarak ayarlandı ve bir sunucuya her bağlandığında ssh protokolü ommit. Bunun çalışması için PuTTY's plink.exe dosyasının kurulu olması gerekir.

Çözüm

1. Mx özelleştirme değişkeni (ve ardından Enter tuşuna basın)
2. tramp-default-method (ve sonra tekrar Enter tuşuna basın)
3. Metin alanına plink koyun ve sonra Arabelleği Uygula ve Kaydet
4. Uzak bir sunucuya erişmeye çalıştığımda artık Cxf / user @ host: kullanıyorum ve sonra şifreyi giriyorum. Bağlantı artık uzak sunucuma Windows'taki Emacs altında doğru bir şekilde yapılıyor.

ssh -t foobar @ localhost yourscript.pl