admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 1 | #!/usr/bin/env python |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 2 | """ |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 3 | Created on 24-Oct-2012 |
Jeremy Songster | ae01bba | 2016-07-11 15:39:17 -0700 | [diff] [blame] | 4 | Modified 2016 by ON.Lab |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 5 | |
Jeremy Songster | ae01bba | 2016-07-11 15:39:17 -0700 | [diff] [blame] | 6 | Please refer questions to either the onos test mailing list at <onos-test@onosproject.org>, |
| 7 | the System Testing Plans and Results wiki page at <https://wiki.onosproject.org/x/voMg>, |
| 8 | or the System Testing Guide page at <https://wiki.onosproject.org/x/WYQg> |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 9 | |
| 10 | TestON is free software: you can redistribute it and/or modify |
| 11 | it under the terms of the GNU General Public License as published by |
| 12 | the Free Software Foundation, either version 2 of the License, or |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 13 | ( at your option ) any later version. |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 14 | |
| 15 | TestON is distributed in the hope that it will be useful, |
| 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | GNU General Public License for more details. |
| 19 | |
| 20 | You should have received a copy of the GNU General Public License |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 21 | along with TestON. If not, see <http://www.gnu.org/licenses/>. |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 22 | """ |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 23 | import pexpect |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 24 | import re |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 25 | |
| 26 | from drivers.component import Component |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 27 | |
| 28 | |
| 29 | class CLI( Component ): |
| 30 | |
| 31 | """ |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 32 | This will define common functions for CLI included. |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 33 | """ |
| 34 | def __init__( self ): |
Devin Lim | dc78e20 | 2017-06-09 18:30:07 -0700 | [diff] [blame] | 35 | super( CLI, self ).__init__() |
| 36 | def checkPrompt(self): |
| 37 | for key in self.options: |
| 38 | if key == "prompt" and self.options['prompt'] is not None: |
| 39 | self.prompt = self.options['prompt'] |
| 40 | break |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 41 | |
| 42 | def connect( self, **connectargs ): |
| 43 | """ |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 44 | Connection will establish to the remote host using ssh. |
| 45 | It will take user_name ,ip_address and password as arguments<br> |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 46 | and will return the handle. |
| 47 | """ |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 48 | for key in connectargs: |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 49 | vars( self )[ key ] = connectargs[ key ] |
Devin Lim | dc78e20 | 2017-06-09 18:30:07 -0700 | [diff] [blame] | 50 | self.checkPrompt() |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 51 | |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 52 | connect_result = super( CLI, self ).connect() |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 53 | ssh_newkey = 'Are you sure you want to continue connecting' |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 54 | refused = "ssh: connect to host " + \ |
| 55 | self.ip_address + " port 22: Connection refused" |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 56 | if self.port: |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 57 | self.handle = pexpect.spawn( |
| 58 | 'ssh -p ' + |
| 59 | self.port + |
| 60 | ' ' + |
| 61 | self.user_name + |
| 62 | '@' + |
| 63 | self.ip_address, |
Jon Hall | 9aaba88 | 2015-01-19 15:05:15 -0800 | [diff] [blame] | 64 | env={ "TERM": "xterm-mono" }, |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 65 | maxread=50000 ) |
| 66 | else: |
| 67 | self.handle = pexpect.spawn( |
| 68 | 'ssh -X ' + |
| 69 | self.user_name + |
| 70 | '@' + |
| 71 | self.ip_address, |
Jon Hall | 9aaba88 | 2015-01-19 15:05:15 -0800 | [diff] [blame] | 72 | env={ "TERM": "xterm-mono" }, |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 73 | maxread=1000000, |
| 74 | timeout=60 ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 75 | |
Jon Hall | 73057ee | 2016-08-23 09:57:26 -0700 | [diff] [blame] | 76 | # set tty window size |
| 77 | self.handle.setwinsize( 24, 250 ) |
| 78 | |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 79 | self.handle.logfile = self.logfile_handler |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 80 | i = 5 |
| 81 | while i == 5: |
| 82 | i = self.handle.expect( [ |
acsmars | e2be32c | 2015-06-29 16:16:28 -0700 | [diff] [blame] | 83 | ssh_newkey, |
Jon Hall | 05f8868 | 2015-06-09 14:57:53 -0700 | [diff] [blame] | 84 | 'password:|Password:', |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 85 | pexpect.EOF, |
| 86 | pexpect.TIMEOUT, |
| 87 | refused, |
| 88 | 'teston>', |
Devin Lim | dc78e20 | 2017-06-09 18:30:07 -0700 | [diff] [blame] | 89 | self.prompt ], |
acsmars | 07f9d39 | 2015-07-15 10:30:58 -0700 | [diff] [blame] | 90 | 120 ) |
acsmars | 32de0bc | 2015-06-30 09:57:12 -0700 | [diff] [blame] | 91 | if i == 0: # Accept key, then expect either a password prompt or access |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 92 | main.log.info( "ssh key confirmation received, send yes" ) |
| 93 | self.handle.sendline( 'yes' ) |
acsmars | 32de0bc | 2015-06-30 09:57:12 -0700 | [diff] [blame] | 94 | i = 5 # Run the loop again |
acsmars | 07f9d39 | 2015-07-15 10:30:58 -0700 | [diff] [blame] | 95 | continue |
| 96 | if i == 1: # Password required |
Jon Hall | 6360493 | 2015-02-26 17:09:50 -0800 | [diff] [blame] | 97 | if self.pwd: |
| 98 | main.log.info( |
acsmars | 07f9d39 | 2015-07-15 10:30:58 -0700 | [diff] [blame] | 99 | "ssh connection asked for password, gave password" ) |
Jon Hall | 6360493 | 2015-02-26 17:09:50 -0800 | [diff] [blame] | 100 | else: |
acsmars | 07f9d39 | 2015-07-15 10:30:58 -0700 | [diff] [blame] | 101 | main.log.info( "Server asked for password, but none was " |
| 102 | "given in the .topo file. Trying " |
| 103 | "no password.") |
| 104 | self.pwd = "" |
| 105 | self.handle.sendline( self.pwd ) |
| 106 | j = self.handle.expect( [ |
Devin Lim | dc78e20 | 2017-06-09 18:30:07 -0700 | [diff] [blame] | 107 | self.prompt, |
acsmars | 07f9d39 | 2015-07-15 10:30:58 -0700 | [diff] [blame] | 108 | 'password:|Password:', |
| 109 | pexpect.EOF, |
| 110 | pexpect.TIMEOUT ], |
| 111 | 120 ) |
| 112 | if j != 0: |
| 113 | main.log.error( "Incorrect Password" ) |
| 114 | return main.FALSE |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 115 | elif i == 2: |
| 116 | main.log.error( "Connection timeout" ) |
| 117 | return main.FALSE |
| 118 | elif i == 3: # timeout |
| 119 | main.log.error( |
| 120 | "No route to the Host " + |
| 121 | self.user_name + |
| 122 | "@" + |
| 123 | self.ip_address ) |
| 124 | return main.FALSE |
| 125 | elif i == 4: |
| 126 | main.log.error( |
| 127 | "ssh: connect to host " + |
| 128 | self.ip_address + |
| 129 | " port 22: Connection refused" ) |
| 130 | return main.FALSE |
| 131 | elif i == 6: |
| 132 | main.log.info( "Password not required logged in" ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 133 | |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 134 | self.handle.sendline( "" ) |
Devin Lim | dc78e20 | 2017-06-09 18:30:07 -0700 | [diff] [blame] | 135 | self.handle.expect( self.prompt ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 136 | return self.handle |
| 137 | |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 138 | def disconnect( self ): |
| 139 | result = super( CLI, self ).disconnect( self ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 140 | result = main.TRUE |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 141 | # self.execute( cmd="exit",timeout=120,prompt="(.*)" ) |
| 142 | |
| 143 | def execute( self, **execparams ): |
| 144 | """ |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 145 | It facilitates the command line execution of a given command. It has arguments as : |
| 146 | cmd => represents command to be executed, |
| 147 | prompt => represents expect command prompt or output, |
| 148 | timeout => timeout for command execution, |
| 149 | more => to provide a key press if it is on. |
| 150 | |
| 151 | It will return output of command exection. |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 152 | """ |
| 153 | result = super( CLI, self ).execute( self ) |
admin | aef0055 | 2014-05-08 09:18:36 -0700 | [diff] [blame] | 154 | defaultPrompt = '.*[$>\#]' |
Jon Hall | 3b489db | 2015-10-05 14:38:37 -0700 | [diff] [blame] | 155 | args = utilities.parse_args( [ "CMD", |
| 156 | "TIMEOUT", |
| 157 | "PROMPT", |
| 158 | "MORE" ], |
| 159 | **execparams ) |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 160 | |
| 161 | expectPrompt = args[ "PROMPT" ] if args[ "PROMPT" ] else defaultPrompt |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 162 | self.LASTRSP = "" |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 163 | timeoutVar = args[ "TIMEOUT" ] if args[ "TIMEOUT" ] else 10 |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 164 | cmd = '' |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 165 | if args[ "CMD" ]: |
| 166 | cmd = args[ "CMD" ] |
| 167 | else: |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 168 | return 0 |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 169 | if args[ "MORE" ] is None: |
| 170 | args[ "MORE" ] = " " |
| 171 | self.handle.sendline( cmd ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 172 | self.lastCommand = cmd |
Jon Hall | 3b489db | 2015-10-05 14:38:37 -0700 | [diff] [blame] | 173 | index = self.handle.expect( [ expectPrompt, |
| 174 | "--More--", |
| 175 | 'Command not found.', |
| 176 | pexpect.TIMEOUT, |
| 177 | "^:$" ], |
| 178 | timeout=timeoutVar ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 179 | if index == 0: |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 180 | self.LASTRSP = self.LASTRSP + \ |
| 181 | self.handle.before + self.handle.after |
Jon Hall | 3b489db | 2015-10-05 14:38:37 -0700 | [diff] [blame] | 182 | main.log.info( "Executed :" + str(cmd ) + |
| 183 | " \t\t Expected Prompt '" + str( expectPrompt) + |
| 184 | "' Found" ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 185 | elif index == 1: |
| 186 | self.LASTRSP = self.LASTRSP + self.handle.before |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 187 | self.handle.send( args[ "MORE" ] ) |
| 188 | main.log.info( |
| 189 | "Found More screen to go , Sending a key to proceed" ) |
| 190 | indexMore = self.handle.expect( |
| 191 | [ "--More--", expectPrompt ], timeout=timeoutVar ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 192 | while indexMore == 0: |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 193 | main.log.info( |
| 194 | "Found anoother More screen to go , Sending a key to proceed" ) |
| 195 | self.handle.send( args[ "MORE" ] ) |
| 196 | indexMore = self.handle.expect( |
| 197 | [ "--More--", expectPrompt ], timeout=timeoutVar ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 198 | self.LASTRSP = self.LASTRSP + self.handle.before |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 199 | elif index == 2: |
| 200 | main.log.error( "Command not found" ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 201 | self.LASTRSP = self.LASTRSP + self.handle.before |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 202 | elif index == 3: |
Jon Hall | 3b489db | 2015-10-05 14:38:37 -0700 | [diff] [blame] | 203 | main.log.error( "Expected Prompt not found, Time Out!!" ) |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 204 | main.log.error( expectPrompt ) |
Jon Hall | 3b489db | 2015-10-05 14:38:37 -0700 | [diff] [blame] | 205 | self.LASTRSP = self.LASTRSP + self.handle.before |
| 206 | return self.LASTRSP |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 207 | elif index == 4: |
| 208 | self.LASTRSP = self.LASTRSP + self.handle.before |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 209 | # self.handle.send( args[ "MORE" ] ) |
| 210 | self.handle.sendcontrol( "D" ) |
| 211 | main.log.info( |
Jon Hall | 3b489db | 2015-10-05 14:38:37 -0700 | [diff] [blame] | 212 | "Found More screen to go, Sending a key to proceed" ) |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 213 | indexMore = self.handle.expect( |
| 214 | [ "^:$", expectPrompt ], timeout=timeoutVar ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 215 | while indexMore == 0: |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 216 | main.log.info( |
Jon Hall | 3b489db | 2015-10-05 14:38:37 -0700 | [diff] [blame] | 217 | "Found another More screen to go, Sending a key to proceed" ) |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 218 | self.handle.sendcontrol( "D" ) |
| 219 | indexMore = self.handle.expect( |
| 220 | [ "^:$", expectPrompt ], timeout=timeoutVar ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 221 | self.LASTRSP = self.LASTRSP + self.handle.before |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 222 | main.last_response = self.remove_contol_chars( self.LASTRSP ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 223 | return self.LASTRSP |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 224 | |
| 225 | def remove_contol_chars( self, response ): |
| 226 | # RE_XML_ILLEGAL = '([\u0000-\u0008\u000b-\u000c\u000e-\u001f\ufffe-\uffff])|([%s-%s][^%s-%s])|([^%s-%s][%s-%s])|([%s-%s]$)|(^[%s-%s])'%( unichr( 0xd800 ),unichr( 0xdbff ),unichr( 0xdc00 ),unichr( 0xdfff ),unichr( 0xd800 ),unichr( 0xdbff ),unichr( 0xdc00 ),unichr( 0xdfff ),unichr( 0xd800 ),unichr( 0xdbff ),unichr( 0xdc00 ),unichr( 0xdfff ) ) |
| 227 | # response = re.sub( RE_XML_ILLEGAL, "\n", response ) |
| 228 | response = re.sub( r"[\x01-\x1F\x7F]", "", response ) |
| 229 | # response = re.sub( r"\[\d+\;1H", "\n", response ) |
| 230 | response = re.sub( r"\[\d+\;\d+H", "", response ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 231 | return response |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 232 | |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 233 | def runAsSudoUser( self, handle, pwd, default ): |
| 234 | |
| 235 | i = handle.expect( [ ".ssword:*", default, pexpect.EOF ] ) |
| 236 | if i == 0: |
| 237 | handle.sendline( pwd ) |
Jon Hall | 5ec6b1b | 2015-09-17 18:20:14 -0700 | [diff] [blame] | 238 | handle.sendline( "\n" ) |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 239 | |
| 240 | if i == 1: |
| 241 | handle.expect( default ) |
| 242 | |
| 243 | if i == 2: |
| 244 | main.log.error( "Unable to run as Sudo user" ) |
| 245 | |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 246 | return handle |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 247 | |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 248 | def onfail( self ): |
| 249 | if 'onfail' in main.componentDictionary[ self.name ]: |
| 250 | commandList = main.componentDictionary[ |
| 251 | self.name ][ 'onfail' ].split( "," ) |
| 252 | for command in commandList: |
| 253 | response = self.execute( |
| 254 | cmd=command, |
| 255 | prompt="(.*)", |
| 256 | timeout=120 ) |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 257 | |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 258 | def secureCopy( self, userName, ipAddress, filePath, dstPath, pwd="", |
| 259 | direction="from" ): |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 260 | """ |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 261 | Definition: |
| 262 | Execute scp command in linux to copy to/from a remote host |
| 263 | Required: |
| 264 | str userName - User name of the remote host |
| 265 | str ipAddress - IP address of the remote host |
| 266 | str filePath - File path including the file it self |
| 267 | str dstPath - Destination path |
| 268 | Optional: |
| 269 | str pwd - Password of the host |
| 270 | str direction - Direction of the scp, default to "from" which means |
| 271 | copy "from" the remote machine to local machine, |
| 272 | while "to" means copy "to" the remote machine from |
| 273 | local machine |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 274 | """ |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 275 | returnVal = main.TRUE |
admin | bae64d8 | 2013-08-01 10:50:15 -0700 | [diff] [blame] | 276 | ssh_newkey = 'Are you sure you want to continue connecting' |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 277 | refused = "ssh: connect to host " + \ |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 278 | ipAddress + " port 22: Connection refused" |
acsmars | 07f9d39 | 2015-07-15 10:30:58 -0700 | [diff] [blame] | 279 | |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 280 | if direction == "from": |
| 281 | cmd = 'scp ' + str( userName ) + '@' + str( ipAddress ) + ':' + \ |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 282 | str( filePath ) + ' ' + str( dstPath ) |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 283 | elif direction == "to": |
| 284 | cmd = 'scp ' + str( filePath ) + ' ' + str( userName ) + \ |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 285 | '@' + str( ipAddress ) + ':' + str( dstPath ) |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 286 | else: |
| 287 | main.log.debug( "Wrong direction using secure copy command!" ) |
| 288 | return main.FALSE |
kelvin | 8ec7144 | 2015-01-15 16:57:00 -0800 | [diff] [blame] | 289 | |
| 290 | main.log.info( "Sending: " + cmd ) |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 291 | self.handle.sendline( cmd ) |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 292 | i = 0 |
| 293 | while i < 2: |
| 294 | i = self.handle.expect( [ |
| 295 | ssh_newkey, |
| 296 | 'password:', |
| 297 | "100%", |
| 298 | refused, |
| 299 | "No such file or directory", |
Jon Hall | 53c5e66 | 2016-04-13 16:06:56 -0700 | [diff] [blame] | 300 | "Permission denied", |
Devin Lim | dc78e20 | 2017-06-09 18:30:07 -0700 | [diff] [blame] | 301 | self.prompt, |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 302 | pexpect.EOF, |
| 303 | pexpect.TIMEOUT ], |
| 304 | 120 ) |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 305 | if i == 0: # ask for ssh key confirmation |
| 306 | main.log.info( "ssh key confirmation received, sending yes" ) |
| 307 | self.handle.sendline( 'yes' ) |
| 308 | elif i == 1: # Asked for ssh password |
| 309 | main.log.info( "ssh connection asked for password, gave password" ) |
| 310 | self.handle.sendline( pwd ) |
| 311 | elif i == 2: # File finished transfering |
| 312 | main.log.info( "Secure copy successful" ) |
| 313 | returnVal = main.TRUE |
| 314 | elif i == 3: # Connection refused |
| 315 | main.log.error( |
| 316 | "ssh: connect to host " + |
| 317 | ipAddress + |
| 318 | " port 22: Connection refused" ) |
| 319 | returnVal = main.FALSE |
| 320 | elif i == 4: # File Not found |
| 321 | main.log.error( "No such file found" ) |
| 322 | returnVal = main.FALSE |
Jon Hall | 53c5e66 | 2016-04-13 16:06:56 -0700 | [diff] [blame] | 323 | elif i == 5: # Permission denied |
| 324 | main.log.error( "Permission denied. Check folder permissions" ) |
| 325 | returnVal = main.FALSE |
| 326 | elif i == 6: # prompt returned |
| 327 | return returnVal |
| 328 | elif i == 7: # EOF |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 329 | main.log.error( "Pexpect.EOF found!!!" ) |
| 330 | main.cleanup() |
| 331 | main.exit() |
Jon Hall | 53c5e66 | 2016-04-13 16:06:56 -0700 | [diff] [blame] | 332 | elif i == 8: # timeout |
Jon Hall | 547e058 | 2015-09-21 17:35:40 -0700 | [diff] [blame] | 333 | main.log.error( |
| 334 | "No route to the Host " + |
| 335 | userName + |
| 336 | "@" + |
| 337 | ipAddress ) |
| 338 | returnVal = main.FALSE |
Devin Lim | dc78e20 | 2017-06-09 18:30:07 -0700 | [diff] [blame] | 339 | self.handle.expect( self.prompt ) |
kelvin-onlab | d9e23de | 2015-08-06 10:34:44 -0700 | [diff] [blame] | 340 | return returnVal |
| 341 | |
| 342 | def scp( self, remoteHost, filePath, dstPath, direction="from" ): |
| 343 | """ |
| 344 | Definition: |
| 345 | Execute scp command in linux to copy to/from a remote host |
| 346 | Required: |
| 347 | * remoteHost - Test ON component to be parsed |
| 348 | str filePath - File path including the file it self |
| 349 | str dstPath - Destination path |
| 350 | Optional: |
| 351 | str direction - Direction of the scp, default to "from" which means |
| 352 | copy "from" the remote machine to local machine, |
| 353 | while "to" means copy "to" the remote machine from |
| 354 | local machine |
| 355 | """ |
| 356 | return self.secureCopy( remoteHost.user_name, |
| 357 | remoteHost.ip_address, |
| 358 | filePath, |
| 359 | dstPath, |
| 360 | pwd=remoteHost.pwd, |
| 361 | direction=direction ) |