def testCreateRhel7CustomImage(self):
vm_class = virtual_machine.GetVmClass(providers.GCP, os_types.RHEL7)
fake_image = 'fake-custom-rhel-image'
spec = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type='fake-machine-type',
image=fake_image)
with PatchCriticalObjects(
self._CreateFakeReturnValues()) as issue_command:
vm = vm_class(spec)
vm._Create()
vm.created = True
command_string = ' '.join(issue_command.call_args[0][0])
self.assertEqual(issue_command.call_count, 1)
self.assertIn('gcloud compute instances create', command_string)
self.assertIn('--image ' + fake_image, command_string)
self.assertIn('--image-project rhel-cloud', command_string)
vm._PostCreate()
self.assertEqual(issue_command.call_count, 2)
vm_metadata = vm.GetResourceMetadata()
self.assertDictContainsSubset(
{
'image': fake_image,
'image_project': 'rhel-cloud'
}, vm_metadata)
self.assertNotIn('image_family', vm_metadata)
def setUp(self):
super(GceVirtualMachineOsTypesTestCase, self).setUp()
FLAGS.gcp_instance_metadata_from_file = ''
FLAGS.gcp_instance_metadata = ''
FLAGS.gcloud_path = 'gcloud'
p = mock.patch(gce_virtual_machine.__name__ +
'.gce_network.GceNetwork.GetNetwork')
self.mock_get_network = p.start()
self.addCleanup(p.stop)
p = mock.patch(gce_virtual_machine.__name__ +
'.gce_network.GceFirewall.GetFirewall')
self.mock_get_firewall = p.start()
self.addCleanup(p.stop)
self.spec = gce_virtual_machine.GceVmSpec(
_COMPONENT, machine_type='fake-machine-type')
p = mock.patch(gce_virtual_machine.__name__ +
'.linux_vm.BaseLinuxMixin._GetNumCpus')
self.mock_get_num_cpus = p.start()
self.addCleanup(p.stop)
get_tmp_dir_mock = mock.patch(vm_util.__name__ + '.GetTempDir',
return_value='TempDir')
get_tmp_dir_mock.start()
self.addCleanup(get_tmp_dir_mock.stop)
def testCreateUbuntuInCustomProject(self):
"""Test simulating passing --image and --image_project."""
vm_class = virtual_machine.GetVmClass(providers.GCP,
os_types.UBUNTU1604)
fake_image = 'fake-ubuntu1604'
fake_image_project = 'fake-project'
spec = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type='fake-machine-type',
image=fake_image,
image_project=fake_image_project)
with PatchCriticalObjects(
self._CreateFakeReturnValues(fake_image)) as issue_command:
vm = vm_class(spec)
vm._Create()
vm.created = True
command_string = ' '.join(issue_command.call_args[0][0])
self.assertEqual(issue_command.call_count, 1)
self.assertIn('gcloud compute instances create', command_string)
self.assertIn(
'--image fake-ubuntu1604 --image-project fake-project',
command_string)
self.assertNotIn('--image-family', command_string)
vm._PostCreate()
self.assertEqual(issue_command.call_count, 2)
vm_metadata = vm.GetResourceMetadata()
self.assertDictContainsSubset(
{
'image': fake_image,
'image_project': 'fake-project'
}, vm_metadata)
self.assertNotIn('image_family', vm_metadata)
def testCustomMachineTypeFlagOverride(self):
FLAGS['machine_type'].parse('{cpus: 1, memory: 7.5GiB}')
result = gce_virtual_machine.GceVmSpec(
_COMPONENT, flag_values=FLAGS, machine_type='n1-standard-8')
self.assertEqual(result.machine_type, None)
self.assertEqual(result.cpus, 1)
self.assertEqual(result.memory, 7680)
def testCustomVmNonPreemptible(self):
spec = gce_virtual_machine.GceVmSpec(_COMPONENT, machine_type={
'cpus': 1, 'memory': '1.0GiB'}, project='p')
vm = gce_virtual_machine.GceVirtualMachine(spec)
self.assertDictContainsSubset(
{'cpus': 1, 'memory_mib': 1024, 'project': 'p',
'dedicated_host': False},
vm.GetResourceMetadata())
def testVmWithMachineTypeNonPreemptible(self):
spec = gce_virtual_machine.GceVmSpec(
_COMPONENT, machine_type='test_machine_type', project='p')
vm = gce_virtual_machine.GceVirtualMachine(spec)
self.assertDictContainsSubset(
{'dedicated_host': False, 'machine_type': 'test_machine_type',
'project': 'p'},
vm.GetResourceMetadata()
)
def testCustomMachineType(self):
result = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type={
'cpus': 1,
'memory': '7.5GiB'
})
self.assertEqual(result.machine_type, None)
self.assertEqual(result.cpus, 1)
self.assertEqual(result.memory, 7680)
def testVmWithMachineTypePreemptible(self):
spec = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type='test_machine_type',
preemptible=True)
vm = gce_virtual_machine.GceVirtualMachine(spec)
self.assertEqual(vm.GetMachineTypeDict(), {
'machine_type': 'test_machine_type',
'preemptible': True
})
def testStringMachineTypeFlagOverride(self):
flags = mock_flags.MockFlags()
flags['machine_type'].Parse('n1-standard-8')
result = gce_virtual_machine.GceVmSpec(
_COMPONENT, flag_values=flags,
machine_type={'cpus': 1, 'memory': '7.5GiB'})
self.assertEqual(result.machine_type, 'n1-standard-8')
self.assertEqual(result.cpus, None)
self.assertEqual(result.memory, None)
def testCustomMachineTypeFlagOverride(self):
flags = mock_flags.MockFlags()
flags.machine_type = '{cpus: 1, memory: 7.5GiB}'
result = gce_virtual_machine.GceVmSpec(_COMPONENT,
flag_values=flags,
machine_type='n1-standard-8')
self.assertEqual(result.machine_type, None)
self.assertEqual(result.cpus, 1)
self.assertEqual(result.memory, 7680)
def testMigrateOnMaintenanceFlagFalseWithGpus(self):
with PatchCriticalObjects() as issue_command:
self._mocked_flags['gce_migrate_on_maintenance'].parse(False)
vm_spec = gce_virtual_machine.GceVmSpec(
'test_vm_spec.GCP', self._mocked_flags, image='image',
machine_type='test_machine_type', gpu_count=1, gpu_type='k80')
vm = gce_virtual_machine.GceVirtualMachine(vm_spec)
vm._Create()
self.assertEquals(issue_command.call_count, 1)
def testStringMachineTypeWithGpus(self):
gpu_count = 2
gpu_type = 'k80'
result = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type='n1-standard-8',
gpu_count=gpu_count,
gpu_type=gpu_type)
self.assertEqual(result.machine_type, 'n1-standard-8')
self.assertEqual(result.gpu_type, 'k80')
self.assertEqual(result.gpu_count, 2)
def testMissingGpuType(self):
flags = mock_flags.MockFlags()
with self.assertRaises(errors.Config.MissingOption) as cm:
gce_virtual_machine.GceVmSpec('test_vm_spec.GCP',
flags,
machine_type='test_machine_type',
gpu_count=1)
self.assertEqual(str(cm.exception),
('gpu_type must be specified if gpu_count is set'))
def testCustomVmPreemptible(self):
spec = gce_virtual_machine.GceVmSpec(
_COMPONENT, machine_type={'cpus': 1, 'memory': '1.0GiB'},
preemptible=True,
project='fakeproject')
vm = pkb_common_test_case.TestGceVirtualMachine(spec)
vm.created = True
self.assertDictContainsSubset({
'cpus': 1, 'memory_mib': 1024, 'project': 'fakeproject',
'dedicated_host': False, 'preemptible': True}, vm.GetResourceMetadata())
def testPreemptibleVMFlag(self):
with self._PatchCriticalObjects() as issue_command:
self._mocked_flags['gce_preemptible_vms'].Parse(True)
vm_spec = gce_virtual_machine.GceVmSpec(
'test_vm_spec.GCP', self._mocked_flags, image='image',
machine_type='test_machine_type')
vm = gce_virtual_machine.GceVirtualMachine(vm_spec)
vm._Create()
self.assertEquals(issue_command.call_count, 1)
self.assertIn('--preemptible', issue_command.call_args[0][0])
def testVmWithMachineTypePreemptible(self):
spec = gce_virtual_machine.GceVmSpec(
_COMPONENT, machine_type='test_machine_type', preemptible=True,
project='p')
vm = pkb_common_test_case.TestGceVirtualMachine(spec)
vm.created = True
self.assertDictContainsSubset(
{'dedicated_host': False, 'machine_type': 'test_machine_type',
'preemptible': True, 'project': 'p'},
vm.GetResourceMetadata()
)
def testVmWithMachineTypeNonPreemptible(self):
spec = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type='test_machine_type',
project='p')
vm = gce_virtual_machine.GceVirtualMachine(spec)
self.assertEqual(
vm.GetMachineTypeDict(), {
'dedicated_host': False,
'machine_type': 'test_machine_type',
'project': 'p'
})
def testCustomVmNonPreemptible(self):
spec = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type={
'cpus': 1,
'memory': '1.0GiB'
})
vm = gce_virtual_machine.GceVirtualMachine(spec)
self.assertEqual(vm.GetMachineTypeDict(), {
'cpus': 1,
'memory_mib': 1024
})
def testCreateVMUnsupportedConfig(self, fake_stderr):
fake_rets = [('stdout', fake_stderr, 1)]
with PatchCriticalObjects(fake_rets):
spec = gce_virtual_machine.GceVmSpec(
_COMPONENT, machine_type={
'cpus': 1,
'memory': '1.0GiB',
})
vm = pkb_common_test_case.TestGceVirtualMachine(spec)
with self.assertRaises(errors.Benchmarks.UnsupportedConfigError):
vm._Create()
def testVmWithoutGpu(self):
with PatchCriticalObjects() as issue_command:
spec = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type={
'cpus': 1,
'memory': '1.0GiB',
})
vm = pkb_common_test_case.TestGceVirtualMachine(spec)
vm._Create()
self.assertEqual(issue_command.call_count, 1)
self.assertNotIn('--accelerator', issue_command.call_args[0][0])
def setUp(self):
p = mock.patch(gce_virtual_machine.__name__ +
'.gce_network.GceNetwork.GetNetwork')
self.mock_get_network = p.start()
self.addCleanup(p.stop)
p = mock.patch(gce_virtual_machine.__name__ +
'.gce_network.GceFirewall.GetFirewall')
self.mock_get_firewall = p.start()
self.addCleanup(p.stop)
self.spec = gce_virtual_machine.GceVmSpec(
_COMPONENT, machine_type='fake-machine-type')
def testCreateVMAlreadyExists(self):
fake_rets = [('stdout', 'The resource already exists', 1)]
with PatchCriticalObjects(fake_rets):
spec = gce_virtual_machine.GceVmSpec(_COMPONENT,
machine_type={
'cpus': 1,
'memory': '1.0GiB',
})
vm = pkb_common_test_case.TestGceVirtualMachine(spec)
with self.assertRaises(errors.Resource.CreationError):
vm._Create()
def testInvalidGpuCount(self):
flags = mock_flags.MockFlags()
with self.assertRaises(errors.Config.InvalidValue) as cm:
gce_virtual_machine.GceVmSpec('test_vm_spec.GCP',
flags,
machine_type='test_machine_type',
gpu_count=0,
gpu_type='k80')
self.assertEqual(str(cm.exception),
('Invalid test_vm_spec.GCP.gpu_count value: "0". '
'Value must be at least 1.'))
def testCustomVmWithGpus(self):
spec = gce_virtual_machine.GceVmSpec(
_COMPONENT,
machine_type={'cpus': 1, 'memory': '1.0GiB'},
gpu_count=2,
gpu_type='k80',
project='fakeproject')
vm = gce_virtual_machine.GceVirtualMachine(spec)
self.assertDictContainsSubset({
'cpus': 1, 'memory_mib': 1024, 'project': 'fakeproject',
'dedicated_host': False, 'gpu_count': 2, 'gpu_type': 'k80'
}, vm.GetResourceMetadata())
def _CreateVmCommand(self, **flag_kwargs):
with PatchCriticalObjects() as issue_command:
for key, value in flag_kwargs.items():
FLAGS[key].parse(value)
vm_spec = gce_virtual_machine.GceVmSpec(
'test_vm_spec.GCP',
FLAGS,
image='image',
machine_type='test_machine_type')
vm = gce_virtual_machine.GceVirtualMachine(vm_spec)
vm._Create()
return ' '.join(issue_command.call_args[0][0]), issue_command.call_count
def testAcceleratorTypeOverrideFlag(self):
with PatchCriticalObjects() as issue_command:
self._mocked_flags['gce_accelerator_type_override'].parse('fake_type')
vm_spec = gce_virtual_machine.GceVmSpec(
'test_vm_spec.GCP', self._mocked_flags, image='image',
machine_type='test_machine_type', gpu_count=1, gpu_type='k80')
vm = gce_virtual_machine.GceVirtualMachine(vm_spec)
vm._Create()
self.assertEquals(issue_command.call_count, 1)
self.assertIn('--accelerator', issue_command.call_args[0][0])
self.assertIn('type=fake_type,count=1',
issue_command.call_args[0][0])
def testImageProjectFlag(self):
"""Tests that custom image_project flag is supported."""
with self._PatchCriticalObjects() as issue_command:
self._mocked_flags.image_project = 'bar'
vm_spec = gce_virtual_machine.GceVmSpec(
'test_vm_spec.GCP', self._mocked_flags, image='image',
machine_type='test_machine_type')
vm = gce_virtual_machine.GceVirtualMachine(vm_spec)
vm._Create()
self.assertEquals(issue_command.call_count, 1)
self.assertIn('--image-project bar',
' '.join(issue_command.call_args[0][0]))
def testInvalidGpuType(self):
flags = mock_flags.MockFlags()
with self.assertRaises(errors.Config.InvalidValue) as cm:
gce_virtual_machine.GceVmSpec('test_vm_spec.GCP',
flags,
machine_type='test_machine_type',
gpu_count=1,
gpu_type='bad_type')
self.assertEqual(
str(cm.exception),
('Invalid test_vm_spec.GCP.gpu_type value: "bad_type". '
'Value must be one of the following: k80.'))
def testMigrateOnMaintenanceFlagTrueWithGpus(self):
with PatchCriticalObjects():
self._mocked_flags['gce_migrate_on_maintenance'].parse(True)
vm_spec = gce_virtual_machine.GceVmSpec(
'test_vm_spec.GCP', self._mocked_flags, image='image',
machine_type='test_machine_type', gpu_count=1, gpu_type='k80')
vm = gce_virtual_machine.GceVirtualMachine(vm_spec)
with self.assertRaises(errors.Config.InvalidValue) as cm:
vm._Create()
self.assertEqual(str(cm.exception), (
'Cannot set flag gce_migrate_on_maintenance on '
'instances with GPUs, as it is not supported by GCP.'))
def testGenerateCreateCommand(self, machine_type, min_cpu_platform_flag,
min_cpu_platform_in_command):
spec = gce_virtual_machine.GceVmSpec(
_COMPONENT,
machine_type=machine_type,
gpu_count=2,
gpu_type='t4',
project='fakeproject',
min_cpu_platform=min_cpu_platform_flag)
vm = pkb_common_test_case.TestGceVirtualMachine(spec)
gcloud_cmd = vm._GenerateCreateCommand('x')
self.assertEqual(min_cpu_platform_in_command,
gcloud_cmd.flags.get('min-cpu-platform'))
