create/local_image_local_instance.py - platform/tools/acloud - Git at Google

 #!/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.
 r"""LocalImageLocalInstance class.

 Create class that is responsible for creating a local instance AVD with a
 local image.
 """

 from __future__ import print_function
 import logging
 import os
 import subprocess
 import sys

 from acloud import errors
 from acloud.create import base_avd_create
 from acloud.delete import delete
 from acloud.internal import constants
 from acloud.internal.lib import utils
 from acloud.public import report

 logger = logging.getLogger(__name__)

 _CMD_LAUNCH_CVD_ARGS = (" --daemon --cpus %s --x_res %s --y_res %s --dpi %s "
                         "--memory_mb %s --blank_data_image_mb %s "
                         "--data_policy always_create "
                         "--system_image_dir %s "
                         "--vnc_server_port %s")
 _CONFIRM_RELAUNCH = ("\nCuttlefish AVD is already running. \n"
                      "Enter 'y' to terminate current instance and launch a new "
                      "instance, enter anything else to exit out[y/N]: ")
 _ENV_ANDROID_HOST_OUT = "ANDROID_HOST_OUT"
 _LAUNCH_CVD_TIMEOUT_SECS = 60  # setup timeout as 60 seconds
 _LAUNCH_CVD_TIMEOUT_ERROR = ("Cuttlefish AVD launch timeout, did not complete "
                              "within %d secs." % _LAUNCH_CVD_TIMEOUT_SECS)

 class LocalImageLocalInstance(base_avd_create.BaseAVDCreate):
     """Create class for a local image local instance AVD."""

     @utils.TimeExecute(function_description="Total time: ",
                        print_before_call=False, print_status=False)
     def _CreateAVD(self, avd_spec, no_prompts):
         """Create the AVD.

         Args:
             avd_spec: AVDSpec object that tells us what we're going to create.
             no_prompts: Boolean, True to skip all prompts.
         """
         # Running instances on local is not supported on all OS.
         if not utils.IsSupportedPlatform(print_warning=True):
             result_report = report.Report(constants.LOCAL_INS_NAME)
             result_report.SetStatus(report.Status.FAIL)
             return result_report

         self.PrintDisclaimer()
         local_image_path, host_bins_path = self.GetImageArtifactsPath(avd_spec)

         launch_cvd_path = os.path.join(host_bins_path, "bin",
                                        constants.CMD_LAUNCH_CVD)
         cmd = self.PrepareLaunchCVDCmd(launch_cvd_path,
                                        avd_spec.hw_property,
                                        local_image_path)
         try:
             self.CheckLaunchCVD(cmd, host_bins_path, no_prompts)
         except errors.LaunchCVDFail as launch_error:
             raise launch_error

         result_report = report.Report(constants.LOCAL_INS_NAME)
         result_report.SetStatus(report.Status.SUCCESS)
         result_report.AddData(
             key="devices",
             value={"adb_port": constants.DEFAULT_ADB_PORT,
                    constants.VNC_PORT: constants.DEFAULT_VNC_PORT})
         # Launch vnc client if we're auto-connecting.
         if avd_spec.autoconnect:
             utils.LaunchVNCFromReport(result_report, avd_spec, no_prompts)
         return result_report

     @staticmethod
     def GetImageArtifactsPath(avd_spec):
         """Get image artifacts path.

         This method will check if launch_cvd is exist and return the tuple path
         (image path and host bins path) where they are located respectively.
         For remote image, RemoteImageLocalInstance will override this method and
         return the artifacts path which is extracted and downloaded from remote.

         Args:
             avd_spec: AVDSpec object that tells us what we're going to create.

         Returns:
             Tuple of (local image file, host bins package) paths.
         """
         # Check if launch_cvd is exist.
         host_bins_path = os.environ.get(_ENV_ANDROID_HOST_OUT)
         launch_cvd_path = os.path.join(host_bins_path, "bin",
                                        constants.CMD_LAUNCH_CVD)
         if not os.path.exists(launch_cvd_path):
             raise errors.GetCvdLocalHostPackageError(
                 "No launch_cvd found. Please run \"m launch_cvd\" first")

         return avd_spec.local_image_dir, host_bins_path

     @staticmethod
     def PrepareLaunchCVDCmd(launch_cvd_path, hw_property, system_image_dir):
         """Prepare launch_cvd command.

         Create the launch_cvd commands with all the required args and add
         in the user groups to it if necessary.

         Args:
             launch_cvd_path: String of launch_cvd path.
             hw_property: dict object of hw property.
             system_image_dir: String of local images path.

         Returns:
             String, launch_cvd cmd.
         """
         launch_cvd_w_args = launch_cvd_path + _CMD_LAUNCH_CVD_ARGS % (
             hw_property["cpu"], hw_property["x_res"], hw_property["y_res"],
             hw_property["dpi"], hw_property["memory"], hw_property["disk"],
             system_image_dir, constants.DEFAULT_VNC_PORT)

         launch_cmd = utils.AddUserGroupsToCmd(launch_cvd_w_args,
                                               constants.LIST_CF_USER_GROUPS)
         logger.debug("launch_cvd cmd:\n %s", launch_cmd)
         return launch_cmd

     def CheckLaunchCVD(self, cmd, host_bins_path, no_prompts=False):
         """Execute launch_cvd command and wait for boot up completed.

         Args:
             cmd: String, launch_cvd command.
             host_bins_path: String of host package directory.
             no_prompts: Boolean, True to skip all prompts.
         """
         # launch_cvd assumes host bins are in $ANDROID_HOST_OUT, let's overwrite
         # it to wherever we're running launch_cvd since they could be in a
         # different dir (e.g. downloaded image).
         os.environ[_ENV_ANDROID_HOST_OUT] = host_bins_path
         # Cuttlefish support launch single AVD at one time currently.
         if utils.IsCommandRunning(constants.CMD_LAUNCH_CVD):
             logger.info("Cuttlefish AVD is already running.")
             if no_prompts or utils.GetUserAnswerYes(_CONFIRM_RELAUNCH):
                 stop_cvd_cmd = os.path.join(host_bins_path,
                                             "bin",
                                             constants.CMD_STOP_CVD)
                 with open(os.devnull, "w") as dev_null:
                     subprocess.check_call(
                         utils.AddUserGroupsToCmd(
                             stop_cvd_cmd, constants.LIST_CF_USER_GROUPS),
                         stderr=dev_null, stdout=dev_null, shell=True)

                 # Delete ssvnc viewer
                 delete.CleanupSSVncviewer(constants.CF_TARGET_VNC_PORT)

             else:
                 print("Exiting out")
                 sys.exit()
         self._LaunchCvd(cmd)

     @staticmethod
     @utils.TimeExecute(function_description="Waiting for AVD(s) to boot up")
     @utils.TimeoutException(_LAUNCH_CVD_TIMEOUT_SECS, _LAUNCH_CVD_TIMEOUT_ERROR)
     def _LaunchCvd(cmd):
         """Execute Launch CVD.

         Kick off the launch_cvd command and log the output.

         Args:
             cmd: String, launch_cvd command.

         Raises:
             errors.LaunchCVDFail when any CalledProcessError.
         """
         try:
             # Check the result of launch_cvd command.
             # An exit code of 0 is equivalent to VIRTUAL_DEVICE_BOOT_COMPLETED
             logger.debug(subprocess.check_output(cmd, shell=True,
                                                  stderr=subprocess.STDOUT))
         except subprocess.CalledProcessError as error:
             raise errors.LaunchCVDFail(
                 "Can't launch cuttlefish AVD.%s. \nFor more detail: "
                 "~/cuttlefish_runtime/launcher.log" % error.message)

     @staticmethod
     def PrintDisclaimer():
         """Print Disclaimer."""
         utils.PrintColorString(
             "(Disclaimer: Local cuttlefish instance is not a fully supported\n"
             "runtime configuration, fixing breakages is on a best effort SLO.)\n",
             utils.TextColors.WARNING)
	#!/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.
	r"""LocalImageLocalInstance class.

	Create class that is responsible for creating a local instance AVD with a
	local image.
	"""

	from __future__ import print_function
	import logging
	import os
	import subprocess
	import sys

	from acloud import errors
	from acloud.create import base_avd_create
	from acloud.delete import delete
	from acloud.internal import constants
	from acloud.internal.lib import utils
	from acloud.public import report

	logger = logging.getLogger(__name__)

	_CMD_LAUNCH_CVD_ARGS = (" --daemon --cpus %s --x_res %s --y_res %s --dpi %s "
	"--memory_mb %s --blank_data_image_mb %s "
	"--data_policy always_create "
	"--system_image_dir %s "
	"--vnc_server_port %s")
	_CONFIRM_RELAUNCH = ("\nCuttlefish AVD is already running. \n"
	"Enter 'y' to terminate current instance and launch a new "
	"instance, enter anything else to exit out[y/N]: ")
	_ENV_ANDROID_HOST_OUT = "ANDROID_HOST_OUT"
	_LAUNCH_CVD_TIMEOUT_SECS = 60 # setup timeout as 60 seconds
	_LAUNCH_CVD_TIMEOUT_ERROR = ("Cuttlefish AVD launch timeout, did not complete "
	"within %d secs." % _LAUNCH_CVD_TIMEOUT_SECS)

	class LocalImageLocalInstance(base_avd_create.BaseAVDCreate):
	"""Create class for a local image local instance AVD."""

	@utils.TimeExecute(function_description="Total time: ",
	print_before_call=False, print_status=False)
	def _CreateAVD(self, avd_spec, no_prompts):
	"""Create the AVD.

	Args:
	avd_spec: AVDSpec object that tells us what we're going to create.
	no_prompts: Boolean, True to skip all prompts.
	"""
	# Running instances on local is not supported on all OS.
	if not utils.IsSupportedPlatform(print_warning=True):
	result_report = report.Report(constants.LOCAL_INS_NAME)
	result_report.SetStatus(report.Status.FAIL)
	return result_report

	self.PrintDisclaimer()
	local_image_path, host_bins_path = self.GetImageArtifactsPath(avd_spec)

	launch_cvd_path = os.path.join(host_bins_path, "bin",
	constants.CMD_LAUNCH_CVD)
	cmd = self.PrepareLaunchCVDCmd(launch_cvd_path,
	avd_spec.hw_property,
	local_image_path)
	try:
	self.CheckLaunchCVD(cmd, host_bins_path, no_prompts)
	except errors.LaunchCVDFail as launch_error:
	raise launch_error

	result_report = report.Report(constants.LOCAL_INS_NAME)
	result_report.SetStatus(report.Status.SUCCESS)
	result_report.AddData(
	key="devices",
	value={"adb_port": constants.DEFAULT_ADB_PORT,
	constants.VNC_PORT: constants.DEFAULT_VNC_PORT})
	# Launch vnc client if we're auto-connecting.
	if avd_spec.autoconnect:
	utils.LaunchVNCFromReport(result_report, avd_spec, no_prompts)
	return result_report

	@staticmethod
	def GetImageArtifactsPath(avd_spec):
	"""Get image artifacts path.

	This method will check if launch_cvd is exist and return the tuple path
	(image path and host bins path) where they are located respectively.
	For remote image, RemoteImageLocalInstance will override this method and
	return the artifacts path which is extracted and downloaded from remote.

	Args:
	avd_spec: AVDSpec object that tells us what we're going to create.

	Returns:
	Tuple of (local image file, host bins package) paths.
	"""
	# Check if launch_cvd is exist.
	host_bins_path = os.environ.get(_ENV_ANDROID_HOST_OUT)
	launch_cvd_path = os.path.join(host_bins_path, "bin",
	constants.CMD_LAUNCH_CVD)
	if not os.path.exists(launch_cvd_path):
	raise errors.GetCvdLocalHostPackageError(
	"No launch_cvd found. Please run \"m launch_cvd\" first")

	return avd_spec.local_image_dir, host_bins_path

	@staticmethod
	def PrepareLaunchCVDCmd(launch_cvd_path, hw_property, system_image_dir):
	"""Prepare launch_cvd command.

	Create the launch_cvd commands with all the required args and add
	in the user groups to it if necessary.

	Args:
	launch_cvd_path: String of launch_cvd path.
	hw_property: dict object of hw property.
	system_image_dir: String of local images path.

	Returns:
	String, launch_cvd cmd.
	"""
	launch_cvd_w_args = launch_cvd_path + _CMD_LAUNCH_CVD_ARGS % (
	hw_property["cpu"], hw_property["x_res"], hw_property["y_res"],
	hw_property["dpi"], hw_property["memory"], hw_property["disk"],
	system_image_dir, constants.DEFAULT_VNC_PORT)

	launch_cmd = utils.AddUserGroupsToCmd(launch_cvd_w_args,
	constants.LIST_CF_USER_GROUPS)
	logger.debug("launch_cvd cmd:\n %s", launch_cmd)
	return launch_cmd

	def CheckLaunchCVD(self, cmd, host_bins_path, no_prompts=False):
	"""Execute launch_cvd command and wait for boot up completed.

	Args:
	cmd: String, launch_cvd command.
	host_bins_path: String of host package directory.
	no_prompts: Boolean, True to skip all prompts.
	"""
	# launch_cvd assumes host bins are in $ANDROID_HOST_OUT, let's overwrite
	# it to wherever we're running launch_cvd since they could be in a
	# different dir (e.g. downloaded image).
	os.environ[_ENV_ANDROID_HOST_OUT] = host_bins_path
	# Cuttlefish support launch single AVD at one time currently.
	if utils.IsCommandRunning(constants.CMD_LAUNCH_CVD):
	logger.info("Cuttlefish AVD is already running.")
	if no_prompts or utils.GetUserAnswerYes(_CONFIRM_RELAUNCH):
	stop_cvd_cmd = os.path.join(host_bins_path,
	"bin",
	constants.CMD_STOP_CVD)
	with open(os.devnull, "w") as dev_null:
	subprocess.check_call(
	utils.AddUserGroupsToCmd(
	stop_cvd_cmd, constants.LIST_CF_USER_GROUPS),
	stderr=dev_null, stdout=dev_null, shell=True)

	# Delete ssvnc viewer
	delete.CleanupSSVncviewer(constants.CF_TARGET_VNC_PORT)

	else:
	print("Exiting out")
	sys.exit()
	self._LaunchCvd(cmd)

	@staticmethod
	@utils.TimeExecute(function_description="Waiting for AVD(s) to boot up")
	@utils.TimeoutException(_LAUNCH_CVD_TIMEOUT_SECS, _LAUNCH_CVD_TIMEOUT_ERROR)
	def _LaunchCvd(cmd):
	"""Execute Launch CVD.

	Kick off the launch_cvd command and log the output.

	Args:
	cmd: String, launch_cvd command.

	Raises:
	errors.LaunchCVDFail when any CalledProcessError.
	"""
	try:
	# Check the result of launch_cvd command.
	# An exit code of 0 is equivalent to VIRTUAL_DEVICE_BOOT_COMPLETED
	logger.debug(subprocess.check_output(cmd, shell=True,
	stderr=subprocess.STDOUT))
	except subprocess.CalledProcessError as error:
	raise errors.LaunchCVDFail(
	"Can't launch cuttlefish AVD.%s. \nFor more detail: "
	"~/cuttlefish_runtime/launcher.log" % error.message)

	@staticmethod
	def PrintDisclaimer():
	"""Print Disclaimer."""
	utils.PrintColorString(
	"(Disclaimer: Local cuttlefish instance is not a fully supported\n"
	"runtime configuration, fixing breakages is on a best effort SLO.)\n",
	utils.TextColors.WARNING)