def vsphere_check_with_api(api, run_time, text): """Uses api to perform checking of vms on vsphere-type provider. Args: api: api endpoint to vsphere run_time: when this run time is exceeded for the VM, it will be deleted text: when this string is found in the name of VM, it may be deleted """ vms = VirtualMachine.all(api.api) vms_to_delete = [] templates_to_delete = [] nightly_templates = [VirtualMachine.get(api.api, name=x) for x in api.list_template() if "miq-nightly" in x] nightly_templates.sort(key=lambda x: datetime.datetime.strptime(x.name[-12:], "%Y%m%d%H%M")) if len(nightly_templates) > MRU_NIGHTLIES: for template in nightly_templates[:-MRU_NIGHTLIES]: templates_to_delete.append(template.name) for vm in vms: vm_name = vm.name running_for = vm.summary.quickStats.uptimeSeconds / SEC_IN_DAY if running_for >= run_time and is_affected(vm_name, text): print("To delete: {} with runtime: {}".format(vm_name, running_for)) vms_to_delete.append(vm_name) return (vms_to_delete, templates_to_delete)
def check_template_exists(hostname, username, password, name): client = Client(server=hostname, username=username, password=password) try: VirtualMachine.get(client, name=name) print "VSPHERE: A Machine with that name already exists" except ObjectNotFoundError: return False client.logout() return True
def get_host(self, hostname): ''' Read info about a specific host or VM from cache or VMware API. ''' inv = self._get_cache(hostname, None) if inv is not None: return inv if not self.guests_only: try: host = HostSystem.get(self.client, name=hostname) inv = self._get_host_info(host) except ObjectNotFoundError: pass if inv is None: try: vm = VirtualMachine.get(self.client, name=hostname) inv = self._get_vm_info(vm) except ObjectNotFoundError: pass if inv is not None: self._put_cache(hostname, inv) return inv or {}
def changevmMemory(self,vm_name,memory): try: new_config = self.client.create("VirtualMachineConfigSpec") new_config.memoryMB = memory vm = VirtualMachine.get(self.client, name=vm_name) print("Reconfiguring %s" % vm_name) if vm.config.hardware.memoryMB== vm_name: print("Not reconfiguring %s as it already has %s memory" % (vm_name,memory)) sys.exit() task = vm.ReconfigVM_Task(spec=new_config) while task.info.state in ["queued", "running"]: print("Waiting 5 more seconds for VM starting") time.sleep(5) task.update() if task.info.state == "success": elapsed_time = task.info.completeTime - task.info.startTime print("Successfully reconfigured VM %s. Server took %s seconds." % (vm_name, elapsed_time.seconds)) elif task.info.state == "error": print("ERROR: The task for reconfiguring the VM has finished with" " an error. If an error was reported it will follow.") print("ERROR: %s" % task.info.error.localizedMessage) except VimFault, e: print("Failed to reconfigure %s: " % e) sys.exit()
def upload_ova(hostname, username, password, name, datastore, cluster, datacenter, url, host): client = Client(server=hostname, username=username, password=password) try: VirtualMachine.get(client, name=name) print "VSPHERE: A Machine with that name already exists" sys.exit(127) except ObjectNotFoundError: pass client.logout() cmd_args = ['ovftool'] cmd_args.append("--datastore=%s" % datastore) cmd_args.append("--name=%s" % name) cmd_args.append("--vCloudTemplate=True") cmd_args.append(url) cmd_args.append("vi://%s@%s/%s/host/%s" % (username, hostname, datacenter, cluster)) print "VSPHERE: Running OVFTool..." proc = subprocess.Popen(cmd_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out_string = "" while "'yes' or 'no'" not in out_string and "Password:"******"'yes' or 'no'" in out_string: proc.stdin.write("yes\n") proc.stdin.flush() print "VSPHERE: Added host to SSL hosts" out_string = "" while "Password:"******"\n") output = proc.stdout.read() error = proc.stderr.read() if "successfully" in output: print " VSPHERE: Upload completed" return 0, output else: print "VSPHERE: Upload did not complete" return -1, "\n".join([output, error])
def make_template(client, name): print("VSPHERE: Marking as Template") vm = VirtualMachine.get(client.api, name=name) try: vm.MarkAsTemplate() print(" VSPHERE: Successfully templatized machine") except: print(" VSPHERE: Failed to templatize machine") sys.exit(127)
def make_template(client, name, provider): print("VSPHERE:{} Marking as Template".format(provider)) vm = VirtualMachine.get(client.api, name=name) try: vm.MarkAsTemplate() print(" VSPHERE:{} Successfully templatized machine".format(provider)) except: print(" VSPHERE:{} Failed to templatize machine".format(provider)) sys.exit(127)
def vsphere_is_vm_down(api, vm_name): """Returns True if VM on vsphere is down. Args: api: api endpoint to vsphere vm_name: name og the vm """ vm = VirtualMachine.get(api.api, name=vm_name) if vm.runtime.powerState == 'poweredOff': return True return False
def make_template(client, name, hostname, username, password): print "VSPHERE: Marking as Template" client = Client(server=hostname, username=username, password=password) vm = VirtualMachine.get(client, name=name) try: vm.MarkAsTemplate() print " VSPHERE: Successfully templatized machine" except: print " VSPHERE: Failed to templatize machine" sys.exit(127)
def vsphere_is_vm_up(api, vm_name): """Returns True if VM on vsphere is up. Args: api: api endpoint to vsphere vm_name: name of the vm """ vm = VirtualMachine.get(api.api, name=vm_name) if vm.runtime.powerState == "poweredOn": return True return False
def stop(self, vmname): vm = VirtualMachine.get(self.client, name=vmname) print 'Attempting to shut down ' + vmname try: shutdown = vm.ShutdownGuest() self.task(vm, shutdown) except suds.WebFault as e: if self.force: print 'Attempting to forcefully power off ' + vmname pass else: raise e print 'Attempting to power off ' + vmname poweroff = vm.PowerOffVM_Task() self.task(vm, poweroff)
def destroy_vm(self, vm_name): """ Destroys VM*, deleting its contents and removing it from parent folder Params: - vm: (str) The name of the virtual machine to be deleted. *Assumes proper permissions (VirtualMachine.Inventory.Delete) """ vm = VirtualMachine.get(self.client, name=vm_name) try: log._info("Destroying %s" % vm.name) task = vm.Destroy_Task() except VimFault as e: log._warn("ERROR: Failed to destroy %s %s" % (vm.name, e))
def add_disk(client, name): print "VSPHERE: Beginning disk add..." backing = client.create("VirtualDiskFlatVer2BackingInfo") backing.datastore = None backing.diskMode = "persistent" backing.thinProvisioned = True disk = client.create("VirtualDisk") disk.backing = backing disk.controllerKey = 1000 disk.key = 3000 disk.unitNumber = 1 disk.capacityInKB = 8388608 disk_spec = client.create("VirtualDeviceConfigSpec") disk_spec.device = disk file_op = client.create("VirtualDeviceConfigSpecFileOperation") disk_spec.fileOperation = file_op.create operation = client.create("VirtualDeviceConfigSpecOperation") disk_spec.operation = operation.add devices = [] devices.append(disk_spec) nc = client.create("VirtualMachineConfigSpec") nc.deviceChange = devices vm = VirtualMachine.get(client, name=name) task = vm.ReconfigVM_Task(spec=nc) def check_task(task): task.update() return task.info.state wait_for(check_task, [task], fail_condition="running") if task.info.state == "success": print " VSPHERE: Successfully added new disk" client.logout() else: client.logout() print " VSPHERE: Failed to add disk" sys.exit(127)
def vsphere_delete_vm(api, vm_name): """Deletes VM from vsphere-type provider. If needed, stops the VM first, then deletes it. Args: api: api endpoint to vsphere vm_name: name of the vm """ vm = VirtualMachine.get(api.api, name=vm_name) vm_status = vsphere_vm_status(api, vm_name) if vm_status != "poweredOn" and vm_status != "poweredOff": # something is wrong, locked image etc exc_msg = "VM status: {}".format(vm_status) raise Exception(exc_msg) print("status: {}".format(vm_status)) if vm_status == "poweredOn": print("Powering down: {}".format(vm.name)) vm.PowerOffVM_Task() wait_for(vsphere_is_vm_down, [api, vm_name], fail_condition=False, delay=10, num_sec=120) print("Deleting: {}".format(vm_name)) vm.Destroy_Task()
def clone(self,cursor,payload): ''' clone the template with our payload ''' while payload: data = payload.pop(0) try: cluster = ClusterComputeResource.get(cursor, name=data['cluster']) except Exception, e: log.error("Unable to locate a cluster resource witht the name {}. Omitting build".format(data['cluster'])) else: pool = cluster.resourcePool esxhost = choice(cluster.host) datastore = choice(cluster.datastore) log.info("Cloning virtual machine named {} into cluster {} from template {}".format(data['vm_name'],data['cluster'],data['template'])) template = VirtualMachine.get(cursor, name=data['template']) folder = cluster.parent.parent.vmFolder _ip_spec = self._vm_ip_spec(cursor, domain = data['domain'], dns = data['dns'], gateway = data['gateway'], ip = data['ip'], netmask = data['netmask']) _adapter_spec = self._vm_adapter_spec(cursor,_ip_spec) _net_spec = self._vm_net_spec(cursor,cluster.network, vlan = data['vlan']) _custom_spec = self._vm_custom_spec(cursor, _adapter_spec, template = data['template'], domain = data['domain'], name = data['vm_name'], ip = data['ip'], gateway = data['gateway'], netmask = data['netmask'], dns = data['dns']) _config_spec = self._vm_config_spec(cursor, _net_spec, memory = data['memory'], cpus = data['cpus'], cores = data['cores'], name = data['vm_name']) _relo_spec = self._vm_relo_spec(cursor,esxhost,datastore,pool) _clone_spec = self._vm_clone_spec(cursor, _relo_spec, _config_spec, _custom_spec) try: #self.wait_for_task(template.CloneVM_Task(folder = folder, name = data['vm_name'], spec=_clone_spec)) template.CloneVM_Task(folder = folder, name = data['vm_name'], spec=_clone_spec) except VimFault, e: print e
import sys import time from psphere.client import Client from psphere.soap import VimFault from psphere.managedobjects import VirtualMachine from psphere.errors import ObjectNotFoundError vm_name = sys.argv[1] client = Client() new_config = client.create("VirtualMachineConfigSpec") new_config.numCPUs = 2 try: vm = VirtualMachine.get(client, name=vm_name) except ObjectNotFoundError: print("ERROR: No VM found with name %s" % vm_name) print("Reconfiguring %s" % vm_name) if vm.config.hardware.numCPU == 2: print("Not reconfiguring %s as it already has 2 CPUs" % vm_name) sys.exit() try: task = vm.ReconfigVM_Task(spec=new_config) except VimFault, e: print("Failed to reconfigure %s: " % e) sys.exit() while task.info.state in ["queued", "running"]:
def start(self, vmname): vm = VirtualMachine.get(self.client, name=vmname) print 'Attempting to power on %s' % (vmname) poweron = vm.PowerOnVM_Task() self.task(vm, poweron)
import time import sys from psphere.client import Client from psphere.managedobjects import VirtualMachine scatter_secs = 8 nodes = sys.argv[1:] client = Client() print("Powering on %s VMs" % len(nodes)) print("Estimated run time with %s seconds sleep between each power on: %s" % (scatter_secs, scatter_secs*len(nodes))) for node in nodes: try: vm = VirtualMachine.get(client, name=node, properties=["name", "runtime"]) except ObjectNotFoundError: print("WARNING: Could not find VM with name %s" % node) pass print("Powering on %s" % vm.name) if vm.runtime.powerState == "poweredOn": print("%s is already powered on." % vm.name) continue task = vm.PowerOnVM_Task() time.sleep(scatter_secs)
def exportVM(serverIp, user, passwd, vmName, workingDir): try: print "Connecting to the server...." client = Client(serverIp, user, passwd) except WebFault: print "Can't connect to the server" sys.exit(1) print "Connected" validVms = {} if vmName <> 'all': try: vm = VirtualMachine.get(client, name=vmName) if vm.runtime.powerState <> 'poweredOff': print 'Skipping VM:' + vm.name + ' VM is not powered off' sys.exit(5) if len(vm.network) <> 1: print 'Skipping VM:' + vm.name + ' The number of network devices is not equal to 1' sys.exit(5) vmdkPath = getVMDKUri(serverIp, vm) if vmdkPath != None: validVms[vm.name] = vmdkPath except ObjectNotFoundError: print 'Invalid VM name' client.logout() sys.exit(2) else: # inspect all vms vms = VirtualMachine.all(client) for vm in vms: if vm.runtime.powerState <> 'poweredOff': print 'Skipping VM:' + vm.name + ' VM is not powered off' continue if len(vm.network) <> 1: print 'Skipping VM:' + vm.name + ' The number of network devices is not equal to 1' continue vmdkPath = getVMDKUri(serverIp, vm) if vmdkPath != None: validVms[vm.name] = vmdkPath else: continue client.logout() if len(validVms.keys()) == 0: print 'Nothing to export' sys.exit(2) # get vmdks for all valid vms for vmName in validVms.keys(): directory = workingDir + '/' + vmName + '/' if not os.path.exists(directory): os.makedirs(directory) VmdkUri = validVms[vmName] downloadFile(VmdkUri, user, passwd, directory + vmName + '.vmdk') extends = parseVMDK(directory + vmName + '.vmdk') if extends == None: print 'No accessable extends' sys.exit(3) else: available = getAvalableDiskSpaceBytes(workingDir) for s in extends.values(): available = available - s if available < 0: print 'There is not enough free disk space to download all extends for VM:' + vmName exit(4) for e in extends.keys(): m = re.match('^(.+?)/folder/(.+?)/(.+?)\?(.+)$', VmdkUri) uri = m.group(1) + '/folder/' + m.group(2) + '/' + urllib2.quote(e) + '?' + m.group(4) downloadFile(uri, user, passwd, directory + e) sys.exit(0)
#!/usr/bin/python import sys from psphere.client import Client from psphere.managedobjects import HostSystem, VirtualMachine client = Client(sys.argv[1], sys.argv[2], sys.argv[3]) host_systems = HostSystem.all(client) print("HostSystem.all(client) finds these hosts") for host_system in host_systems: print(host_system.name) vm = VirtualMachine.get(client, name="genesis", overallStatus="green") print('VirtualMachine.get(client, name="genesis", overallStatus="green")' ' got the following host:') print("Name: %s" % vm.name) print("overallStatus: %s" % vm.overallStatus)
def vsphere_vm_status(api, vm_name): vm = VirtualMachine.get(api.api, name=vm_name) return vm.runtime.powerState