1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
# Copyright (C) 2013 Intel Corporation
#
# Released under the MIT license (see COPYING.MIT)
# Provides a class for setting up ssh connections,
# running commands and copying files to/from a target.
# It's used by testimage.bbclass and tests in lib/oeqa/runtime.
import subprocess
import time
import os
import select
class SSHControl(object):
def __init__(self, host=None, timeout=300, logfile=None):
self.host = host
self.timeout = timeout
self._starttime = None
self._out = ''
self._ret = 126
self.logfile = logfile
self.ssh_options = [
'-o', 'UserKnownHostsFile=/dev/null',
'-o', 'StrictHostKeyChecking=no',
'-o', 'LogLevel=ERROR'
]
self.ssh = ['ssh', '-l', 'root'] + self.ssh_options
def log(self, msg):
if self.logfile:
with open(self.logfile, "a") as f:
f.write("%s\n" % msg)
def _internal_run(self, cmd):
# We need this for a proper PATH
cmd = ". /etc/profile; " + cmd
command = self.ssh + [self.host, cmd]
self.log("[Running]$ %s" % " ".join(command))
self._starttime = time.time()
# ssh hangs without os.setsid
proc = subprocess.Popen(command, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
return proc
def run(self, cmd, timeout=None):
"""Run cmd and get it's return code and output.
Let it run for timeout seconds and then terminate/kill it,
if time is 0 will let cmd run until it finishes.
Time can be passed to here or can be set per class instance."""
if self.host:
sshconn = self._internal_run(cmd)
else:
raise Exception("Remote IP/host hasn't been set, I can't run ssh without one.")
# run the command forever
if timeout == 0:
output = sshconn.communicate()[0]
else:
# use the default timeout
if timeout is None:
tdelta = self.timeout
# use the specified timeout
else:
tdelta = timeout
endtime = self._starttime + tdelta
output = ''
eof = False
while time.time() < endtime and not eof:
if select.select([sshconn.stdout], [], [], 5)[0] != []:
data = os.read(sshconn.stdout.fileno(), 1024)
if not data:
sshconn.stdout.close()
eof = True
else:
output += data
endtime = time.time() + tdelta
# process hasn't returned yet
if sshconn.poll() is None:
sshconn.terminate()
time.sleep(3)
try:
sshconn.kill()
except OSError:
pass
output += "\n[!!! SSH command killed - no output for %d seconds. Total running time: %d seconds." % (tdelta, time.time() - self._starttime)
self._ret = sshconn.poll()
# strip the last LF so we can test the output
self._out = output.rstrip()
self.log("%s" % self._out)
self.log("[SSH command returned after %d seconds]: %s" % (time.time() - self._starttime, self._ret))
return (self._ret, self._out)
def _internal_scp(self, cmd):
cmd = ['scp'] + self.ssh_options + cmd
self.log("[Running SCP]$ %s" % " ".join(cmd))
self._starttime = time.time()
scpconn = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=os.setsid)
out = scpconn.communicate()[0]
ret = scpconn.poll()
self.log("%s" % out)
self.log("[SCP command returned after %d seconds]: %s" % (time.time() - self._starttime, ret))
if ret != 0:
# we raise an exception so that tests fail in setUp and setUpClass without a need for an assert
raise Exception("Error running %s, output: %s" % ( " ".join(cmd), out))
return (ret, out)
def copy_to(self, localpath, remotepath):
actualcmd = [localpath, 'root@%s:%s' % (self.host, remotepath)]
return self._internal_scp(actualcmd)
def copy_from(self, remotepath, localpath):
actualcmd = ['root@%s:%s' % (self.host, remotepath), localpath]
return self._internal_scp(actualcmd)
def get_status(self):
return self._ret
def get_output(self):
return self._out
|
