def main():
"""
Sample for adding a vm NIC to a Distributed Virtual Switch
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_NAME,
cli.Argument.PORT_GROUP, cli.Argument.VM_MAC)
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
print("Search VDS PortGroup by Name ...")
portgroup = pchelper.get_obj(content,
[vim.dvs.DistributedVirtualPortgroup],
args.port_group)
if portgroup is None:
print("Portgroup not Found in DVS ...")
sys.exit(0)
print("Search Available(Unused) port for VM...")
dvs = portgroup.config.distributedVirtualSwitch
port_key = search_port(dvs, portgroup.key)
port = port_find(dvs, port_key)
print("Search VM by Name ...")
vm = None
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm:
print("Find Vm , Add Nic Card ...")
add_nic(vm, args.vm_mac, port)
else:
print("Vm not Found ...")
def main():
"""
Let this thing fly
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_NAME, cli.Argument.TEMPLATE)
# if no locationis provided, thefirst available datacenter, datastore, etc. will be used
parser.add_optional_arguments(
cli.Argument.DATACENTER_NAME, cli.Argument.VMFOLDER,
cli.Argument.DATASTORE_NAME, cli.Argument.DATASTORECLUSTER_NAME,
cli.Argument.CLUSTER_NAME, cli.Argument.RESOURCE_POOL,
cli.Argument.POWER_ON, cli.Argument.OPAQUE_NETWORK_NAME)
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
template = pchelper.get_obj(content, [vim.VirtualMachine], args.template)
if template:
clone_vm(content, template, args.vm_name, args.datacenter_name,
args.vm_folder, args.datastore_name, args.cluster_name,
args.resource_pool, args.power_on, args.datastorecluster_name)
if args.opaque_network_name:
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
add_nic(si, vm, args.opaque_network_name)
else:
print("template not found")
def main():
"""
Sample for adding a raw disk to vm
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DEVICE_NAME)
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID,
cli.Argument.DISK_MODE,
cli.Argument.COMPATIBILITY_MODE)
args = parser.get_args()
si = service_instance.connect(args)
vm = None
if args.uuid:
search_index = si.content.searchIndex
vm = search_index.FindByUuid(None, args.uuid, True)
elif args.vm_name:
content = si.RetrieveContent()
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm:
add_raw_disk(vm, si, args.device_name, args.disk_mode,
args.disk_compatibility_mode)
else:
print("VM not found")
def create_vm(si, vm_name, datacenter_name, host_ip, datastore_name=None):
content = si.RetrieveContent()
destination_host = pchelper.get_obj(content, [vim.HostSystem], host_ip)
source_pool = destination_host.parent.resourcePool
if datastore_name is None:
datastore_name = destination_host.datastore[0].name
config = create_config_spec(datastore_name=datastore_name, name=vm_name)
for child in content.rootFolder.childEntity:
if child.name == datacenter_name:
vm_folder = child.vmFolder # child is a datacenter
break
else:
print("Datacenter %s not found!" % datacenter_name)
sys.exit(1)
try:
WaitForTask(
vm_folder.CreateVm(config, pool=source_pool,
host=destination_host))
print("VM created: %s" % vm_name)
except vim.fault.DuplicateName:
print("VM duplicate name: %s" % vm_name, file=sys.stderr)
except vim.fault.AlreadyExists:
print("VM name %s already exists." % vm_name, file=sys.stderr)
def main():
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_NAME)
parser.add_custom_argument('--unitnumber',
required=True,
help='HDD number to delete.',
type=int)
parser.add_custom_argument('--yes',
help='Confirm disk deletion.',
action='store_true')
parser.add_custom_argument('--language',
default='English',
help='Language your vcenter used.')
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
print('Searching for VM {}'.format(args.vm_name))
vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm_obj:
if not args.yes:
cli.prompt_y_n_question("Are you sure you want "
"to delete HDD "
"{}?".format(args.unitnumber),
default='no')
delete_virtual_disk(si, vm_obj, args.unitnumber, args.language)
print('VM HDD "{}" successfully deleted.'.format(args.unitnumber))
else:
print('VM not found')
def main():
""" Upgrades the hardware version of a Virtual Machine. """
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_NAME)
parser.add_custom_argument(
'--release',
required=False,
action='store',
default=None,
help='Version/release number of the Virtual machine hardware')
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if not vm:
print("Could not find VM %s" % args.vm_name)
else:
print("Upgrading VM %s" % args.vm_name)
# Set the hardware version to use if specified
if args.release is not None:
print("New version will be %s" % args.release)
version = "vmx-{:02d}".format(args.release)
else:
version = None
# Upgrade the VM
try:
task.WaitForTask(task=vm.UpgradeVM_Task(version), si=si)
print("Upgrade complete")
except vim.fault.AlreadyUpgraded:
print("VM is already upgraded")
def main():
"""
Simple command-line program for creating a snapshot of a first class disk.
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DATASTORE_NAME, cli.Argument.FIRST_CLASS_DISK_NAME,
cli.Argument.SNAPSHOT_NAME)
args = parser.get_args()
si = service_instance.connect(args)
try:
content = si.RetrieveContent()
# Retrieve Datastore Object
datastore = pchelper.get_obj(content, [vim.Datastore], args.datastore_name)
# Retrieve FCD Object
vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name)
# Create FCD Snapshot
storage = content.vStorageObjectManager
task = storage.VStorageObjectCreateSnapshot_Task(
vdisk.config.id, datastore, args.snapshot_name)
tasks.wait_for_tasks(si, [task])
print("FCD snapshot created!")
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
def main():
"""
Simple command-line program for listing all snapshots of a fcd
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DATASTORE_NAME,
cli.Argument.FIRST_CLASS_DISK_NAME)
args = parser.get_args()
si = service_instance.connect(args)
try:
content = si.RetrieveContent()
# Retrieve Datastore Object
datastore = pchelper.get_obj(content, [vim.Datastore],
args.datastore_name)
# Retrieve FCD Object
vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name)
# Retrieve all Snapshots
list_fcd_snapshots(content, vdisk)
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
def reconfigureVM(self, uuid, portGroup):
self.check_connectivity()
_content = self.service_instance.RetrieveContent()
target_vm = _content.searchIndex.FindByUuid(None, uuid, True)
device_change = []
for device in target_vm.config.hardware.device:
if isinstance(device, vim.vm.device.VirtualEthernetCard):
nicspec = vim.vm.device.VirtualDeviceSpec()
nicspec.operation = \
vim.vm.device.VirtualDeviceSpec.Operation.edit
nicspec.device = device
nicspec.device.wakeOnLanEnabled = True
if True:
nicspec.device.backing = \
vim.vm.device.VirtualEthernetCard.NetworkBackingInfo()
nicspec.device.backing.network = \
pchelper.get_obj(_content, [vim.Network], portGroup)
nicspec.device.backing.deviceName = portGroup
else:
network = pchelper.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
nicspec.device.backing = \
vim.vm.device.VirtualEthernetCard. \
DistributedVirtualPortBackingInfo()
nicspec.device.backing.port = dvs_port_connection
nicspec.device.connectable = \
vim.vm.device.VirtualDevice.ConnectInfo()
nicspec.device.connectable.startConnected = True
nicspec.device.connectable.allowGuestControl = True
device_change.append(nicspec)
break
config_spec = vim.vm.ConfigSpec(deviceChange=device_change)
task = target_vm.ReconfigVM_Task(config_spec)
retval = tasks.wait_for_tasks(self.service_instance, [task])
print("reconfigure result ", retval)
return retval
def configure_dvs_pg(si, dvs_name, dv_pg_name):
"""
Configures the distributed port group
:param si: Vcenter service instance
:param dvs_name: Name of the distributed virtual switch
:param dv_pg_name: Name of distributed virtual port group
"""
# Retrieve the content
content = si.RetrieveContent()
# get distributed Switch and its port group objects
dvs = pchelper.get_obj(content, [vim.DistributedVirtualSwitch], dvs_name)
dv_pg = pchelper.get_obj(content, [vim.dvs.DistributedVirtualPortgroup], dv_pg_name)
print("The distributed virtual Switch is {0}" .format(dvs))
print("The distributed port group is {0}".format(dv_pg))
# construct selection sets
selection_sets = []
dv_pg_ss = vim.dvs.DistributedVirtualPortgroupSelection()
dv_pg_ss.dvsUuid = dvs.uuid
dv_pg_ss.portgroupKey.append(dv_pg.key)
selection_sets.append(dv_pg_ss)
print("The selected port group configurations are {0}"
.format(selection_sets))
# Backup/Export the configuration
entity_backup_config = si.content\
.dvSwitchManager\
.DVSManagerExportEntity_Task(selection_sets)
export_result = entity_backup_config.info.result
print("The result of export configuration are {0}".format(export_result))
# Destroy the port group configuration
dv_pg.Destroy_Task()
# Restore/Import port group configuration
entity_restore_config = si.content\
.dvSwitchManager\
.DVSManagerImportEntity_Task(export_result,
'createEntityWithOriginalIdentifier')
print("The result of restore configuration is {0}"
.format(entity_restore_config.info.result))
def main():
"""
Simple command-line program for attaching a first class disk to a vm.
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DATASTORE_NAME,
cli.Argument.FIRST_CLASS_DISK_NAME)
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID)
args = parser.get_args()
si = service_instance.connect(args)
try:
content = si.RetrieveContent()
# Retrieve Datastore Object
datastore = pchelper.get_obj(content, [vim.Datastore],
args.datastore_name)
# Retrieve FCD Object
vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name)
# Retrieve VM
vm = None
if args.uuid:
search_index = content.searchIndex
vm = search_index.FindByUuid(None, args.uuid, True)
elif args.vm_name:
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
# Attaching FCD to VM
if vm:
task = attach_fcd_to_vm(vm, vdisk)
tasks.wait_for_tasks(si, [task])
else:
raise RuntimeError("VM not found.")
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
def main():
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DATACENTER_NAME)
parser.add_custom_argument('--dvswitch-name',
required=False,
help='name of the dvswitch',
default='all')
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
datacenter = pchelper.get_obj(content, [vim.Datacenter],
args.datacenter_name)
if datacenter is None:
print("Failed to find the datacenter %s" % args.datacenter_name)
return 0
if args.dvswitch_name == 'all':
dvs_lists = pchelper.get_all_obj(content,
[vim.DistributedVirtualSwitch],
folder=datacenter.networkFolder)
else:
dvsn = pchelper.search_for_obj(content, [vim.DistributedVirtualSwitch],
args.dvswitch_name)
if dvsn is None:
print("Failed to find the dvswitch %s" % args.dvswitch_name)
return 0
dvs_lists = [dvsn]
print('Datacenter Name'.ljust(40) + ' :', args.datacenter_name)
for dvs in dvs_lists:
print(40 * '#')
print('Dvswitch Name'.ljust(40) + ' :', dvs.name)
print(40 * '#')
for dvs_pg in dvs.portgroup:
vlan_info = dvs_pg.config.defaultPortConfig.vlan
vlan_spec = vim.dvs.VmwareDistributedVirtualSwitch.TrunkVlanSpec
if isinstance(vlan_info, vlan_spec):
vlanlist = []
for item in vlan_info.vlanId:
if item.start == item.end:
vlanlist.append(str(item.start))
else:
vlanlist.append(str(item.start) + '-' + str(item.end))
vlan_id = " | Trunk | vlan id: " + ','.join(vlanlist)
else:
vlan_id = " | vlan id: " + str(vlan_info.vlanId)
print(dvs_pg.name.ljust(40) + vlan_id)
return 0
def main():
"""
Simple command-line program for deleting a snapshot of a first class disk.
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DATASTORE_NAME, cli.Argument.FIRST_CLASS_DISK_NAME,
cli.Argument.SNAPSHOT_NAME)
parser.add_custom_argument('--yes', action='store_true', help='Confirm disk deletion.')
args = parser.get_args()
si = service_instance.connect(args)
try:
content = si.RetrieveContent()
# Retrieve Datastore Object
datastore = pchelper.get_obj(content, [vim.Datastore], args.datastore_name)
# Retrieve FCD Object
vdisk = disk.retrieve_fcd(content, datastore, args.fcd_name)
# Retrieve Snapshot Object
snapshot = disk.retrieve_fcd_snapshot(
content, datastore, vdisk, args.snapshot_name)
# Confirming Snapshot deletion
if not args.yes:
response = cli.prompt_y_n_question("Are you sure you want to "
"delete snapshot '" +
args.snapshot_name + "'?",
default='no')
if not response:
print("Exiting script. User chose not to delete snapshot.")
sys.exit()
# Delete FCD Snapshot
storage = content.vStorageObjectManager
task = storage.DeleteSnapshot_Task(
vdisk.config.id, datastore, snapshot)
tasks.wait_for_tasks(si, [task])
print("FCD snapshot deleted!")
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
def main():
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_NAME, cli.Argument.DISK_MODE)
parser.add_custom_argument('--disk-number', required=True, help='Disk number to change mode.')
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
print('Searching for VM {}'.format(args.vm_name))
vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm_obj:
change_disk_mode(si, vm_obj, args.disk_number, args.disk_mode)
print('VM Disk {} successfully changed to mode {}.'.format(args.disk_number,
args.disk_mode))
else:
print("VM not found.")
def add_nic(si, vm, network_name):
"""
:param si: Service Instance
:param vm: Virtual Machine Object
:param network_name: Name of the Virtual 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 = si.RetrieveContent()
network = pchelper.get_obj(content, [vim.Network], network_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
vm.ReconfigVM_Task(spec=spec)
print("NIC CARD ADDED")
def main():
"""
Simple command-line program demonstrating how to update
ESXi Advanced Settings
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.CLUSTER_NAME)
parser.add_custom_argument('--key',
required=True,
action='store',
help='Name of ESXi Advanced Setting to update')
parser.add_custom_argument(
'--value',
required=True,
action='store',
help='Value of the ESXi Advanced Setting to update')
args = parser.get_args()
try:
si = service_instance.connect(args)
content = si.RetrieveContent()
cluster = pchelper.get_obj(content, [vim.ClusterComputeResource],
args.cluster_name)
hosts = cluster.host
for host in hosts:
option_manager = host.configManager.advancedOption
option = vim.option.OptionValue(key=args.key,
value=int(args.value))
print("Updating %s on ESXi host %s "
"with value of %s" % (args.key, host.name, args.value))
if option_manager.UpdateOptions(changedValue=[option]):
print("Settings updated!")
except vmodl.MethodFault as ex:
print("Caught vmodl fault : " + ex.msg)
return -1
except Exception as ex:
print("Caught exception : " + str(ex))
return -1
return 0
def main():
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_NAME, cli.Argument.NIC_STATE)
parser.add_custom_argument('--unitnumber',
required=True,
help='NIC number.',
type=int)
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
print('Searching for VM {}'.format(args.vm_name))
vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm_obj:
update_virtual_nic_state(si, vm_obj, args.unitnumber, args.nic_state)
print('VM NIC {} successfully state changed to {}'.format(
args.unitnumber, args.nic_state))
else:
print("VM not found")
def main():
parser = cli.Parser()
parser.add_optional_arguments(cli.Argument.VM_NAME)
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
if args.vm_name:
print('Searching for VM {}'.format(args.vm_name))
vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm_obj:
print(_columns_four.format('Name', 'Status',
'Version', 'Version Status'))
print_vmwareware_tools_status(vm_obj)
else:
print("VM not found")
else:
print(_columns_four.format('Name', 'Status', 'Version', 'Version Status'))
for vm_obj in get_vms(content):
print_vmwareware_tools_status(vm_obj)
def main():
"""
Sample for adding a NIC to vm
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.PORT_GROUP)
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID)
args = parser.get_args()
si = service_instance.connect(args)
vm = None
if args.uuid:
search_index = si.content.searchIndex
vm = search_index.FindByUuid(None, args.uuid, True)
elif args.vm_name:
content = si.RetrieveContent()
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm:
add_nic(si, vm, args.port_group)
else:
print("VM not found")
def main():
"""
Sample for adding a disk to vm
"""
parser = cli.Parser()
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID,
cli.Argument.DISK_TYPE, cli.Argument.DISK_SIZE)
args = parser.get_args()
si = service_instance.connect(args)
vm = None
if args.uuid:
search_index = si.content.searchIndex
vm = search_index.FindByUuid(None, args.uuid, True)
elif args.vm_name:
content = si.RetrieveContent()
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm:
add_disk(vm, args.disk_size, args.disk_type)
else:
print("VM not found")
def main():
parser = cli.Parser()
parser.add_optional_arguments(cli.Argument.UUID, cli.Argument.VM_NAME)
parser.add_custom_argument('--unit-number',
required=True,
action='store',
help='unit number')
args = parser.get_args()
si = service_instance.connect(args)
vm = None
if args.uuid:
search_index = si.content.searchIndex
vm = search_index.FindByUuid(None, args.uuid, True)
elif args.vm_name:
content = si.RetrieveContent()
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm:
if del_nic(si, vm, int(args.unit_number)):
print("Successfully deleted NIC CARD")
else:
print("VM not found")
def main():
"""
Simple command-line program for creating host and VM folders in a
datacenter.
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DATACENTER_NAME,
cli.Argument.FOLDER_NAME)
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
datacenter = pchelper.get_obj(content, [vim.Datacenter],
args.datacenter_name)
if pchelper.search_for_obj(content, [vim.Folder], args.folder_name):
print("Folder '%s' already exists", args.folder_name)
return 0
create_folder(datacenter.hostFolder, args.folder_name)
print("Successfully created the host folder '%s'" % args.folder_name)
create_folder(datacenter.vmFolder, args.folder_name)
print("Successfully created the VM folder '%s'" % args.folder_name)
return 0
def main():
"""
Simple command-line program for retrieving a port group
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.PORT_GROUP)
args = parser.get_args()
si = service_instance.connect(args)
try:
content = si.RetrieveContent()
# searching for port group
port_group = pchelper.get_obj(content, [vim.Network], args.port_group)
print(port_group)
except vmodl.MethodFault as error:
print("Caught vmodl fault : {0}".format(error.msg))
return -1
return 0
def main():
"""
Simple command-line program for detaching a disk from a virtual machine.
"""
parser = cli.Parser()
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID,
cli.Argument.LANGUAGE)
parser.add_custom_argument('--disk-number',
required=True,
help='HDD number to detach.')
args = parser.get_args()
si = service_instance.connect(args)
try:
content = si.RetrieveContent()
# Retrieve VM
vm = None
if args.uuid:
search_index = content.searchIndex
vm = search_index.FindByUuid(None, args.uuid, True)
elif args.vm_name:
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
# Detaching Disk from VM
if vm:
task = detach_disk_from_vm(vm, args.disk_number, args.language)
tasks.wait_for_tasks(si, [task])
else:
raise RuntimeError("VM not found.")
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
def main():
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_NAME)
# Full path to iso. i.e. "[ds1] folder/Ubuntu.iso"
# If not provided, backend will set to RemotePassThrough
parser.add_optional_arguments(cli.Argument.ISO)
parser.add_custom_argument('--unitnumber',
required=True,
help='CD/DVD unit number.',
type=int)
args = parser.get_args()
si = service_instance.connect(args)
content = si.RetrieveContent()
print('Searching for VM {}'.format(args.vm_name))
vm_obj = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if vm_obj:
update_virtual_cd_backend_by_obj(si, vm_obj, args.unitnumber, args.iso)
device_change = args.iso if args.iso else 'Client Device'
print('VM CD/DVD {} successfully state changed to {}'.format(
args.unitnumber, device_change))
else:
print("VM not found")
def main():
"""
Simple command-line program for creating Dummy VM based on Marvel character
names
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.DATASTORE_NAME,
cli.Argument.FOLDER_NAME,
cli.Argument.RESOURCE_POOL,
cli.Argument.OPAQUE_NETWORK_NAME)
parser.add_custom_argument('--count',
type=int,
required=True,
action='store',
help='Number of VMs to create')
# NOTE (hartsock): as a matter of good security practice, never ever
# save a credential of any kind in the source code of a file. As a
# matter of policy we want to show people good programming practice in
# these samples so that we don't encourage security audit problems for
# people in the future.
parser.add_custom_argument(
'--public_key_file',
required=False,
action='store',
help='Name of the file holding your marvel public key,'
' the key should be the first only of the file. '
'Set one up at developer.marvel.com/account')
parser.add_custom_argument(
'--private_key_file',
required=False,
action='store',
help='Name of the file holding your marvel private '
'key, the key should be the only line of the '
'file. '
'Set one up at developer.marvel.com/account')
args = parser.get_args()
si = service_instance.connect(args)
if args.public_key_file:
with open(args.public_key_file) as key_file:
marvel_public_key = key_file.readline().strip()
else:
marvel_public_key = input('Marvel public key: ').strip()
if args.private_key_file:
with open(args.private_key_file) as key_file:
marvel_private_key = key_file.readline().strip()
else:
marvel_private_key = input('Marvel private key: ').strip()
content = si.RetrieveContent()
vmfolder = pchelper.get_obj(content, [vim.Folder], args.folder_name)
resource_pool = pchelper.get_obj(content, [vim.ResourcePool],
args.resource_pool)
print("Connecting to Marvel API and retrieving " + str(args.count) +
" random character(s) ...")
characters = get_marvel_characters(args.count, marvel_public_key,
marvel_private_key)
for name in characters:
vm_name = 'MARVEL-' + name
create_dummy_vm(vm_name, si, vmfolder, resource_pool,
args.datastore_name)
if args.opaque_network_name:
vm = pchelper.get_obj(content, [vim.VirtualMachine], vm_name)
add_nic(si, vm, args.opaque_network_name)
return 0
def main():
"""
Simple command-line program for executing a process in the VM without the
network requirement to actually access it.
"""
parser = cli.Parser()
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID,
cli.Argument.VM_USER, cli.Argument.VM_PASS)
parser.add_custom_argument(
'--path_to_program',
required=False,
action='store',
help='Path inside VM to the program. e.g. "/bin/cat"')
parser.add_custom_argument('--program_arguments',
required=False,
action='store',
help='Program command line options. '
'e.g. "/etc/network/interfaces > /tmp/plop"')
args = parser.get_args()
si = service_instance.connect(args)
try:
content = si.RetrieveContent()
vm = None
if args.uuid:
# if instanceUuid(last argument) is false it will search for VM BIOS UUID instead
vm = content.searchIndex.FindByUuid(None, args.uuid, True)
elif args.vm_name:
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if not vm:
raise SystemExit("Unable to locate the virtual machine.")
tools_status = vm.guest.toolsStatus
if tools_status in ('toolsNotInstalled', 'toolsNotRunning'):
raise SystemExit(
"VMwareTools is either not running or not installed. "
"Rerun the script after verifying that VMwareTools "
"is running")
creds = vim.vm.guest.NamePasswordAuthentication(username=args.vm_user,
password=args.vm_pwd)
try:
profile_manager = content.guestOperationsManager.processManager
if args.program_arguments:
program_spec = vim.vm.guest.ProcessManager.ProgramSpec(
programPath=args.path_to_program,
arguments=args.program_arguments)
else:
program_spec = vim.vm.guest.ProcessManager.ProgramSpec(
programPath=args.path_to_program)
res = profile_manager.StartProgramInGuest(vm, creds, program_spec)
if res > 0:
print("Program submitted, PID is %d" % res)
pid_exitcode = \
profile_manager.ListProcessesInGuest(vm, creds, [res]).pop().exitCode
# If its not a numeric result code, it says None on submit
while re.match('[^0-9]+', str(pid_exitcode)):
print("Program running, PID is %d" % res)
time.sleep(5)
pid_exitcode = \
profile_manager.ListProcessesInGuest(vm, creds, [res]).pop().exitCode
if pid_exitcode == 0:
print("Program %d completed with success" % res)
break
# Look for non-zero code to fail
elif re.match('[1-9]+', str(pid_exitcode)):
print("ERROR: Program %d completed with Failute" % res)
print(" tip: Try running this on guest %r to debug" %
vm.summary.guest.ipAddress)
print("ERROR: More info on process")
print(
profile_manager.ListProcessesInGuest(
vm, creds, [res]))
break
except IOError as ex:
print(ex)
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
def main():
"""
Simple command-line program for Uploading a file from host to guest
"""
parser = cli.Parser()
parser.add_required_arguments(cli.Argument.VM_USER, cli.Argument.VM_PASS,
cli.Argument.REMOTE_FILE_PATH,
cli.Argument.LOCAL_FILE_PATH)
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.UUID)
args = parser.get_args()
vm_path = args.remote_file_path
try:
si = service_instance.connect(args)
content = si.RetrieveContent()
vm = None
if args.uuid:
search_index = si.content.searchIndex
vm = search_index.FindByUuid(None, args.uuid, True)
elif args.vm_name:
content = si.RetrieveContent()
vm = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if not vm:
raise SystemExit("Unable to locate VirtualMachine.")
print("Found: {0}".format(vm.name))
tools_status = vm.guest.toolsStatus
if (tools_status == 'toolsNotInstalled'
or tools_status == 'toolsNotRunning'):
raise SystemExit(
"VMwareTools is either not running or not installed. "
"Rerun the script after verifying that VMWareTools "
"is running")
creds = vim.vm.guest.NamePasswordAuthentication(username=args.vm_user,
password=args.vm_pwd)
with open(args.local_file_path, 'rb') as myfile:
data_to_send = myfile.read()
try:
file_attribute = vim.vm.guest.FileManager.FileAttributes()
url = content.guestOperationsManager.fileManager. \
InitiateFileTransferToGuest(vm, creds, vm_path,
file_attribute,
len(data_to_send), True)
# When : host argument becomes https://*:443/guestFile?
# Ref: https://github.com/vmware/pyvmomi/blob/master/docs/ \
# vim/vm/guest/FileManager.rst
# Script fails in that case, saying URL has an invalid label.
# By having hostname in place will take take care of this.
url = re.sub(r"^https://\*:", "https://" + str(args.host) + ":",
url)
resp = requests.put(url, data=data_to_send, verify=False)
if not resp.status_code == 200:
print("Error while uploading file")
else:
print("Successfully uploaded file")
except IOError as ex:
print(ex)
except vmodl.MethodFault as error:
print("Caught vmodl fault : " + error.msg)
return -1
return 0
# Example script to reboot a VirtualMachine
from tools import cli, service_instance, tasks, pchelper
from pyVmomi import vim
parser = cli.Parser()
parser.add_optional_arguments(cli.Argument.VM_NAME, cli.Argument.DNS_NAME,
cli.Argument.UUID, cli.Argument.VM_IP)
args = parser.get_args()
si = service_instance.connect(args)
VM = None
if args.uuid:
VM = si.content.searchIndex.FindByUuid(None, args.uuid, True, True)
elif args.dns_name:
VM = si.content.searchIndex.FindByDnsName(None, args.dns_name, True)
elif args.vm_ip:
VM = si.content.searchIndex.FindByIp(None, args.vm_ip, True)
elif args.vm_name:
content = si.RetrieveContent()
VM = pchelper.get_obj(content, [vim.VirtualMachine], args.vm_name)
if VM is None:
raise SystemExit("Unable to locate VirtualMachine.")
print("Found: {0}".format(VM.name))
print("The current powerState is: {0}".format(VM.runtime.powerState))
TASK = VM.ResetVM_Task()
tasks.wait_for_tasks(si, [TASK])
print("its done.")
def clone_vm(content, template, vm_name, datacenter_name, vm_folder,
datastore_name, cluster_name, resource_pool, power_on,
datastorecluster_name):
"""
Clone a VM from a template/VM, datacenter_name, vm_folder, datastore_name
cluster_name, resource_pool, and power_on are all optional.
"""
# if none git the first one
datacenter = pchelper.get_obj(content, [vim.Datacenter], datacenter_name)
if vm_folder:
destfolder = pchelper.search_for_obj(content, [vim.Folder], vm_folder)
else:
destfolder = datacenter.vmFolder
if datastore_name:
datastore = pchelper.search_for_obj(content, [vim.Datastore],
datastore_name)
else:
datastore = pchelper.get_obj(content, [vim.Datastore],
template.datastore[0].info.name)
# if None, get the first one
cluster = pchelper.search_for_obj(content, [vim.ClusterComputeResource],
cluster_name)
if not cluster:
clusters = pchelper.get_all_obj(content, [vim.ResourcePool])
cluster = list(clusters)[0]
if resource_pool:
resource_pool = pchelper.search_for_obj(content, [vim.ResourcePool],
resource_pool)
else:
resource_pool = cluster.resourcePool
vmconf = vim.vm.ConfigSpec()
if datastorecluster_name:
podsel = vim.storageDrs.PodSelectionSpec()
pod = pchelper.get_obj(content, [vim.StoragePod],
datastorecluster_name)
podsel.storagePod = pod
storagespec = vim.storageDrs.StoragePlacementSpec()
storagespec.podSelectionSpec = podsel
storagespec.type = 'create'
storagespec.folder = destfolder
storagespec.resourcePool = resource_pool
storagespec.configSpec = vmconf
try:
rec = content.storageResourceManager.RecommendDatastores(
storageSpec=storagespec)
rec_action = rec.recommendations[0].action[0]
real_datastore_name = rec_action.destination.name
except Exception:
real_datastore_name = template.datastore[0].info.name
datastore = pchelper.get_obj(content, [vim.Datastore],
real_datastore_name)
# set relospec
relospec = vim.vm.RelocateSpec()
relospec.datastore = datastore
relospec.pool = resource_pool
clonespec = vim.vm.CloneSpec()
clonespec.location = relospec
clonespec.powerOn = power_on
print("cloning VM...")
task = template.Clone(folder=destfolder, name=vm_name, spec=clonespec)
wait_for_task(task)
print("VM cloned.")
