# Copyright 2015 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Utility script to run tests on the Chromoting bot."""
from __future__ import print_function
import hashlib
import os
from os.path import expanduser
import re
import shutil
import socket
import subprocess
import psutil
PROD_DIR_ID = '#PROD_DIR#'
CRD_ID = 'chrome-remote-desktop' # Used in a few file/folder names
HOST_READY_INDICATOR = 'Host ready to receive connections.'
BROWSER_TEST_ID = 'browser_tests'
HOST_HASH_VALUE = hashlib.md5(socket.gethostname()).hexdigest()
NATIVE_MESSAGING_DIR = 'NativeMessagingHosts'
# On a Swarming bot where these tests are executed, a temp folder is created
# under which the files specified in an .isolate are copied. This temp folder
# has a random name, which we'll store here for use later.
# Note that the test-execution always starts from the testing/chromoting folder
# under the temp folder.
ISOLATE_CHROMOTING_HOST_PATH = 'remoting/host/linux/linux_me2me_host.py'
ISOLATE_TEMP_FOLDER = os.path.abspath(os.path.join(os.getcwd(), '../..'))
CHROMOTING_HOST_PATH = os.path.join(ISOLATE_TEMP_FOLDER,
ISOLATE_CHROMOTING_HOST_PATH)
MAX_RETRIES = 1
class HostOperationFailedException(Exception):
pass
def RunCommandInSubProcess(command):
"""Creates a subprocess with command-line that is passed in.
Args:
command: The text of command to be executed.
Returns:
results: stdout contents of executing the command.
"""
cmd_line = [command]
try:
print('Going to run:\n%s' % command)
results = subprocess.check_output(cmd_line,
stderr=subprocess.STDOUT,
shell=True)
except subprocess.CalledProcessError as e:
results = e.output
finally:
print(results)
return results
def TestMachineCleanup(user_profile_dir, host_logs=None):
"""Cleans up test machine so as not to impact other tests.
Args:
user_profile_dir: the user-profile folder used by Chromoting tests.
host_logs: List of me2me host logs; these will be deleted.
"""
# Stop the host service.
RunCommandInSubProcess(CHROMOTING_HOST_PATH + ' --stop')
# Cleanup any host logs.
if host_logs:
for host_log in host_logs:
RunCommandInSubProcess('rm %s' % host_log)
# Remove the user-profile dir
if os.path.exists(user_profile_dir):
shutil.rmtree(user_profile_dir)
def InitialiseTestMachineForLinux(cfg_file):
"""Sets up a Linux machine for connect-to-host chromoting tests.
Copy over me2me host-config to expected locations.
By default, the Linux me2me host expects the host-config file to be under
$HOME/.config/chrome-remote-desktop
Its name is expected to have a hash that is specific to a machine.
Args:
cfg_file: location of test account's host-config file.
Raises:
Exception: if host did not start properly.
"""
# First get home directory on current machine.
home_dir = expanduser('~')
default_config_file_location = os.path.join(home_dir, '.config', CRD_ID)
if os.path.exists(default_config_file_location):
shutil.rmtree(default_config_file_location)
os.makedirs(default_config_file_location)
# Copy over test host-config to expected location, with expected file-name.
# The file-name should contain a hash-value that is machine-specific.
default_config_file_name = 'host#%s.json' % HOST_HASH_VALUE
config_file_src = os.path.join(os.getcwd(), cfg_file)
shutil.copyfile(
config_file_src,
os.path.join(default_config_file_location, default_config_file_name))
# Make sure chromoting host is running.
RestartMe2MeHost()
def RestartMe2MeHost():
"""Stops and starts the Me2Me host on the test machine.
Launches the me2me start-host command, and parses the stdout of the execution
to obtain the host log-file name.
Returns:
log_file: Host log file.
Raises:
Exception: If host-log does not contain string indicating host is ready.
"""
# To start the host, we want to be in the temp-folder for this test execution.
# Store the current folder to return back to it later.
previous_directory = os.getcwd()
os.chdir(ISOLATE_TEMP_FOLDER)
# Stop chromoting host.
RunCommandInSubProcess(CHROMOTING_HOST_PATH + ' --stop')
# Start chromoting host.
print('Starting chromoting host from %s' % CHROMOTING_HOST_PATH)
results = RunCommandInSubProcess(CHROMOTING_HOST_PATH + ' --start')
os.chdir(previous_directory)
# Get log file from results of above command printed to stdout. Example:
# Log file: /tmp/tmp0c3EcP/chrome_remote_desktop_20150929_101525_B0o89t
start_of_host_log = results.index('Log file: ') + len('Log file: ')
log_file = results[start_of_host_log:].rstrip()
# Confirm that the start process completed, and we got:
# "Host ready to receive connections." in the log.
if HOST_READY_INDICATOR not in results:
# Host start failed. Print out host-log. Don't run any tests.
with open(log_file, 'r') as f:
print(f.read())
raise HostOperationFailedException('Host restart failed.')
return log_file
def CleanupUserProfileDir(args):
SetupUserProfileDir(args.me2me_manifest_file, args.it2me_manifest_file,
args.user_profile_dir)
def SetupUserProfileDir(me2me_manifest_file, it2me_manifest_file,
user_profile_dir):
"""Sets up the Google Chrome user profile directory.
Delete the previous user profile directory if exists and create a new one.
This invalidates any state changes by the previous test so each test can start
with the same environment.
When a user launches the remoting web-app, the native messaging host process
is started. For this to work, this function places the me2me and it2me native
messaging host manifest files in a specific folder under the user-profile dir.
Args:
me2me_manifest_file: location of me2me native messaging host manifest file.
it2me_manifest_file: location of it2me native messaging host manifest file.
user_profile_dir: Chrome user-profile-directory.
"""
native_messaging_folder = os.path.join(user_profile_dir, NATIVE_MESSAGING_DIR)
if os.path.exists(user_profile_dir):
shutil.rmtree(user_profile_dir)
os.makedirs(native_messaging_folder)
manifest_files = [me2me_manifest_file, it2me_manifest_file]
for manifest_file in manifest_files:
manifest_file_src = os.path.join(os.getcwd(), manifest_file)
manifest_file_dest = (os.path.join(native_messaging_folder,
os.path.basename(manifest_file)))
shutil.copyfile(manifest_file_src, manifest_file_dest)
def PrintRunningProcesses():
processes = psutil.get_process_list()
processes = sorted(processes, key=lambda process: process.name)
print('List of running processes:\n')
for process in processes:
print(process.name)
def PrintHostLogContents(host_log_files=None):
if host_log_files:
host_log_contents = ''
for log_file in sorted(host_log_files):
with open(log_file, 'r') as log:
host_log_contents += '\nHOST LOG %s\n CONTENTS:\n%s' % (log_file,
log.read())
print(host_log_contents)
def TestCaseSetup(args):
# Reset the user profile directory to start each test with a clean slate.
CleanupUserProfileDir(args)
# Stop+start me2me host process.
return RestartMe2MeHost()
def GetJidListFromTestResults(results):
"""Parse the output of a test execution to obtain the JID used by the test.
Args:
results: stdio contents of test execution.
Returns:
jids_used: List of JIDs used by test; empty list if not found.
"""
# Reg-ex defining the JID information in the string being parsed.
jid_re = '(Connecting to )(.*.gserviceaccount.com/chromoting.*)(. Local.*)'
jids_used = []
for line in results.split('\n'):
match = re.search(jid_re, line)
if match:
jid_used = match.group(2)
if jid_used not in jids_used:
jids_used.append(jid_used)
return jids_used
def GetJidFromHostLog(host_log_file):
"""Parse the me2me host log to obtain the JID that the host registered.
Args:
host_log_file: path to host-log file that should be parsed for a JID.
Returns:
host_jid: host-JID if found in host-log, else None
"""
host_jid = None
with open(host_log_file, 'r') as log_file:
for line in log_file:
# The host JID will be recorded in a line saying 'Signaling
# connected'.
if 'Signaling connected. ' in line:
components = line.split(':')
host_jid = components[-1].lstrip()
break
return host_jid
Codebase Browser
chromium