| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| package com.cloud.hypervisor.ovm3.objects; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.commons.lang3.StringUtils; |
| |
| public class Xen extends OvmObject { |
| private static final String VNCLISTEN = "vnclisten"; |
| private static final String MEMORY = "memory"; |
| private static final String MAXVCPUS = "maxvcpus"; |
| private static final String VCPUS = "vcpus"; |
| private static final String DOMTYPE = "OVM_domain_type"; |
| private static final String EXTRA = "extra"; |
| private Map<String, Vm> vmList = null; |
| private Vm defVm = new Vm(); |
| |
| public Xen(Connection c) { |
| setClient(c); |
| } |
| |
| /* |
| * a vm class.... Setting up a VM is different than retrieving one from OVM. |
| * It's either a list retrieval or |
| * /usr/lib64/python2.4/site-packages/agent/lib/xenvm.py |
| */ |
| public class Vm { |
| /* 'vfb': [ 'type=vnc,vncunused=1,vnclisten=127.0.0.1,keymap=en-us'] */ |
| private static final long serialVersionUID = 1L; |
| private final List<String> vmVncElement = new ArrayList<String>(); |
| private Map<String, String> vmVnc = new HashMap<String, String>() { |
| { |
| put("type", "vnc"); |
| put("vncunused", "1"); |
| put(VNCLISTEN, "127.0.0.1"); |
| put("keymap", "en-us"); |
| } |
| private static final long serialVersionUID = 1L; |
| }; |
| |
| /* |
| * 'disk': [ |
| * 'file:/OVS/Repositories/0004fb0000030000aeaca859e4a8f8c0/VirtualDisks/0004fb0000120000c444117fd87ea251.img,xvda,w'] |
| */ |
| private final List<String> vmDisks = new ArrayList<String>(); |
| private Map<String, String> vmDisk = new HashMap<String, String>() { |
| { |
| put("id", ""); |
| put("uuid", ""); |
| put("dev", ""); |
| put("bootable", "1"); |
| put("mode", "w"); |
| put("VDI", ""); |
| put("backend", "0"); |
| put("protocol", "x86_32-abi"); |
| put("uname", ""); |
| } |
| private static final long serialVersionUID = 1L; |
| }; |
| |
| /* 'vif': [ 'mac=00:21:f6:00:00:00,bridge=c0a80100'] */ |
| private final ArrayList<String> vmVifs = new ArrayList<String>(); |
| private final Integer maxVifs = 7; |
| private final String[] xvmVifs = new String[maxVifs -1]; |
| private final String vmSimpleName = ""; |
| private final String vmName = ""; |
| private final String vmUuid = ""; |
| /* |
| * the pool the vm.cfg will live on, this is the same as the primary |
| * storage pool (should be unified with disk pool ?) |
| */ |
| private String vmPrimaryPoolUuid = ""; |
| private final String vmOnReboot = "restart"; |
| /* weight is relative for all VMs compared to each other */ |
| private final int vmCpuWeight = 27500; |
| /* minimum memory allowed */ |
| private final int vmMemory = 256; |
| private final int vmCpuCap = 0; |
| /* dynam scaling for cpus */ |
| private final int vmMaxVcpus = 0; |
| /* default to 1, can't be higher than maxvCpus */ |
| private final int vmVcpus = 1; |
| /* high available */ |
| private final Boolean vmHa = false; |
| private final String vmDescription = ""; |
| private final String vmOnPoweroff = "destroy"; |
| private final String vmOnCrash = "restart"; |
| private final String vmBootloader = "/usr/bin/pygrub"; |
| private final String vmBootArgs = ""; |
| private final String vmExtra = ""; |
| /* default to linux */ |
| private final String vmOs = "Other Linux"; |
| private final String vmCpuCompatGroup = ""; |
| /* pv is default */ |
| private final String vmDomainType = "xen_pvm"; |
| /* start counting disks at A -> 0 */ |
| private final int diskZero = 97; |
| private int diskCount = diskZero; |
| |
| private Map<String, Object> vmParams = new HashMap<String, Object>() { |
| { |
| put("vif", vmVifs); |
| put("OVM_simple_name", vmSimpleName); |
| put("disk", vmDisks); |
| put("bootargs", vmBootArgs); |
| put("uuid", vmUuid); |
| put("on_reboot", vmOnReboot); |
| put("cpu_weight", vmCpuWeight); |
| put(MEMORY, vmMemory); |
| put("cpu_cap", vmCpuCap); |
| put(MAXVCPUS, vmMaxVcpus); |
| put("OVM_high_availability", vmHa); |
| put("OVM_description", vmDescription); |
| put("on_poweroff", vmOnPoweroff); |
| put("on_crash", vmOnCrash); |
| put("bootloader", vmBootloader); |
| put("name", vmName); |
| put("guest_os_type", vmOs); |
| put("vfb", vmVncElement); |
| put(VCPUS, vmVcpus); |
| put("OVM_cpu_compat_group", vmCpuCompatGroup); |
| put(DOMTYPE, vmDomainType); |
| put(EXTRA, vmExtra); |
| } |
| private static final long serialVersionUID = 1L; |
| }; |
| |
| public boolean isControlDomain() { |
| if ("Domain-0".equals(getVmName())) { |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean setPrimaryPoolUuid(String poolId) { |
| vmPrimaryPoolUuid = poolId; |
| return true; |
| } |
| |
| public String getPrimaryPoolUuid() throws Ovm3ResourceException { |
| if ("".equals(vmPrimaryPoolUuid)) { |
| return getVmRootDiskPoolId(); |
| } else { |
| return vmPrimaryPoolUuid; |
| } |
| } |
| |
| public Map<String, Object> getVmParams() { |
| return vmParams; |
| } |
| |
| public void setVmParams(Map<String, Object> params) { |
| vmParams = params; |
| } |
| |
| public boolean setVmExtra(final String args) { |
| vmParams.put(EXTRA, args); |
| return true; |
| } |
| |
| public String getVmExtra() { |
| return (String) vmParams.get(EXTRA); |
| } |
| |
| public String getVmBootArgs() { |
| return (String) vmParams.get("bootloader_args"); |
| } |
| |
| public void setVmMaxCpus(Integer val) { |
| vmParams.put(MAXVCPUS, val); |
| } |
| |
| public Integer getVmMaxCpus() { |
| return (Integer) vmParams.get(MAXVCPUS); |
| } |
| |
| public void setVmCpus(Integer val) { |
| if (getVmMaxCpus() == 0 || getVmMaxCpus() >= val) { |
| vmParams.put(VCPUS, val); |
| } else if (getVmMaxCpus() < val) { |
| setVmCpus(getVmMaxCpus()); |
| } |
| } |
| |
| public Integer getVmCpus() { |
| return (Integer) vmParams.get(VCPUS); |
| } |
| |
| public Boolean setVmMemory(long memory) { |
| vmParams.put(MEMORY, Long.toString(memory)); |
| return true; |
| } |
| |
| public long getVmMemory() { |
| return Integer.parseInt((String) vmParams.get(MEMORY)); |
| } |
| |
| public Boolean setVmDomainType(String domtype) { |
| vmParams.put(DOMTYPE, domtype); |
| return true; |
| } |
| |
| /* iiiis this a good idea ? */ |
| public String getVmDomainType() { |
| String domType = (String) vmParams.get(DOMTYPE); |
| if (domType.equals(vmDomainType)) { |
| String builder = (String) vmParams.get("builder"); |
| if (builder == null || builder.contains("linux")) { |
| domType = "xen_pvm"; |
| } else { |
| domType = "hvm"; |
| } |
| } |
| return domType; |
| } |
| |
| public String getVmState() { |
| return (String) vmParams.get("state"); |
| } |
| |
| public Boolean setVmName(String name) { |
| vmParams.put("name", name); |
| vmParams.put("OVM_simple_name", name); |
| return true; |
| } |
| |
| public String getVmName() { |
| return (String) vmParams.get("name"); |
| } |
| |
| public Boolean setVmUuid(String uuid) { |
| vmParams.put("uuid", uuid); |
| return true; |
| } |
| |
| public String getVmUuid() { |
| return (String) vmParams.get("uuid"); |
| } |
| |
| public void setVmVncs(List<String> vncs) { |
| vmVncElement.addAll(vncs); |
| } |
| |
| public List<String> getVmVncs() { |
| return vmVncElement; |
| } |
| |
| public void setVmDisks(List<String> disks) { |
| vmDisks.addAll(disks); |
| } |
| |
| public List<String> getVmDisks() { |
| return vmDisks; |
| } |
| |
| public void setVmVifs(List<String> vifs) { |
| vmVifs.addAll(vifs); |
| } |
| |
| public List<String> getVmVifs() { |
| return vmVifs; |
| } |
| |
| public Integer getVifIdByMac(String mac) { |
| Integer c = 0; |
| for (final String entry : vmVifs) { |
| final String[] parts = entry.split(","); |
| final String[] macpart = parts[0].split("="); |
| assert macpart.length == 2 : "Invalid entry: " + entry; |
| if ("mac".equals(macpart[0]) && macpart[1].equals(mac)) { |
| return c; |
| } |
| c += 1; |
| } |
| logger.debug("No vif matched mac: " + mac + " in " + vmVifs); |
| return -1; |
| } |
| public Integer getVifIdByIp(String ip) { |
| Integer c = 0; |
| for (final String entry : vmVifs) { |
| final String[] parts = entry.split(","); |
| final String[] ippart = parts[1].split("="); |
| assert ippart.length == 2 : "Invalid entry: " + entry; |
| if ("mac".equals(ippart[0]) && ippart[1].equals(ip)) { |
| return c; |
| } |
| c += 1; |
| } |
| logger.debug("No vif matched ip: " + ip + " in " + vmVifs); |
| return -1; |
| } |
| |
| public Boolean addVif(Integer id, String bridge, String mac) { |
| if (getVifIdByMac(mac) > 0) { |
| logger.debug("Already nic with mac present: " + mac); |
| return false; |
| } |
| String vif = "mac=" + mac + ",bridge=" + bridge; |
| xvmVifs[id] = vif; |
| return true; |
| } |
| |
| public boolean setupVifs() { |
| for (String vif : xvmVifs) { |
| if (vif != null && !vmVifs.contains(vif)) { |
| vmVifs.add(vif); |
| } |
| } |
| vmParams.put("vif", vmVifs); |
| return true; |
| } |
| |
| public Boolean removeVif(String bridge, String mac) { |
| List<String> newVifs = new ArrayList<String>(); |
| try { |
| String remove = "mac=" + mac + ",bridge=" + bridge; |
| for (String vif : getVmVifs()) { |
| if (vif.equals(remove)) { |
| logger.debug("leaving out vif: " + remove); |
| } else { |
| logger.debug("keeping vif: " + vif); |
| newVifs.add(vif); |
| } |
| } |
| vmParams.put("vif", newVifs); |
| } catch (Exception e) { |
| logger.debug(e); |
| } |
| return true; |
| } |
| |
| /* 'file:/OVS/Repositories/d5f5a4480515467ca1638554f085b278/ISOs/e14c811ebbf84f0b8221e5b7404a554e.iso,hdc:cdrom,r' */ |
| /* device is coupled with vmtype enumerate and cdboot ? */ |
| public Boolean addRootDisk(String image) { |
| Boolean ret = false; |
| if (diskCount > diskZero) { |
| Integer oVmDisk = diskCount; |
| diskCount = diskZero; |
| ret = addDisk(image, "w"); |
| diskCount = oVmDisk; |
| } else { |
| ret = addDisk(image, "w"); |
| } |
| return ret; |
| } |
| |
| public Boolean addDataDisk(String image) { |
| /* |
| * w! means we're able to share the disk nice for clustered FS? |
| */ |
| return addDisk(image, "w!"); |
| } |
| |
| public Boolean addIso(String image) { |
| return addDisk(image, "r!"); |
| } |
| |
| private Boolean addDisk(String image, String mode) { |
| String devName = null; |
| /* better accounting then diskCount += 1 */ |
| diskCount = diskZero + vmDisks.size(); |
| if (getVmDomainType().contains("hvm")) { |
| diskCount += 2; |
| devName = Character.toString((char) diskCount); |
| } else { |
| devName = "xvd" + Character.toString((char) diskCount); |
| } |
| |
| /* check for iso, force mode and additions */ |
| if (image.endsWith(".iso")) { |
| devName = devName + ":cdrom"; |
| mode = "r"; |
| } |
| return addDiskToDisks(image, devName, mode); |
| } |
| |
| /* should be on device id too, or else we get random attaches... */ |
| private Boolean addDiskToDisks(String image, String devName, String mode) { |
| for (String disk : vmDisks) { |
| if (disk.contains(image)) { |
| logger.debug(vmName + " already has disk " +image+ ":" + devName + ":" + mode); |
| return true; |
| } |
| } |
| vmDisks.add("file:" + image + "," + devName + "," + mode); |
| vmParams.put("disk", vmDisks); |
| return true; |
| } |
| |
| public Boolean removeDisk(String image) { |
| for (String disk : vmDisks) { |
| if (disk.contains(image)) { |
| vmDisks.remove(disk); |
| vmParams.put("disk", vmDisks); |
| return true; |
| } |
| } |
| logger.debug("No disk found corresponding to image: " + image); |
| return false; |
| } |
| |
| /* The conflict between getVm and getVmConfig becomes clear */ |
| public String getVmRootDiskPoolId() throws Ovm3ResourceException { |
| String poolId = getVmDiskPoolId(0); |
| setPrimaryPoolUuid(poolId); |
| return poolId; |
| } |
| |
| private String getVmDiskPoolId(int disk) throws Ovm3ResourceException { |
| int fi = 3; |
| String diskPath = ""; |
| try { |
| diskPath = getVmDiskDetailFromMap(disk, "uname"); |
| } catch (NullPointerException e) { |
| throw new Ovm3ResourceException("No valid disk found for id: " |
| + disk); |
| } |
| String[] st = diskPath.split("/"); |
| return st[fi]; |
| } |
| |
| private String getVmDiskDetailFromMap(int disk, String dest) { |
| Map<String, Object[]> o = (Map<String, Object[]>) vmParams |
| .get("device"); |
| if (o == null) { |
| logger.info("No devices found" + vmName); |
| return null; |
| } |
| vmDisk = (Map<String, String>) o.get("vbd")[disk]; |
| return vmDisk.get(dest); |
| } |
| |
| private boolean setVnc() { |
| List<String> vfb = new ArrayList<String>(); |
| for (final String key : vmVnc.keySet()) { |
| vfb.add(key + "=" + vmVnc.get(key)); |
| } |
| vmVncElement.add(StringUtils.join(vfb, ",")); |
| return true; |
| } |
| |
| public Boolean setVnc(String address, String password) { |
| setVncAddress(address); |
| setVncPassword(password); |
| return setVnc(); |
| } |
| |
| public void setVncUsed(String used) { |
| vmVnc.put("vncused", used); |
| } |
| |
| public String getVncUsed() { |
| return vmVnc.get("vncused"); |
| } |
| |
| public void setVncPassword(String pass) { |
| vmVnc.put("vncpasswd", pass); |
| } |
| |
| public String getVncPassword() { |
| return vmVnc.get("vncpasswd"); |
| } |
| |
| public void setVncAddress(String address) { |
| vmVnc.put(VNCLISTEN, address); |
| } |
| |
| public String getVncAddress() throws Ovm3ResourceException { |
| Integer port = getVncPort(); |
| if (port == null) { |
| return null; |
| } |
| return vmVnc.get(VNCLISTEN); |
| } |
| |
| public Integer getVncPort() throws Ovm3ResourceException { |
| if (getFromVncMap("port") != null) { |
| return Integer.parseInt(getFromVncMap("port")); |
| } |
| String vnc = getVncLocation(); |
| if (vnc != null && vnc.contains(":")) { |
| final String[] res = vnc.split(":"); |
| vmVnc.put(VNCLISTEN, res[0]); |
| vmVnc.put("port", res[1]); |
| return Integer.parseInt(res[1]); |
| } |
| throw new Ovm3ResourceException("No VNC port found"); |
| } |
| |
| public String getVncLocation() { |
| return getFromVncMap("location"); |
| } |
| |
| private String getFromVncMap(String el) { |
| Map<String, Object[]> o = (Map<String, Object[]>) vmParams |
| .get("device"); |
| if (o == null) { |
| return null; |
| } |
| vmVnc = (Map<String, String>) o.get("vfb")[0]; |
| if (vmVnc.containsKey(el)) { |
| return vmVnc.get(el); |
| } else { |
| return null; |
| } |
| } |
| |
| private Object get(String key) { |
| return vmParams.get(key); |
| } |
| } |
| |
| /* |
| * delete_assembly, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: assembly_id - |
| * default: None |
| */ |
| |
| /* |
| * unconfigure_template, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * template_id - default: None argument: params - default: None |
| */ |
| |
| /* |
| * sysrq_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: letter - default: None |
| */ |
| |
| /* |
| * list_vms, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None |
| */ |
| public Map<String, Vm> listVms() throws Ovm3ResourceException { |
| Object[] result = (Object[]) callWrapper("list_vms"); |
| if (result == null) { |
| logger.debug("no vm results on list_vms"); |
| return null; |
| } |
| |
| try { |
| vmList = new HashMap<String, Vm>(); |
| for (Object x : result) { |
| /* put the vmparams in, as x is a hashmap */ |
| Vm vm = new Vm(); |
| vm.setVmParams((Map<String, Object>) x); |
| vmList.put((String) vm.get("name"), vm); |
| } |
| } catch (Exception e) { |
| String msg = "Unable to list VMs: " + e.getMessage(); |
| throw new Ovm3ResourceException(msg, e); |
| } |
| return vmList; |
| } |
| |
| /* |
| * this should become getVmConfig later... getVmConfig returns the |
| * configuration file, while getVm returns the "live" configuration. It |
| * makes perfect sense if you think about it..... ....long enough |
| */ |
| public Vm getRunningVmConfig(String name) throws Ovm3ResourceException { |
| return getRunningVmConfigs().get(name); |
| } |
| |
| public Map<String, Vm> getRunningVmConfigs() throws Ovm3ResourceException { |
| return listVms(); |
| } |
| |
| /* |
| * delete_vm_core, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: core_date - default: None |
| */ |
| |
| /* |
| * delete_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None |
| */ |
| public Boolean deleteVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| return nullIsTrueCallWrapper("delete_vm", repoId, vmId); |
| } |
| |
| /* |
| * save_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: checkpoint - default: None |
| *//* add checkpoint */ |
| |
| /* |
| * configure_template, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * template_id - default: None argument: params - default: None |
| */ |
| |
| /* |
| * create_template, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: template_id - |
| * default: None argument: params - default: None |
| */ |
| |
| /* |
| * list_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None |
| */ |
| |
| public Boolean listVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| defVm.setVmParams((Map<String, Object>) callWrapper("list_vm", repoId, |
| vmId)); |
| if (defVm.getVmParams() == null) { |
| logger.debug("no vm results on list_vm"); |
| return false; |
| } |
| return true; |
| } |
| |
| /* |
| * dump_vm_core, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: live - default: None argument: crash - default: |
| * None argument: reset - default: None |
| */ |
| |
| /* |
| * assembly_del_file, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * assembly_id - default: None argument: filename - default: None |
| */ |
| |
| /* |
| * get_template_config, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * template_id - default: None |
| */ |
| |
| /* |
| * set_assembly_config_xml, <class 'agent.api.hypervisor.xenxm.Xen'> |
| * argument: self - default: None argument: repo_id - default: None |
| * argument: assembly_id - default: None argument: cfg - default: None |
| */ |
| |
| /* |
| * assembly_add_file, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * assembly_id - default: None argument: url - default: None argument: |
| * filename - default: None argument: option - default: None |
| */ |
| |
| /* |
| * send_to_guest, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: params - default: None |
| */ |
| |
| /* |
| * set_assembly_config, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * assembly_id - default: None argument: cfg - default: None |
| */ |
| |
| /* |
| * configure_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: params - default: None |
| */ |
| private Boolean configureVm(String repoId, String vmId, |
| Map<String, Object> params) throws Ovm3ResourceException { |
| return nullIsTrueCallWrapper("configure_vm", repoId, vmId, params); |
| } |
| |
| public Boolean configureVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| return configureVm(repoId, vmId, defVm.getVmParams()); |
| } |
| |
| /* |
| * cleanup_migration_target, <class 'agent.api.hypervisor.xenxm.Xen'> |
| * argument: self - default: None argument: repo_id - default: None |
| * argument: vm_id - default: None |
| */ |
| |
| /* |
| * pause_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None |
| */ |
| public Boolean pauseVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| return nullIsTrueCallWrapper("pause_vm", repoId, vmId); |
| } |
| |
| /* |
| * setup_migration_target, <class 'agent.api.hypervisor.xenxm.Xen'> |
| * argument: self - default: None argument: repo_id - default: None |
| * argument: vm_id - default: None |
| */ |
| |
| /* |
| * deploy_assembly, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: assembly_id - |
| * default: None argument: to_deploy - default: None argument: |
| * target_repo_id - default: None argument: option - default: None |
| */ |
| |
| /* |
| * stop_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: force - default: None |
| */ |
| public Boolean stopVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| Object x = callWrapper("stop_vm", repoId, vmId, false); |
| if (x == null) { |
| return true; |
| } |
| return false; |
| } |
| |
| public Boolean stopVm(String repoId, String vmId, Boolean force) |
| throws Ovm3ResourceException { |
| Object x = callWrapper("stop_vm", repoId, vmId, force); |
| if (x == null) { |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * set_template_config, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * template_id - default: None argument: params - default: None |
| */ |
| |
| /* |
| * assembly_rename_file, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * assembly_id - default: None argument: filename - default: None argument: |
| * new_filename - default: None |
| */ |
| |
| /* |
| * migrate_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: dest - default: None argument: live - default: |
| * None argument: ssl - default: None |
| */ |
| public Boolean migrateVm(String repoId, String vmId, String dest) |
| throws Ovm3ResourceException { |
| return nullIsTrueCallWrapper("migrate_vm", repoId, vmId, dest); |
| } |
| |
| public Boolean migrateVm(String repoId, String vmId, String dest, |
| boolean live, boolean ssl) throws Ovm3ResourceException { |
| Object x = callWrapper("migrate_vm", repoId, vmId, dest, live, ssl); |
| if (x == null) { |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * configure_vm_ha, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: enable_ha - default: None |
| */ |
| public Boolean configureVmHa(String repoId, String vmId, Boolean ha) |
| throws Ovm3ResourceException { |
| Object x = callWrapper("configure_vm_ha", repoId, vmId, ha); |
| if (x == null) { |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * create_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: params - default: None |
| */ |
| public Boolean createVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| return nullIsTrueCallWrapper("create_vm", repoId, vmId, |
| defVm.getVmParams()); |
| } |
| |
| public Boolean createVm(String repoId, String vmId, |
| Map<String, Object> vmParams) throws Ovm3ResourceException { |
| return nullIsTrueCallWrapper("create_vm", repoId, vmId, vmParams); |
| } |
| |
| /* |
| * pack_assembly, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: assembly_id - |
| * default: None |
| */ |
| |
| /* |
| * restore_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: paused - default: None |
| */ |
| |
| /* |
| * start_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None |
| */ |
| public Boolean startVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| return nullIsTrueCallWrapper("start_vm", repoId, vmId); |
| } |
| |
| /* |
| * unpause_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None |
| */ |
| |
| /* |
| * trigger_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: name - default: None argument: vcpu - default: |
| * None |
| */ |
| |
| /* |
| * set_vm_config, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: params - default: None |
| */ |
| |
| /* |
| * delete_template, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: template_id - |
| * default: None |
| */ |
| |
| /* |
| * reboot_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: wait - default: None |
| */ |
| public Boolean rebootVm(String repoId, String vmId, int wait) |
| throws Ovm3ResourceException { |
| Object x = callWrapper("reboot_vm", repoId, vmId, wait); |
| if (x == null) { |
| return true; |
| } |
| return false; |
| } |
| |
| public Boolean rebootVm(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| Object x = callWrapper("reboot_vm", repoId, vmId, 3); |
| if (x == null) { |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * unpack_assembly, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: assembly_id - |
| * default: None |
| */ |
| |
| /* |
| * get_vm_config, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None |
| */ |
| public Vm getVmConfig(String vmName) throws Ovm3ResourceException { |
| defVm = getRunningVmConfig(vmName); |
| if (defVm == null) { |
| logger.debug("Unable to retrieve running config for " + vmName); |
| return defVm; |
| } |
| return getVmConfig(defVm.getVmRootDiskPoolId(), defVm.getVmUuid()); |
| } |
| |
| public Vm getVmConfig() { |
| return defVm; |
| } |
| |
| /* |
| * returns the configuration file contents, so we parse it for configuration |
| * alterations we might want to do (/$repo/VirtualMachines/$uuid/vm.cfg) |
| */ |
| public Vm getVmConfig(String repoId, String vmId) |
| throws Ovm3ResourceException { |
| try { |
| Xen.Vm nVm = new Xen.Vm(); |
| Map<String, Object[]> x = (Map<String, Object[]>) callWrapper( |
| "get_vm_config", repoId, vmId); |
| if (x == null) { |
| logger.debug("Unable to find vm with id:" + vmId + " on repoId:" + repoId); |
| return nVm; |
| } |
| nVm.setVmVifs(Arrays.asList(Arrays.copyOf(x.get("vif"), |
| x.get("vif").length, String[].class))); |
| x.remove("vif"); |
| nVm.setVmDisks(Arrays.asList(Arrays.copyOf(x.get("disk"), |
| x.get("disk").length, String[].class))); |
| x.remove("disk"); |
| nVm.setVmVncs(Arrays.asList(Arrays.copyOf(x.get("vfb"), |
| x.get("vfb").length, String[].class))); |
| x.remove("vfb"); |
| Map<String, Object> remains = new HashMap<String, Object>(); |
| for (final Map.Entry<String, Object[]> not : x.entrySet()) { |
| remains.put(not.getKey(), not.getValue()); |
| } |
| nVm.setVmParams(remains); |
| nVm.setPrimaryPoolUuid(repoId); |
| /* to make sure stuff doesn't blow up in our face... */ |
| defVm = nVm; |
| return nVm; |
| } catch (Ovm3ResourceException e) { |
| throw e; |
| } |
| } |
| |
| /* |
| * get_assembly_config_xml, <class 'agent.api.hypervisor.xenxm.Xen'> |
| * argument: self - default: None argument: repo_id - default: None |
| * argument: assembly_id - default: None |
| */ |
| |
| /* |
| * import_assembly, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: assembly_id - |
| * default: None argument: url - default: None argument: option - default: |
| * None |
| */ |
| |
| /* |
| * create_assembly, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: assembly_id - |
| * default: None argument: templates - default: None |
| */ |
| |
| /* |
| * get_assembly_config, <class 'agent.api.hypervisor.xenxm.Xen'> argument: |
| * self - default: None argument: repo_id - default: None argument: |
| * assembly_id - default: None |
| */ |
| |
| /* |
| * unconfigure_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: params - default: None |
| */ |
| |
| /* |
| * import_template, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self |
| * - default: None argument: repo_id - default: None argument: template_id - |
| * default: None argument: url_list - default: None argument: option - |
| * default: None |
| */ |
| |
| /* |
| * import_vm, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None argument: url_list - default: None argument: option - |
| * default: None |
| */ |
| |
| /* |
| * list_vm_core, <class 'agent.api.hypervisor.xenxm.Xen'> argument: self - |
| * default: None argument: repo_id - default: None argument: vm_id - |
| * default: None |
| */ |
| } |