def testProcessArtifacts(self, mock_upload, mock_download):
"""test ProcessArtifacts."""
# Test image source type is local.
args = mock.MagicMock()
args.config_file = ""
args.avd_type = constants.TYPE_CF
args.flavor = "phone"
args.local_image = None
avd_spec_local_img = avd_spec.AVDSpec(args)
fake_image_name = "/fake/aosp_cf_x86_phone-img-eng.username.zip"
fake_host_package_name = "/fake/host_package.tar.gz"
factory_local_img = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
avd_spec_local_img,
fake_image_name,
fake_host_package_name)
factory_local_img._ProcessArtifacts(constants.IMAGE_SRC_LOCAL)
self.assertEqual(mock_upload.call_count, 1)
# Test image source type is remote.
args.local_image = ""
args.build_id = "1234"
args.branch = "fake_branch"
args.build_target = "fake_target"
args.system_build_id = "2345"
args.system_branch = "sys_branch"
args.system_build_target = "sys_target"
args.kernel_build_id = "3456"
args.kernel_branch = "kernel_branch"
args.kernel_build_target = "kernel_target"
avd_spec_remote_img = avd_spec.AVDSpec(args)
self.Patch(cvd_compute_client_multi_stage.CvdComputeClient, "UpdateFetchCvd")
factory_remote_img = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
avd_spec_remote_img)
factory_remote_img._ProcessArtifacts(constants.IMAGE_SRC_REMOTE)
self.assertEqual(mock_download.call_count, 1)
def testRemoteHostInstanceName(self):
"""Test Remote host instance name."""
args = mock.MagicMock()
args.config_file = ""
args.avd_type = constants.TYPE_CF
args.flavor = "phone"
args.remote_host = "1.1.1.1"
args.local_image = None
args.adb_port = None
fake_avd_spec = avd_spec.AVDSpec(args)
fake_avd_spec.cfg.enable_multi_stage = True
fake_avd_spec._instance_name_to_reuse = None
fake_uuid = mock.MagicMock(hex="1234")
self.Patch(uuid, "uuid4", return_value=fake_uuid)
self.Patch(cvd_compute_client_multi_stage.CvdComputeClient, "CreateInstance")
self.Patch(cvd_compute_client_multi_stage.CvdComputeClient, "InitRemoteHost")
fake_host_package_name = "/fake/host_package.tar.gz"
fake_image_name = "/fake/aosp_cf_x86_phone-img-eng.username.zip"
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
fake_avd_spec,
fake_image_name,
fake_host_package_name)
self.assertEqual(factory._InitRemotehost(), "host-1.1.1.1-userbuild-aosp_cf_x86_phone")
# No image zip path, it uses local build images.
fake_image_name = ""
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
fake_avd_spec,
fake_image_name,
fake_host_package_name)
self.assertEqual(factory._InitRemotehost(), "host-1.1.1.1-userbuild-fake-target")
def testGetLaunchCvdArgs(self, _mock_check_img, _mock_env):
"""test GetLaunchCvdArgs."""
# test GetLaunchCvdArgs with avd_spec
fake_avd_spec = avd_spec.AVDSpec(self.args)
expeted_args = [
"-x_res=1080", "-y_res=1920", "-dpi=240", "-cpus=2",
"-memory_mb=4096", "-num_instances=2",
"--setupwizard_mode=REQUIRED", "-gpu_mode=drm_virgl",
"-undefok=report_anonymous_usage_stats",
"-report_anonymous_usage_stats=y"
]
launch_cvd_args = self.cvd_compute_client_multi_stage._GetLaunchCvdArgs(
fake_avd_spec)
self.assertEqual(launch_cvd_args, expeted_args)
# test GetLaunchCvdArgs without avd_spec
expeted_args = [
"-x_res=720", "-y_res=1280", "-dpi=160",
"--setupwizard_mode=REQUIRED", "-gpu_mode=drm_virgl",
"-undefok=report_anonymous_usage_stats",
"-report_anonymous_usage_stats=y"
]
launch_cvd_args = self.cvd_compute_client_multi_stage._GetLaunchCvdArgs(
avd_spec=None)
self.assertEqual(launch_cvd_args, expeted_args)
def testGetBuildInfoDict(self):
"""Test GetBuildInfoDict."""
fake_host_package_name = "/fake/host_package.tar.gz"
fake_image_name = "/fake/aosp_cf_x86_phone-img-eng.username.zip"
args = mock.MagicMock()
# Test image source type is local.
args.config_file = ""
args.avd_type = constants.TYPE_CF
args.flavor = "phone"
args.local_image = "fake_local_image"
args.adb_port = None
args.cheeps_betty_image = None
avd_spec_local_image = avd_spec.AVDSpec(args)
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
avd_spec_local_image,
fake_image_name,
fake_host_package_name)
self.assertEqual(factory.GetBuildInfoDict(), None)
# Test image source type is remote.
args.local_image = ""
args.build_id = "123"
args.branch = "fake_branch"
args.build_target = "fake_target"
args.system_build_id = "234"
args.system_branch = "sys_branch"
args.system_build_target = "sys_target"
args.kernel_build_id = "345"
args.kernel_branch = "kernel_branch"
args.kernel_build_target = "kernel_target"
avd_spec_remote_image = avd_spec.AVDSpec(args)
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
avd_spec_remote_image,
fake_image_name,
fake_host_package_name)
expected_build_info = {
"build_id": "123",
"branch": "fake_branch",
"build_target": "fake_target",
"system_build_id": "234",
"system_branch": "sys_branch",
"system_build_target": "sys_target",
"kernel_build_id": "345",
"kernel_branch": "kernel_branch",
"kernel_build_target": "kernel_target"
}
self.assertEqual(factory.GetBuildInfoDict(), expected_build_info)
def setUp(self):
"""Initialize new avd_spec.AVDSpec."""
super(AvdSpecTest, self).setUp()
self.args = mock.MagicMock()
self.args.flavor = ""
self.args.local_image = ""
self.args.config_file = ""
self.args.build_target = "fake_build_target"
self.args.adb_port = None
self.Patch(list_instances, "ChooseOneRemoteInstance", return_value=mock.MagicMock())
self.Patch(list_instances, "GetInstancesFromInstanceNames", return_value=mock.MagicMock())
self.AvdSpec = avd_spec.AVDSpec(self.args)
def testProcessRemoteBuildArgs(self):
"""Test _ProcessRemoteBuildArgs."""
self.args.branch = "git_master"
self.args.build_id = "1234"
# Verify auto-assigned avd_type if build_targe contains "_gce_".
self.args.build_target = "aosp_gce_x86_phone-userdebug"
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertTrue(self.AvdSpec.avd_type == "gce")
# Verify auto-assigned avd_type if build_targe contains "gce_".
self.args.build_target = "gce_x86_phone-userdebug"
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertTrue(self.AvdSpec.avd_type == "gce")
# Verify auto-assigned avd_type if build_targe contains "_cf_".
self.args.build_target = "aosp_cf_x86_phone-userdebug"
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertTrue(self.AvdSpec.avd_type == "cuttlefish")
# Verify auto-assigned avd_type if build_targe contains "cf_".
self.args.build_target = "cf_x86_phone-userdebug"
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertTrue(self.AvdSpec.avd_type == "cuttlefish")
# Verify auto-assigned avd_type if build_targe contains "sdk_".
self.args.build_target = "sdk_phone_armv7-sdk"
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertTrue(self.AvdSpec.avd_type == "goldfish")
# Verify auto-assigned avd_type if build_targe contains "_sdk_".
self.args.build_target = "aosp_sdk_phone_armv7-sdk"
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertTrue(self.AvdSpec.avd_type == "goldfish")
# Verify auto-assigned avd_type if no match, default as cuttlefish.
self.args.build_target = "mini_emulator_arm64-userdebug"
self.args.avd_type = "cuttlefish"
# reset args.avd_type default value as cuttlefish.
self.AvdSpec = avd_spec.AVDSpec(self.args)
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertTrue(self.AvdSpec.avd_type == "cuttlefish")
self.args.cheeps_betty_image = 'abcdefg'
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertEqual(
self.AvdSpec.remote_image[constants.CHEEPS_BETTY_IMAGE],
self.args.cheeps_betty_image)
self.args.cheeps_betty_image = None
self.AvdSpec._ProcessRemoteBuildArgs(self.args)
self.assertEqual(
self.AvdSpec.remote_image[constants.CHEEPS_BETTY_IMAGE],
self.args.cheeps_betty_image)
def testUploadArtifacts(self, mock_ssh_run, mock_shell):
"""Test UploadArtifacts."""
fake_host_package = "/fake/host_package.tar.gz"
fake_image = "/fake/aosp_cf_x86_phone-img-eng.username.zip"
fake_local_image_dir = "/fake_image"
fake_ip = ssh.IP(external="1.1.1.1", internal="10.1.1.1")
args = mock.MagicMock()
# Test local image extract from image zip case.
args.config_file = ""
args.avd_type = constants.TYPE_CF
args.flavor = "phone"
args.local_image = "fake_local_image"
args.adb_port = None
avd_spec_local_image = avd_spec.AVDSpec(args)
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
avd_spec_local_image,
fake_image,
fake_host_package)
factory._ssh = ssh.Ssh(ip=fake_ip,
user=constants.GCE_USER,
ssh_private_key_path="/fake/acloud_rea")
factory._UploadArtifacts(fake_image, fake_host_package, fake_local_image_dir)
expected_cmd1 = ("/usr/bin/install_zip.sh . < %s" % fake_image)
expected_cmd2 = ("tar -x -z -f - < %s" % fake_host_package)
mock_ssh_run.assert_has_calls([
mock.call(expected_cmd1),
mock.call(expected_cmd2)])
# Test local image get from local folder case.
fake_image = None
self.Patch(glob, "glob", return_value=["fake.img"])
factory._UploadArtifacts(fake_image, fake_host_package, fake_local_image_dir)
expected_cmd = (
"tar -cf - --lzop -S -C %s fake.img | "
"%s -- tar -xf - --lzop -S" %
(fake_local_image_dir, factory._ssh.GetBaseCmd(constants.SSH_BIN)))
mock_shell.assert_called_once_with(expected_cmd)
mock_shell.reset_mock()
m = mock.mock_open(read_data = (
"boot.img\n"
"cache.img\n"
"super.img\n"
"userdata.img\n"
"vendor_boot.img\n"))
with mock.patch.object(six.moves.builtins, "open", m):
factory._UploadArtifacts(fake_image, fake_host_package, fake_local_image_dir)
expected_cmd = (
"tar -cf - --lzop -S -C %s boot.img cache.img super.img userdata.img vendor_boot.img | "
"%s -- tar -xf - --lzop -S" %
(fake_local_image_dir, factory._ssh.GetBaseCmd(constants.SSH_BIN)))
mock_shell.assert_called_once_with(expected_cmd)
def testCreateInstance(self, mock_shell, mock_create_gce):
fake_host_package = "/fake/host_package.tar.gz"
fake_ip = ssh.IP(external="1.1.1.1", internal="10.1.1.1")
args = mock.MagicMock()
# Test local image extract from image zip case.
args.config_file = ""
args.avd_type = constants.TYPE_FVP
args.flavor = "phone"
args.local_image = "fake_local_image"
args.local_image_dir = "fake_local_image_dir"
args.adb_port = None
avd_spec_local_image = avd_spec.AVDSpec(args)
factory = remote_instance_fvp_device_factory.RemoteInstanceDeviceFactory(
avd_spec_local_image)
factory._ssh = ssh.Ssh(ip=fake_ip,
user=constants.GCE_USER,
ssh_private_key_path="/fake/acloud_rea")
m = mock.mock_open(read_data=("bl1.bin\n"
"boot.img\n"
"fip.bin\n"
"system-qemu.img\n"
"userdata.img\n"))
with mock.patch.object(six.moves.builtins, "open", m):
factory.CreateInstance()
mock_create_gce.assert_called_once()
expected_cmds = [
("tar -cf - --lzop -S -C /path/to/product/out bl1.bin boot.img "
"fip.bin system-qemu.img userdata.img | "
"%s -- tar -xf - --lzop -S" %
factory._ssh.GetBaseCmd(constants.SSH_BIN)),
("tar -cf - --lzop -S -C /path/to/model . | "
"%s -- tar -xf - --lzop -S" %
factory._ssh.GetBaseCmd(constants.SSH_BIN)),
("%s device/generic/goldfish/fvpbase/run_model_only "
"[email protected]:run_model_only" %
factory._ssh.GetBaseCmd(constants.SCP_BIN)),
("%s -- mkdir -p lib64" %
factory._ssh.GetBaseCmd(constants.SSH_BIN)),
("%s /path/to/host/out/lib64/bind_to_localhost.so "
"[email protected]:lib64/bind_to_localhost.so" %
factory._ssh.GetBaseCmd(constants.SCP_BIN)),
("%s -- sh -c \"'ANDROID_HOST_OUT=. ANDROID_PRODUCT_OUT=. "
"MODEL_BIN=./FVP_Base_RevC-2xAEMv8A "
"./run_model_only > /dev/null 2> /dev/null &'\"" %
factory._ssh.GetBaseCmd(constants.SSH_BIN)),
]
mock_shell.assert_has_calls([mock.call(cmd) for cmd in expected_cmds])
def Run(args):
"""Run create.
Args:
args: Namespace object from argparse.parse_args.
Returns:
A Report instance.
"""
if not args.skip_pre_run_check:
PreRunCheck(args)
spec = avd_spec.AVDSpec(args)
avd_creator_class = GetAvdCreatorClass(spec.avd_type, spec.instance_type,
spec.image_source)
avd_creator = avd_creator_class()
report = avd_creator.Create(spec, args.no_prompt)
return report
def testCreateGceInstanceNameMultiStage(self):
"""test create gce instance."""
# Mock uuid
args = mock.MagicMock()
args.config_file = ""
args.avd_type = constants.TYPE_CF
args.flavor = "phone"
args.local_image = None
args.adb_port = None
fake_avd_spec = avd_spec.AVDSpec(args)
fake_avd_spec.cfg.enable_multi_stage = True
fake_avd_spec._instance_name_to_reuse = None
fake_uuid = mock.MagicMock(hex="1234")
self.Patch(uuid, "uuid4", return_value=fake_uuid)
self.Patch(cvd_compute_client_multi_stage.CvdComputeClient, "CreateInstance")
self.Patch(cvd_compute_client_multi_stage.CvdComputeClient,
"GetHostImageName", return_value="fake_image")
fake_host_package_name = "/fake/host_package.tar.gz"
fake_image_name = "/fake/aosp_cf_x86_phone-img-eng.username.zip"
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
fake_avd_spec,
fake_image_name,
fake_host_package_name)
self.assertEqual(factory._CreateGceInstance(), "ins-1234-userbuild-aosp-cf-x86-phone")
# Can't get target name from zip file name.
fake_image_name = "/fake/aosp_cf_x86_phone.username.zip"
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
fake_avd_spec,
fake_image_name,
fake_host_package_name)
self.assertEqual(factory._CreateGceInstance(), "ins-1234-userbuild-fake-target")
# No image zip path, it uses local build images.
fake_image_name = ""
factory = remote_instance_cf_device_factory.RemoteInstanceDeviceFactory(
fake_avd_spec,
fake_image_name,
fake_host_package_name)
self.assertEqual(factory._CreateGceInstance(), "ins-1234-userbuild-fake-target")
def testCreateInstance(self, _get_user, _get_disk_args, mock_create,
_get_image, _compare_machine_size, mock_check_img,
_mock_env):
"""Test CreateInstance."""
expected_metadata = {
"cvd_01_dpi":
str(self.DPI),
"cvd_01_fetch_android_build_target":
self.TARGET,
"cvd_01_fetch_android_bid":
"{branch}/{build_id}".format(branch=self.BRANCH,
build_id=self.BUILD_ID),
"cvd_01_fetch_kernel_bid":
"{branch}/{build_id}".format(branch=self.KERNEL_BRANCH,
build_id=self.KERNEL_BUILD_ID),
"cvd_01_fetch_kernel_build_target":
self.KERNEL_BUILD_TARGET,
"cvd_01_x_res":
str(self.X_RES),
"cvd_01_y_res":
str(self.Y_RES),
"user":
"******",
"cvd_01_data_policy":
self.cvd_compute_client.DATA_POLICY_CREATE_IF_MISSING,
"cvd_01_blank_data_disk_size":
str(self.EXTRA_DATA_DISK_SIZE_GB * 1024),
}
expected_metadata_local_image = {
"cvd_01_dpi":
str(self.DPI),
"cvd_01_x_res":
str(self.X_RES),
"cvd_01_y_res":
str(self.Y_RES),
"user":
"******",
"cvd_01_data_policy":
self.cvd_compute_client.DATA_POLICY_CREATE_IF_MISSING,
"cvd_01_blank_data_disk_size":
str(self.EXTRA_DATA_DISK_SIZE_GB * 1024),
}
expected_metadata.update(self.METADATA)
expected_metadata_local_image.update(self.METADATA)
remote_image_metadata = dict(expected_metadata)
remote_image_metadata["cvd_01_launch"] = self.LAUNCH_ARGS
expected_disk_args = [{"fake_arg": "fake_value"}]
self.cvd_compute_client.CreateInstance(self.INSTANCE,
self.IMAGE,
self.IMAGE_PROJECT,
self.TARGET,
self.BRANCH,
self.BUILD_ID,
self.KERNEL_BRANCH,
self.KERNEL_BUILD_ID,
self.KERNEL_BUILD_TARGET,
self.EXTRA_DATA_DISK_SIZE_GB,
extra_scopes=self.EXTRA_SCOPES)
mock_create.assert_called_with(self.cvd_compute_client,
instance=self.INSTANCE,
image_name=self.IMAGE,
image_project=self.IMAGE_PROJECT,
disk_args=expected_disk_args,
metadata=remote_image_metadata,
machine_type=self.MACHINE_TYPE,
network=self.NETWORK,
zone=self.ZONE,
extra_scopes=self.EXTRA_SCOPES)
#test use local image in the remote instance.
local_image_metadata = dict(expected_metadata_local_image)
args = mock.MagicMock()
mock_check_img.return_value = True
args.local_image = None
args.config_file = ""
args.avd_type = constants.TYPE_CF
args.flavor = "phone"
args.adb_port = None
args.remote_host = False
fake_avd_spec = avd_spec.AVDSpec(args)
fake_avd_spec.hw_property[constants.HW_X_RES] = str(self.X_RES)
fake_avd_spec.hw_property[constants.HW_Y_RES] = str(self.Y_RES)
fake_avd_spec.hw_property[constants.HW_ALIAS_DPI] = str(self.DPI)
fake_avd_spec.hw_property[constants.HW_ALIAS_DISK] = str(
self.EXTRA_DATA_DISK_SIZE_GB * 1024)
local_image_metadata["avd_type"] = constants.TYPE_CF
local_image_metadata["flavor"] = "phone"
local_image_metadata[constants.INS_KEY_DISPLAY] = (
"%sx%s (%s)" % (fake_avd_spec.hw_property[constants.HW_X_RES],
fake_avd_spec.hw_property[constants.HW_Y_RES],
fake_avd_spec.hw_property[constants.HW_ALIAS_DPI]))
self.cvd_compute_client.CreateInstance(self.INSTANCE,
self.IMAGE,
self.IMAGE_PROJECT,
self.TARGET,
self.BRANCH,
self.BUILD_ID,
self.KERNEL_BRANCH,
self.KERNEL_BUILD_ID,
self.KERNEL_BUILD_TARGET,
self.EXTRA_DATA_DISK_SIZE_GB,
fake_avd_spec,
extra_scopes=self.EXTRA_SCOPES)
mock_create.assert_called_with(self.cvd_compute_client,
instance=self.INSTANCE,
image_name=self.IMAGE,
image_project=self.IMAGE_PROJECT,
disk_args=expected_disk_args,
metadata=local_image_metadata,
machine_type=self.MACHINE_TYPE,
network=self.NETWORK,
zone=self.ZONE,
extra_scopes=self.EXTRA_SCOPES)
def testCreateInstance(self, _get_user, _get_disk_args, mock_create,
_get_image, _compare_machine_size, mock_check_img,
_mock_env):
"""Test CreateInstance."""
expected_metadata = dict()
expected_metadata_local_image = dict()
expected_metadata.update(self.METADATA)
expected_metadata_local_image.update(self.METADATA)
remote_image_metadata = dict(expected_metadata)
expected_disk_args = [{"fake_arg": "fake_value"}]
fake_avd_spec = avd_spec.AVDSpec(self.args)
fake_avd_spec._instance_name_to_reuse = None
created_subprocess = mock.MagicMock()
created_subprocess.stdout = mock.MagicMock()
created_subprocess.stdout.readline = mock.MagicMock(return_value=b"")
created_subprocess.poll = mock.MagicMock(return_value=0)
created_subprocess.returncode = 0
created_subprocess.communicate = mock.MagicMock(return_value=('', ''))
self.Patch(cvd_compute_client_multi_stage.CvdComputeClient,
"_RecordSystemAndKernelInfo")
self.Patch(subprocess, "Popen", return_value=created_subprocess)
self.Patch(subprocess, "check_call")
self.Patch(os, "chmod")
self.Patch(os, "stat")
self.Patch(os, "remove")
self.Patch(os, "rmdir")
self.cvd_compute_client_multi_stage.CreateInstance(
self.INSTANCE,
self.IMAGE,
self.IMAGE_PROJECT,
self.TARGET,
self.BRANCH,
self.BUILD_ID,
self.KERNEL_BRANCH,
self.KERNEL_BUILD_ID,
self.KERNEL_BUILD_TARGET,
self.EXTRA_DATA_DISK_SIZE_GB,
extra_scopes=self.EXTRA_SCOPES)
mock_create.assert_called_with(self.cvd_compute_client_multi_stage,
instance=self.INSTANCE,
image_name=self.IMAGE,
image_project=self.IMAGE_PROJECT,
disk_args=expected_disk_args,
metadata=remote_image_metadata,
machine_type=self.MACHINE_TYPE,
network=self.NETWORK,
zone=self.ZONE,
extra_scopes=self.EXTRA_SCOPES,
gpu=self.GPU,
tags=None)
mock_check_img.return_value = True
#test use local image in the remote instance.
local_image_metadata = dict(expected_metadata_local_image)
fake_avd_spec.hw_property[constants.HW_X_RES] = str(self.X_RES)
fake_avd_spec.hw_property[constants.HW_Y_RES] = str(self.Y_RES)
fake_avd_spec.hw_property[constants.HW_ALIAS_DPI] = str(self.DPI)
fake_avd_spec.hw_property[constants.HW_ALIAS_DISK] = str(
self.EXTRA_DATA_DISK_SIZE_GB * 1024)
local_image_metadata["avd_type"] = constants.TYPE_CF
local_image_metadata["flavor"] = "phone"
local_image_metadata[constants.INS_KEY_DISPLAY] = (
"%sx%s (%s)" % (fake_avd_spec.hw_property[constants.HW_X_RES],
fake_avd_spec.hw_property[constants.HW_Y_RES],
fake_avd_spec.hw_property[constants.HW_ALIAS_DPI]))
self.cvd_compute_client_multi_stage.CreateInstance(
self.INSTANCE,
self.IMAGE,
self.IMAGE_PROJECT,
self.TARGET,
self.BRANCH,
self.BUILD_ID,
self.KERNEL_BRANCH,
self.KERNEL_BUILD_ID,
self.KERNEL_BUILD_TARGET,
self.EXTRA_DATA_DISK_SIZE_GB,
fake_avd_spec,
extra_scopes=self.EXTRA_SCOPES)
mock_create.assert_called_with(self.cvd_compute_client_multi_stage,
instance=self.INSTANCE,
image_name=self.IMAGE,
image_project=self.IMAGE_PROJECT,
disk_args=expected_disk_args,
metadata=local_image_metadata,
machine_type=self.MACHINE_TYPE,
network=self.NETWORK,
zone=self.ZONE,
extra_scopes=self.EXTRA_SCOPES,
gpu=self.GPU,
tags=None)
