package com.bocloud.cmp.model.h3c;

import java.util.List;

public class H3cServerModel {
    /**
     * 虚拟机名称，名称的最大输入长度为64个字符，且只允许输入字母、数字、减号、下划线及点。字符串（String）类型，必须。
     */
    private String name;
    /**
     * 虚拟机显示名称，最大输入长度为64个字符。字符串（String）类型，必须。
     */
    private String title;
    /**
     * 描述,最大输入长度为120个字符。字符串（String）类型，可选项。
     */
    private String description;
    /**
     * 内存大小，单位为MB，最小值为512最大值由主机实际情况决定。整型（Integer）类型，必须。
     */
    private Integer memory;
    /**
     * 内存大小，单位为由memoryUnit决定,换算成MB后，必须与memory指定的值相同。 整型（Integer）类型，必须。
     */
    private Integer memoryInit;
    /**
     * 内存显示单位，字符串。 枚举类型：GB,MB。
     */
    private String memoryUnit;
    /**
     * 内存资源优先级。枚举值：0=低，50=中，100=高 整型（Integer）类型，取值:0,50,100。必填。
     */
    private Integer memoryPriority;
    /**
     * 内存预留。内存预留百分比。 整型（Integer）类型，取值范围:0-100。必填。
     */
    private Integer memoryBacking;
    /**
     * CPU个数，最小值为1，最大值由主机实际情况决定。 整型（Integer）类型，必须。
     */
    private Integer cpuSockets;
    /**
     * CPU核数，最小值为1，最大值由主机实际情况决定。 整型（Integer）类型，必须。
     */
    private Integer cpuCores;
    /**
     * CPU调度优先级，枚举值：1024：高，512：中，256：低。 整型（Integer）类型，必须。
     */
    private Integer cpuShares;
    /**
     * 主机允许的最大CPU核数。 整型（Integer）类型，必须。
     */
    private Integer maxCpuSocket;
    /**
     * I/O优先级，枚举值：500：高，300：中，200：低。 整型（Integer）类型，必须。
     */
    private Integer blkiotune;
    /**
     * 操作系统类型，枚举值：0：Windows,1：Linux。 整型（Integer）类型，必须。
     */
    private Integer system;
    /**
     * 操作系统版本，枚举值： 当操作系统为Windows: Microsoft Windows Server 2012, Microsoft Windows
     * Server 2012 R2, Microsoft Windows Server 2008 R2(64-bit), Microsoft Windows
     * Server 2008(64-bit), Microsoft Windows Server 2008(32-bit), Microsoft Windows
     * Server 2003(64-bit), Microsoft Windows Server 2003(32-bit), Microsoft Windows
     * 8(64-bit), Microsoft Windows 8(32-bit), Microsoft Windows 7(64-bit),
     * Microsoft Windows 7(32-bit), Microsoft Windows Vista(64-bit), Microsoft
     * Windows Vista(32-bit), Microsoft Windows XP Professional(64-bit), Microsoft
     * Windows XP Professional(32-bit), Microsoft Windows 2000, Microsoft Windows
     * NT, Microsoft Windows 98, Microsoft Windows 95, Microsoft Windows 3.1,
     * Microsoft MS-DOS 当操作系统为Linux: Red Hat Enterprise Linux7(64-bit), Red Hat
     * Enterprise Linux7(32-bit), Red Hat Enterprise Linux6(64-bit), Red Hat
     * Enterprise Linux6(32-bit), Red Hat Enterprise Linux5(64-bit), Red Hat
     * Enterprise Linux5(32-bit), Red Hat Enterprise Linux4(64-bit), Red Hat
     * Enterprise Linux4(32-bit), Red Hat Enterprise Linux3(64-bit), Red Hat
     * Enterprise Linux3(32-bit), Red Hat Enterprise Linux2.1, Novell SUSE Linux
     * Enterprise 11(64-bit), Novell SUSE Linux Enterprise 11(32-bit), Novell SUSE
     * Linux Enterprise 10(64-bit), Novell SUSE Linux Enterprise 10(32-bit), Novell
     * SUSE Linux Enterprise 8/9(64-bit), Novell SUSE Linux Enterprise 8/9(32-bit),
     * CentOS 4/5/6(64bit), CentOS 4/5/6(32bit), Debian GUN/Linux 6(64-bit), Debian
     * GUN/Linux 6(32-bit), Debian GUN/Linux 5(64-bit), Debian GUN/Linux 5(32-bit),
     * Debian GUN/Linux 4(64-bit), Debian GUN/Linux 4(32-bit), Asianux 4(64-bit),
     * Asianux 4(32-bit), Asianux 3(64-bit), Asianux 3(32-bit), Oracle Linux
     * 4/5/6(64-bit), Oracle Linux 4/5/6(32-bit), Ubuntu Linux(64-bit), Ubuntu
     * Linux(32-bit), Other 2.6.x Linux(64-bit), Other 2.6.x Linux(32-bit), Other
     * 2.4.x Linux(64-bit), Other 2.4.x Linux(32-bit), Other Linux(64-bit), Other
     * Linux(32-bit) 字符串（String）类型，必须。
     */
    private String osVersion;
    /**
     * 是否允许虚拟机自动迁移;，实现资源动态调整，枚举值：1=允许，0=不允许。 整型（Integer）类型，必须。
     */
    private Integer autoMigrate;
    /**
     * 启动优先级;，当集群启用HA后有效，枚举值：0：低级，1：中级，2：高级。 整型（Integer）类型，必须。
     */
    private Integer priority;
    /**
     * 主机id;。 长整型（Long）类型，必须。
     */
    private Long hostId;
    /**
     * 主机池id;。 长整型（Long）类型，必须。
     */
    private Long hostPoolId;
    /**
     * 是否可用;。 整型（Integer）类型，设置为1，必须。
     */
    private Integer formatEnable;
    /**
     * 绑定物理CPU配置;。 自定义类型，可选项。
     */
    private H3cBindCpuModel bindcpu;
    /**
     * 虚拟机网络配置;。 自定义类型，必须。
     */
    private List<H3cNetWorkModel> networks;
    /**
     * 虚拟机存储配置;。 自定义类型，必须。
     */
    private List<H3cStorageModel> storages;
    /**
     * usb 虚拟机USB设备配置; 自定义类型，可选。
     */
    private List<H3cUsbModel> usb;
    /**
     * pci 虚拟机PCI设备配置;。 自定义类型，可选。
     */
    private List<H3cPciModel> pci;
    /**
     * 虚拟机GPU直通显卡配置,最多只能有一个。 自定义类型，可选。
     */
    private H3cGpuModel gpu;
    /**
     * 虚拟机 ID。 长整型（Long）类型。
     */
    private Long id;
    /**
     * 集群 ID。 长整型（Long）类型。
     */
    private Long clusterId;
    /**
     * 主机名称。 字符串（String）类型。
     */
    private String hostName;
    /**
     * 虚拟机CPU利用率。 小数（double）类型。
     */
    private Double cpuRate;
    /**
     * cpu
     */
    private Integer cpu;
    /**
     * 虚拟机虚拟CPU个数（CPU个数 *CPU核数） 。 整型（Integer）类型。
     */
    private Integer memRate;
    /**
     * 虚拟机状态。 字符串（String）类型，shutOff:关闭，shutdown:关闭，running:运行，paused:暂停，unknown:未知
     */
    private String vmStatus;
    /**
     * 虚拟机UUID。 字符串（String）类型。
     */
    private String uuid;
    /**
     * 虚拟机安装的操作系统描述。 字符串（String）类型。
     */
    private String osDesc;
    /**
     * 虚拟机所属标志0:不属于用户以及用户组 1:属于用户 2:属于用户组。 整型（Integer）类型
     */
    private Integer flag;
    /**
     * 虚拟机类型 0:CAS虚拟机 1:VMware虚拟机。 整型（Integer）类型
     */
    private Integer type;
    /**
     * 是否快速部署过。 布尔（Boolean）类型
     */
    private Boolean deployed;
    /**
     * 是否存在raw格式。 布尔（Boolean）类型
     */
    private Boolean existRaw;
    /**
     * 虚拟机HA状态，枚举值，0:正常 1:未加入HA 2:已加入HA，配置文件不同步 整型（Integer）类型
     */
    private Integer haStatus;
    /**
     * 虚拟机是否被HA管理，枚举值，0：未被HA管理，1：被HA管理。 整型（Integer）类型
     */
    private Integer haManage;
    /**
     * 基本信息 。 对象类型。
     */
    private Basic basic;
    /**
     * CPU配置信息。 对象类型。
     */
    private Cpu cpuObj;
    private Memory memoryObj;
    private BootDev bootDev;
    private List<Graphics> graphics;
    /**
     * 虚拟机状态。 2：运行 3：关闭 4：暂停。 整数（int）类型。
     */
    private Integer status;

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public static class Basic {
        /**
         * 是否启用PAE：1-启用，0-不启用。 整数（int）类型。
         */
        private Integer pae;
        /**
         * 是否启用ACPI;：1-启用，0-不启用 整数（int）类型。
         */
        private Integer acpi;
        /**
         * 是否启用APIC;：1-启用，0-不启用。 整数（int）类型。
         */
        private Integer apic;
        /**
         * 时钟设置;：本地：localtime，世界时钟 ：utc。 字符串（String）类型。
         */
        private String clock;
        /**
         * 虚拟机描述信息;。 字符串（String）类型。
         */
        private String description;
        /**
         * O优先级; 高=500，中=300，低=200。 整数（int）类型。
         */
        private Integer blkiotune;
        /**
         * 虚拟机启动优先级; 0:低级 1:中级 2:高级。 整数（int）类型。
         */
        private Integer startPriority;
        /**
         * 虚拟机是否允许自动迁移;。1:允许，0：否。 整数（int）类型。
         */
        private Integer autoMigrate;
        /**
         * 虚拟机HA管理标志; 1:开启高可靠性，0：关闭高可靠性。 字符串（String）类型。
         */
        private String haManage;
        /**
         * 系统架构; 如：X86_64。 字符串（String）类型。
         */
        private String architecture;
        /**
         * 管理程序;。 字符串（String）类型。
         */
        private String manager;
        /**
         * 模拟器;。 字符串（String）类型。
         */
        private String emulator;
        /**
         * 系统故障策略; 0:不处理 1:故障重启 2:故障迁移。 整数（int）类型。
         */
        private Integer osha;
        /**
         * 同步虚拟机时间与主机时间; 1:同步，0：不同步 整数（int）类型。
         */
        private Integer timeSync;

        public Integer getPae() {
            return pae;
        }

        public void setPae(Integer pae) {
            this.pae = pae;
        }

        public Integer getAcpi() {
            return acpi;
        }

        public void setAcpi(Integer acpi) {
            this.acpi = acpi;
        }

        public Integer getApic() {
            return apic;
        }

        public void setApic(Integer apic) {
            this.apic = apic;
        }

        public String getClock() {
            return clock;
        }

        public void setClock(String clock) {
            this.clock = clock;
        }

        public String getDescription() {
            return description;
        }

        public void setDescription(String description) {
            this.description = description;
        }

        public Integer getBlkiotune() {
            return blkiotune;
        }

        public void setBlkiotune(Integer blkiotune) {
            this.blkiotune = blkiotune;
        }

        public Integer getStartPriority() {
            return startPriority;
        }

        public void setStartPriority(Integer startPriority) {
            this.startPriority = startPriority;
        }

        public Integer getAutoMigrate() {
            return autoMigrate;
        }

        public void setAutoMigrate(Integer autoMigrate) {
            this.autoMigrate = autoMigrate;
        }

        public String getHaManage() {
            return haManage;
        }

        public void setHaManage(String haManage) {
            this.haManage = haManage;
        }

        public String getArchitecture() {
            return architecture;
        }

        public void setArchitecture(String architecture) {
            this.architecture = architecture;
        }

        public String getManager() {
            return manager;
        }

        public void setManager(String manager) {
            this.manager = manager;
        }

        public String getEmulator() {
            return emulator;
        }

        public void setEmulator(String emulator) {
            this.emulator = emulator;
        }

        public Integer getOsha() {
            return osha;
        }

        public void setOsha(Integer osha) {
            this.osha = osha;
        }

        public Integer getTimeSync() {
            return timeSync;
        }

        public void setTimeSync(Integer timeSync) {
            this.timeSync = timeSync;
        }
    }

    public static class Cpu {
        /**
         * CPU个数。 整数（int）类型。
         */
        private Integer cpuSockets;
        /**
         * CPU核数。 整数（int）类型。
         */
        private Integer cpuCores;
        /**
         * 虚拟机CPU优调度先级。 高=1024，中=512，低=256。 整数（int）类型。
         */
        private Integer cpuShares;
        /**
         * CPU最大核数（主机CPU核数）。 整数（int）类型。
         */
        private Integer maxCpuNum;
        /**
         * CPU工作模式，取值为：custom、host-model、host-passthrough。 字符串（String）类型。
         */
        private String cpuMode;
        /**
         * CPU体系结构，取值为：x86_64、i686。 字符串（String）类型。
         */
        private String cpuArch;
        /**
         * CPU周期限制值。 小数（double）类型。
         */
        private Double cpuQuota;
        /**
         * CPU周期限制 单位。 字符串（String）类型。
         */
        private String cpuQuotaUnit;
        /**
         * CPU周期最小限制。 长整数（long）类型。
         */
        private Long cpuMinRate;
        /**
         * CPU周期最大限制。 长整数（long）类型。
         */
        private Long cpuMaxRate;
        /**
         * CPU预留;。 长整数（long）类型。
         */
        private Long cpuGurantee;

        public Integer getCpuSockets() {
            return cpuSockets;
        }

        public void setCpuSockets(Integer cpuSockets) {
            this.cpuSockets = cpuSockets;
        }

        public Integer getCpuCores() {
            return cpuCores;
        }

        public void setCpuCores(Integer cpuCores) {
            this.cpuCores = cpuCores;
        }

        public Integer getCpuShares() {
            return cpuShares;
        }

        public void setCpuShares(Integer cpuShares) {
            this.cpuShares = cpuShares;
        }

        public Integer getMaxCpuNum() {
            return maxCpuNum;
        }

        public void setMaxCpuNum(Integer maxCpuNum) {
            this.maxCpuNum = maxCpuNum;
        }

        public String getCpuMode() {
            return cpuMode;
        }

        public void setCpuMode(String cpuMode) {
            this.cpuMode = cpuMode;
        }

        public String getCpuArch() {
            return cpuArch;
        }

        public void setCpuArch(String cpuArch) {
            this.cpuArch = cpuArch;
        }

        public Double getCpuQuota() {
            return cpuQuota;
        }

        public void setCpuQuota(Double cpuQuota) {
            this.cpuQuota = cpuQuota;
        }

        public String getCpuQuotaUnit() {
            return cpuQuotaUnit;
        }

        public void setCpuQuotaUnit(String cpuQuotaUnit) {
            this.cpuQuotaUnit = cpuQuotaUnit;
        }

        public Long getCpuMinRate() {
            return cpuMinRate;
        }

        public void setCpuMinRate(Long cpuMinRate) {
            this.cpuMinRate = cpuMinRate;
        }

        public Long getCpuMaxRate() {
            return cpuMaxRate;
        }

        public void setCpuMaxRate(Long cpuMaxRate) {
            this.cpuMaxRate = cpuMaxRate;
        }

        public Long getCpuGurantee() {
            return cpuGurantee;
        }

        public void setCpuGurantee(Long cpuGurantee) {
            this.cpuGurantee = cpuGurantee;
        }
    }

    public static class Memory {
        /**
         * 大小。 长整数（long）类型。
         */
        Long size;
        /**
         * 内存预留百分比 0-10。 整数（int）类型。
         */
        private Integer memoryBacking;
        /**
         * 内存资源优先级。 高=100，中=50，低=0。 整数（int）类型。
         */
        private Integer memoryPriority;
        /**
         * 内存单位。 字符串（String）类型。
         */
        private String memoryUnit;
        /**
         * 最大内存（主机内存）。 长整数（long）类型。
         */
        private Long maxMemory;
        /**
         * 内存限制。 小数（double）类型。
         */
        private Double memoryLimit;
        /**
         * 内存限制单位，枚举值：MB,GB。 字符串（String）类型。
         */
        private String memoryLimitUnit;
        /**
         * 显示内存。 小数（double）类型。
         */
        private Double memoryInit;

        public Long getSize() {
            return size;
        }

        public void setSize(Long size) {
            this.size = size;
        }

        public Integer getMemoryBacking() {
            return memoryBacking;
        }

        public void setMemoryBacking(Integer memoryBacking) {
            this.memoryBacking = memoryBacking;
        }

        public Integer getMemoryPriority() {
            return memoryPriority;
        }

        public void setMemoryPriority(Integer memoryPriority) {
            this.memoryPriority = memoryPriority;
        }

        public String getMemoryUnit() {
            return memoryUnit;
        }

        public void setMemoryUnit(String memoryUnit) {
            this.memoryUnit = memoryUnit;
        }

        public Long getMaxMemory() {
            return maxMemory;
        }

        public void setMaxMemory(Long maxMemory) {
            this.maxMemory = maxMemory;
        }

        public Double getMemoryLimit() {
            return memoryLimit;
        }

        public void setMemoryLimit(Double memoryLimit) {
            this.memoryLimit = memoryLimit;
        }

        public String getMemoryLimitUnit() {
            return memoryLimitUnit;
        }

        public void setMemoryLimitUnit(String memoryLimitUnit) {
            this.memoryLimitUnit = memoryLimitUnit;
        }

        public Double getMemoryInit() {
            return memoryInit;
        }

        public void setMemoryInit(Double memoryInit) {
            this.memoryInit = memoryInit;
        }
    }

    public static class Graphics {
        /**
         * 控制台类型，取值为：vnc、spice。 字符串（String）类型。
         */
        private String type;
        /**
         * 控制台端口。 整数（int）类型。
         */
        private Integer port;
        /**
         * 地址。 字符串（String）类型。
         */
        private String address;
        /**
         * 控制台密码。 字符串（String）类型。
         */
        private String password;
        /**
         * 键盘映射。 字符串（String）类型。
         */
        private String kayboardMap;
        /**
         * 是否启用VNC代理，1-启用，0-不启用。 整数（int）类型。
         */
        private Integer enableVncProxy;
        /**
         * SSL安全端口号。 字符串（String）类型。
         */
        private String tlsPort;
        /**
         * SSL加密通道名称。 取值为：main、display、inputs、cursor、playback、record、smartcard、usbredir。
         * 字符串（String）类型。
         */
        private String spiceTlsChannel;

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public Integer getPort() {
            return port;
        }

        public void setPort(Integer port) {
            this.port = port;
        }

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }

        public String getKayboardMap() {
            return kayboardMap;
        }

        public void setKayboardMap(String kayboardMap) {
            this.kayboardMap = kayboardMap;
        }

        public Integer getEnableVncProxy() {
            return enableVncProxy;
        }

        public void setEnableVncProxy(Integer enableVncProxy) {
            this.enableVncProxy = enableVncProxy;
        }

        public String getTlsPort() {
            return tlsPort;
        }

        public void setTlsPort(String tlsPort) {
            this.tlsPort = tlsPort;
        }

        public String getSpiceTlsChannel() {
            return spiceTlsChannel;
        }

        public void setSpiceTlsChannel(String spiceTlsChannel) {
            this.spiceTlsChannel = spiceTlsChannel;
        }
    }

    private static class BootDev {
        /**
         * 自动启动。 1-自动启动，0-不自动启动。 整数（int）类型。。
         */
        private Integer autoStart;
        /**
         * 虚拟机引导设备及顺序;，形式：dev1,dev2,net1...。 字符串（String）类型。
         */
        private String bootdevs;

        @SuppressWarnings("unused")
        public Integer getAutoStart() {
            return autoStart;
        }

        @SuppressWarnings("unused")
        public void setAutoStart(Integer autoStart) {
            this.autoStart = autoStart;
        }

        @SuppressWarnings("unused")
        public String getBootdevs() {
            return bootdevs;
        }

        @SuppressWarnings("unused")
        public void setBootdevs(String bootdevs) {
            this.bootdevs = bootdevs;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Integer getMemory() {
        return memory;
    }

    public void setMemory(Integer memory) {
        this.memory = memory;
    }

    public Integer getMemoryInit() {
        return memoryInit;
    }

    public void setMemoryInit(Integer memoryInit) {
        this.memoryInit = memoryInit;
    }

    public String getMemoryUnit() {
        return memoryUnit;
    }

    public void setMemoryUnit(String memoryUnit) {
        this.memoryUnit = memoryUnit;
    }

    public Integer getMemoryPriority() {
        return memoryPriority;
    }

    public void setMemoryPriority(Integer memoryPriority) {
        this.memoryPriority = memoryPriority;
    }

    public Integer getMemoryBacking() {
        return memoryBacking;
    }

    public void setMemoryBacking(Integer memoryBacking) {
        this.memoryBacking = memoryBacking;
    }

    public Integer getCpuSockets() {
        return cpuSockets;
    }

    public void setCpuSockets(Integer cpuSockets) {
        this.cpuSockets = cpuSockets;
    }

    public Integer getCpuCores() {
        return cpuCores;
    }

    public void setCpuCores(Integer cpuCores) {
        this.cpuCores = cpuCores;
    }

    public Integer getCpuShares() {
        return cpuShares;
    }

    public void setCpuShares(Integer cpuShares) {
        this.cpuShares = cpuShares;
    }

    public Integer getMaxCpuSocket() {
        return maxCpuSocket;
    }

    public void setMaxCpuSocket(Integer maxCpuSocket) {
        this.maxCpuSocket = maxCpuSocket;
    }

    public Integer getBlkiotune() {
        return blkiotune;
    }

    public void setBlkiotune(Integer blkiotune) {
        this.blkiotune = blkiotune;
    }

    public Integer getSystem() {
        return system;
    }

    public void setSystem(Integer system) {
        this.system = system;
    }

    public String getOsVersion() {
        return osVersion;
    }

    public void setOsVersion(String osVersion) {
        this.osVersion = osVersion;
    }

    public Integer getAutoMigrate() {
        return autoMigrate;
    }

    public void setAutoMigrate(Integer autoMigrate) {
        this.autoMigrate = autoMigrate;
    }

    public Integer getPriority() {
        return priority;
    }

    public void setPriority(Integer priority) {
        this.priority = priority;
    }

    public Long getHostId() {
        return hostId;
    }

    public void setHostId(Long hostId) {
        this.hostId = hostId;
    }

    public Long getHostPoolId() {
        return hostPoolId;
    }

    public void setHostPoolId(Long hostPoolId) {
        this.hostPoolId = hostPoolId;
    }

    public Integer getFormatEnable() {
        return formatEnable;
    }

    public void setFormatEnable(Integer formatEnable) {
        this.formatEnable = formatEnable;
    }

    public H3cBindCpuModel getBindcpu() {
        return bindcpu;
    }

    public void setBindcpu(H3cBindCpuModel bindcpu) {
        this.bindcpu = bindcpu;
    }

    public H3cGpuModel getGpu() {
        return gpu;
    }

    public void setGpu(H3cGpuModel gpu) {
        this.gpu = gpu;
    }

    public List<H3cNetWorkModel> getNetworks() {
        return networks;
    }

    public void setNetworks(List<H3cNetWorkModel> networks) {
        this.networks = networks;
    }

    public List<H3cStorageModel> getStorages() {
        return storages;
    }

    public void setStorages(List<H3cStorageModel> storages) {
        this.storages = storages;
    }

    public List<H3cUsbModel> getUsb() {
        return usb;
    }

    public void setUsb(List<H3cUsbModel> usb) {
        this.usb = usb;
    }

    public List<H3cPciModel> getPci() {
        return pci;
    }

    public void setPci(List<H3cPciModel> pci) {
        this.pci = pci;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getClusterId() {
        return clusterId;
    }

    public void setClusterId(Long clusterId) {
        this.clusterId = clusterId;
    }

    public String getHostName() {
        return hostName;
    }

    public void setHostName(String hostName) {
        this.hostName = hostName;
    }

    public Double getCpuRate() {
        return cpuRate;
    }

    public void setCpuRate(Double cpuRate) {
        this.cpuRate = cpuRate;
    }

    public Integer getCpu() {
        return cpu;
    }

    public void setCpu(Integer cpu) {
        this.cpu = cpu;
    }

    public Integer getMemRate() {
        return memRate;
    }

    public void setMemRate(Integer memRate) {
        this.memRate = memRate;
    }

    public String getVmStatus() {
        return vmStatus;
    }

    public void setVmStatus(String vmStatus) {
        this.vmStatus = vmStatus;
    }

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        this.uuid = uuid;
    }

    public String getOsDesc() {
        return osDesc;
    }

    public void setOsDesc(String osDesc) {
        this.osDesc = osDesc;
    }

    public Integer getFlag() {
        return flag;
    }

    public void setFlag(Integer flag) {
        this.flag = flag;
    }

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public Boolean getDeployed() {
        return deployed;
    }

    public void setDeployed(Boolean deployed) {
        this.deployed = deployed;
    }

    public Boolean getExistRaw() {
        return existRaw;
    }

    public void setExistRaw(Boolean existRaw) {
        this.existRaw = existRaw;
    }

    public Integer getHaStatus() {
        return haStatus;
    }

    public void setHaStatus(Integer haStatus) {
        this.haStatus = haStatus;
    }

    public Integer getHaManage() {
        return haManage;
    }

    public void setHaManage(Integer haManage) {
        this.haManage = haManage;
    }

    public Basic getBasic() {
        return basic;
    }

    public void setBasic(Basic basic) {
        this.basic = basic;
    }

    public BootDev getBootDev() {
        return bootDev;
    }

    public void setBootDev(BootDev bootDev) {
        this.bootDev = bootDev;
    }

    public List<Graphics> getGraphics() {
        return graphics;
    }

    public void setGraphics(List<Graphics> graphics) {
        this.graphics = graphics;
    }

    public Cpu getCpuObj() {
        return cpuObj;
    }

    public void setCpuObj(Cpu cpuObj) {
        this.cpuObj = cpuObj;
    }

    public Memory getMemoryObj() {
        return memoryObj;
    }

    public void setMemoryObj(Memory memoryObj) {
        this.memoryObj = memoryObj;
    }
}