| """Utils for running a desktop cast_shell instance.""" |
| |
| from __future__ import absolute_import |
| import json |
| import logging |
| import os |
| import shutil |
| import socket |
| import sys |
| import time |
| |
| # The step property key that stores the cast_shell executable path. |
| CAST_SHELL_EXE_PATH = 'cast_shell_exe_path' |
| |
| _AVAILABILITY_RETRY_WAIT_TIME_SECS = 10 |
| _AVAILABILITY_WAIT_TIME_SECS = 80 |
| _CAST_V2_DEBUG_APP_ID = 'C566BECD' |
| _CONNECTION_NAMESPACE = 'urn:x-cast:com.google.cast.tp.connection' |
| _SETUP_API_ROOT = 'http://{device_ip}:8008/setup/{api}' |
| _OZONE_PLATFORM_CAST = 'cast' |
| _OZONE_PLATFORM_HEADLESS = 'headless' # Used for chirp_shell. |
| |
| # Default cast_shell parameters |
| _CAST_V2_PORT = 8009 |
| _MULTIZONE_PORT = 10001 |
| _REMOTE_DUBIGGING_PORT = 9222 |
| _MDNS_MULTICAST_PORT = 5353 |
| _GCM_SUB_PATH = 'gcm_cast_cq' |
| |
| _DUMP_LOGCAT_MSG = ('dump of cast_shell logs: \n' |
| '*** BEGIN CAST_SHELL ***\n' |
| '%s\n' |
| '*** END CAST_SHELL ***\n') |
| |
| |
| class CastShellError(Exception): |
| """An error while trying to use cast_shell.""" |
| |
| |
| class CastShellTimeoutError(Exception): |
| """A timeout error while trying to use cast_shell.""" |
| |
| |
| def start_cast_shell(executor, |
| test_project_path, |
| cast_shell_path, |
| tmp_dir, |
| enable_cma_media_pipeline=False, |
| enable_ccs_transport_v2=False, |
| use_headless_ozone_platform=False, |
| launch_utility_process=False): |
| """Starts a local x86 cast shell. |
| |
| Note: if multiple cast_shell instances are to be started, they must |
| all have unique ports for all the keyword ports specified below and unique |
| HOME and TMPDIR directories. |
| |
| Args: |
| executor: Executor to run the subprocess |
| test_project_path: Path to the 'test' project. This will be appened to the |
| sys.path if it is not already there. |
| cast_shell_path: Path the to cast_shell executable |
| tmp_dir: A temporary dir to use as HOME and TMPDIR. If there are multiple |
| cast_shell instances, this should be unique across all instances. |
| enable_cma_media_pipeline: If True, pass in --enable-cma-media-pipeline |
| enable_ccs_transport_v2: If True, pass in --enable-ccs-transport-v2 |
| use_headless_ozone_platform: If True, use "headless" as --ozone-platform |
| (required for assistant-enabled cast_shells); otherwise, uses "cast". |
| launch_utility_process: If True, launches the utility process (required to |
| start the assistant debug HTTP server at port 8007). |
| |
| Returns: |
| A tuple of (<started subprocess>, |
| <file descriptor of cast_shell output file>, |
| <absolute path of cast_shell output file>). |
| These can be passed to upload_cast_shell_logs() below to store the log |
| files in GCS. |
| |
| Raises: |
| CastShellError: if cast_shell does not start correctly. |
| CastShellTimeoutError: if cast_shell takes too long to become available. |
| """ |
| if test_project_path not in sys.path: |
| sys.path.append(test_project_path) |
| |
| if use_headless_ozone_platform: |
| ozone_platform = _OZONE_PLATFORM_HEADLESS |
| else: |
| ozone_platform = _OZONE_PLATFORM_CAST |
| |
| command = [ |
| cast_shell_path, |
| '--no-sandbox', |
| '--disable-gpu', |
| '--ignore-gpu-blacklist', |
| '--ozone-platform={}'.format(ozone_platform), |
| '--port-for-cast-v2={}'.format(_CAST_V2_PORT), |
| '--port-for-multizone={}'.format(_MULTIZONE_PORT), |
| '--remote-debugging-port={}'.format(_REMOTE_DUBIGGING_PORT), |
| '--port-for-mdns-multicast={}'.format(_MDNS_MULTICAST_PORT), |
| '--gcm-sub-path="{}"'.format(_GCM_SUB_PATH), |
| '--disable-reboot-on-config-update', |
| ] |
| |
| if launch_utility_process: |
| # max-output-volume-dba1m is required when --launch-utility-process |
| # is specified. |
| command.extend(['--launch-utility-process', '--max-output-volume-dba1m=88']) |
| |
| if enable_cma_media_pipeline: |
| command.append('--enable-cma-media-pipeline') |
| if enable_ccs_transport_v2: |
| command.append('--enable-ccs-transport-v2') |
| |
| # HOME and TMPDIR should be unique across any running cast_shell instances. |
| cast_shell_env = {'HOME': tmp_dir, 'TMPDIR': tmp_dir} |
| |
| try: |
| subprocess, log_file_descriptor, log_file_path = ( |
| executor.exec_non_blocking_subprocess(command, env=cast_shell_env)) |
| |
| if subprocess.returncode is not None: |
| raise CastShellError('cast_shell startup failed') |
| |
| if not _await_cast_shell_availability(): |
| raise CastShellTimeoutError( |
| 'cast_shell took too long to become available.') |
| |
| except: |
| logging.exception('Unable to start Cast Shell.') |
| _dump_cast_shell_logs(log_file_descriptor, log_file_path) |
| raise |
| |
| logging.info('cast_shell started successfully.') |
| return subprocess, log_file_descriptor, log_file_path |
| |
| |
| def _dump_cast_shell_logs(log_file_descriptor, log_file_path): |
| """Dump the cast_shell logcat to the logger.""" |
| os.fsync(log_file_descriptor) |
| os.close(log_file_descriptor) |
| with open(log_file_path, 'r') as log_file: |
| logging.info(_DUMP_LOGCAT_MSG, log_file.read()) |
| |
| |
| def upload_cast_shell_logs(log_file_descriptor, log_file_path, gcs_root_dir, |
| sub_dir, upload_file_name): |
| """Move the process log file into GCS folder so that it's uploaded. |
| |
| Args: |
| log_file_descriptor: File descriptor of log file to be copied. This should |
| be the descriptor returned by start_cast_shell() above. |
| log_file_path: Absolute path of the log file to be copied. This should be |
| the path returned by start_cast_shell() above. |
| gcs_root_dir: The GCS directory. |
| sub_dir: The sub directory within GCS to upload to. |
| upload_file_name: A string; log file will be renamed and uploaded with this |
| name. |
| """ |
| output_dir = os.path.join(gcs_root_dir, sub_dir) |
| if not os.path.exists(output_dir): |
| os.makedirs(output_dir) |
| os.fsync(log_file_descriptor) |
| shutil.copy(log_file_path, os.path.join(output_dir, upload_file_name)) |
| logging.info( |
| 'cast_shell log will be avilable on GCS in the gs://cast-cq bucket under ' |
| '%s for this CL. (See the end of stdio of the "shell" step for the ' |
| 'specific path. It should be similar to: ' |
| 'gs://cast-cq/eureka-interal/project/branch/issue/patchset', |
| os.path.join(sub_dir, upload_file_name)) |
| |
| |
| def _get_eureka_info(executor, ip_address='localhost', params=None): |
| """Returns the parsed eureka info. |
| |
| The //chromecast/internal/setup/eureka_info.h describes the various fields |
| that will be available. |
| |
| This assumes that a cast_shell instance is available at |ip_address| (such |
| as from running start_cast_shell above). |
| |
| Args: |
| executor: Executor to run the subprocess |
| ip_address: IP address (as a string) of the device to get the info from. |
| (Defaults to 'localhost') |
| params: A list of parameters (as strings) to get from euruka_info. This must |
| be specified and cannot be an empty list. e.g. params=['name', |
| 'wifi.ssid', 'setup.stats.num_obtain_ip'] will |
| return {'name': 'devicename', |
| 'wifi': {'ssid': 'wifi-ssid-value'}, |
| 'setup': {'stats': {'num_obtain_ip': 0}}} |
| |
| Returns: |
| A dict with the eureka_info information on success, or an empty dict on |
| failure. |
| """ |
| api_endpoint = _SETUP_API_ROOT.format( |
| device_ip=ip_address, |
| api='eureka_info?params={}'.format(','.join(params))) |
| logging.info('Making Request to API Endpoint: %s', api_endpoint) |
| returncode, json_result, _ = executor.exec_subprocess(['curl', api_endpoint], |
| quiet=True) |
| if returncode == 0: |
| return json.loads(json_result) |
| |
| return {} |
| |
| |
| def get_device_name(executor, ip_address='localhost'): |
| """Returns the name of the device at |ip_address|.""" |
| return _get_eureka_info(executor, ip_address, ['name']).get('name') |
| |
| |
| def _await_cast_shell_availability(max_wait_time=_AVAILABILITY_WAIT_TIME_SECS): |
| """Wait's until max_wait_time seconds for cast shell availability. |
| |
| Args: |
| max_wait_time: Integer of wait time in seconds. |
| |
| Returns: |
| True if cast shell is up and running. |
| """ |
| remaining_time = max_wait_time |
| while remaining_time >= 0: |
| time.sleep(_AVAILABILITY_RETRY_WAIT_TIME_SECS) |
| remaining_time -= _AVAILABILITY_RETRY_WAIT_TIME_SECS |
| try: |
| if _connect_cast_shell(): |
| return True |
| except (socket.error, AssertionError): |
| logging.exception('Cast shell is not ready, will retry for %d seconds', |
| remaining_time) |
| return False |
| |
| |
| def _connect_cast_shell(): |
| """Returns True if able to to connect and send a message to cast shell. |
| |
| Returns: |
| True if able to to connect and send a message to cast shell. |
| |
| Raises: |
| Socket.error: if not able to connect to cast shell. |
| AssertionError: if not able to send message to cast shell. |
| """ |
| |
| # Assumes that test/ is on the PYTHONPATH |
| transport = __import__( |
| 'cast.tools.transport', |
| fromlist=[ |
| 'application', 'application_connection', 'receiver', 'transport' |
| ]) |
| receiver = transport.receiver.Receiver('receiver-0', 'localhost') |
| app = transport.application.Application(receiver, _CAST_V2_DEBUG_APP_ID) |
| try: |
| with (transport.application_connection.ApplicationConnection( |
| app, 'sender-1')) as app_conn: |
| app_conn.ConnectToReceiver() |
| message = transport.transport.BuildMessage( |
| 'sender-1', 'receiver-0', _CONNECTION_NAMESPACE, b'', binary=True) |
| app_conn.Send(message) |
| app_conn.Status() |
| except transport.socket_helper.SocketError as e: |
| raise socket.error(socket.error(e), sys.exc_info()[2]) |
| |
| return True |
