精华内容
下载资源
问答
  • Linux expect用法

    2015-03-04 19:30:40
    使用expect实现自动登录的脚本,网上有很多,可是都没有一个明白的说明,初学者一般都是照抄、收藏。可是为什么要这么写却不知其然。本文用一个最短的例子说明脚本的原理。脚本代码如下: ########################...

    使用expect实现自动登录的脚本,网上有很多,可是都没有一个明白的说明,初学者一般都是照抄、收藏。可是为什么要这么写却不知其然。本文用一个最短的例子说明脚本的原理。脚本代码如下:

    ##############################################
    
    #!/usr/bin/expect
    
    set timeout 30
    
    spawn ssh -l username 192.168.1.1
    
    expect "password:"
    
    send "ispass/r"
    
    interact
    
    ##############################################

    1. [#!/usr/bin/expect]

    这一行告诉操作系统脚本里的代码使用那一个shell来执行。这里的expect其实和linux下的bash、windows下的cmd是一类东西。

    注意:这一行需要在脚本的第一行。

    2. [set timeout 30]

    基本上认识英文的都知道这是设置超时时间的,现在你只要记住他的计时单位是:秒

    3. [spawn ssh -l username 192.168.1.1]

    spawn是进入expect环境后才可以执行的expect内部命令,如果没有装expect或者直接在默认的SHELL下执行是找不到spawn命令的。所以不要用 “which spawn“之类的命令去找spawn命令。好比windows里的dir就是一个内部命令,这个命令由shell自带,你无法找到一个dir.com 或 dir.exe 的可执行文件。

    它主要的功能是给ssh运行进程加个壳,用来传递交互指令。

    4. [expect "password:"]

    这里的expect也是expect的一个内部命令,有点晕吧,expect的shell命令和内部命令是一样的,但不是一个功能,习惯就好了。这个命令的意思是判断上次输出结果里是否包含“password:”的字符串,如果有则立即返回,否则就等待一段时间后返回,这里等待时长就是前面设置的30秒

    5. [send "ispass/r"]

    这里就是执行交互动作,与手工输入密码的动作等效。

    温馨提示: 命令字符串结尾别忘记加上 “/r”,如果出现异常等待的状态可以核查一下。

    6. [interact]

    执行完成后保持交互状态,把控制权交给控制台,这个时候就可以手工操作了。如果没有这一句登录完成后会退出,而不是留在远程终端上。如果你只是登录过去执行一段命令就退出,可改为[expect eof] 


    展开全文
  • Linux expect 用法

    万次阅读 2015-09-08 13:48:58
    expect是建立在tcl基础上的一个工具,它用来让一些需要交互的任务自动化地完成。因为expect是基于tcl的,所以需要你的系统中安装有tcl如何检查?[root@dev ~]# whereis tcltcl: /usr/lib/tcl8.4 /usr/share/tcl8.4...
    expect是建立在tcl基础上的一个工具,它用来让一些需要交互的任务自动化地完成。
    


    因为expect是基于tcl的,所以需要你的系统中安装有tcl
    如何检查?
    [root@dev ~]# whereis tcl
    tcl: /usr/lib/tcl8.4 /usr/share/tcl8.4
    如果看不到结果,请先安装tcl


    安装


    > 安装tcl
    解压tcl安装包后
    cd tcl8.4.11/unix/
    ./configure --prefix=/usr/local/tcl/ --enable-shared
    make && make install


    > 安装expect
    解压expect安装包后
    cd expect-5.43
    ./configure --prefix=/usr/local/expect/ --with-tcl=/usr/local/tcl/lib/ --with-tclinclude=/opt/tcl8.4.11/generic/ --enable-shared
    make && make install
    注意:指定的/opt/tcl8.4.11/generic/ 为我们上面解压的tcl目录


    > 创建连接符号
    ln -s /usr/local/expect/bin/expect /usr/bin/expect
    > 查看连接符号
    ls -l /usr/bin/expect
    lrwxrwxrwx. 1 root root 28 9月   8 11:21 /usr/bin/expect -> /usr/local/expect/bin/expect
    这个符号链接将在编写expect脚本文件时用到,例如在expect文件头部会指定用于执行该脚本的shell 
    #!/usr/bin/expect 


    > 测试
    [root@localhost opt]# expect
    expect1.1> exit
    [root@localhost opt]# 

    这样就可以开始运行expect脚本了。


    用法

    1. [#!/usr/bin/expect] 
    这一行告诉操作系统脚本里的代码使用那一个shell来执行。这里的expect其实和linux下的bash、windows下的cmd是一类东西。 
    注意:这一行需要在脚本的第一行。 


    2. [set timeout 30] 
    基本上认识英文的都知道这是设置超时时间的,现在你只要记住他的计时单位是:秒。timeout -1 为永不超时,默认情况下,timeout是10秒;


    3. [spawn ssh -l username 192.168.1.1] 
    spawn是进入expect环境后才可以执行的expect内部命令,如果没有装expect或者直接在默认的SHELL下执行是找不到spawn命令的。所以不要用 “which spawn“之类的命令去找spawn命令。好比windows里的dir就是一个内部命令,这个命令由shell自带,你无法找到一个dir.com 或 dir.exe 的可执行文件。 
    它主要的功能是给ssh运行进程加个壳,用来传递交互指令。 
    spawn后面加上需要执行的shell命令,比如说spawn sudo touch testfile


    4. [expect "password:"] 
    这里的expect也是expect的一个内部命令,有点晕吧,expect的shell命令和内部命令是一样的,但不是一个功能,习惯就好了。这个命令的意思是判断上次输出结果里是否包含“password:”的字符串,如果有则立即返回,否则就等待一段时间后返回,这里等待时长就是前面设置的30秒 


    5. [send "ispass\r"] 
    这里就是执行交互动作,与手工输入密码的动作等效。 
    温馨提示: 命令字符串结尾别忘记加上“\r”,如果出现异常等待的状态可以核查一下。 


    6. [interact] 
    执行完成后保持交互状态,把控制权交给控制台,这个时候就可以手工操作了。如果没有这一句登录完成后会退出,而不是留在远程终端上。如果你只是登录过去执行 


    7. $argv 参数数组
    expect脚本可以接受从bash传递过来的参数.可以使用[lindex $argv n]获得,n从0开始,分别表示第一个,第二个,第三个....参数
    其中,$argc为命令行参数的个数,$argv0为脚本名字本身,$argv为命令行参数。[lrange $argv 0 0]表示第1个参数,[lrange $argv 0 4]为第一个到第五个参数。与c语言不一样的地方在于,$argv不包含脚本名字本身。


    8. send和send_user
    send会将expect脚本中需要的信息发送给spawn启动的那个进程,而send_user只是回显用户发出的信息,类似于shell中的echo而已。


    9. 如果你在第一行(#!那行)使用-d (debug参数),可以在运行的时候输出一些很有用的信息
    比如你会看见
    argv[0] = /usr/bin/expect argv[1] = -d argv[2] = ./launch.exp argv[3] = 1 argv[4] = 2 argv[5] = 3
    使用这些也可以完成参数传递

    10. exp_continue的用法

    expect {
            -re "Permission denied, please try again." {
                    send_user "Error:Permission denied.\n"
                    exit
            }
            -re "Are you sure you want to continue connecting (yes/no)?" {
                    send "yes\r";exp_continue
            }
            -re "assword:" {
                    send "$loginpass\r";exp_continue
            }
            -re "Connection refused" {
                    exit
            }
            timeout {
                    exit
            }
            eof {
                    exit
            }
    }

    使用exp_continue后,会重新从当前expect块的开始重新执行,可以简单理解问while循环的continue

    例子

    下面的脚本例子,实现了:登录一个Linux服务器,执行 df -h 等命令

    vi expectExample.sh 后输入下面的脚本内容保存后,使用chmod +x expectExample.sh 命令为脚本赋予可执行权限。


    #!/usr/bin/expect -f


    #-------------------------------------------- set the variable,you can modify the value
    set ipaddr [lrange $argv 0 0]
    set port [lrange $argv 1 1]
    set loginuser [lrange $argv 2 2]
    set loginpass [lrange $argv 3 3]
    set cmd_prompt "]#|~]?"

    # 超时时间,单位(秒)
    set timeout 3600


    #-------------------------------------------- login by ssh
    spawn ssh -p $port $loginuser@$ipaddr


    expect {
            -re "Permission denied, please try again." {
                    send_user "Error:Permission denied.\n"
                    exit
            }
                    -re "Connection refused" {
                    send_user "Error:Connection refused.\n"
                    exit
            }
            timeout {
                    exit
            }
            eof {
                    exit
            }
            -re "Are you sure you want to continue connecting (yes/no)?" {
                    send "yes\r"
                    exp_continue
            }
            -re "assword:" {
                    send "$loginpass\r"
                    exp_continue
            }
            -re $cmd_prompt {
                    send "\r"


            }
    }




    #-------------------------------------------- now,we do some commands
    expect {
            -re $cmd_prompt {
                    send "df -h\r"
            }
    }


    expect {
            -re $cmd_prompt {
                    send "free -m\r"
            }
    }


    expect {
            -re $cmd_prompt {
                    send "uptime\r"
            }
    }


    send "cd /opt\r"
    send "mkdir shanhy123\r"
    send "cd shanhy123\r"
    send "echo 123 > 123.txt\r"


    send "/opt/xs.sh\r"


    send "exit\r"


    expect eof
    #interact


    -------------------------------------------------

    其中 xs.sh 为我写的一个测试的 shell 脚本,里面故意做了一个sleep 模拟耗时操作,代码如下:

    #!/bin/bash
    sleep 10
    echo abc > /opt/abc.txt


    注意:expect脚本必须以interact或expect eof结束,执行自动化任务通常expect eof就够了。




    展开全文
  • linux expect 自动交互脚本用法

    万次阅读 2019-05-07 17:18:04
    检查是否安装tcl,expect 如果没有安装,使用yum安装: yum install -y tcl yum install -y expect expect参数 启用选项 -c:执行脚本前先执行的命令,可多次使用。 -d:debug模式,可以在运行时输出一些诊断信息,与在...

    检查是否安装tcl,expect

    如果没有安装,使用yum安装:
    yum install -y tcl
    yum install -y expect
    

    expect参数

    启用选项

    • -c:执行脚本前先执行的命令,可多次使用。
    • -d:debug模式,可以在运行时输出一些诊断信息,与在脚本开始处使用exp_internal 1相似。
    • -D:启用交换调式器,可设一整数参数。
    • -f:从文件读取命令,仅用于使用#!时。如果文件名为"-",则从stdin读取(使用"./-"从文件名为-的文件读取)。
    • -i:交互式输入命令,使用"exit"或"EOF"退出输入状态。
    • --:标示选项结束(如果你需要传递与expect选项相似的参数给脚本时),可放到#!行:#!/usr/bin/expect --
    • -v:显示expect版本信息。

    expect的4个命令

    Expect中最关键的四个命令是send,expect,spawn,interact。

    命令说明
    send用于向进程发送字符串
    expect从进程接收字符串
    spawn启动新的进程
    interact允许用户交互

    常用命令

    `# 命令行参数`
    
    `# $argv,参数数组,使用[lindex $argv n]获取,$argv 0为脚本名字`
    
    `# $argc,参数个数`
    
    `set` `username [lindex $argv 1]` `# 获取第1个参数`
    
    `set` `passwd` `[lindex $argv 2]` `# 获取第2个参数`
    
    `set` `timeout 30` `# 设置超时`
    
    `# spawn是expect内部命令,开启ssh连接`
    
    `spawn` `ssh` `-l username 192.168.1.1`
    
    `# 判断上次输出结果里是否包含“password:”的字符串,如果有则立即返回,否则就等待一段时间(timeout)后返回`
    
    `expect` `"password:"`
    
    `# 发送内容ispass(密码、命令等)`
    
    `send` `"ispass\r"`
    
    `# 发送内容给用户`
    
    `send_user` `"$argv0 [lrange $argv 0 2]\n"`
    
    `send_user` `"It's OK\r"`
    
    `# 执行完成后保持交互状态,控制权交给控制台(手工操作)。否则会完成后会退出。`
    
    `interact`
    

    命令介绍

    • close:关闭当前进程的连接。
    • debug:控制调试器。
    • disconnect:断开进程连接(进程仍在后台运行)。
      • 定时读取密码、执行priv_prog
            `send_user` `"password?\ "`
    
            `expect_user -re` `"(.*)\n"`
    
            `for` `{} 1 {} {`
    
            `if` `{[fork]!=0} {``sleep` `3600;``continue``}`
    
            `disconnect`
    
            `spawn priv_prog`
    
            `expect Password:`
    
            `send` `"$expect_out(1,string)\r"`
    
            `. . .`
    
            `exit`
    
            `}`
    
    • exit:退出expect。
    • exp_continue [-continue_timer]:继续执行下面的匹配。
    • exp_internal [-f file] value:

    expect范例

    1.远程登录并创建文件后退出
    #!/usr/bin/expect           ##注意路径,使用 [whereis expect] 查看
    set user "hadoop"           ##设定参数,注意",'的区别
    set pwd "yangkun"
    set host "48.93.36.144"
    
    set timeout -1              ##;号可有可无
    spawn ssh -p 2020 $user@$host
    expect {                    ##expect后有空格
        "*yes/no" {send "yes\r";exp_continue}
        "*password:" {send "$pwd\r"}
    }
    expect "]*"                 ## 通配符,使用 ]* 有效, 使用  *# 无效
    send "touch /home/hadoop/aa.txt\r"
    expect "]*"
    send "echo hello world >> /home/hadoop/aa.txt\r"
    expect "]*"
    [interact]                  ##人为交互
    send "exit\r"               ##退出
    
    2.配置免密登录并安装JDK
    #!/bin/bash
    #!/usr/bin/expect
    SERVERS="114.114.114.114"       ##数组以空格分隔,可以为目标ip 或者hostName
    PASSWORD="yangkun"
    
    ## 实现免密登录配置的函数
    auto_ssh_copy_id() {
        expect -c "set timeout -1;
            spawn ssh-copy-id \"-p 2020 $1\";       ## 这里要注意,使用'或\'不可行
            expect {
                *(yes/no)* {send -- yes\r;exp_continue;}
                *password:* {send -- $2\r;exp_continue;}
                eof {exit 0;}
            }";
    }
    
    ## 循环执行,配置主机到从节点所有免密
    ssh_copy_id_to_all() {
        for SERVER in $SERVERS              ## 取值需要加$
        do
            auto_ssh_copy_id $SERVER $PASSWORD
        done    
    }
    
    ## 调用循环配置函数
    ssh_copy_id_to_all
    
    
    ## 批量部署
    for SERVER in $SERVERS
    do
        scp install.sh root@$SERVER:/root
        ssh root@$SERVER /root/install.sh
    done
    
    • 读取文件中的host配置
    让脚本自动读取slaves文件中的机器名来批量安装
    cat slaves | while read host
    do
    echo $host
    expect -c "set timeout -f
    spawn ssh-copy-id $host"
    done
    

    3.批量配置JDK,install.sh

    #!/bin/bash
    BASE_SERVER=master
    BASE_PATH=/home/hadoop/soft
    TARGET_PATH=/usr/local
    JAVA_PATH=$TARGET_PATH/java
    ## 1.判断是否存在文件夹,不存在则创建soft文件夹
    #if [ ! -d "$BASE_PATH" ]; then
    #   mkdir "$BASE_PATH"
    #fi
    
    ## 2.从指定host拷贝jdk到目标机器上(已经拷贝文件夹)
    scp -r $BASE_SERVER:$BASE_PATH $BASE_PATH
    
    ## 2.解压jdk到指定目录
    if [ ! -d "$JAVA_PATH" ]; then
        sudo -S mkdir -p "$JAVA_PATH"
    fi
    
    ## 赋予权限
    sudo -S chmod -R hadoop:hadoop $JAVA_PATH
    
    tar -zxvf $BASE_PATH/jdk1.8.0_121.tar.gz -C $JAVA_PATH
    
    #### 3.配置环境变量
    sudo -S cat>>/etc/profile<<EOF
    export JAVA_HOME=$JAVA_PATH/jdk1.8.0_121
    export PATH=\$PATH:\$JAVA_HOME/bin
    EOF
    
    • 自动telnet会话
     #!/usr/bin/expect -f
    set ip [lindex $argv 0 ]         # 接收第1个参数,作为IP
    set userid [lindex $argv 1 ]     # 接收第2个参数,作为userid
    set mypassword [lindex $argv 2 ] # 接收第3个参数,作为密码
    set mycommand [lindex $argv 3 ]  # 接收第4个参数,作为命令
    set timeout 10                   # 设置超时时间
     
    # 向远程服务器请求打开一个telnet会话,并等待服务器询问用户名
    spawn telnet $ip
        expect "username:"
        # 输入用户名,并等待服务器询问密码
        send "$userid\r"
        expect "password:"
        # 输入密码,并等待键入需要运行的命令
        send "$mypassword\r"
        expect "%"
        # 输入预先定好的密码,等待运行结果
        send "$mycommand\r"
        expect "%"
        # 将运行结果存入到变量中,显示出来或者写到磁盘中
        set results $expect_out(buffer)
        # 退出telnet会话,等待服务器的退出提示EOF
        send "exit\r"
        expect eof
    

    4.自动建立FTP会话

       #!/usr/bin/expect -f
    set ip [lindex $argv 0 ]         # 接收第1个参数,作为IP
    set userid [lindex $argv 1 ]     # 接收第2个参数,作为Userid
    set mypassword [lindex $argv 2 ] # 接收第3个参数,作为密码
    set timeout 10                   # 设置超时时间
     
    # 向远程服务器请求打开一个FTP会话,并等待服务器询问用户名
    spawn ftp $ip
        expect "username:"
        # 输入用户名,并等待服务器询问密码
        send "$userid\r"
        expect "password:"
        # 输入密码,并等待FTP提示符的出现
        send "$mypassword\r"
        expect "ftp>"
        # 切换到二进制模式,并等待FTP提示符的出现
        send "bin\r"
        expect "ftp>"
        # 关闭ftp的提示符
        send "prompt\r"
        expect "ftp>"
        # 下载所有文件
        send "mget *\r"
        expect "ftp>"
        # 退出此次ftp会话,并等待服务器的退出提示EOF
        send "bye\r"
        expect eof
    
    • 自动登录ssh执行命令
    #!/usr/bin/expect
    set IP     [lindex $argv 0]
    set USER   [lindex $argv 1]
    set PASSWD [lindex $argv 2]
    set CMD    [lindex $argv 3]
     
    spawn ssh $USER@$IP $CMD
    expect {
        "(yes/no)?" {
            send "yes\r"
            expect "password:"
            send "$PASSWD\r"
            }
        "password:" {send "$PASSWD\r"}
        "* to host" {exit 1}
        }
    expect eof
    

    5.自动登录ssh

    #!/usr/bin/expect -f  
    set ip [lindex $argv 0 ]         # 接收第1个参数,作为IP
    set username [lindex $argv 1 ]   # 接收第2个参数,作为username
    set mypassword [lindex $argv 2 ] # 接收第3个参数,作为密码
    set timeout 10                   # 设置超时时间 
     
    spawn ssh $username@$ip       # 发送ssh请求
    expect {                      # 返回信息匹配 
    "*yes/no" { send "yes\r"; exp_continue}  # 第一次ssh连接会提示yes/no,继续  
    "*password:" { send "$mypassword\r" }    # 出现密码提示,发送密码  
    } 
    interact        # 交互模式,用户会停留在远程服务器上面
    

    6.批量登录ssh服务器执行操作范例,设定增量的for循环

     #!/usr/bin/expect
    for {set i 10} {$i <= 12} {incr i} {
      set timeout 30
      set ssh_user [lindex $argv 0]
      spawn ssh -i .ssh/$ssh_user abc$i.com
    
      expect_before "no)?" {
      send "yes\r" }
      sleep 1
      expect "password*"
      send "hello\r"
      expect "*#"
      send "echo hello expect! > /tmp/expect.txt\r"
      expect "*#"
      send "echo\r"
    }
    exit
    

    7.批量登录ssh并执行命令,foreach语法

    #!/usr/bin/expect
    if {$argc!=2} {
        send_user "usage: ./expect ssh_user password\n"
        exit
    }
    foreach i {11 12} {
        set timeout 30
        set ssh_user [lindex $argv 0]
        set password [lindex $argv 1]
        spawn ssh -i .ssh/$ssh_user root@xxx.yy.com
        expect_before "no)?" {
        send "yes\r" }
        sleep 1
     
        expect "Enter passphrase for key*"
        send "password\r"
        expect "*#"
        send "echo hello expect! > /tmp/expect.txt\r"
        expect "*#"
        send "echo\r"
    }
    exit
    

    8.另一自动ssh范例,从命令行获取服务器IP,foreach语法,expect嵌套

        #!/usr/bin/expect
    # 使用方法: script_name ip1 ip2 ip3 ...
     
    set timeout 20
    if {$argc < 1} {
      puts "Usage: script IPs"
      exit 1
    }
    # 替换你自己的用户名
    set user "username"
    #替换你自己的登录密码
    set password "yourpassword"
     
    foreach IP $argv {
    spawn ssh $user@$IP
     
    expect \
      "(yes/no)?" {
        send "yes\r"
        expect "password:?" {
          send "$password\r"
        }
      } "password:?" {
        send "$password\r"
    }
     
    expect "\$?"
    # 替换你要执行的命令
    send "last\r"
    expect "\$?"
    sleep 10
    send "exit\r"
    expect eof
    }
    

    9.批量ssh执行命令,用shell调用tclsh方式、多进程同时执行

    *   tclsh - Simple shell containing Tcl interpreter
    
     #!/bin/sh
    # -*- tcl -*- \
    exec tclsh $0 "$@"
    package require Expect
    set username [lindex $argv 0]
    set password [lindex $argv 1]
    set argv [lrange $argv 2 end]
    set prompt "(%|#|\\$) $"
    foreach ip $argv {
        spawn ssh -t $username@$ip sh
        lappend ids $spawn_id
    }
    expect_before -i ids eof {
        set index [lsearch $ids $expect_out(spawn_id)]
        set ids [lreplace $ids $index $index]
        if [llength $ids] exp_continue
    }
    expect -i ids "(yes/no)\\?" {
        send -i $expect_out(spawn_id) yes\r
        exp_continue
    } -i ids "Enter passphrase for key" {
        send -i $expect_out(spawn_id) \r
        exp_continue
    } -i ids "assword:" {
        send -i $expect_out(spawn_id) $password\r
        exp_continue
    } -i ids -re $prompt {
        set spawn_id $expect_out(spawn_id)
        send "echo hello; exit\r"
        exp_continue
    } timeout {
        exit 1
    }
    

    10.ssh登录过程常规提示文字

    The authenticity of host '192.168.17.35 (192.168.17.35)' can't be established.
    RSA key fingerprint is 25:e8:4c:89:a3:b2:06:ee:de:66:c7:7e:1b:fa:1c:c5.
    Are you sure you want to continue connecting (yes/no)?
    
    
    Warning: Permanently added '192.168.17.35' (RSA) to the list of known hosts.
    Enter passphrase for key '/data/key/my_dsa':
    
    
    Last login: Sun Jan 26 13:39:37 2014 from 192.168.11.143
    [root@master003 ~]#
    
    
    root@192.168.16.90's password:
    
    
    Last login: Thu Jan 23 17:50:43 2014 from 192.168.11.102
    [root@lvsmaster ~]#
    

    11.ssh自动登录expect脚本:ssh.expect

        #!/usr/bin/expect -f
    # Auther:YuanXing
    # Update:2014-02-08
    if {$argc < 4} {
        send_user "Usage:\n  $argv0 IPaddr User Passwd Port Passphrase\n"
        puts stderr "argv error!\n"
        sleep 1
        exit 1
    }
     
    set ip         [lindex $argv 0 ]
    set user       [lindex $argv 1 ]
    set passwd     [lindex $argv 2 ]
    set port       [lindex $argv 3 ]
    set passphrase [lindex $argv 4 ]
    set timeout 6
    if {$port == ""} {
        set port 22
    }
    #send_user "IP:$ip,User:$user,Passwd:$passwd,Port:$port,Passphrase:$passphrase"
    spawn ssh -p $port $user@$ip
     
    expect_before "(yes/no)\\?" {
        send "yes\r"}
     
    expect \
    "Enter passphrase for key*" {
        send "$passphrase\r"
        exp_continue
    } " password:?" {
        send "$passwd\r"
        exp_continue
    } "*\[#\\\$]" {
        interact
    } "* to host" {
        send_user "Connect faild!"
        exit 2
    } timeout {
        send_user "Connect timeout!"
        exit 2
    } eof {
        send_user "Lost connect!"
        exit
    }
    

    12.Mikrotik backup script using ssh and expect

    #!/bin/bash
    # TAG: mikrotik, ssh, expect, lftp
     
    BACKUP_DIR="/var/backups"
    HOSTNAME="192.168.88.1"
    PORT="22"
    USER="admin"
    PASS="123456"
    TMP=$(mktemp)
    TODAY=$(date +%F)
    FILENAME="$HOSTNAME-$TODAY"
    PATH="/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin"
     
    # create expect script
    cat > $TMP << EOF 
    #exp_internal 1 # Uncomment for debug
    set timeout -1
    spawn ssh -p$PORT $USER@$HOSTNAME
    match_max 100000
    expect -exact "password:"
    send -- "$PASS\r"
    sleep 1
    expect " > "
    send -- "/export file=$FILENAME\r"
    expect " > "
    send -- "/system backup save name=$FILENAME\r"
    expect " > "
    send -- "quit\r"
    expect eof
    EOF
     
    # run expect script
    #cat $TMP # Uncomment for debug
    expect -f $TMP
     
    # remove expect script
    rm $TMP
     
    # download and remove backup files
    # "xfer:clobber on" means overwrite existing files
    cd ${BACKUP_DIR}
    echo "
      set xfer:clobber on
      get ${FILENAME}.rsc
      rm ${FILENAME}.rsc 
      get ${FILENAME}.backup
      rm ${FILENAME}.backup" | 
    lftp -u $USER,$PASS $HOSTNAME
    
    展开全文
  • 实战:expect实现无交互登录 正则表达式 sed awk awk高级应用 cut
  • 通过expect指令,将 ssh-key -t -rsa -b 2048 自动免交互。 平常手动要操作的操作(假设是无密码按回车,按y): $ cat testExpect.sh #!/usr/bin/expect echo "test expect ....." expect -c " spawn ssh-keygen...

    通过expect指令,将 ssh-key -t -rsa -b 2048 自动免交互。
    平常手动要操作的操作(假设是无密码按回车,按y):
    在这里插入图片描述

    $ cat testExpect.sh
    #!/usr/bin/expect
    
    echo "test expect ....."
    expect -c "
            spawn ssh-keygen -t rsa -b 2048
            expect {
                    \"Enter file in\" {send \"\r\"; exp_continue}
                    \"Overwrite\" {send \"y\r\"; exp_continue}
                    \"Enter passphrase\" {send \"\r\";exp_continue}
                    \"passphrase again\" {send \"\r exit\";exp_continue}
    
            }
    "
    
    echo "end ....."
    

    =分割线===

    参考例子:

    # -c:执行脚本前先执行的命令,可多次使用。
        expect -c "
            #使用spawn进行 连接操作
           spawn ssh -p $PORT $USER@$IP
           expect {
              #当碰到 yes/no的时候send发送 yes , \r表示回车键, 否则 exp_continue表继续执行
              \"(yes/no)\" {send \"yes\r\"; exp_continue}
              \"password:\" {send \"$PASS\r\"; exp_continue}
               # 碰到 $USER@*时,这里的*是通配符。  
              \"$USER@*\" {send \"$COMMAND\r exit\r\"; exp_continue}
           }
        "
    

    参考博客:https://blog.csdn.net/zhandar44/article/details/91488287

    展开全文
  • linux expect使用详解

    千次阅读 2020-12-30 12:54:47
    Expect使用来实现这种功能的工具。  Expect是一个免费的 编程工具语言,用来实现自动和交互式任务进行通信,而无需人的干预。Expect的作者Don Libes在1990年 开始编写Expect时对Expect做有如下定义:Expect是一...
  • Linux expect 介绍和用法

    2021-10-18 21:41:11
    expect是一个自动化交互套件,主要应用于执行命令和程序时,系统以交互形式要求输入指定字符串,实现交互通信。
  • linux expect 用法

    2015-01-16 16:02:02
    一、概述 我们通过Shell可以实现简单的控制流功能如循环、判断...而Expect使用来实现这种功能的工具。 Expect是一个免费的编程工具语言用来实现自动和交互式任务进行通信而无需人的干预。Expect的作者Don Libes在1...
  • Linux expect用法介绍

    2020-07-25 14:10:34
    expect是一个自动化交互套件,主要应用于执行命令和程序时,系统以交互形式要求输入指定字符串,实现交互通信。 expect自动交互流程: spawn启动指定进程---expect获取指定关键字---send向指定程序发送指定字符---...
  • linux expect用法之ssh远程自动登录

    千次阅读 2017-01-06 11:22:26
    /usr/bin/expect set timeout 30 spawn ssh root@192.168.12.1 expect "root@192.168.12.1's password:" send "10141018\r" interactexpect是一个用来处理交互的命令。借助Expect,我们可以将交互过程写在一个脚本上...
  • 使用expect实现自动登录的脚本,网上有很多,可是都没有一个明白的说明,初学者一般都是照抄、收藏。可是为什么要这么写却不知其然。本文用一个最短的例子说明脚本的原理。  脚本代码如下:  ###################...
  • expect是一种自动交互语言,能实现在shell脚本中为scp和ssh等自动输入密码自动登录。下面这篇文章主要介绍了linux使用expect方法示例,需要的朋友可以参考借鉴,下面来一起学习学习吧。
  • 使用expect实现自动登录的脚本,网上有很多,可是都没有一个明白的说明,初学者一般都是照抄、收藏。可是为什么要这么写却不知其然。本文用一个最短的例子说明脚本的原理。 脚本代码如下: ######################...
  • Linux expect spawn用法

    万次阅读 2019-07-24 17:33:39
    背景 开发中,经常会有一些任务需要人机交互,比如登录到某台server上...使用expect + 其内部命令 spawn 可以实现类似的自动化需求。 案例1 脚本1:test1.sh 实现功能: 远程登录到server上,并执行指定的操作,如...
  • linux expect、spawn用法

    千次阅读 2018-10-22 22:10:57
    使用expect实现自动登录的脚本 脚本代码如下: #!/usr/bin/expect set timeout 30 spawn ssh username@192.168.1.1 expect "password:" send "ispass\r" interact 1. [#!/usr/bin/expect]...
  • Linuxexpect使用

    千次阅读 2019-07-24 14:26:51
    expect是建立在tcl(参见:Tcl/Tk快速入门 )基础上的一个工具,它可以让一些需要交互的任务自动化地完成。相当于模拟了用户和命令行的交互操作。 **一个具体的场景:**远程登陆服务器,并执行命令 登录时输入密码...
  • 使用expect实现自动登录的脚本,网上有很多,可是都没有一个明白的说明,初学者一般都是照抄、收藏。可是为什么要这么写却不知其然。本文用一个最短的例子说明脚本的原理。 脚本代码如下: 1 #!/usr/bin/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,682
精华内容 5,872
关键字:

linuxexpect用法

linux 订阅