def create_vm(vm_folder, resource_pool, datastore, net_name, vm_name, CPU, RAM,
disk, provision):
"""
Create a VM with following configurations: CPU, memory, disk
RAM and attached network/switch
"""
new_datastore = '[' + datastore.name + '] ' + vm_name # This creates a new directory with the same naming scheme as the new VM
vm_config = vim.vm.ConfigSpec()
"""
Create a custom nic specification...
behold!... this is just a cluster of methods
going back and forth...
Exactly how this looks behind the scenes is explained
in the report
"""
device_config = []
# Create NIC
nic_type = vim.vm.device.VirtualE1000()
nic_edit = vim.vm.device.VirtualDeviceSpec(
) # Create a "template" for a new NIC
nic_edit.operation = vim.vm.device.VirtualDeviceSpec.Operation.add # tell the API that we want to create a new device
nic_edit.device = nic_type # create a device specikation with the nic_edit name
nic_edit.device.deviceInfo = vim.Description(
) # Initialize methods to set info for the NIC
nic_edit.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo(
) # Add backing information to the device specification
nic_edit.device.backing.network = net_name # Associate an existing network with the device description
nic_edit.device.backing.deviceName = net_name.name # set the device name to the physical or logical network the nic is connected to.
device_config.append(nic_edit)
# addd iscsi controller to machine
scsi_type = vim.vm.device.VirtualLsiLogicController()
scsi_ctl = vim.vm.device.VirtualDeviceSpec()
scsi_ctl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
scsi_ctl.device = scsi_type
scsi_ctl.device.deviceInfo = vim.Description()
scsi_ctl.device.slotInfo = vim.vm.device.VirtualDevice.PciBusSlotInfo()
scsi_ctl.device.slotInfo.pciSlotNumber = 16
scsi_ctl.device.key = 22 # random number
scsi_ctl.device.sharedBus = vim.vm.device.VirtualSCSIController.sharedBus = 'noSharing'
scsi_ctl.device.busNumber = 0
scsi_ctl.device.device = 0
scsi_ctl.device.scsiCtlrUnitNumber = 7
device_config.append(scsi_ctl)
vm_config.numCPUs = CPU
vm_config.name = vm_name
vm_config.memoryMB = RAM
vm_config.guestId = 'ubuntu64Guest'
vm_config.deviceChange = device_config # Set custom hardware specications from the newly created NIC and vHDD
vm_files = vim.vm.FileInfo()
vm_files.vmPathName = new_datastore
vm_config.files = vm_files
print('\nCreating VM without disk...')
vm_folder.CreateVM_Task(config=vm_config, pool=resource_pool)
add_disk_to_vm(vm_folder, vm_name, disk, provision, datastore)
return True
def _new_nic_spec(self, vm_obj, nic_obj=None, network_params=None):
network = self._get_network_object(vm_obj, network_params)
if network_params:
connected = network_params['connected']
device_type = network_params['device_type'].lower()
directpath_io = network_params['directpath_io']
guest_control = network_params['guest_control']
label = network_params['label']
mac_address = network_params['mac_address']
start_connected = network_params['start_connected']
wake_onlan = network_params['wake_onlan']
else:
connected = self.params['connected']
device_type = self.params['device_type'].lower()
directpath_io = self.params['directpath_io']
guest_control = self.params['guest_control']
label = self.params['label']
mac_address = self.params['mac_address']
start_connected = self.params['start_connected']
wake_onlan = self.params['wake_onlan']
if not nic_obj:
device_obj = self.nic_device_type[device_type]
nic_spec = vim.vm.device.VirtualDeviceSpec(device=device_obj())
if mac_address:
nic_spec.device.addressType = 'manual'
nic_spec.device.macAddress = mac_address
if label:
nic_spec.device.deviceInfo = vim.Description(label=label)
else:
nic_spec = vim.vm.device.VirtualDeviceSpec(
operation=vim.vm.device.VirtualDeviceSpec.Operation.edit,
device=nic_obj)
if label and label != nic_obj.deviceInfo.label:
nic_spec.device.deviceInfo = vim.Description(label=label)
if mac_address and mac_address != nic_obj.macAddress:
nic_spec.device.addressType = 'manual'
nic_spec.device.macAddress = mac_address
nic_spec.device.backing = self._nic_backing_from_obj(network)
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo(
startConnected=start_connected,
allowGuestControl=guest_control,
connected=connected)
nic_spec.device.wakeOnLanEnabled = wake_onlan
if directpath_io and not isinstance(nic_spec.device,
vim.vm.device.VirtualVmxnet3):
self.module.fail_json(
msg=
'directpath_io can only be used with the vmxnet3 device type')
if directpath_io and isinstance(nic_spec.device,
vim.vm.device.VirtualVmxnet3):
nic_spec.device.uptCompatibilityEnabled = True
return nic_spec
def create_vm(name, si, vm_folder, resource_pool, datastore, network):
vm_name = name
datastore_path = "[" + datastore + "]/" + vm_name + "/" + vm_name + ".vmx"
vmx_file = vim.vm.FileInfo(logDirectory=None,
snapshotDirectory=None,
suspendDirectory=None,
vmPathName=datastore_path)
configspec = vim.vm.ConfigSpec(name=vm_name,
memoryMB=int(guest['ramsize']),
numCPUs=int(guest['vcpus']),
guestId=guest['guestID'],
version=guest['version'],
files=vmx_file,
cpuHotAddEnabled=True,
memoryHotAddEnabled=True)
##添加虚拟设备nic
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
nic_spec.device.backing.useAutoDetect = False
content = si.RetrieveContent()
nic_spec.device.backing.network = get_obj(content, [vim.Network], network)
nic_spec.device.backing.deviceName = network
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = False
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'assigned'
configspec.deviceChange.append(nic_spec)
print("网卡添加成功")
##添加sisc控制器
scsictl_spec = vim.vm.device.VirtualDeviceSpec()
scsictl_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
scsictl_spec.device = vim.vm.device.VirtualLsiLogicController()
scsictl_spec.device.deviceInfo = vim.Description()
scsictl_spec.device.slotInfo = vim.vm.device.VirtualDevice.PciBusSlotInfo()
scsictl_spec.device.slotInfo.pciSlotNumber = 16
scsictl_spec.device.controllerKey = 100
scsictl_spec.device.unitNumber = 3
scsictl_spec.device.busNumber = 0
scsictl_spec.device.hotAddRemove = True
scsictl_spec.device.sharedBus = 'noSharing'
scsictl_spec.device.scsiCtlrUnitNumber = 7
configspec.deviceChange.append(scsictl_spec)
print("scsi控制器添加成功")
print("Creating VM{}...".format(vm_name))
task = vm_folder.CreateVM_Task(config=configspec, pool=resource_pool)
tasks.wait_for_tasks(si, [task])
def add_nic(self, vm, network_name):
"""
添加网卡
:param network_name: esxi上网卡名称
:return:
"""
spec = vim.vm.ConfigSpec()
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualVmxnet3()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo(
)
nic_spec.device.backing.useAutoDetect = False
nic_spec.device.backing.network = self.get_obj([vim.Network],
network_name)
nic_spec.device.backing.deviceName = network_name
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = True
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'generated'
spec.deviceChange = [nic_spec]
task = vm.ReconfigVM_Task(spec=spec)
tasks.wait_for_tasks(self.si, [task])
def run(self, vm_id, network_id, ip, subnet, gateway=None, domain=None):
# convert ids to stubs
virtualmachine = inventory.get_virtualmachine(self.service_instance, vm_id)
network = inventory.get_network(self.service_instance, network_id)
# add new vnic
configspec = vim.vm.ConfigSpec()
nic = vim.vm.device.VirtualDeviceSpec()
nic.operation = vim.vm.device.VirtualDeviceSpec.Operation.add # or edit if a device exists
nic.device = vim.vm.device.VirtualVmxnet3()
nic.device.wakeOnLanEnabled = True
nic.device.addressType = 'assigned'
# docs recommend using unique negative integers as temporary keys.
# See https://github.com/vmware/pyvmomi/blob/master/docs/vim/vm/device/VirtualDevice.rst
nic.device.key = -1
nic.device.deviceInfo = vim.Description()
nic.device.deviceInfo.label = 'Network Adapter-%s' % (ip)
nic.device.deviceInfo.summary = 'summary'
nic.device.backing = vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo()
nic.device.backing.port = vim.dvs.PortConnection()
nic.device.backing.port.switchUuid = network.config.distributedVirtualSwitch.uuid
nic.device.backing.port.portgroupKey = network.config.key
nic.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic.device.connectable.startConnected = True
nic.device.connectable.allowGuestControl = True
configspec.deviceChange = [nic]
add_vnic_task = virtualmachine.ReconfigVM_Task(configspec)
successfully_added_vnic = self._wait_for_task(add_vnic_task)
# customize VM
cust_item = vim.CustomizationSpecItem()
cust_specinfo = vim.CustomizationSpecInfo()
cust_specinfo.name = 'assignip-' + str(uuid.uuid4())
cust_specinfo.type = 'Linux'
cust_item.info = cust_specinfo
# fixed ip
cust_spec = vim.vm.customization.Specification()
cust_item.spec = cust_spec
ip_adapter_mapping = vim.vm.customization.AdapterMapping()
ip_adapter_mapping.adapter = vim.vm.customization.IPSettings()
ip_adapter_mapping.adapter.ip = vim.vm.customization.FixedIp()
ip_adapter_mapping.adapter.ip.ipAddress = ip
ip_adapter_mapping.adapter.subnetMask = subnet
ip_adapter_mapping.adapter.gateway = gateway
ip_adapter_mapping.adapter.dnsDomain = domain
cust_spec.nicSettingMap = [ip_adapter_mapping]
cust_spec.identity = vim.vm.customization.LinuxPrep()
cust_spec.identity.hostName = vim.vm.customization.PrefixNameGenerator()
cust_spec.identity.hostName.base = 'st2'
cust_spec.identity.domain = 'demo.net'
cust_spec.globalIPSettings = vim.vm.customization.GlobalIPSettings()
try:
self.service_instance.customizationSpecManager.CreateCustomizationSpec(cust_item)
except:
self.logger.exception('Failed to create customization spec.')
raise
return {'state': successfully_added_vnic}
def add_nic(self, vm, network):
'''Function that adds a NIC to the VM and connects it to the portgroup'''
# Define specifications
spec = vim.vm.ConfigSpec()
nic_changes = []
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.deviceInfo.summary = 'vCenter API test'
nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo(
)
nic_spec.device.backing.useAutoDetect = False
nic_spec.device.backing.deviceName = network.name
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = False
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'assigned'
nic_changes.append(nic_spec)
spec.deviceChange = nic_changes
# Perform creation task
try:
print("Attaching VM to portgroup ...")
task = vm.ReconfigVM_Task(spec=spec)
WaitForTask(task)
print("Successfully added VM to portgroup.")
except Exception as e:
print(e)
def add_floppy(self, vm):
# 查找设备控制器
for dev in vm.config.hardware.device:
if isinstance(dev, vim.vm.device.VirtualIDEController):
# If there are less than 2 devices attached, we can use it.
if len(dev.device) < 2:
controller = dev
else:
controller = None
spec = vim.vm.ConfigSpec()
floppy_spec = vim.vm.device.VirtualDeviceSpec()
floppy_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
floppy_spec.device = vim.vm.device.VirtualFloppy()
floppy_spec.device.deviceInfo = vim.Description()
floppy_spec.device.backing = vim.vm.device.VirtualFloppy.RemoteDeviceBackingInfo(
)
floppy_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo(
)
floppy_spec.device.connectable.allowGuestControl = True
floppy_spec.device.connectable.startConnected = False
floppy_spec.device.controllerKey = controller.key
floppy_spec.device.key = 8000
spec.deviceChange = [floppy_spec]
task = vm.ReconfigVM_Task(spec=spec)
tasks.wait_for_tasks(self.si, [task])
def _add_new_hard_disk(self, disk_label, size_gb, unit_number, controller_key=1000, thin_provision=True, datastore_path=None, vm_name=None):
key = random.randint(-2099, -2000)
size_kb = int(size_gb * 1024.0 * 1024.0)
disk_spec = vim.vm.device.VirtualDeviceSpec()
disk_spec.fileOperation = 'create'
disk_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
disk_spec.device = vim.vm.device.VirtualDisk()
disk_spec.device.key = key
disk_spec.device.deviceInfo = vim.Description()
disk_spec.device.deviceInfo.label = disk_label
disk_spec.device.deviceInfo.summary = "{0} GB".format(size_gb)
disk_spec.device.backing = vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
disk_spec.device.backing.thinProvisioned = thin_provision
disk_spec.device.backing.diskMode = 'persistent'
disk_spec.device.backing.fileName = '{datastore_path}/{disk_label}.vmdk'.format(datastore_path=datastore_path, disk_label=disk_label)
disk_spec.device.controllerKey = controller_key
disk_spec.device.unitNumber = unit_number
disk_spec.device.capacityInKB = size_kb
return disk_spec
def create_controller(self, ctl_type, bus_sharing, bus_number=0):
"""
Create new disk or USB controller with specified type
Args:
ctl_type: controller type
bus_number: disk controller bus number
bus_sharing: noSharing, virtualSharing, physicalSharing
Return: Virtual device spec for virtual controller
"""
if ctl_type == 'sata' or ctl_type == 'nvme' or ctl_type in self.device_helper.scsi_device_type.keys(
):
disk_ctl = self.device_helper.create_disk_controller(
ctl_type, bus_number, bus_sharing)
elif ctl_type in self.device_helper.usb_device_type.keys():
disk_ctl = vim.vm.device.VirtualDeviceSpec()
disk_ctl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
disk_ctl.device = self.device_helper.usb_device_type.get(
ctl_type)()
if ctl_type == 'usb2':
disk_ctl.device.key = 7000
elif ctl_type == 'usb3':
disk_ctl.device.key = 14000
disk_ctl.device.deviceInfo = vim.Description()
disk_ctl.device.busNumber = bus_number
return disk_ctl
def esxi_add_new_nic_process(vm, si, network_name):
nic_prefix_label = 'Network adapter '
nic_count = 0
for dev in vm.config.hardware.device:
if dev.deviceInfo.label.find(nic_prefix_label) >= 0:
nic_count = nic_count + 1
nic_label = nic_prefix_label + str(nic_count + 1)
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000()
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'generated'
nic_spec.device.key = 4000
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.deviceInfo.label = nic_label
nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo(
)
nic_spec.device.backing.network = get_obj(si.content, [vim.Network],
network_name)
nic_spec.device.backing.deviceName = network_name
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.connected = True
nic_spec.device.connectable.allowGuestControl = True
dev_changes = []
dev_changes.append(nic_spec)
spec = vim.vm.ConfigSpec()
spec.deviceChange = dev_changes
task = vm.ReconfigVM_Task(spec=spec)
tasks.wait_for_tasks(si, [task])
def create_controller(self, ctl_type, bus_number=0):
"""
Create new disk or USB controller with specified type
Args:
ctl_type: controller type
bus_number: disk controller bus number
Return: Virtual device spec for virtual controller
"""
disk_ctl = vim.vm.device.VirtualDeviceSpec()
disk_ctl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
if ctl_type == 'sata':
disk_ctl.device = self.sata_device_type()
disk_ctl.device.key = -randint(15000, 19999)
elif ctl_type == 'nvme':
disk_ctl.device = self.nvme_device_type()
disk_ctl.device.key = -randint(31000, 39999)
elif ctl_type in self.scsi_device_type.keys():
disk_ctl.device = self.scsi_device_type.get(ctl_type)()
disk_ctl.device.key = -randint(1000, 6999)
disk_ctl.device.hotAddRemove = True
disk_ctl.device.sharedBus = 'noSharing'
disk_ctl.device.scsiCtlrUnitNumber = 7
elif ctl_type in self.usb_device_type.keys():
disk_ctl.device = self.usb_device_type.get(ctl_type)()
if ctl_type == 'usb2':
disk_ctl.device.key = 7000
elif ctl_type == 'usb3':
disk_ctl.device.key = 14000
disk_ctl.device.deviceInfo = vim.Description()
disk_ctl.device.busNumber = bus_number
return disk_ctl
def create_tpm(self):
vtpm_device_spec = vim.vm.device.VirtualDeviceSpec()
vtpm_device_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
vtpm_device_spec.device = vim.vm.device.VirtualTPM()
vtpm_device_spec.device.deviceInfo = vim.Description()
return vtpm_device_spec
def create_scsi_controller(self,
scsi_type,
bus_number,
bus_sharing='noSharing'):
"""
Create SCSI Controller with given SCSI Type and SCSI Bus Number
Args:
scsi_type: Type of SCSI
bus_number: SCSI Bus number to be assigned
bus_sharing: noSharing, virtualSharing, physicalSharing
Returns: Virtual device spec for SCSI Controller
"""
scsi_ctl = vim.vm.device.VirtualDeviceSpec()
scsi_ctl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
scsi_device = self.scsi_device_type.get(
scsi_type, vim.vm.device.ParaVirtualSCSIController)
scsi_ctl.device = scsi_device()
scsi_ctl.device.deviceInfo = vim.Description()
scsi_ctl.device.busNumber = bus_number
# While creating a new SCSI controller, temporary key value
# should be unique negative integers
scsi_ctl.device.key = -randint(1000, 9999)
scsi_ctl.device.hotAddRemove = True
scsi_ctl.device.sharedBus = bus_sharing
scsi_ctl.device.scsiCtlrUnitNumber = 7
return scsi_ctl
def vnic_compose_empty(device=None):
"""
Compose empty vNIC for next attaching to a network
:param device: <vim.vm.device.VirtualVmxnet3 or None> Device for this this 'spec' will be composed.
If 'None' a new device will be composed.
'Operation' - edit/add' depends on if device existed
:return: <vim.vm.device.VirtualDeviceSpec>
"""
nicspec = vim.vm.device.VirtualDeviceSpec()
if device:
nicspec.device = device
nicspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.edit
else:
nicspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nicspec.device = vim.vm.device.VirtualVmxnet3()
nicspec.device.wakeOnLanEnabled = True
nicspec.device.deviceInfo = vim.Description()
nicspec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo(
)
nicspec.device.connectable.startConnected = True
nicspec.device.connectable.allowGuestControl = True
return nicspec
def add_nic(content, vm, network, macAddress):
spec = vim.vm.ConfigSpec()
nic_changes = []
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.deviceInfo.summary = 'automated'
nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
nic_spec.device.backing.useAutoDetect = False
nic_spec.device.backing.network = GetNet(content, network)
nic_spec.device.backing.deviceName = network
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = True
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'manual'
nic_spec.device.macAddress = macAddress
nic_changes.append(nic_spec)
spec.deviceChange = nic_changes
e = vm.ReconfigVM_Task(spec=spec)
print "\t\tNIC added to VM"
def add_nic(si, vm, network):
spec = vim.vm.ConfigSpec()
nic_changes = []
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.deviceInfo.summary = 'vCenter API test'
nic_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
nic_spec.device.backing.useAutoDetect = False
content = si.RetrieveContent()
nic_spec.device.backing.network = get_obj(content, [vim.Network], network)
nic_spec.device.backing.deviceName = network
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = False
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'assigned'
nic_changes.append(nic_spec)
spec.deviceChange = nic_changes
e = vm.ReconfigVM_Task(spec=spec)
print "NIC CARD ADDED"
def create_nic(content, portGroup):
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000e()
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.deviceInfo = vim.Description()
try:
network = get_obj(content, [vim.dvs.DistributedVirtualPortgroup],
portGroup)
dvs_port_connection = vim.dvs.PortConnection()
dvs_port_connection.portgroupKey = network.key
dvs_port_connection.switchUuid = network.config.distributedVirtualSwitch.uuid
nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo(
)
nic_spec.device.backing.port = dvs_port_connection
except:
nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo(
)
nic_spec.device.backing.network = get_obj(content, [vim.Network],
portGroup)
nic_spec.device.backing.deviceName = portGroup
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = True
return nic_spec
def get_vm_reconfig_spec(self, network_obj, stay_connected, network_type,
wake_on_lan):
network_spec = vim.vm.device.VirtualDeviceSpec()
network_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
if network_type.lower() == 'e1000':
network_spec.device = vim.vm.device.VirtualE1000()
elif network_type.lower() == 'flexible':
network_spec.device = vim.vm.device.VirtualPCNet32()
elif network_type.lower() == 'vmxnet':
network_spec.device = vim.vm.device.VirtualVmxnet()
elif network_type.lower() == 'enhancedvmxnet':
network_spec.device = vim.vm.device.VirtualVmxnet2()
elif network_type.lower() == 'vmxnet3':
network_spec.device = vim.vm.device.VirtualVmxnet3()
else:
network_spec.device = vim.vm.device.VirtualEthernetCard()
network_spec.device.wakeOnLanEnabled = wake_on_lan
network_spec.device.deviceInfo = vim.Description()
network_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
network_spec.device.backing.network = network_obj
network_spec.device.backing.deviceName = network_obj.name
network_spec.device.connectable = \
vim.vm.device.VirtualDevice.ConnectInfo()
network_spec.device.connectable.startConnected = stay_connected
network_spec.device.connectable.allowGuestControl = True
# creating reconfig spec
vm_reconfig_spec = vim.vm.ConfigSpec()
vm_reconfig_spec.deviceChange = [network_spec]
return vm_reconfig_spec
def nic_info(self,
nic_type='Vmxnet3',
mac_address=None,
label=None,
dv_pg_obj=None):
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
if nic_type == 'Vmxnet3':
nic_spec.device = vim.vm.device.VirtualVmxnet3()
elif nic_type == 'E1000':
nic_spec.device = vim.vm.device.VirtualE1000()
if mac_address:
nic_spec.device.macAddress = mac_address
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = True
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'assigned'
if label:
nic_spec.device.deviceInfo.label = label
port = vim.dvs.PortConnection()
# port.switchUuid = '54 01 36 50 13 35 cf f0-3d ad c9 74 36 95 2f 7e'
# port.portgroupKey = 'dvportgroup-43'
if dv_pg_obj:
port.portgroupKey = dv_pg_obj.key
port.switchUuid = dv_pg_obj.config.distributedVirtualSwitch.uuid
nic_spec.device.backing = vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo(
)
nic_spec.device.backing.port = port
return nic_spec
def vnic_attach_to_network_standard(nicspec, network, logger):
"""
Attach vNIC to a 'usual' network
:param nicspec: <vim.vm.device.VirtualDeviceSpec>
:param network: <vim.Network>
:param logger:
:return: updated 'nicspec'
"""
if nicspec and network_is_standard(network):
network_name = network.name
nicspec.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo(
)
nicspec.device.backing.network = network
nicspec.device.wakeOnLanEnabled = True
nicspec.device.deviceInfo = vim.Description()
nicspec.device.backing.deviceName = network_name
nicspec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo(
)
nicspec.device.connectable.startConnected = True
nicspec.device.connectable.allowGuestControl = True
logger.debug(
u"Assigning network '{}' for vNIC".format(network_name))
else:
# logger.warn(u"Cannot assigning network '{}' for vNIC {}".format(network, nicspec))
logger.warn(u"Cannot assigning network for vNIC ".format(
network, nicspec))
return nicspec
def attach_cdrom_drive(self, name):
"""Attaches cd/dvd drive to the virtual machine."""
vm = self.get_vm_obj(name, fail_missing=True)
controller = None
cdrom_device_key = 3000 # 300x reserved for cd/dvd drives in vmware
# Find last IDE controller and free device key
for device in vm.config.hardware.device:
if isinstance(device, vim.vm.device.VirtualIDEController):
controller = device
if isinstance(device, vim.vm.device.VirtualCdrom):
cdrom_device_key = int(device.key) + 1
cdspec = vim.vm.device.VirtualDeviceSpec()
cdspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
cdspec.device = vim.vm.device.VirtualCdrom(deviceInfo=vim.Description(
label='CD/DVD drive 1', summary='Remote device'))
cdspec.device.key = cdrom_device_key
cdspec.device.controllerKey = controller.key
cdspec.device.backing = vim.vm.device.VirtualCdrom.RemotePassthroughBackingInfo(
deviceName='', useAutoDetect=False, exclusive=False)
cdspec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo(
startConnected=False,
allowGuestControl=True,
connected=False,
status='untried')
config_spec = vim.vm.ConfigSpec(deviceChange=[cdspec])
self.logger.info('Attaching device to the virtual machine...')
task = vm.ReconfigVM_Task(config_spec)
self.wait_for_tasks([task])
def attach_floppy_drive(self, name):
"""Attaches floppy drive to the virtual machine."""
vm = self.get_vm_obj(name, fail_missing=True)
controller = None
floppy_device_key = 8000 # 800x reserved for floppies
# Find Super I/O controller and free device key
for device in vm.config.hardware.device:
if isinstance(device, vim.vm.device.VirtualSIOController):
controller = device
if isinstance(device, vim.vm.device.VirtualFloppy):
floppy_device_key = int(device.key) + 1
floppyspec = vim.vm.device.VirtualDeviceSpec()
floppyspec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
floppyspec.device = vim.vm.device.VirtualFloppy(
deviceInfo=vim.Description(label='Floppy drive 1',
summary='Remote device'))
floppyspec.device.key = floppy_device_key
floppyspec.device.controllerKey = controller.key
floppyspec.device.backing = vim.vm.device.VirtualFloppy.RemoteDeviceBackingInfo(
deviceName='', useAutoDetect=False)
floppyspec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo(
startConnected=False,
allowGuestControl=True,
connected=False,
status='untried')
config_spec = vim.vm.ConfigSpec(deviceChange=[floppyspec])
self.logger.info('Attaching device to the virtual machine...')
task = vm.ReconfigVM_Task(config_spec)
self.wait_for_tasks([task])
def add_nic(vm, mac, port):
"""
Add NIC to vm
"""
spec = vim.vm.ConfigSpec()
nic_changes = []
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.deviceInfo.summary = 'vCenter API'
nic_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo()
nic_spec.device.backing.port = vim.dvs.PortConnection()
nic_spec.device.backing.port.portgroupKey = port.portgroupKey
nic_spec.device.backing.port.switchUuid = port.dvsUuid
nic_spec.device.backing.port.portKey = port.key
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = False
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'assigned'
nic_spec.device.macAddress = mac
nic_changes.append(nic_spec)
spec.deviceChange = nic_changes
vm.ReconfigVM_Task(spec=spec)
print("Nic card added success ...")
def create_network_adapter(self, device_info):
nic = vim.vm.device.VirtualDeviceSpec()
nic.device = self.get_device_type(
device_type=device_info.get('device_type', 'vmxnet3'))
nic.device.deviceInfo = vim.Description()
nic.device.deviceInfo.summary = device_info['name']
nic.device.backing = vim.vm.device.VirtualEthernetCard.NetworkBackingInfo(
)
nic.device.backing.deviceName = device_info['name']
nic.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic.device.connectable.startConnected = device_info.get(
'start_connected', True)
nic.device.connectable.allowGuestControl = True
nic.device.connectable.connected = device_info.get('connected', True)
if 'manual_mac' in device_info:
nic.device.addressType = 'manual'
nic.device.macAddress = device_info['manual_mac']
else:
nic.device.addressType = 'generated'
if 'directpath_io' in device_info:
if isinstance(nic.device, vim.vm.device.VirtualVmxnet3):
nic.device.uptCompatibilityEnabled = device_info[
'directpath_io']
else:
self.module.fail_json(
msg='UPT is only compatible for Vmxnet3 adapter.' +
' Clients can set this property enabled or disabled if ethernet virtual device is Vmxnet3.'
)
return nic
def create_nvdimm_controller(self):
nvdimm_ctl = vim.vm.device.VirtualDeviceSpec()
nvdimm_ctl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nvdimm_ctl.device = vim.vm.device.VirtualNVDIMMController()
nvdimm_ctl.device.deviceInfo = vim.Description()
nvdimm_ctl.device.key = -randint(27000, 27999)
return nvdimm_ctl
def add_network(self, networks):
networks = json.loads(networks)
devs = self.vm.config.hardware.device
# nic_prefix_label = 'Network adapter '
for network in networks:
# 获取网络设备信息
local_network_port_group = network_port_group_manage.get_network_by_id(
network)
# 开始添加网卡信息
spec = vim.vm.ConfigSpec()
nic_changes = []
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualE1000()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.deviceInfo.summary = 'vCenter API test'
# content = self.si.RetrieveContent()
network = get_obj(self.content, [vim.Network],
local_network_port_group.name)
if isinstance(network, vim.OpaqueNetwork):
nic_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.OpaqueNetworkBackingInfo()
nic_spec.device.backing.opaqueNetworkType = \
network.summary.opaqueNetworkType
nic_spec.device.backing.opaqueNetworkId = \
network.summary.opaqueNetworkId
else:
nic_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
nic_spec.device.backing.useAutoDetect = False
nic_spec.device.backing.deviceName = network.name
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo(
)
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = False
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'assigned'
nic_changes.append(nic_spec)
spec.deviceChange = nic_changes
task = self.vm.ReconfigVM_Task(spec=spec)
wait_for_tasks(self.si, [task])
# 同步云主机网卡信息
sync_network_device(self.platform_id, self.vm)
class Hardware:
device_obj = vim.vm.device.VirtualEthernetCard() # type: ignore
device_obj.deviceInfo = vim.Description() # type: ignore
device_obj.deviceInfo.label = 'Network adapter 123'
device_obj.macAddress = 'mac test'
device_obj.backing = vim.vm.device.VirtualDevice.BackingInfo(
) # type: ignore
device_obj.wakeOnLanEnabled = True
device = [device_obj]
def create_nvme_controller(bus_number):
nvme_ctl = vim.vm.device.VirtualDeviceSpec()
nvme_ctl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nvme_ctl.device = vim.vm.device.VirtualNVMEController()
nvme_ctl.device.deviceInfo = vim.Description()
nvme_ctl.device.key = -randint(31000, 39999)
nvme_ctl.device.busNumber = bus_number
return nvme_ctl
def create_sata_controller(bus_number):
sata_ctl = vim.vm.device.VirtualDeviceSpec()
sata_ctl.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
sata_ctl.device = vim.vm.device.VirtualAHCIController()
sata_ctl.device.deviceInfo = vim.Description()
sata_ctl.device.busNumber = bus_number
sata_ctl.device.key = -randint(15000, 19999)
return sata_ctl
def ADD_NIC(content, VM_name, network, si):
# VM exist ?
VM = get_obj(content, [vim.VirtualMachine], VM_name)
if VM is None:
raise SystemExit(bcolors.FAIL + "Unable to locate VirtualMachine " + VM_name + bcolors.ENDC)
# NIC exist ?
exist_networks = GET_NICs(content, VM_name)
for check_network in exist_networks:
if check_network == network:
print (bcolors.WARNING + network + " at " + VM_name + " already exist" + bcolors.ENDC)
return
spec = vim.vm.ConfigSpec()
nic_changes = []
nic_spec = vim.vm.device.VirtualDeviceSpec()
nic_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic_spec.device = vim.vm.device.VirtualVmxnet3()
nic_spec.device.deviceInfo = vim.Description()
nic_spec.device.deviceInfo.summary = 'vCenter API test'
nic_spec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
nic_spec.device.backing.useAutoDetect = False
content = si.RetrieveContent()
nic_spec.device.backing.network = get_obj(content, [vim.Network], network)
nic_spec.device.backing.deviceName = network
nic_spec.device.connectable = vim.vm.device.VirtualDevice.ConnectInfo()
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.startConnected = True
nic_spec.device.connectable.allowGuestControl = True
nic_spec.device.connectable.connected = False
nic_spec.device.connectable.status = 'untried'
nic_spec.device.wakeOnLanEnabled = True
nic_spec.device.addressType = 'assigned'
nic_changes.append(nic_spec)
spec.deviceChange = nic_changes
try:
VM.ReconfigVM_Task(spec=spec)
print (bcolors.OKGREEN + "NIC CARD with Network " + network + " added to VM " + VM_name + bcolors.ENDC)
return
except:
print (bcolors.FAIL + "Error VM " + VM_name + bcolors.ENDC)
return
