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)
예제 #4
0
 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)
예제 #5
0
 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())
예제 #6
0
 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)
예제 #8
0
 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
     })
예제 #9
0
 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)
예제 #10
0
 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)
예제 #11
0
 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())
예제 #15
0
 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'
         })
예제 #18
0
 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])
예제 #21
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.'))
예제 #24
0
 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
예제 #26
0
 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])
예제 #27
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.'))
예제 #29
0
  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'))