xref: /aosp_15_r20/tools/acloud/public/actions/create_goldfish_action.py (revision 800a58d989c669b8eb8a71d8df53b1ba3d411444)

#!/usr/bin/env python
#
# 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.
"""Action to create goldfish device instances.

A Goldfish device is an emulated android device based on the android
emulator.
"""
import logging
import os
import re

from acloud import errors
from acloud.public.actions import base_device_factory
from acloud.public.actions import common_operations
from acloud.internal import constants
from acloud.internal.lib import android_build_client
from acloud.internal.lib import auth
from acloud.internal.lib import goldfish_compute_client
from acloud.internal.lib import utils


logger = logging.getLogger(__name__)

_EMULATOR_INFO_FILENAME = "emulator-info.txt"
_SYSIMAGE_INFO_FILENAME = "android-info.txt"
_VERSION_PATTERN = r"version-.*=(\d+)"


class GoldfishDeviceFactory(base_device_factory.BaseDeviceFactory):
    """A class that can produce a goldfish device.

    Attributes:
        _cfg: An AcloudConfig instance.
        _build_target: String, the build target, e.g. aosp_x86-eng.
        _build_id: String, Build id, e.g. "2263051", "P2804227"
        _emulator_build_target: String, the emulator build target, e.g. aosp_x86-eng.
        _emulator_build_id: String, emulator build id.
        _gpu: String, GPU to attach to the device or None. e.g. "nvidia-tesla-k80"
        _blank_data_disk_size_gb: Integer, extra disk size
        _build_client: An AndroidBuildClient instance
        _branch: String, android branch name, e.g. git_master
        _emulator_branch: String, emulator branch name, e.g. "aosp-emu-master-dev"
    """
    LOG_FILES = ["/home/vsoc-01/emulator.log",
                 "/home/vsoc-01/log/logcat.log",
                 "/home/vsoc-01/log/adb.log",
                 "/var/log/daemon.log"]

    def __init__(self,
                 cfg,
                 build_target,
                 build_id,
                 emulator_build_target,
                 emulator_build_id,
                 kernel_build_id=None,
                 kernel_branch=None,
                 kernel_build_target=None,
                 gpu=None,
                 avd_spec=None,
                 tags=None,
                 branch=None,
                 emulator_branch=None):

        """Initialize.

        Args:
            cfg: An AcloudConfig instance.
            build_target: String, the build target, e.g. aosp_x86-eng.
            build_id: String, Build id, e.g. "2263051", "P2804227"
            emulator_build_target: String, the emulator build target, e.g. aosp_x86-eng.
            emulator_build_id: String, emulator build id.
            gpu: String, GPU to attach to the device or None. e.g. "nvidia-tesla-k80"
            avd_spec: An AVDSpec instance.
            tags: A list of tags to associate with the instance. e.g.
                  ["http-server", "https-server"]
            branch: String, branch of the emulator build target.
            emulator_branch: String, branch of the emulator.
        """

        self.credentials = auth.CreateCredentials(cfg)

        compute_client = goldfish_compute_client.GoldfishComputeClient(
            cfg, self.credentials)
        super().__init__(compute_client)

        # Private creation parameters
        self._cfg = cfg
        self._gpu = gpu
        self._avd_spec = avd_spec
        self._blank_data_disk_size_gb = cfg.extra_data_disk_size_gb
        self._extra_scopes = cfg.extra_scopes
        self._tags = tags

        # Configure clients
        self._build_client = android_build_client.AndroidBuildClient(
            self.credentials)

        # Get build info
        self.build_info = self._build_client.GetBuildInfo(
            build_target, build_id, branch)
        self.emulator_build_info = self._build_client.GetBuildInfo(
            emulator_build_target, emulator_build_id, emulator_branch)
        self.kernel_build_info = self._build_client.GetBuildInfo(
            kernel_build_target or cfg.kernel_build_target, kernel_build_id,
            kernel_branch)

    def GetBuildInfoDict(self):
        """Get build info dictionary.

        Returns:
          A build info dictionary
        """
        build_info_dict = {
            key: val for key, val in utils.GetDictItems(self.build_info) if val}

        build_info_dict.update(
            {"emulator_%s" % key: val
             for key, val in utils.GetDictItems(self.emulator_build_info) if val}
            )

        build_info_dict.update(
            {"kernel_%s" % key: val
             for key, val in utils.GetDictItems(self.kernel_build_info) if val}
            )

        return build_info_dict

    def CreateInstance(self):
        """Creates single configured goldfish device.

        Override method from parent class.

        Returns:
            String, the name of the created instance.
        """
        instance = self._compute_client.GenerateInstanceName(
            build_id=self.build_info.build_id,
            build_target=self.build_info.build_target)

        self._compute_client.CreateInstance(
            instance=instance,
            image_name=self._cfg.stable_goldfish_host_image_name,
            image_project=self._cfg.stable_goldfish_host_image_project,
            build_target=self.build_info.build_target,
            branch=self.build_info.branch,
            build_id=self.build_info.build_id,
            emulator_branch=self.emulator_build_info.branch,
            emulator_build_id=self.emulator_build_info.build_id,
            emulator_build_target=self.emulator_build_info.build_target,
            kernel_branch=self.kernel_build_info.branch,
            kernel_build_id=self.kernel_build_info.build_id,
            kernel_build_target=self.kernel_build_info.build_target,
            gpu=self._gpu,
            blank_data_disk_size_gb=self._blank_data_disk_size_gb,
            avd_spec=self._avd_spec,
            tags=self._tags,
            extra_scopes=self._extra_scopes,
            launch_args=self._cfg.launch_args)

        return instance


def ParseBuildInfo(filename):
    """Parse build id based on a substring.

    This will parse a file which contains build information to be used. For an
    emulator build, the file will contain the information about the
    corresponding stable system image build id. In emulator-info.txt, the file
    will contains the information about the corresponding stable emulator
    build id, for example "require version-emulator=5292001". In
    android-info.txt, the file will contains the information about a stable
    system image build id, for example
    "version-sysimage-git_pi-dev-sdk_gphone_x86_64-userdebug=4833817"

    Args:
        filename: Name of file to parse.

    Returns:
        Build id parsed from the file based on pattern
        Returns None if pattern not found in file
    """
    with open(filename) as build_info_file:
        for line in build_info_file:
            match = re.search(_VERSION_PATTERN, line)
            if match:
                return match.group(1)
    return None


def _FetchBuildIdFromFile(cfg, build_target, build_id, filename):
    """Parse and fetch build id from a file based on a pattern.

    Verify if one of the system image or emulator binary build id is missing.
    If found missing, then update according to the resource file.

    Args:
        cfg: An AcloudConfig instance.
        build_target: Target name.
        build_id: Build id, a string, e.g. "2263051", "P2804227"
        filename: Name of file containing the build info.

    Returns:
        A build id or None
    """
    build_client = android_build_client.AndroidBuildClient(
        auth.CreateCredentials(cfg))

    with utils.TempDir() as tempdir:
        temp_filename = os.path.join(tempdir, filename)
        build_client.DownloadArtifact(build_target,
                                      build_id,
                                      filename,
                                      temp_filename)

        return ParseBuildInfo(temp_filename)


#pylint: disable=too-many-locals
def CreateDevices(avd_spec=None,
                  cfg=None,
                  build_target=None,
                  build_id=None,
                  emulator_build_id=None,
                  emulator_branch=None,
                  emulator_build_target=None,
                  kernel_build_id=None,
                  kernel_branch=None,
                  kernel_build_target=None,
                  gpu=None,
                  num=1,
                  serial_log_file=None,
                  autoconnect=False,
                  branch=None,
                  tags=None,
                  report_internal_ip=False,
                  boot_timeout_secs=None):
    """Create one or multiple Goldfish devices.

    Args:
        avd_spec: An AVDSpec instance.
        cfg: An AcloudConfig instance.
        build_target: String, the build target, e.g. aosp_x86-eng.
        build_id: String, Build id, e.g. "2263051", "P2804227"
        branch: String, Branch name for system image.
        emulator_build_id: String, emulator build id.
        emulator_branch: String, emulator branch name.
        emulator_build_target: String, emulator build target.
        gpu: String, GPU to attach to the device or None. e.g. "nvidia-k80"
        kernel_build_id: Kernel build id, a string.
        kernel_branch: Kernel branch name, a string.
        kernel_build_target: Kernel build artifact, a string.
        num: Integer, Number of devices to create.
        serial_log_file: String, A path to a file where serial output should
                        be saved to.
        autoconnect: Boolean, Create ssh tunnel(s) and adb connect after device
                     creation.
        branch: String, Branch name for system image.
        tags: A list of tags to associate with the instance. e.g.
              ["http-server", "https-server"]
        report_internal_ip: Boolean to report the internal ip instead of
                            external ip.
        boot_timeout_secs: Integer, the maximum time in seconds used to
                           wait for the AVD to boot.

    Returns:
        A Report instance.
    """
    client_adb_port = None
    if avd_spec:
        cfg = avd_spec.cfg
        build_target = avd_spec.remote_image[constants.BUILD_TARGET]
        build_id = avd_spec.remote_image[constants.BUILD_ID]
        branch = avd_spec.remote_image[constants.BUILD_BRANCH]
        num = avd_spec.num
        emulator_build_id = avd_spec.emulator_build_id
        emulator_build_target = avd_spec.emulator_build_target
        gpu = avd_spec.gpu
        serial_log_file = avd_spec.serial_log_file
        autoconnect = avd_spec.autoconnect
        report_internal_ip = avd_spec.report_internal_ip
        client_adb_port = avd_spec.client_adb_port
        boot_timeout_secs = avd_spec.boot_timeout_secs

    if not emulator_build_target:
        emulator_build_target = cfg.emulator_build_target

    # If emulator_build_id and emulator_branch is None, retrieve emulator
    # build id from platform build emulator-info.txt artifact
    # Example: require version-emulator=5292001
    if not emulator_build_id and not emulator_branch:
        logger.info("emulator_build_id not provided. "
                    "Attempting to get %s from build %s/%s.", _EMULATOR_INFO_FILENAME,
                    build_id, build_target)
        emulator_build_id = _FetchBuildIdFromFile(cfg,
                                                  build_target,
                                                  build_id,
                                                  _EMULATOR_INFO_FILENAME)

    if not emulator_build_id:
        raise errors.CommandArgError("Emulator build id not found "
                                     "in %s" % _EMULATOR_INFO_FILENAME)

    # If build_id and branch is None, retrieve build_id from
    # emulator build android-info.txt artifact
    # Example: version-sysimage-git_pi-dev-sdk_gphone_x86_64-userdebug=4833817
    if not build_id and not branch:
        build_id = _FetchBuildIdFromFile(cfg,
                                         emulator_build_target,
                                         emulator_build_id,
                                         _SYSIMAGE_INFO_FILENAME)

    if not build_id:
        raise errors.CommandArgError("Emulator system image build id not found "
                                     "in %s" % _SYSIMAGE_INFO_FILENAME)
    logger.info(
        "Creating a goldfish device in project %s, build_target: %s, "
        "build_id: %s, emulator_bid: %s, emulator_branch: %s, kernel_build_id: %s, "
        "kernel_branch: %s, kernel_build_target: %s, GPU: %s, num: %s, "
        "serial_log_file: %s, "
        "autoconnect: %s", cfg.project, build_target, build_id,
        emulator_build_id, emulator_branch, kernel_build_id, kernel_branch,
        kernel_build_target, gpu, num, serial_log_file, autoconnect)

    device_factory = GoldfishDeviceFactory(
        cfg, build_target, build_id,
        emulator_build_target,
        emulator_build_id, gpu=gpu,
        avd_spec=avd_spec, tags=tags,
        branch=branch,
        emulator_branch=emulator_branch,
        kernel_build_id=kernel_build_id,
        kernel_branch=kernel_branch,
        kernel_build_target=kernel_build_target)

    return common_operations.CreateDevices("create_gf", cfg, device_factory,
                                           num, constants.TYPE_GF,
                                           report_internal_ip, autoconnect,
                                           serial_log_file, client_adb_port,
                                           boot_timeout_secs)