1
2 """
3 Created on 24-Oct-2012
4
5 author:s: Anil Kumar ( anilkumar.s@paxterrasolutions.com ),
6 Raghav Kashyap( raghavkashyap@paxterrasolutions.com )
7
8
9 TestON is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 2 of the License, or
12 ( at your option ) any later version.
13
14 TestON is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with TestON. If not, see <http://www.gnu.org/licenses/>.
21
22
23
24 """
25 import pexpect
26 import re
27
28 from drivers.component import Component
29
30
31 -class CLI( Component ):
32
33 """
34 This will define common functions for CLI included.
35 """
38
39 - def connect( self, **connectargs ):
40 """
41 Connection will establish to the remote host using ssh.
42 It will take user_name ,ip_address and password as arguments<br>
43 and will return the handle.
44 """
45 for key in connectargs:
46 vars( self )[ key ] = connectargs[ key ]
47
48 connect_result = super( CLI, self ).connect()
49 ssh_newkey = 'Are you sure you want to continue connecting'
50 refused = "ssh: connect to host " + \
51 self.ip_address + " port 22: Connection refused"
52 if self.port:
53 self.handle = pexpect.spawn(
54 'ssh -p ' +
55 self.port +
56 ' ' +
57 self.user_name +
58 '@' +
59 self.ip_address,
60 env={ "TERM": "xterm-mono" },
61 maxread=50000 )
62 else:
63 self.handle = pexpect.spawn(
64 'ssh -X ' +
65 self.user_name +
66 '@' +
67 self.ip_address,
68 env={ "TERM": "xterm-mono" },
69 maxread=1000000,
70 timeout=60 )
71
72 self.handle.logfile = self.logfile_handler
73 i = 5
74 while i == 5:
75 i = self.handle.expect( [
76 ssh_newkey,
77 'password:|Password:',
78 pexpect.EOF,
79 pexpect.TIMEOUT,
80 refused,
81 'teston>',
82 '>|#|\$' ],
83 120 )
84 if i == 0:
85 main.log.info( "ssh key confirmation received, send yes" )
86 self.handle.sendline( 'yes' )
87 i = 5
88 continue
89 if i == 1:
90 if self.pwd:
91 main.log.info(
92 "ssh connection asked for password, gave password" )
93 else:
94 main.log.info( "Server asked for password, but none was "
95 "given in the .topo file. Trying "
96 "no password.")
97 self.pwd = ""
98 self.handle.sendline( self.pwd )
99 j = self.handle.expect( [
100 '>|#|\$',
101 'password:|Password:',
102 pexpect.EOF,
103 pexpect.TIMEOUT ],
104 120 )
105 if j != 0:
106 main.log.error( "Incorrect Password" )
107 return main.FALSE
108 elif i == 2:
109 main.log.error( "Connection timeout" )
110 return main.FALSE
111 elif i == 3:
112 main.log.error(
113 "No route to the Host " +
114 self.user_name +
115 "@" +
116 self.ip_address )
117 return main.FALSE
118 elif i == 4:
119 main.log.error(
120 "ssh: connect to host " +
121 self.ip_address +
122 " port 22: Connection refused" )
123 return main.FALSE
124 elif i == 6:
125 main.log.info( "Password not required logged in" )
126
127 self.handle.sendline( "" )
128 self.handle.expect( '>|#|\$' )
129 return self.handle
130
132 result = super( CLI, self ).disconnect( self )
133 result = main.TRUE
134
135
136 - def execute( self, **execparams ):
137 """
138 It facilitates the command line execution of a given command. It has arguments as :
139 cmd => represents command to be executed,
140 prompt => represents expect command prompt or output,
141 timeout => timeout for command execution,
142 more => to provide a key press if it is on.
143
144 It will return output of command exection.
145 """
146 result = super( CLI, self ).execute( self )
147 defaultPrompt = '.*[$>\#]'
148 args = utilities.parse_args( [
149 "CMD",
150 "TIMEOUT",
151 "PROMPT",
152 "MORE" ],
153 **execparams )
154
155 expectPrompt = args[ "PROMPT" ] if args[ "PROMPT" ] else defaultPrompt
156 self.LASTRSP = ""
157 timeoutVar = args[ "TIMEOUT" ] if args[ "TIMEOUT" ] else 10
158 cmd = ''
159 if args[ "CMD" ]:
160 cmd = args[ "CMD" ]
161 else:
162 return 0
163 if args[ "MORE" ] is None:
164 args[ "MORE" ] = " "
165 self.handle.sendline( cmd )
166 self.lastCommand = cmd
167 index = self.handle.expect( [
168 expectPrompt,
169 "--More--",
170 'Command not found.',
171 pexpect.TIMEOUT,
172 "^:$" ],
173 timeout=timeoutVar )
174 if index == 0:
175 self.LASTRSP = self.LASTRSP + \
176 self.handle.before + self.handle.after
177 main.log.info(
178 "Executed :" + str(
179 cmd ) + " \t\t Expected Prompt '" + str(
180 expectPrompt) + "' Found" )
181 elif index == 1:
182 self.LASTRSP = self.LASTRSP + self.handle.before
183 self.handle.send( args[ "MORE" ] )
184 main.log.info(
185 "Found More screen to go , Sending a key to proceed" )
186 indexMore = self.handle.expect(
187 [ "--More--", expectPrompt ], timeout=timeoutVar )
188 while indexMore == 0:
189 main.log.info(
190 "Found anoother More screen to go , Sending a key to proceed" )
191 self.handle.send( args[ "MORE" ] )
192 indexMore = self.handle.expect(
193 [ "--More--", expectPrompt ], timeout=timeoutVar )
194 self.LASTRSP = self.LASTRSP + self.handle.before
195 elif index == 2:
196 main.log.error( "Command not found" )
197 self.LASTRSP = self.LASTRSP + self.handle.before
198 elif index == 3:
199 main.log.error( "Expected Prompt not found , Time Out!!" )
200 main.log.error( expectPrompt )
201 return "Expected Prompt not found , Time Out!!"
202
203 elif index == 4:
204 self.LASTRSP = self.LASTRSP + self.handle.before
205
206 self.handle.sendcontrol( "D" )
207 main.log.info(
208 "Found More screen to go , Sending a key to proceed" )
209 indexMore = self.handle.expect(
210 [ "^:$", expectPrompt ], timeout=timeoutVar )
211 while indexMore == 0:
212 main.log.info(
213 "Found another More screen to go , Sending a key to proceed" )
214 self.handle.sendcontrol( "D" )
215 indexMore = self.handle.expect(
216 [ "^:$", expectPrompt ], timeout=timeoutVar )
217 self.LASTRSP = self.LASTRSP + self.handle.before
218
219 main.last_response = self.remove_contol_chars( self.LASTRSP )
220 return self.LASTRSP
221
223
224
225 response = re.sub( r"[\x01-\x1F\x7F]", "", response )
226
227 response = re.sub( r"\[\d+\;\d+H", "", response )
228 return response
229
231
232 i = handle.expect( [ ".ssword:*", default, pexpect.EOF ] )
233 if i == 0:
234 handle.sendline( pwd )
235 handle.sendline( "\r" )
236
237 if i == 1:
238 handle.expect( default )
239
240 if i == 2:
241 main.log.error( "Unable to run as Sudo user" )
242
243 return handle
244
246 if 'onfail' in main.componentDictionary[ self.name ]:
247 commandList = main.componentDictionary[
248 self.name ][ 'onfail' ].split( "," )
249 for command in commandList:
250 response = self.execute(
251 cmd=command,
252 prompt="(.*)",
253 timeout=120 )
254
255 - def secureCopy( self, user_name, ip_address, filepath, pwd, dst_path ):
256
257
258
259 """
260 Connection will establish to the remote host using ssh.
261 It will take user_name ,ip_address and password as arguments<br>
262 and will return the handle.
263 """
264 ssh_newkey = 'Are you sure you want to continue connecting'
265 refused = "ssh: connect to host " + \
266 ip_address + " port 22: Connection refused"
267
268 cmd = 'scp ' + str( user_name ) + '@' + str( ip_address ) + ':' + \
269 str( filepath ) + ' ' + str(dst_path )
270
271 main.log.info( "Sending: " + cmd )
272 self.handle = pexpect.spawn( cmd )
273 i = self.handle.expect( [
274 ssh_newkey,
275 'password:',
276 pexpect.EOF,
277 pexpect.TIMEOUT,
278 refused ],
279 120 )
280
281 if i == 0:
282 main.log.info( "ssh key confirmation received, send yes" )
283 self.handle.sendline( 'yes' )
284 i = self.handle.expect( [ ssh_newkey, 'password:', pexpect.EOF ] )
285 if i == 1:
286 main.log.info( "ssh connection asked for password, gave password" )
287 self.handle.sendline( pwd )
288
289
290 elif i == 2:
291 main.log.error( "Connection timeout" )
292 pass
293 elif i == 3:
294 main.log.error(
295 "No route to the Host " +
296 user_name +
297 "@" +
298 ip_address )
299 return main.FALSE
300 elif i == 4:
301 main.log.error(
302 "ssh: connect to host " +
303 ip_address +
304 " port 22: Connection refused" )
305 return main.FALSE
306
307 self.handle.sendline( "" )
308 self.handle.expect( "$" )
309 print self.handle.before
310
311 return self.handle
312