#
# Copyright 2018 - The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import imp
import os
import sys
import time
from fabric.api import env
from fabric.api import local
from fabric.api import run
from fabric.api import settings
from fabric.api import sudo
from fabric.contrib.files import contains
from fabric.contrib.files import exists
from fabric.context_managers import cd
_PIP_REQUIREMENTS_PATHS = [
"test/vts/script/pip_requirements.txt",
"test/framework/harnesses/host_controller/script/pip_requirements.txt"
]
# Path to the file that contains the abs path to the deployed vtslab pakcage.
_VTSLAB_PACKAGE_PATH_FILENAME = ".vtslab_package_path"
# Zone filter list for GCE instances.
_DEFAULT_GCE_ZONE_LIST = [
"us-east1-b",
"asia-northeast1-a",
]
def SetPassword(password):
"""Sets password for hosts to access through ssh and to run sudo commands
usage: $ fab SetPassword:<password for hosts>
Args:
password: string, password for hosts.
"""
env.password = password
def GetHosts(hosts_file_path, gce_instance_name=None, account=None):
"""Configures env.hosts to a given list of hosts.
usage: $ fab GetHosts:<path to a source file contains hosts info>
Args:
hosts_file_path: string, path to a python file passed from command file
input.
gce_instance_name: string, GCE instance name.
account: string, account name used for the ssh connection.
"""
if hosts_file_path.endswith(".py"):
hosts_module = imp.load_source('hosts_module', hosts_file_path)
env.hosts = hosts_module.EmitHostList()
else:
if not gce_instance_name or not account:
print(
"Please specify gce_instance_name and account using -H option. "
"Example: -H <Google_Cloud_project>,<GCE_instance>,<account>")
sys.exit(0)
env.key_filename = "~/.ssh/google_compute_engine"
gce_list_out = local(
"gcloud compute instances list --project=%s --filter=\"zone:(%s)\""
% (hosts_file_path, " ".join(_DEFAULT_GCE_ZONE_LIST)),
capture=True)
for line in gce_list_out.split("\n")[1:]:
if line.startswith(gce_instance_name):
env.hosts.append("%s@%s" % (account, line.strip().split()[-2]))
def SetupIptables(ip_address_file_path):
"""Configures iptables setting for all hosts listed.
usage: $ fab SetupIptables:<path to a source file contains ip addresses of
certified machines>
Args:
ip_address_file_path: string, path to a python file passed from command
file input.
"""
ip_addresses_module = imp.load_source('ip_addresses_module',
ip_address_file_path)
ip_address_list = ip_addresses_module.EmitIPAddressList()
sudo("apt-get install -y iptables-persistent")
sudo("iptables -P INPUT ACCEPT")
sudo("iptables -P FORWARD ACCEPT")
sudo("iptables -F")
for ip_address in ip_address_list:
sudo(
"iptables -A INPUT -p tcp -s %s --dport 22 -j ACCEPT" % ip_address)
sudo("iptables -P INPUT DROP")
sudo("iptables -P FORWARD DROP")
sudo("iptables -A INPUT -p icmp -j ACCEPT")
sudo("netfilter-persistent save")
sudo("netfilter-persistent reload")
def SetupSudoers():
"""Append sudo rules for vtslab user.
usage: $ fab SetupSudoers
"""
if not contains("/etc/sudoers", "vtslab", use_sudo=True):
sudo("echo '' | sudo tee -a /etc/sudoers")
sudo("echo '# Let vtslab account have all authorization' | "
"sudo tee -a /etc/sudoers")
sudo("echo 'vtslab ALL=(ALL:ALL) ALL' | sudo tee -a /etc/sudoers")
def SetupUSBPermission():
"""Sets up the USB permission for adb and fastboot.
usage: $ fab SetupUSBPermission
"""
sudo("curl --create-dirs -L -o /etc/udev/rules.d/51-android.rules -O -L "
"https://raw.githubusercontent.com/snowdream/51-android/master/"
"51-android.rules")
sudo("chmod a+r /etc/udev/rules.d/51-android.rules")
sudo("service udev restart")
def SetupADBVendorKeysEnvVar():
"""Appends scripts for ADB_VENDOR_KEYS path setup.
In setup step, this function looks into .bashrc file for this script, and
if there is not then appends the below scripts to .bashrc.
Later when shell env created (through ssh or screen instance creation time),
.bashrc file will look for _VTSLAB_PACKAGE_PATH_FILENAME and use the
contents of the file to set ADB_VENDOR_KEYS.
usage: $ fab SetupADBVendorKeysEnvVar
"""
if not contains("~/.bashrc", _VTSLAB_PACKAGE_PATH_FILENAME):
run("echo '' >> ~/.bashrc", )
run("echo '# Set $ADB_VENDOR_KEYS as paths to adb private key files "
"within the vtslab-package' >> ~/.bashrc")
run("echo 'if [ -f ~/%s ]; then' >> ~/.bashrc" %
_VTSLAB_PACKAGE_PATH_FILENAME)
run("echo ' export ADB_VENDOR_KEYS=$(find $(cat ~/%s)/android-vtslab/"
"testcases/DATA/ak -name \".*.ak\" | tr \"\\n\" \":\")' "
">> ~/.bashrc" % _VTSLAB_PACKAGE_PATH_FILENAME)
run("echo 'fi' >> ~/.bashrc")
def _CheckADBVendorKeysEnvVar(vtslab_package_file_name=""):
"""Checks if there is a change in ADB_VENDOR_KEYS env variable.
if there is, then the adbd needs to be restarted in the screen context
before running the HC.
Args:
vtslab_package_file_name: string, the HC package file name that is about
to be deployed.
Returns:
True if the list of the adb vendor key files have changed,
False otherwise.
"""
former_key_set = set()
current_key_set = set()
set_keyfile_set = lambda set, path_list: map(set.add, map(os.path.basename,
path_list))
vtslab_package_path_filepath = "~/%s" % _VTSLAB_PACKAGE_PATH_FILENAME
if exists(vtslab_package_path_filepath):
former_HC_package_path = run("cat %s" % vtslab_package_path_filepath)
former_HC_package_adbkey_path = os.path.join(
former_HC_package_path, "android-vtslab/testcases/DATA/ak")
if exists(former_HC_package_adbkey_path):
adb_vendor_keys_list = run("find %s -name \".*.ak\"" %
former_HC_package_adbkey_path).split()
set_keyfile_set(former_key_set, adb_vendor_keys_list)
if exists("~/run/%s.dir/android-vtslab/testcases/DATA/ak" %
vtslab_package_file_name):
adb_vendor_keys_list = run(
"find ~/run/%s.dir/android-vtslab/testcases/DATA/ak -name \".*.ak\""
% vtslab_package_file_name).split()
set_keyfile_set(current_key_set, adb_vendor_keys_list)
return former_key_set != current_key_set
def SetupPackages(ip_address_file_path=None):
"""Sets up the execution environment for vts `run` command.
Need to temporarily open the ports for apt-get and pip commands.
usage: $ fab SetupPackages
Args:
ip_address_file_path: string, path to a python file passed from command
file input. Will be passed to SetupIptables().
"""
sudo("iptables -P INPUT ACCEPT")
# todo : replace "kr.ubuntu." to "ubuntu" in /etc/apt/sources.list
sudo("apt-get upgrade -y")
sudo("apt-get update -y")
sudo("apt-get install -y git-core gnupg flex bison gperf build-essential "
"zip curl zlib1g-dev gcc-multilib g++-multilib x11proto-core-dev "
"libx11-dev lib32z-dev ccache libgl1-mesa-dev libxml2-utils xsltproc "
"unzip liblz4-tool udev screen")
sudo("apt-get install -y android-tools-adb")
sudo("usermod -aG plugdev $LOGNAME")
SetupUSBPermission()
sudo("apt-get update")
sudo("apt-get install -y python2.7")
sudo("apt-get install -y python-pip")
run("pip install --upgrade pip")
sudo("apt-get install -y python-virtualenv")
sudo("apt-get install -y python-dev python-protobuf protobuf-compiler "
"python-setuptools")
for req_path in _PIP_REQUIREMENTS_PATHS:
full_path = os.path.join(os.environ["ANDROID_BUILD_TOP"], req_path)
pip_requirement_list = []
try:
requirements_fd = open(full_path, "r")
lines = requirements_fd.readlines()
for line in lines:
req = line.rstrip()
if req != "" and not req.startswith("#"):
pip_requirement_list.append(req)
except IOError as e:
print("%s: %s" % (e.strerror, full_path))
return
sudo("pip install %s" % " ".join(pip_requirement_list))
sudo("pip install --upgrade protobuf")
lsb_result = run("lsb_release -c -s")
sudo("echo \"deb http://packages.cloud.google.com/apt cloud-sdk-%s "
"main\" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list" %
lsb_result)
sudo("curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | "
"sudo apt-key add -")
sudo("apt-get update && sudo apt-get install -y google-cloud-sdk")
sudo("apt-get install -y google-cloud-sdk-app-engine-java "
"google-cloud-sdk-app-engine-python kubectl")
sudo("apt-get install -y m4 bison")
if ip_address_file_path is not None:
SetupIptables(ip_address_file_path)
SetupADBVendorKeysEnvVar()
def DeployVtslab(vtslab_package_gcs_url=None):
"""Deploys vtslab package.
Fetches and deploy vtslab by going through the processes described below
1. Send the "exit --wait_for_jobs=True" command to all detached screen.
And let the screen to terminate itself.
2. Create a new screen instance that downloads and runs the new HC,
give password and device command to the HC without actually attaching it
usage: $ fab DeployVtslab -p <password> -H hosts.py -f <gs://vtslab-release/...>
Args:
vtslab_package_gcs_url: string, URL to a certain vtslab package file.
"""
if not vtslab_package_gcs_url:
print("Please specify vtslab package file URL using -f option.")
return
elif not vtslab_package_gcs_url.startswith("gs://vtslab-release/"):
print("Please spcify a valid URL for the vtslab package.")
return
else:
vti = "vtslab-schedule-" + vtslab_package_gcs_url[len(
"gs://vtslab-release/"):].split("/")[0] + ".appspot.com"
with settings(warn_only=True):
screen_list_result = run("screen -list")
lines = screen_list_result.split("\n")
for line in lines:
if "(Detached)" in line:
screen_name = line.split("\t")[1]
print(screen_name)
with settings(warn_only=True):
run("screen -S %s -X stuff \"exit --wait_for_jobs=True\"" %
screen_name)
run("screen -S %s -X stuff \"^M\"" % screen_name)
run("screen -S %s -X stuff \"exit\"" % screen_name)
run("screen -S %s -X stuff \"^M\"" % screen_name)
vtslab_package_file_name = os.path.basename(vtslab_package_gcs_url)
run("mkdir -p ~/run/%s.dir/" % vtslab_package_file_name)
with cd("~/run/%s.dir" % vtslab_package_file_name):
run("gsutil cp %s ./" % vtslab_package_gcs_url)
run("unzip -o %s" % vtslab_package_file_name)
adb_vendor_keys_changed = _CheckADBVendorKeysEnvVar(
vtslab_package_file_name)
run("pwd > ~/%s" % _VTSLAB_PACKAGE_PATH_FILENAME)
with cd("~/run/%s.dir/android-vtslab/tools" % vtslab_package_file_name):
new_screen_name = run("cat ../testcases/version.txt")
with cd("~/run/%s.dir/android-vtslab/tools" % vtslab_package_file_name):
run("./make_screen %s ; sleep 1" % new_screen_name)
if adb_vendor_keys_changed:
reset_adbd = ""
while reset_adbd.lower() not in ["y", "n"]:
if reset_adbd:
print("Please type 'y' or 'n'")
reset_adbd = raw_input(
"Reset adb server daemon on host %s (y/n)? " % env.host)
if reset_adbd.lower() == "y":
run("screen -S %s -X stuff \"adb kill-server^M\"" %
new_screen_name)
run("screen -S %s -X stuff \"adb start-server^M\"" %
new_screen_name)
run("screen -S %s -X stuff \"./run --vti=%s\"" % (new_screen_name, vti))
run("screen -S %s -X stuff \"^M\"" % new_screen_name)
time.sleep(5)
run("screen -S %s -X stuff \"password\"" % new_screen_name)
run("screen -S %s -X stuff \"^M\"" % new_screen_name)
run("screen -S %s -X stuff \"%s\"" % (new_screen_name, env.password))
run("screen -S %s -X stuff \"^M\"" % new_screen_name)
run("screen -S %s -X stuff \"device --lease=True\"" % new_screen_name)
run("screen -S %s -X stuff \"^M\"" % new_screen_name)
with cd("~/run/%s.dir" % vtslab_package_file_name):
run("rm %s" % vtslab_package_file_name)
def DeployGCE(vtslab_package_gcs_url=None):
"""Deploys a vtslab package to GCE nodes.
Fetches and deploy vtslab on monitor-hc by doing;
1. Download android-vtslab-<>.zip from GCS using the given URL and upzip it.
2. Send the Ctrl-c key input to all detached screen, then cursor-up
key input and enter key input, making the screen to execute
the last run command.
usage: $ fab DeployVtslab -p <password> -H <Google Cloud Platform project name> -f <gs://vtslab-release/...>
Args:
vtslab_package_gcs_url: string, URL to a certain vtslab package file.
"""
if not vtslab_package_gcs_url:
print("Please specify vtslab package file URL using -f option.")
return
elif not vtslab_package_gcs_url.startswith("gs://"):
print("Please spcify a valid URL for the vtslab package.")
return
vtslab_package_file_name = os.path.basename(vtslab_package_gcs_url)
with cd("~/run"):
run("gsutil cp %s ./" % vtslab_package_gcs_url)
run("unzip -o %s" % vtslab_package_file_name)
run("rm %s" % vtslab_package_file_name)
with settings(warn_only=True):
screen_list_result = run("screen -list")
lines = screen_list_result.split("\n")
for line in lines:
if "(Detached)" in line:
screen_name = line.split("\t")[1]
run("screen -S %s -X stuff \"^C\"" % screen_name)
run("screen -S %s -X stuff \"\033[A\"" % screen_name)
run("screen -S %s -X stuff \"^M\"" % screen_name)