def __init__(self, flags=None, default_nfs_version=None):
if flags:
disk_spec = disk.BaseDiskSpec(_COMPONENT, flags)
else:
disk_spec = disk.BaseDiskSpec(_COMPONENT)
super(_NfsDisk, self).__init__(disk_spec, 'host1:/volume1',
default_nfs_version)
def __init__(self, default_smb_version=None):
if FLAGS:
disk_spec = disk.BaseDiskSpec(_COMPONENT, FLAGS)
else:
disk_spec = disk.BaseDiskSpec(_COMPONENT)
super(_SmbDisk, self).__init__(
disk_spec, 'host1', {'user': '******', 'pw': 'password'},
default_smb_version)
def testScratchDisks(self):
"""Test for creating and deleting scratch disks.
This test creates two scratch disks on a vm and deletes them, ensuring
that the proper calls to create, format, mount, and delete are made.
"""
vm = self._CreateVm()
disk_spec = disk.BaseDiskSpec(_COMPONENT, mount_point='/mountpoint0')
vm.CreateScratchDisk(disk_spec)
assert len(vm.scratch_disks) == 1, 'Disk not added to scratch disks.'
scratch_disk = vm.scratch_disks[0]
scratch_disk.Create.assert_called_once_with()
vm.FormatDisk.assert_called_once_with(scratch_disk.GetDevicePath(),
None)
vm.MountDisk.assert_called_once_with(scratch_disk.GetDevicePath(),
'/mountpoint0', None,
scratch_disk.mount_options,
scratch_disk.fstab_options)
disk_spec = disk.BaseDiskSpec(_COMPONENT, mount_point='/mountpoint1')
vm.CreateScratchDisk(disk_spec)
assert len(vm.scratch_disks) == 2, 'Disk not added to scratch disks.'
# Check that these execute without exceptions. The return value
# is a MagicMock, not a string, so we can't compare to expected results.
vm.GetScratchDir()
vm.GetScratchDir(0)
vm.GetScratchDir(1)
with self.assertRaises(errors.Error):
vm.GetScratchDir(2)
scratch_disk = vm.scratch_disks[1]
scratch_disk.Create.assert_called_once_with()
vm.FormatDisk.assert_called_with(scratch_disk.GetDevicePath(), None)
vm.MountDisk.assert_called_with(scratch_disk.GetDevicePath(),
'/mountpoint1', None,
scratch_disk.mount_options,
scratch_disk.fstab_options)
vm.DeleteScratchDisks()
vm.scratch_disks[0].Delete.assert_called_once_with()
vm.scratch_disks[1].Delete.assert_called_once_with()
def Prepare(benchmark_spec):
"""Install Cassandra and Java on target vms.
Args:
benchmark_spec: The benchmark specification. Contains all data that is
required to run the benchmark.
"""
vm_dict = benchmark_spec.vm_dict
logging.info('VM dictionary %s', vm_dict)
if vm_dict['default']:
logging.info('No config file is provided, use default settings: '
'1 loader node, 3 data nodes')
vm_dict[LOADER_NODE] = [vm_dict['default'][-1]]
vm_dict[DATA_NODE] = vm_dict['default'][:3]
disk_spec = disk.BaseDiskSpec(
500, bs.DISK_TYPE[benchmark_spec.cloud][bs.STANDARD],
'/cassandra_data')
for vm in vm_dict[DATA_NODE]:
vm.CreateScratchDisk(disk_spec)
logging.info('Authorizing loader[0] permission to access all other vms.')
vm_dict[LOADER_NODE][0].AuthenticateVm()
logging.info('Preparing data files and Java on all vms.')
vm_util.RunThreaded(PrepareVm, benchmark_spec.vms)
def doAzureDiskTest(self, storage_type, disk_type, machine_type,
goal_media, goal_replication, goal_legacy_disk_type):
with mock.patch(azure_disk.__name__ + '.FLAGS') as disk_flags:
disk_flags.azure_storage_type = storage_type
disk_spec = disk.BaseDiskSpec(_COMPONENT,
disk_size=2,
disk_type=disk_type)
context.SetThreadBenchmarkSpec(
benchmark_spec.BenchmarkSpec({}, 'name', 'uid'))
vm_spec = virtual_machine.BaseVmSpec('test_vm_spec.AZURE',
zone='East US 2',
machine_type=machine_type)
vm = azure_virtual_machine.DebianBasedAzureVirtualMachine(vm_spec)
azure_disk.AzureDisk.Create = mock.Mock()
azure_disk.AzureDisk.Attach = mock.Mock()
vm.CreateScratchDisk(disk_spec)
self.assertEqual(
vm.scratch_disks[0].metadata, {
disk.MEDIA: goal_media,
disk.REPLICATION: goal_replication,
disk.LEGACY_DISK_TYPE: goal_legacy_disk_type
})
def CreateVirtualMachineFromNodeSection(self, node_section, node_name):
"""Create a VirtualMachine object from NodeSection.
Args:
node_section: A dictionary of (option name, option value) pairs.
node_name: The name of node.
"""
zone = node_section['zone'] if 'zone' in node_section else self.zones[0]
if zone not in self.zones:
self.zones.append(zone)
if node_section['image'] not in self.image:
self.image.append(node_section['image'])
if node_section['vm_type'] not in self.machine_type:
self.machine_type.append(node_section['vm_type'])
if zone not in self.networks:
network_class = CLASSES[self.cloud][NETWORK]
self.networks[zone] = network_class(zone)
vm_spec = virtual_machine.BaseVirtualMachineSpec(
self.project, zone, node_section['vm_type'], node_section['image'],
self.networks[zone])
vm_class = CLASSES[self.cloud][VIRTUAL_MACHINE]
vms = [vm_class(vm_spec) for _ in range(int(node_section['count']))]
self.vms.extend(vms)
self.vm_dict[node_name].extend(vms)
# Create disk spec.
for option in node_section:
if option.startswith(ini_constants.OPTION_PD_PREFIX):
# Create disk spec.
disk_size, disk_type, mnt_point = node_section[option].split(
':')
disk_size = int(disk_size)
disk_spec = disk.BaseDiskSpec(disk_size, disk_type, mnt_point)
for vm in vms:
vm.disk_specs.append(disk_spec)
def __init__(self, vm_spec):
"""Initialize an Azure virtual machine.
Args:
vm_spec: virtual_machine.BaseVmSpec object of the vm.
"""
super(AzureVirtualMachine, self).__init__(vm_spec)
self.network = azure_network.AzureNetwork.GetNetwork(self)
self.firewall = azure_network.AzureFirewall.GetFirewall()
self.max_local_disks = NUM_LOCAL_VOLUMES.get(self.machine_type) or 1
self._lun_counter = itertools.count()
self._deleted = False
self.resource_group = azure_network.GetResourceGroup()
self.public_ip = AzurePublicIPAddress(self.zone,
self.name + '-public-ip')
self.nic = AzureNIC(self.network.subnet, self.name + '-nic',
self.public_ip.name,
vm_spec.accelerated_networking)
self.storage_account = self.network.storage_account
self.image = vm_spec.image or self.IMAGE_URN
disk_spec = disk.BaseDiskSpec('azure_os_disk')
self.os_disk = azure_disk.AzureDisk(disk_spec,
self.name,
self.machine_type,
self.storage_account,
None,
is_image=True)
def setUp(self):
p = mock.patch(util.__name__ + '.IssueRetryableCommand')
p.start()
self.addCleanup(p.stop)
self.disk = aws_disk.AwsDisk(disk.BaseDiskSpec(None, None, None),
'zone-a')
self.disk.id = 'vol-foo'
def Prepare(benchmark_spec):
"""Install Cassandra and Java on target vms.
Args:
benchmark_spec: The benchmark specification. Contains all data that is
required to run the benchmark.
"""
vm_dict = benchmark_spec.vm_dict
logging.info('VM dictionary %s', vm_dict)
if vm_dict['default']:
logging.info('No config file is provided, use default settings: '
'1 loader node, 3 data nodes')
vm_dict[LOADER_NODE] = [vm_dict['default'][-1]]
vm_dict[DATA_NODE] = vm_dict['default'][:3]
disk_spec = disk.BaseDiskSpec(
FLAGS.scratch_disk_size,
FLAGS.scratch_disk_type,
'/cassandra_data')
for vm in vm_dict[DATA_NODE]:
vm.CreateScratchDisk(disk_spec)
logging.info('Authorizing loader[0] permission to access all other vms.')
vm_dict[LOADER_NODE][0].AuthenticateVm()
logging.info('Preparing data files and Java on all vms.')
vm_util.RunThreaded(lambda vm: vm.Install('cassandra'), benchmark_spec.vms)
seed_vm = vm_dict[DATA_NODE][0]
configure = functools.partial(cassandra.Configure, seed_vms=[seed_vm])
vm_util.RunThreaded(configure, vm_dict[DATA_NODE])
cassandra.StartCluster(seed_vm, vm_dict[DATA_NODE][1:])
def testDeviceId(self):
with mock.patch(disk.__name__ + '.FLAGS') as disk_flags:
disk_flags.os_type = 'windows'
disk_spec = disk.BaseDiskSpec(_COMPONENT, disk_number=1, disk_size=2,
disk_type=gce_disk.PD_STANDARD)
disk_obj = gce_disk.GceDisk(disk_spec, 'name', 'zone', 'project')
self.assertEquals(disk_obj.GetDeviceId(), r'\\.\PHYSICALDRIVE1')
def __init__(self, vm_spec):
"""Initialize an Azure virtual machine.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(AzureVirtualMachine, self).__init__(vm_spec)
self.network = azure_network.AzureNetwork.GetNetwork(self)
self.firewall = azure_network.AzureFirewall.GetFirewall()
self.max_local_disks = 1
self.resource_group = azure_network.GetResourceGroup()
self.public_ip = AzurePublicIPAddress(self.zone,
self.name + '-public-ip')
self.nic = AzureNIC(self.network.subnet, self.name + '-nic')
self.storage_account = self.network.storage_account
self.image = vm_spec.image or self.IMAGE_URN
disk_spec = disk.BaseDiskSpec('azure_os_disk')
self.os_disk = azure_disk.AzureDisk(disk_spec,
self.name,
self.machine_type,
self.storage_account,
None,
is_image=True)
def DoAzureDiskTest(self, storage_type, disk_type, machine_type,
goal_media, goal_replication,
goal_host_caching, disk_size=2,
goal_size=2, goal_stripes=1):
with mock.patch(azure_disk.__name__ + '.FLAGS') as disk_flags:
disk_flags.azure_storage_type = storage_type
disk_flags.azure_host_caching = goal_host_caching
disk_spec = disk.BaseDiskSpec(_COMPONENT, disk_size=disk_size,
disk_type=disk_type,
num_striped_disks=goal_stripes)
vm_spec = virtual_machine.BaseVmSpec(
'test_vm_spec.AZURE', zone='East US 2', machine_type=machine_type)
vm = azure_virtual_machine.DebianBasedAzureVirtualMachine(
vm_spec)
azure_disk.AzureDisk.Create = mock.Mock()
azure_disk.AzureDisk.Attach = mock.Mock()
vm.StripeDisks = mock.Mock()
vm.CreateScratchDisk(disk_spec)
expected = {disk.MEDIA: goal_media,
disk.REPLICATION: goal_replication,
'num_stripes': goal_stripes,
'size': goal_size}
if goal_host_caching:
expected[azure_disk.HOST_CACHING] = goal_host_caching
self.assertDictContainsSubset(expected, vm.scratch_disks[0].metadata)
def __init__(self, vm_spec):
"""Initialize an Azure virtual machine.
Args:
vm_spec: virtual_machine.BaseVmSpec object of the vm.
"""
super(AzureVirtualMachine, self).__init__(vm_spec)
# PKB zone can be either a region or a region with an availability zone.
# Format for Azure availability zone support is "region-availability_zone"
# Example: eastus2-1 is Azure region eastus2 with availability zone 1.
self.region = util.GetRegionFromZone(self.zone)
self.availability_zone = util.GetAvailabilityZoneFromZone(self.zone)
self.use_dedicated_host = vm_spec.use_dedicated_host
self.num_vms_per_host = vm_spec.num_vms_per_host
self.network = azure_network.AzureNetwork.GetNetwork(self)
self.firewall = azure_network.AzureFirewall.GetFirewall()
self.max_local_disks = NUM_LOCAL_VOLUMES.get(self.machine_type) or 1
self._lun_counter = itertools.count()
self._deleted = False
self.resource_group = azure_network.GetResourceGroup()
self.public_ip = AzurePublicIPAddress(self.region,
self.availability_zone,
self.name + '-public-ip')
self.nic = AzureNIC(self.network.subnet, self.name + '-nic',
self.public_ip.name,
vm_spec.accelerated_networking, self.network.nsg)
self.storage_account = self.network.storage_account
if vm_spec.image:
self.image = vm_spec.image
elif self.machine_type in _MACHINE_TYPES_ONLY_SUPPORT_GEN2_IMAGES:
if hasattr(type(self), 'GEN2_IMAGE_URN'):
self.image = type(self).GEN2_IMAGE_URN
else:
raise errors.Benchmarks.UnsupportedConfigError(
'No Azure gen2 image.')
else:
self.image = type(self).IMAGE_URN
self.host = None
if self.use_dedicated_host:
self.host_series_sku = _GetSkuType(self.machine_type)
self.host_list = None
self.low_priority = vm_spec.low_priority
self.low_priority_status_code = None
self.spot_early_termination = False
self.ultra_ssd_enabled = False
disk_spec = disk.BaseDiskSpec('azure_os_disk')
disk_spec.disk_type = (vm_spec.boot_disk_type
or self.storage_account.storage_type)
if vm_spec.boot_disk_size:
disk_spec.disk_size = vm_spec.boot_disk_size
self.os_disk = azure_disk.AzureDisk(disk_spec,
self,
None,
is_image=True)
def testPDStandard(self):
disk_spec = disk.BaseDiskSpec(_COMPONENT, disk_size=2,
disk_type=gce_disk.PD_STANDARD)
disk_obj = gce_disk.GceDisk(disk_spec, 'name', 'zone', 'project')
self.assertDictContainsSubset(
{disk.MEDIA: disk.HDD, disk.REPLICATION: disk.ZONE},
disk_obj.metadata
)
def testDefaults(self): spec = disk.BaseDiskSpec(_COMPONENT) self.assertIsNone(spec.device_path) self.assertIsNone(spec.disk_number) self.assertIsNone(spec.disk_size) self.assertIsNone(spec.disk_type) self.assertIsNone(spec.mount_point) self.assertEqual(spec.num_striped_disks, 1)
def testUnrecognizedOptions(self):
with self.assertRaises(errors.Config.UnrecognizedOption) as cm:
disk.BaseDiskSpec(_COMPONENT,
color='red',
flavor='cherry',
texture=None)
self.assertEqual(str(cm.exception), (
'Unrecognized options were found in test_component: color, flavor, '
'texture.'))
def testProvidedNone(self):
spec = disk.BaseDiskSpec(
_COMPONENT, device_path=None, disk_number=None, disk_size=None,
disk_type=None, mount_point=None)
self.assertIsNone(spec.device_path)
self.assertIsNone(spec.disk_number)
self.assertIsNone(spec.disk_size)
self.assertIsNone(spec.disk_type)
self.assertIsNone(spec.mount_point)
self.assertEqual(spec.num_striped_disks, 1)
def testProvidedValid(self):
spec = disk.BaseDiskSpec(
_COMPONENT, device_path='test_device_path', disk_number=1,
disk_size=75, disk_type='test_disk_type', mount_point='/mountpoint',
num_striped_disks=2)
self.assertEqual(spec.device_path, 'test_device_path')
self.assertEqual(spec.disk_number, 1)
self.assertEqual(spec.disk_size, 75)
self.assertEqual(spec.disk_type, 'test_disk_type')
self.assertEqual(spec.mount_point, '/mountpoint')
self.assertEqual(spec.num_striped_disks, 2)
def testPDStandard(self):
disk_spec = disk.BaseDiskSpec(_COMPONENT,
disk_size=2,
disk_type=gce_disk.PD_STANDARD)
disk_obj = gce_disk.GceDisk(disk_spec, 'name', 'zone', 'project')
self.assertEquals(
disk_obj.metadata, {
disk.MEDIA: disk.HDD,
disk.REPLICATION: disk.ZONE,
disk.LEGACY_DISK_TYPE: disk.STANDARD
})
def __init__(self, vm_spec):
"""Initialize a GCE virtual machine.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(GceVirtualMachine, self).__init__(vm_spec)
disk_spec = disk.BaseDiskSpec(BOOT_DISK_SIZE_GB, BOOT_DISK_TYPE, None)
self.boot_disk = gce_disk.GceDisk(disk_spec, self.name, self.zone,
self.project, self.image)
self.max_local_disks = FLAGS.gce_num_local_ssds
self.local_disk_counter = 0
def __init__(self, vm_spec):
"""Initialize a GCE virtual machine.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(GceVirtualMachine, self).__init__(vm_spec)
self.name = 'perfkit-%s-%s' % (FLAGS.run_uri, self.instance_counter)
GceVirtualMachine.instance_counter += 1
disk_spec = disk.BaseDiskSpec(BOOT_DISK_SIZE_GB, BOOT_DISK_TYPE, None)
self.boot_disk = gce_disk.GceDisk(
disk_spec, self.name, self.zone, self.project, self.image)
self.num_ssds = FLAGS.gce_num_local_ssds
def __init__(self, vm_spec):
"""Initialize a Azure virtual machine.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(AzureVirtualMachine, self).__init__(vm_spec)
self.name = 'perfkit-%s-%s' % (FLAGS.run_uri, self.instance_counter)
AzureVirtualMachine.instance_counter += 1
self.service = AzureService(self.name,
self.network.affinity_group.name)
disk_spec = disk.BaseDiskSpec(None, None, None)
self.os_disk = azure_disk.AzureDisk(disk_spec, self.name)
def __init__(self, vm_spec):
"""Initialize a Azure virtual machine.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(AzureVirtualMachine, self).__init__(vm_spec)
self.service = AzureService(self.name,
self.network.affinity_group.name)
disk_spec = disk.BaseDiskSpec(None, None, None)
self.os_disk = azure_disk.AzureDisk(disk_spec, self.name)
self.max_local_disks = 1
self.local_disk_counter = 0
def __init__(self,
component_full_name,
ip_address=None,
user_name=None,
ssh_private_key=None,
internal_ip=None,
ssh_port=22,
password=None,
disk_specs=None,
os_type=None,
tag=None,
zone=None,
**kwargs):
"""Initialize the StaticVmSpec object.
Args:
component_full_name: string. Fully qualified name of the configurable
component containing the config options.
ip_address: The public ip address of the VM.
user_name: The username of the VM that the keyfile corresponds to.
ssh_private_key: The absolute path to the private keyfile to use to ssh
to the VM.
internal_ip: The internal ip address of the VM.
ssh_port: The port number to use for SSH and SCP commands.
password: The password used to log into the VM (Windows Only).
disk_specs: None or a list of dictionaries containing kwargs used to
create disk.BaseDiskSpecs.
os_type: The OS type of the VM. See the flag of the same name for more
information.
tag: A string that allows the VM to be included or excluded from a run
by using the 'static_vm_tags' flag.
zone: The VM's zone.
**kwargs: Other args for the superclass.
"""
super(StaticVmSpec, self).__init__(component_full_name, **kwargs)
self.ip_address = ip_address
self.user_name = user_name
self.ssh_private_key = ssh_private_key
self.internal_ip = internal_ip
self.ssh_port = ssh_port
self.password = password
self.os_type = os_type
self.tag = tag
self.zone = zone
self.disk_specs = [
disk.BaseDiskSpec('{0}.disk_specs[{1}]'.format(
component_full_name, i),
flag_values=kwargs.get('flag_values'),
**disk_spec)
for i, disk_spec in enumerate(disk_specs or ())
]
def __init__(self, vm_spec):
"""Initialize an Azure virtual machine.
Args:
vm_spec: virtual_machine.BaseVmSpec object of the vm.
"""
super(AzureVirtualMachine, self).__init__(vm_spec)
# PKB zone can be either a location or a location with an availability zone.
# Format for Azure availability zone support is "location-availability_zone"
# Example: eastus2-1 is Azure location eastus2 with availability zone 1.
self.location = util.GetLocationFromZone(self.zone)
self.availability_zone = util.GetAvailabilityZoneFromZone(self.zone)
self.use_dedicated_host = vm_spec.use_dedicated_host
# TODO(buggay): implement num_vms_per_host functionality
self.num_vms_per_host = vm_spec.num_vms_per_host
if self.num_vms_per_host:
raise NotImplementedError(
'Num vms per host for Azure is not supported.')
self.network = azure_network.AzureNetwork.GetNetwork(self)
self.firewall = azure_network.AzureFirewall.GetFirewall()
self.max_local_disks = NUM_LOCAL_VOLUMES.get(self.machine_type) or 1
self._lun_counter = itertools.count()
self._deleted = False
self.resource_group = azure_network.GetResourceGroup()
self.public_ip = AzurePublicIPAddress(self.location,
self.availability_zone,
self.name + '-public-ip')
self.nic = AzureNIC(self.network.subnet, self.name + '-nic',
self.public_ip.name,
vm_spec.accelerated_networking)
self.storage_account = self.network.storage_account
self.image = vm_spec.image or self.IMAGE_URN
self.host = None
if self.use_dedicated_host:
self.host_series_sku = _GetSkuType(self.machine_type)
self.host_list = None
disk_spec = disk.BaseDiskSpec('azure_os_disk')
disk_spec.disk_type = (vm_spec.boot_disk_type
or self.storage_account.storage_type)
if vm_spec.boot_disk_size:
disk_spec.disk_size = vm_spec.boot_disk_size
self.os_disk = azure_disk.AzureDisk(disk_spec,
self.name,
self.machine_type,
self.storage_account,
None,
is_image=True)
def __init__(self, vm_spec):
"""Initialize a Azure virtual machine.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(AzureVirtualMachine, self).__init__(vm_spec)
self.network = azure_network.AzureNetwork.GetNetwork(self)
self.firewall = azure_network.AzureFirewall.GetFirewall()
self.service = AzureService(self.name,
self.network.affinity_group.name)
disk_spec = disk.BaseDiskSpec('azure_os_disk')
self.os_disk = azure_disk.AzureDisk(disk_spec, self.name, self.machine_type)
self.max_local_disks = 1
def testScratchDisks(self):
"""Test for creating and deleting scratch disks.
This test creates two scratch disks on a vm and deletes them, ensuring
that the proper calls to create, format, mount, and delete are made.
"""
vm = self._CreateVm()
disk_spec = disk.BaseDiskSpec(None, None, '/mountpoint0')
vm.CreateScratchDisk(disk_spec)
assert len(vm.scratch_disks) == 1, 'Disk not added to scratch disks.'
scratch_disk = vm.scratch_disks[0]
scratch_disk.Create.assert_called_once_with()
vm.FormatDisk.assert_called_once_with(scratch_disk.GetDevicePath())
vm.MountDisk.assert_called_once_with(scratch_disk.GetDevicePath(),
'/mountpoint0')
disk_spec = disk.BaseDiskSpec(None, None, '/mountpoint1')
vm.CreateScratchDisk(disk_spec)
assert len(vm.scratch_disks) == 2, 'Disk not added to scratch disks.'
scratch_disk = vm.scratch_disks[1]
scratch_disk.Create.assert_called_once_with()
vm.FormatDisk.assert_called_with(scratch_disk.GetDevicePath())
vm.MountDisk.assert_called_with(scratch_disk.GetDevicePath(),
'/mountpoint1')
vm.DeleteScratchDisks()
vm.scratch_disks[0].Delete.assert_called_once_with()
vm.scratch_disks[1].Delete.assert_called_once_with()
def testPresentFlagsOverrideConfigs(self):
flags = mock_flags.MockFlags()
flags['data_disk_size'].Parse(100)
flags['data_disk_type'].Parse('flag_disk_type')
flags['num_striped_disks'].Parse(3)
flags['scratch_dir'].Parse('/flag_scratch_dir')
spec = disk.BaseDiskSpec(
_COMPONENT, flags, device_path='config_device_path', disk_number=1,
disk_size=75, disk_type='config_disk_type', mount_point='/mountpoint',
num_striped_disks=2)
self.assertEqual(spec.device_path, 'config_device_path')
self.assertEqual(spec.disk_number, 1)
self.assertEqual(spec.disk_size, 100)
self.assertEqual(spec.disk_type, 'flag_disk_type')
self.assertEqual(spec.mount_point, '/flag_scratch_dir')
self.assertEqual(spec.num_striped_disks, 3)
def testNonPresentFlagsDoNotOverrideConfigs(self):
flags = mock_flags.MockFlags()
flags['data_disk_size'].value = 100
flags['data_disk_type'].value = 'flag_disk_type'
flags['num_striped_disks'].value = 3
flags['scratch_dir'].value = '/flag_scratch_dir'
spec = disk.BaseDiskSpec(
_COMPONENT, flags, device_path='config_device_path', disk_number=1,
disk_size=75, disk_type='config_disk_type', mount_point='/mountpoint',
num_striped_disks=2)
self.assertEqual(spec.device_path, 'config_device_path')
self.assertEqual(spec.disk_number, 1)
self.assertEqual(spec.disk_size, 75)
self.assertEqual(spec.disk_type, 'config_disk_type')
self.assertEqual(spec.mount_point, '/mountpoint')
self.assertEqual(spec.num_striped_disks, 2)
def __init__(self, vm_spec):
"""Initialize a GCE virtual machine.
Args:
vm_spec: virtual_machine.BaseVirtualMachineSpec object of the vm.
"""
super(GceVirtualMachine, self).__init__(vm_spec)
disk_spec = disk.BaseDiskSpec(self.BOOT_DISK_SIZE_GB,
self.BOOT_DISK_TYPE, None)
self.network = gce_network.GceNetwork.GetNetwork(None)
self.boot_disk = gce_disk.GceDisk(disk_spec, self.name, self.zone,
self.project, self.image)
self.max_local_disks = FLAGS.gce_num_local_ssds
self.boot_metadata = {}
self.preemptible = FLAGS.gce_preemptible_vms
events.sample_created.connect(self.AnnotateSample, weak=False)
