mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 21:09:03 +02:00
ffae400179
This adds SPDX license headers in place of the wide assortment of things currently in our script headers. We default to GPL-2.0-only except for the oeqa code where it was clearly submitted and marked as MIT on the most part or some scripts which had the "or later" GPL versioning. The patch also drops other obsolete bits of file headers where they were encoountered such as editor modelines, obsolete maintainer information or the phrase "All rights reserved" which is now obsolete and not required in copyright headers (in this case its actually confusing for licensing as all rights were not reserved). More work is needed for OE-Core but this takes care of the bulk of the scripts and meta/lib directories. The top level LICENSE files are tweaked to match the new structure and the SPDX naming. (From OE-Core rev: f8c9c511b5f1b7dbd45b77f345cb6c048ae6763e) Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
244 lines
8.5 KiB
Python
244 lines
8.5 KiB
Python
#
|
|
# Copyright (C) 2013 Intel Corporation
|
|
#
|
|
# SPDX-License-Identifier: 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 SSHProcess(object):
|
|
def __init__(self, **options):
|
|
|
|
self.defaultopts = {
|
|
"stdout": subprocess.PIPE,
|
|
"stderr": subprocess.STDOUT,
|
|
"stdin": None,
|
|
"shell": False,
|
|
"bufsize": -1,
|
|
"preexec_fn": os.setsid,
|
|
}
|
|
self.options = dict(self.defaultopts)
|
|
self.options.update(options)
|
|
self.status = None
|
|
self.output = None
|
|
self.process = None
|
|
self.starttime = None
|
|
self.logfile = None
|
|
|
|
# Unset DISPLAY which means we won't trigger SSH_ASKPASS
|
|
env = os.environ.copy()
|
|
if "DISPLAY" in env:
|
|
del env['DISPLAY']
|
|
self.options['env'] = env
|
|
|
|
def log(self, msg):
|
|
if self.logfile:
|
|
with open(self.logfile, "a") as f:
|
|
f.write("%s" % msg)
|
|
|
|
def _run(self, command, timeout=None, logfile=None):
|
|
self.logfile = logfile
|
|
self.starttime = time.time()
|
|
output = ''
|
|
self.process = subprocess.Popen(command, **self.options)
|
|
if timeout:
|
|
endtime = self.starttime + timeout
|
|
eof = False
|
|
while time.time() < endtime and not eof:
|
|
try:
|
|
if select.select([self.process.stdout], [], [], 5)[0] != []:
|
|
data = os.read(self.process.stdout.fileno(), 1024)
|
|
if not data:
|
|
self.process.stdout.close()
|
|
eof = True
|
|
else:
|
|
data = data.decode("utf-8")
|
|
output += data
|
|
self.log(data)
|
|
endtime = time.time() + timeout
|
|
except InterruptedError:
|
|
continue
|
|
|
|
# process hasn't returned yet
|
|
if not eof:
|
|
self.process.terminate()
|
|
time.sleep(5)
|
|
try:
|
|
self.process.kill()
|
|
except OSError:
|
|
pass
|
|
lastline = "\nProcess killed - no output for %d seconds. Total running time: %d seconds." % (timeout, time.time() - self.starttime)
|
|
self.log(lastline)
|
|
output += lastline
|
|
else:
|
|
output = self.process.communicate()[0]
|
|
self.log(output.rstrip())
|
|
|
|
self.status = self.process.wait()
|
|
self.output = output.rstrip()
|
|
|
|
def run(self, command, timeout=None, logfile=None):
|
|
try:
|
|
self._run(command, timeout, logfile)
|
|
except:
|
|
# Need to guard against a SystemExit or other exception occuring whilst running
|
|
# and ensure we don't leave a process behind.
|
|
if self.process.poll() is None:
|
|
self.process.kill()
|
|
self.status = self.process.wait()
|
|
raise
|
|
return (self.status, self.output)
|
|
|
|
class SSHControl(object):
|
|
def __init__(self, ip, logfile=None, timeout=300, user='root', port=None):
|
|
self.ip = ip
|
|
self.defaulttimeout = timeout
|
|
self.ignore_status = True
|
|
self.logfile = logfile
|
|
self.user = user
|
|
self.ssh_options = [
|
|
'-o', 'UserKnownHostsFile=/dev/null',
|
|
'-o', 'StrictHostKeyChecking=no',
|
|
'-o', 'LogLevel=ERROR'
|
|
]
|
|
self.ssh = ['ssh', '-l', self.user ] + self.ssh_options
|
|
self.scp = ['scp'] + self.ssh_options
|
|
if port:
|
|
self.ssh = self.ssh + [ '-p', port ]
|
|
self.scp = self.scp + [ '-P', port ]
|
|
|
|
def log(self, msg):
|
|
if self.logfile:
|
|
with open(self.logfile, "a") as f:
|
|
f.write("%s\n" % msg)
|
|
|
|
def _internal_run(self, command, timeout=None, ignore_status = True):
|
|
self.log("[Running]$ %s" % " ".join(command))
|
|
|
|
proc = SSHProcess()
|
|
status, output = proc.run(command, timeout, logfile=self.logfile)
|
|
|
|
self.log("[Command returned '%d' after %.2f seconds]" % (status, time.time() - proc.starttime))
|
|
|
|
if status and not ignore_status:
|
|
raise AssertionError("Command '%s' returned non-zero exit status %d:\n%s" % (command, status, output))
|
|
|
|
return (status, output)
|
|
|
|
def run(self, command, timeout=None):
|
|
"""
|
|
command - ssh command to run
|
|
timeout=<val> - kill command if there is no output after <val> seconds
|
|
timeout=None - kill command if there is no output after a default value seconds
|
|
timeout=0 - no timeout, let command run until it returns
|
|
"""
|
|
|
|
command = self.ssh + [self.ip, 'export PATH=/usr/sbin:/sbin:/usr/bin:/bin; ' + command]
|
|
|
|
if timeout is None:
|
|
return self._internal_run(command, self.defaulttimeout, self.ignore_status)
|
|
if timeout == 0:
|
|
return self._internal_run(command, None, self.ignore_status)
|
|
return self._internal_run(command, timeout, self.ignore_status)
|
|
|
|
def copy_to(self, localpath, remotepath):
|
|
if os.path.islink(localpath):
|
|
localpath = os.path.dirname(localpath) + "/" + os.readlink(localpath)
|
|
command = self.scp + [localpath, '%s@%s:%s' % (self.user, self.ip, remotepath)]
|
|
return self._internal_run(command, ignore_status=False)
|
|
|
|
def copy_from(self, remotepath, localpath):
|
|
command = self.scp + ['%s@%s:%s' % (self.user, self.ip, remotepath), localpath]
|
|
return self._internal_run(command, ignore_status=False)
|
|
|
|
def copy_dir_to(self, localpath, remotepath):
|
|
"""
|
|
Copy recursively localpath directory to remotepath in target.
|
|
"""
|
|
|
|
for root, dirs, files in os.walk(localpath):
|
|
# Create directories in the target as needed
|
|
for d in dirs:
|
|
tmp_dir = os.path.join(root, d).replace(localpath, "")
|
|
new_dir = os.path.join(remotepath, tmp_dir.lstrip("/"))
|
|
cmd = "mkdir -p %s" % new_dir
|
|
self.run(cmd)
|
|
|
|
# Copy files into the target
|
|
for f in files:
|
|
tmp_file = os.path.join(root, f).replace(localpath, "")
|
|
dst_file = os.path.join(remotepath, tmp_file.lstrip("/"))
|
|
src_file = os.path.join(root, f)
|
|
self.copy_to(src_file, dst_file)
|
|
|
|
|
|
def delete_files(self, remotepath, files):
|
|
"""
|
|
Delete files in target's remote path.
|
|
"""
|
|
|
|
cmd = "rm"
|
|
if not isinstance(files, list):
|
|
files = [files]
|
|
|
|
for f in files:
|
|
cmd = "%s %s" % (cmd, os.path.join(remotepath, f))
|
|
|
|
self.run(cmd)
|
|
|
|
|
|
def delete_dir(self, remotepath):
|
|
"""
|
|
Delete remotepath directory in target.
|
|
"""
|
|
|
|
cmd = "rmdir %s" % remotepath
|
|
self.run(cmd)
|
|
|
|
|
|
def delete_dir_structure(self, localpath, remotepath):
|
|
"""
|
|
Delete recursively localpath structure directory in target's remotepath.
|
|
|
|
This function is very usefult to delete a package that is installed in
|
|
the DUT and the host running the test has such package extracted in tmp
|
|
directory.
|
|
|
|
Example:
|
|
pwd: /home/user/tmp
|
|
tree: .
|
|
└── work
|
|
├── dir1
|
|
│ └── file1
|
|
└── dir2
|
|
|
|
localpath = "/home/user/tmp" and remotepath = "/home/user"
|
|
|
|
With the above variables this function will try to delete the
|
|
directory in the DUT in this order:
|
|
/home/user/work/dir1/file1
|
|
/home/user/work/dir1 (if dir is empty)
|
|
/home/user/work/dir2 (if dir is empty)
|
|
/home/user/work (if dir is empty)
|
|
"""
|
|
|
|
for root, dirs, files in os.walk(localpath, topdown=False):
|
|
# Delete files first
|
|
tmpdir = os.path.join(root).replace(localpath, "")
|
|
remotedir = os.path.join(remotepath, tmpdir.lstrip("/"))
|
|
self.delete_files(remotedir, files)
|
|
|
|
# Remove dirs if empty
|
|
for d in dirs:
|
|
tmpdir = os.path.join(root, d).replace(localpath, "")
|
|
remotedir = os.path.join(remotepath, tmpdir.lstrip("/"))
|
|
self.delete_dir(remotepath)
|