diff --git a/compute/src/main/java/org/zstack/compute/host/HostBase.java b/compute/src/main/java/org/zstack/compute/host/HostBase.java index 38eb654804f..152fd7b6756 100755 --- a/compute/src/main/java/org/zstack/compute/host/HostBase.java +++ b/compute/src/main/java/org/zstack/compute/host/HostBase.java @@ -188,6 +188,8 @@ protected void handleApiMessage(APIMessage msg) { handle((APIPowerResetHostMsg) msg); } else if (msg instanceof APIGetHostPowerStatusMsg) { handle((APIGetHostPowerStatusMsg) msg); + } else if (msg instanceof APIGetBlockDevicesMsg) { + handle((APIGetBlockDevicesMsg) msg); } else { bus.dealWithUnknownMessage(msg); } @@ -214,6 +216,26 @@ public void run(MessageReply reply) { }); } + private void handle(APIGetBlockDevicesMsg msg) { + APIGetBlockDevicesEvent event = new APIGetBlockDevicesEvent(msg.getId()); + GetBlockDevicesOnHostMsg gmsg = new GetBlockDevicesOnHostMsg(); + gmsg.setHostUuid(msg.getHostUuid()); + bus.makeTargetServiceIdByResourceUuid(gmsg, HostConstant.SERVICE_ID, msg.getHostUuid()); + bus.send(gmsg, new CloudBusCallBack(msg) { + @Override + public void run(MessageReply reply) { + if (!reply.isSuccess()) { + event.setSuccess(false); + event.setError(reply.getError()); + } else { + GetBlockDevicesOnHostReply r = reply.castReply(); + event.setBlockDevices(r.getBlockDevices()); + } + bus.publish(event); + } + }); + } + private void handle(APIPowerResetHostMsg msg) { final APIPowerResetHostEvent event = new APIPowerResetHostEvent(msg.getId()); RebootHostMsg rebootHostMsg = new RebootHostMsg(); diff --git a/compute/src/main/java/org/zstack/compute/vm/InstantiateVmFromNewCreatedStruct.java b/compute/src/main/java/org/zstack/compute/vm/InstantiateVmFromNewCreatedStruct.java index 4a0d2ba9627..0d97b12720c 100644 --- a/compute/src/main/java/org/zstack/compute/vm/InstantiateVmFromNewCreatedStruct.java +++ b/compute/src/main/java/org/zstack/compute/vm/InstantiateVmFromNewCreatedStruct.java @@ -29,6 +29,11 @@ public class InstantiateVmFromNewCreatedStruct { private Map> dataVolumeSystemTagsOnIndex; private List disableL3Networks; private List sshKeyPairUuids; + private Boolean enableRootVolumeCache; + private String cacheMode; + private String rootVolumeCachePoolUuid; + private String rootVolumeCacheMode; + private Map dataDiskCacheConfigOnIndex; private final List candidatePrimaryStorageUuidsForRootVolume = new ArrayList<>(); private final List candidatePrimaryStorageUuidsForDataVolume = new ArrayList<>(); @@ -142,6 +147,11 @@ public static InstantiateVmFromNewCreatedStruct fromMessage(InstantiateNewCreate struct.setDataVolumeSystemTagsOnIndex(msg.getDataVolumeSystemTagsOnIndex()); struct.setDisableL3Networks(msg.getDisableL3Networks()); struct.setDiskAOs(msg.getDiskAOs()); + struct.setEnableRootVolumeCache(msg.getEnableRootVolumeCache()); + struct.setCacheMode(msg.getCacheMode()); + struct.setRootVolumeCachePoolUuid(msg.getRootVolumeCachePoolUuid()); + struct.setRootVolumeCacheMode(msg.getRootVolumeCacheMode()); + struct.setDataDiskCacheConfigOnIndex(msg.getDataDiskCacheConfigOnIndex()); return struct; } @@ -161,6 +171,11 @@ public static InstantiateVmFromNewCreatedStruct fromMessage(CreateVmInstanceMsg struct.setDataVolumeSystemTagsOnIndex(msg.getDataVolumeSystemTagsOnIndex()); struct.setDisableL3Networks(msg.getDisableL3Networks()); struct.setDiskAOs(msg.getDiskAOs()); + struct.setEnableRootVolumeCache(msg.getEnableRootVolumeCache()); + struct.setCacheMode(msg.getCacheMode()); + struct.setRootVolumeCachePoolUuid(msg.getRootVolumeCachePoolUuid()); + struct.setRootVolumeCacheMode(msg.getRootVolumeCacheMode()); + struct.setDataDiskCacheConfigOnIndex(msg.getDataDiskCacheConfigOnIndex()); return struct; } @@ -243,4 +258,44 @@ public List getSshKeyPairUuids() { public void setSshKeyPairUuids(List sshKeyPairUuids) { this.sshKeyPairUuids = sshKeyPairUuids; } + + public Boolean getEnableRootVolumeCache() { + return enableRootVolumeCache; + } + + public void setEnableRootVolumeCache(Boolean enableRootVolumeCache) { + this.enableRootVolumeCache = enableRootVolumeCache; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } + + public String getRootVolumeCachePoolUuid() { + return rootVolumeCachePoolUuid; + } + + public void setRootVolumeCachePoolUuid(String rootVolumeCachePoolUuid) { + this.rootVolumeCachePoolUuid = rootVolumeCachePoolUuid; + } + + public String getRootVolumeCacheMode() { + return rootVolumeCacheMode; + } + + public void setRootVolumeCacheMode(String rootVolumeCacheMode) { + this.rootVolumeCacheMode = rootVolumeCacheMode; + } + + public Map getDataDiskCacheConfigOnIndex() { + return dataDiskCacheConfigOnIndex; + } + + public void setDataDiskCacheConfigOnIndex(Map dataDiskCacheConfigOnIndex) { + this.dataDiskCacheConfigOnIndex = dataDiskCacheConfigOnIndex; + } } diff --git a/compute/src/main/java/org/zstack/compute/vm/VmAllocateHostFlow.java b/compute/src/main/java/org/zstack/compute/vm/VmAllocateHostFlow.java index ee542fe36ee..a3320157eff 100755 --- a/compute/src/main/java/org/zstack/compute/vm/VmAllocateHostFlow.java +++ b/compute/src/main/java/org/zstack/compute/vm/VmAllocateHostFlow.java @@ -136,9 +136,43 @@ public String call(L3NetworkInventory arg) { msg.getRequiredPrimaryStorageUuids().addAll(spec.getDiskAOs().stream() .map(APICreateVmInstanceMsg.DiskAO::getPrimaryStorageUuid).filter(Objects::nonNull).collect(Collectors.toList())); } + + // Add cache pool requirements as system tags for host allocation filtering + addCacheSystemTags(spec, msg); + return msg; } + private void addCacheSystemTags(VmInstanceSpec spec, AllocateHostMsg msg) { + boolean enableRoot = Boolean.TRUE.equals(spec.getEnableRootVolumeCache()); + boolean enableData = spec.getDataDiskCacheConfigOnIndex() != null + && !spec.getDataDiskCacheConfigOnIndex().isEmpty(); + if (!enableRoot && !enableData) { + return; + } + + long totalCacheSize = 0; + if (enableRoot) { + // Root volume size: from image size or root disk offering + ImageInventory image = spec.getImageSpec().getInventory(); + if (image != null && image.getSize() != 0) { + totalCacheSize += image.getSize(); + } else if (spec.getRootDiskOffering() != null) { + totalCacheSize += spec.getRootDiskOffering().getDiskSize(); + } + } + if (enableData) { + totalCacheSize += getTotalDataDiskSize(spec); + } + + if (totalCacheSize > 0) { + msg.addSystemTag("volumeCache::requiredSize::" + totalCacheSize); + } + if (spec.getRootVolumeCachePoolUuid() != null) { + msg.addSystemTag("volumeCache::poolUuid::" + spec.getRootVolumeCachePoolUuid()); + } + } + @Override public void run(final FlowTrigger chain, Map data) { taskProgress("allocate candidate hosts"); diff --git a/compute/src/main/java/org/zstack/compute/vm/VmInstanceBase.java b/compute/src/main/java/org/zstack/compute/vm/VmInstanceBase.java index 80ba38486fc..d35254dd756 100755 --- a/compute/src/main/java/org/zstack/compute/vm/VmInstanceBase.java +++ b/compute/src/main/java/org/zstack/compute/vm/VmInstanceBase.java @@ -7355,6 +7355,11 @@ public DiskOfferingVO call(DiskOfferingVO arg) { } spec.setDiskAOs(struct.getDiskAOs()); + spec.setEnableRootVolumeCache(struct.getEnableRootVolumeCache()); + spec.setCacheMode(struct.getCacheMode()); + spec.setRootVolumeCachePoolUuid(struct.getRootVolumeCachePoolUuid()); + spec.setRootVolumeCacheMode(struct.getRootVolumeCacheMode()); + spec.setDataDiskCacheConfigOnIndex(struct.getDataDiskCacheConfigOnIndex()); List cdRomSpecs = buildVmCdRomSpecsForNewCreated(spec); spec.setCdRomSpecs(cdRomSpecs); diff --git a/compute/src/main/java/org/zstack/compute/vm/VmInstanceManagerImpl.java b/compute/src/main/java/org/zstack/compute/vm/VmInstanceManagerImpl.java index 321c7b3325d..07bd4e5bac6 100755 --- a/compute/src/main/java/org/zstack/compute/vm/VmInstanceManagerImpl.java +++ b/compute/src/main/java/org/zstack/compute/vm/VmInstanceManagerImpl.java @@ -1323,6 +1323,11 @@ public void run(FlowTrigger trigger, Map data) { smsg.setDataVolumeSystemTags(msg.getDataVolumeSystemTags()); smsg.setDataVolumeSystemTagsOnIndex(msg.getDataVolumeSystemTagsOnIndex()); smsg.setDiskAOs(msg.getDiskAOs()); + smsg.setEnableRootVolumeCache(msg.getEnableRootVolumeCache()); + smsg.setCacheMode(msg.getCacheMode()); + smsg.setRootVolumeCachePoolUuid(msg.getRootVolumeCachePoolUuid()); + smsg.setRootVolumeCacheMode(msg.getRootVolumeCacheMode()); + smsg.setDataDiskCacheConfigOnIndex(msg.getDataDiskCacheConfigOnIndex()); bus.makeTargetServiceIdByResourceUuid(smsg, VmInstanceConstant.SERVICE_ID, finalVo.getUuid()); bus.send(smsg, new CloudBusCallBack(smsg) { @Override diff --git a/compute/src/main/java/org/zstack/compute/vm/VmInstanceUtils.java b/compute/src/main/java/org/zstack/compute/vm/VmInstanceUtils.java index f0bdeded2af..9f4f97d06a9 100644 --- a/compute/src/main/java/org/zstack/compute/vm/VmInstanceUtils.java +++ b/compute/src/main/java/org/zstack/compute/vm/VmInstanceUtils.java @@ -65,6 +65,11 @@ public static CreateVmInstanceMsg fromAPICreateVmInstanceMsg(APICreateVmInstance cmsg.setStrategy(msg.getStrategy()); cmsg.setDiskAOs(msg.getDiskAOs()); + cmsg.setEnableRootVolumeCache(msg.getEnableRootVolumeCache()); + cmsg.setCacheMode(msg.getCacheMode()); + cmsg.setRootVolumeCachePoolUuid(msg.getRootVolumeCachePoolUuid()); + cmsg.setRootVolumeCacheMode(msg.getRootVolumeCacheMode()); + cmsg.setDataDiskCacheConfigOnIndex(msg.getDataDiskCacheConfigOnIndex()); if (CollectionUtils.isNotEmpty(msg.getDataDiskOfferingUuids()) || CollectionUtils.isNotEmpty(msg.getDataDiskSizes())) { cmsg.setPrimaryStorageUuidForDataVolume(getPSUuidForDataVolume(msg.getSystemTags())); diff --git a/compute/src/main/java/org/zstack/compute/vm/VmInstantiateOtherDiskFlow.java b/compute/src/main/java/org/zstack/compute/vm/VmInstantiateOtherDiskFlow.java index 19a715c9a87..30b973dce20 100644 --- a/compute/src/main/java/org/zstack/compute/vm/VmInstantiateOtherDiskFlow.java +++ b/compute/src/main/java/org/zstack/compute/vm/VmInstantiateOtherDiskFlow.java @@ -24,6 +24,9 @@ import org.zstack.header.storage.primary.*; import org.zstack.header.vm.*; import org.zstack.header.volume.*; +import org.zstack.header.localVolumeCache.EnableVolumeCacheMsg; +import org.zstack.header.localVolumeCache.EnableVolumeCacheReply; +import org.zstack.header.localVolumeCache.VmLocalVolumeCacheConstant; import org.zstack.identity.AccountManager; import org.zstack.utils.CollectionUtils; import org.zstack.utils.Utils; @@ -398,6 +401,37 @@ public void run(MessageReply reply) { }); } }); + + // Enable volume cache if requested for this DiskAO + if (Boolean.TRUE.equals(diskAO.getEnableCache())) { + flow(new NoRollbackFlow() { + String __name__ = String.format("enable-cache-for-diskAO-volume-on-vm-%s", vmUuid); + + @Override + public void run(final FlowTrigger innerTrigger, Map data) { + if (volumeInventory == null) { + innerTrigger.next(); + return; + } + EnableVolumeCacheMsg emsg = new EnableVolumeCacheMsg(); + emsg.setVolumeUuid(volumeInventory.getUuid()); + emsg.setPoolUuid(diskAO.getCachePoolUuid()); + emsg.setCacheMode(diskAO.getCacheMode()); + bus.makeLocalServiceId(emsg, VmLocalVolumeCacheConstant.CACHE_SERVICE_ID); + bus.send(emsg, new CloudBusCallBack(innerTrigger) { + @Override + public void run(MessageReply reply) { + if (!reply.isSuccess()) { + logger.warn(String.format("failed to enable cache for DiskAO volume[uuid:%s]: %s", + volumeInventory.getUuid(), reply.getError())); + } + // Don't fail the whole flow if cache enablement fails + innerTrigger.next(); + } + }); + } + }); + } } private void setupAttachOtherDiskFlows() { diff --git a/conf/db/upgrade/V5.5.12__schema.sql b/conf/db/upgrade/V5.5.12__schema.sql new file mode 100644 index 00000000000..f04bcbbfa7a --- /dev/null +++ b/conf/db/upgrade/V5.5.12__schema.sql @@ -0,0 +1,35 @@ +CREATE TABLE IF NOT EXISTS `VmLocalVolumeCachePoolVO` ( + `uuid` VARCHAR(32) NOT NULL, + `hostUuid` VARCHAR(32) NOT NULL, + `name` VARCHAR(255) DEFAULT NULL, + `description` VARCHAR(2048) DEFAULT NULL, + `metadata` VARCHAR(2048) DEFAULT NULL, + `totalCapacity` BIGINT NOT NULL DEFAULT 0, + `availableCapacity` BIGINT NOT NULL DEFAULT 0, + `state` VARCHAR(32) NOT NULL, + `status` VARCHAR(32) NOT NULL, + `createDate` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + `lastOpDate` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + PRIMARY KEY (`uuid`), + CONSTRAINT `fkVmLocalVolumeCachePoolVOHostEO` + FOREIGN KEY (`hostUuid`) REFERENCES `HostEO` (`uuid`) + ON DELETE CASCADE + ) ENGINE = InnoDB DEFAULT CHARSET = utf8; + +CREATE TABLE IF NOT EXISTS `VmLocalVolumeCacheVO` ( + `uuid` VARCHAR(32) NOT NULL, + `volumeUuid` VARCHAR(32) NOT NULL, + `poolUuid` VARCHAR(32) DEFAULT NULL, + `cacheMode` VARCHAR(32) NOT NULL, + `state` VARCHAR(32) NOT NULL, + `createDate` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + `lastOpDate` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, + PRIMARY KEY (`uuid`), + UNIQUE KEY `uniVmLocalVolumeCacheVOVolumeUuid` (`volumeUuid`), + CONSTRAINT `fkVmLocalVolumeCacheVOVolumeEO` + FOREIGN KEY (`volumeUuid`) REFERENCES `VolumeEO` (`uuid`) + ON DELETE CASCADE, + CONSTRAINT `fkVmLocalVolumeCacheVOPoolUuid` + FOREIGN KEY (`poolUuid`) REFERENCES `VmLocalVolumeCachePoolVO` (`uuid`) + ON DELETE SET NULL + ) ENGINE = InnoDB DEFAULT CHARSET = utf8; diff --git a/conf/globalConfig/kvm.xml b/conf/globalConfig/kvm.xml index 76d53a5453a..2cbaaecf873 100755 --- a/conf/globalConfig/kvm.xml +++ b/conf/globalConfig/kvm.xml @@ -273,4 +273,28 @@ 10737418240 java.lang.Long + + + kvm + localVolumeCache.pool.capacitySync.interval + Interval in seconds between periodic capacity sync tasks for local volume cache pools. + 300 + java.lang.Long + + + + kvm + localVolumeCache.pool.healthCheck.interval + Interval in seconds between periodic health check tasks for local volume cache pools. + 60 + java.lang.Long + + + + kvm + localVolumeCache.pool.gc.interval + Interval in seconds between periodic garbage collection tasks for local volume cache pools. + 3600 + java.lang.Long + diff --git a/conf/persistence.xml b/conf/persistence.xml index 30c36210dd6..bd878788b96 100755 --- a/conf/persistence.xml +++ b/conf/persistence.xml @@ -217,6 +217,8 @@ org.zstack.network.hostNetworkInterface.lldp.entity.HostNetworkInterfaceLldpRefVO org.zstack.header.volume.block.BlockVolumeVO org.zstack.header.host.HostHwMonitorStatusVO + org.zstack.header.localVolumeCache.VmLocalVolumeCachePoolVO + org.zstack.header.localVolumeCache.VmLocalVolumeCacheVO org.zstack.kvm.xmlhook.XmlHookVO org.zstack.kvm.xmlhook.XmlHookVmInstanceRefVO org.zstack.log.server.LogServerVO diff --git a/conf/serviceConfig/vmLocalVolumeCache.xml b/conf/serviceConfig/vmLocalVolumeCache.xml new file mode 100644 index 00000000000..b1ead4b02d2 --- /dev/null +++ b/conf/serviceConfig/vmLocalVolumeCache.xml @@ -0,0 +1,12 @@ + + + vmLocalVolumeCache + + + org.zstack.header.localVolumeCache.APIEnableVolumeCacheMsg + + + + org.zstack.header.localVolumeCache.APIDisableVolumeCacheMsg + + diff --git a/conf/serviceConfig/vmLocalVolumeCachePool.xml b/conf/serviceConfig/vmLocalVolumeCachePool.xml new file mode 100644 index 00000000000..4ea9301967d --- /dev/null +++ b/conf/serviceConfig/vmLocalVolumeCachePool.xml @@ -0,0 +1,37 @@ + + + vmLocalVolumeCachePool + + + org.zstack.header.localVolumeCache.APICreateVmLocalVolumeCachePoolMsg + + + + org.zstack.header.localVolumeCache.APIDeleteVmLocalVolumeCachePoolMsg + + + + org.zstack.header.localVolumeCache.APIUpdateVmLocalVolumeCachePoolMsg + + + + org.zstack.header.localVolumeCache.APIChangeVmLocalVolumeCachePoolStateMsg + + + + org.zstack.header.localVolumeCache.APIReconnectVmLocalVolumeCachePoolMsg + + + + org.zstack.header.localVolumeCache.APIExtendVmLocalVolumeCachePoolMsg + + + + org.zstack.header.localVolumeCache.APISyncVmLocalVolumeCachePoolCapacityMsg + + + + org.zstack.header.localVolumeCache.APIQueryVmLocalVolumeCachePoolMsg + query + + diff --git a/conf/springConfigXml/VmInstanceManager.xml b/conf/springConfigXml/VmInstanceManager.xml index ef3d5a7cc9e..63385199b77 100755 --- a/conf/springConfigXml/VmInstanceManager.xml +++ b/conf/springConfigXml/VmInstanceManager.xml @@ -39,6 +39,7 @@ org.zstack.compute.vm.VmAllocateNicIpFlow org.zstack.compute.vm.VmAllocateCdRomFlow org.zstack.compute.vm.VmInstantiateResourcePreFlow + org.zstack.compute.vm.VmInstantiateCacheFlow org.zstack.compute.vm.VmCreateOnHypervisorFlow org.zstack.compute.vm.VmInstantiateResourcePostFlow @@ -58,8 +59,7 @@ org.zstack.compute.vm.VmReleaseResourceFlow org.zstack.compute.vm.VmImageSelectBackupStorageFlow org.zstack.compute.vm.VmAllocateNicForStartingVmFlow - org.zstack.compute.vm.VmInstantiateResourcePreFlow - org.zstack.compute.vm.VmStartOnHypervisorFlow + org.zstack.compute.vm.VmInstantiateResourcePreFlow org.zstack.compute.vm.VmInstantiateCacheFlow org.zstack.compute.vm.VmStartOnHypervisorFlow org.zstack.compute.vm.VmInstantiateResourcePostFlow @@ -69,6 +69,7 @@ org.zstack.compute.vm.VmImageSelectBackupStorageFlow org.zstack.compute.vm.VmAllocateNicForStartingVmFlow org.zstack.compute.vm.VmInstantiateResourcePreFlow + org.zstack.compute.vm.VmInstantiateCacheFlow org.zstack.compute.vm.VmStartOnHypervisorFlow org.zstack.compute.vm.VmInstantiateResourcePostFlow @@ -98,6 +99,7 @@ org.zstack.compute.vm.VmInstantiateAttachingVolumeFlow org.zstack.compute.vm.VmAfterInstantiateVolumeInAttachingVolumeFlow org.zstack.compute.vm.VmAssignDeviceIdToAttachingVolumeFlow + org.zstack.compute.vm.VmInstantiateCacheFlow org.zstack.compute.vm.VmAttachVolumeOnHypervisorFlow diff --git a/conf/springConfigXml/localVolumeCache.xml b/conf/springConfigXml/localVolumeCache.xml new file mode 100644 index 00000000000..ce6fb6eb831 --- /dev/null +++ b/conf/springConfigXml/localVolumeCache.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/conf/zstack.xml b/conf/zstack.xml index c0a5da2a80f..b723b6eadcc 100755 --- a/conf/zstack.xml +++ b/conf/zstack.xml @@ -122,4 +122,5 @@ + diff --git a/header/src/main/java/org/zstack/header/host/APIGetBlockDevicesEvent.java b/header/src/main/java/org/zstack/header/host/APIGetBlockDevicesEvent.java new file mode 100644 index 00000000000..dcb396d6796 --- /dev/null +++ b/header/src/main/java/org/zstack/header/host/APIGetBlockDevicesEvent.java @@ -0,0 +1,45 @@ +package org.zstack.header.host; + +import org.zstack.header.message.APIEvent; +import org.zstack.header.rest.RestResponse; + +import java.util.Collections; +import java.util.List; + +@RestResponse(fieldsTo = "all") +public class APIGetBlockDevicesEvent extends APIEvent { + private List blockDevices; + + public APIGetBlockDevicesEvent() { + } + + public APIGetBlockDevicesEvent(String apiId) { + super(apiId); + } + + public List getBlockDevices() { + return blockDevices; + } + + public void setBlockDevices(List blockDevices) { + this.blockDevices = blockDevices; + } + + public static APIGetBlockDevicesEvent __example__() { + APIGetBlockDevicesEvent event = new APIGetBlockDevicesEvent(); + HostBlockDeviceStruct struct = new HostBlockDeviceStruct(); + struct.setWwid("3600508b400105e5a0000800001490000"); + struct.setVendor("VMware"); + struct.setModel("Virtual disk"); + struct.setWwn("0x6000c2990b2c19db"); + struct.setSerial("6000c2990b2c19db"); + struct.setHctl("0:0:0:0"); + struct.setType("disk"); + struct.setSize(107374182400L); + struct.setPath("/dev/sda"); + struct.setSource("block"); + struct.setTransport("fc"); + event.setBlockDevices(Collections.singletonList(struct)); + return event; + } +} diff --git a/header/src/main/java/org/zstack/header/host/APIGetBlockDevicesMsg.java b/header/src/main/java/org/zstack/header/host/APIGetBlockDevicesMsg.java new file mode 100644 index 00000000000..8b5cc35e8b7 --- /dev/null +++ b/header/src/main/java/org/zstack/header/host/APIGetBlockDevicesMsg.java @@ -0,0 +1,35 @@ +package org.zstack.header.host; + +import org.springframework.http.HttpMethod; +import org.zstack.header.message.APIMessage; +import org.zstack.header.message.APIParam; +import org.zstack.header.rest.RestRequest; + +@RestRequest( + path = "/hosts/{uuid}/block-devices", + method = HttpMethod.GET, + responseClass = APIGetBlockDevicesEvent.class +) +public class APIGetBlockDevicesMsg extends APIMessage implements HostMessage { + @APIParam(nonempty = true, resourceType = HostVO.class) + private String uuid; + + public String getUuid() { + return uuid; + } + + public void setUuid(String uuid) { + this.uuid = uuid; + } + + @Override + public String getHostUuid() { + return uuid; + } + + public static APIGetBlockDevicesMsg __example__() { + APIGetBlockDevicesMsg msg = new APIGetBlockDevicesMsg(); + msg.setUuid(uuid()); + return msg; + } +} diff --git a/header/src/main/java/org/zstack/header/host/GetBlockDevicesOnHostMsg.java b/header/src/main/java/org/zstack/header/host/GetBlockDevicesOnHostMsg.java new file mode 100644 index 00000000000..13e8764068b --- /dev/null +++ b/header/src/main/java/org/zstack/header/host/GetBlockDevicesOnHostMsg.java @@ -0,0 +1,16 @@ +package org.zstack.header.host; + +import org.zstack.header.message.NeedReplyMessage; + +public class GetBlockDevicesOnHostMsg extends NeedReplyMessage implements HostMessage { + private String hostUuid; + + public void setHostUuid(String hostUuid) { + this.hostUuid = hostUuid; + } + + @Override + public String getHostUuid() { + return hostUuid; + } +} diff --git a/header/src/main/java/org/zstack/header/host/GetBlockDevicesOnHostReply.java b/header/src/main/java/org/zstack/header/host/GetBlockDevicesOnHostReply.java new file mode 100644 index 00000000000..1407c081abf --- /dev/null +++ b/header/src/main/java/org/zstack/header/host/GetBlockDevicesOnHostReply.java @@ -0,0 +1,17 @@ +package org.zstack.header.host; + +import org.zstack.header.message.MessageReply; + +import java.util.List; + +public class GetBlockDevicesOnHostReply extends MessageReply { + private List blockDevices; + + public List getBlockDevices() { + return blockDevices; + } + + public void setBlockDevices(List blockDevices) { + this.blockDevices = blockDevices; + } +} diff --git a/header/src/main/java/org/zstack/header/host/HostBlockDeviceStruct.java b/header/src/main/java/org/zstack/header/host/HostBlockDeviceStruct.java new file mode 100644 index 00000000000..4e9c4e7e60a --- /dev/null +++ b/header/src/main/java/org/zstack/header/host/HostBlockDeviceStruct.java @@ -0,0 +1,131 @@ +package org.zstack.header.host; + +import java.io.Serializable; + +public class HostBlockDeviceStruct implements Serializable { + private String wwid; + private String vendor; + private String model; + private String wwn; + private String serial; + private String hctl; + private String type; + private String path; + private Long size; + private String source; + private String transport; + private String targetIdentifier; + + public HostBlockDeviceStruct() { + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + HostBlockDeviceStruct that = (HostBlockDeviceStruct) o; + return wwid != null ? wwid.equals(that.wwid) : that.wwid == null; + } + + @Override + public int hashCode() { + return wwid != null ? wwid.hashCode() : 0; + } + + public String getWwid() { + return wwid; + } + + public void setWwid(String wwid) { + this.wwid = wwid; + } + + public String getVendor() { + return vendor; + } + + public void setVendor(String vendor) { + this.vendor = vendor; + } + + public String getModel() { + return model; + } + + public void setModel(String model) { + this.model = model; + } + + public String getWwn() { + return wwn; + } + + public void setWwn(String wwn) { + this.wwn = wwn; + } + + public String getSerial() { + return serial; + } + + public void setSerial(String serial) { + this.serial = serial; + } + + public String getHctl() { + return hctl; + } + + public void setHctl(String hctl) { + this.hctl = hctl; + } + + public String getType() { + return type; + } + + public void setType(String type) { + this.type = type; + } + + public String getPath() { + return path; + } + + public void setPath(String path) { + this.path = path; + } + + public Long getSize() { + return size; + } + + public void setSize(Long size) { + this.size = size; + } + + public String getSource() { + return source; + } + + public void setSource(String source) { + this.source = source; + } + + public String getTransport() { + return transport; + } + + public void setTransport(String transport) { + this.transport = transport; + } + + public String getTargetIdentifier() { + return targetIdentifier; + } + + public void setTargetIdentifier(String targetIdentifier) { + this.targetIdentifier = targetIdentifier; + } +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/EnableVolumeCacheMsg.java b/header/src/main/java/org/zstack/header/localVolumeCache/EnableVolumeCacheMsg.java new file mode 100644 index 00000000000..687689a16d1 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/EnableVolumeCacheMsg.java @@ -0,0 +1,33 @@ +package org.zstack.header.localVolumeCache; + +import org.zstack.header.message.NeedReplyMessage; + +public class EnableVolumeCacheMsg extends NeedReplyMessage { + private String volumeUuid; + private String poolUuid; + private String cacheMode; + + public String getVolumeUuid() { + return volumeUuid; + } + + public void setVolumeUuid(String volumeUuid) { + this.volumeUuid = volumeUuid; + } + + public String getPoolUuid() { + return poolUuid; + } + + public void setPoolUuid(String poolUuid) { + this.poolUuid = poolUuid; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/EnableVolumeCacheReply.java b/header/src/main/java/org/zstack/header/localVolumeCache/EnableVolumeCacheReply.java new file mode 100644 index 00000000000..cffc628f147 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/EnableVolumeCacheReply.java @@ -0,0 +1,15 @@ +package org.zstack.header.localVolumeCache; + +import org.zstack.header.message.MessageReply; + +public class EnableVolumeCacheReply extends MessageReply { + private VmLocalVolumeCacheInventory inventory; + + public VmLocalVolumeCacheInventory getInventory() { + return inventory; + } + + public void setInventory(VmLocalVolumeCacheInventory inventory) { + this.inventory = inventory; + } +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheConstant.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheConstant.java new file mode 100644 index 00000000000..d75cc7e46cb --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheConstant.java @@ -0,0 +1,5 @@ +package org.zstack.header.localVolumeCache; + +public interface VmLocalVolumeCacheConstant { + String CACHE_SERVICE_ID = "vmLocalVolumeCache"; +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheInventory.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheInventory.java new file mode 100644 index 00000000000..e0d5a306ba7 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheInventory.java @@ -0,0 +1,108 @@ +package org.zstack.header.localVolumeCache; + +import org.zstack.header.configuration.PythonClassInventory; +import org.zstack.header.search.Inventory; + +import java.io.Serializable; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +@Inventory(mappingVOClass = VmLocalVolumeCacheVO.class) +@PythonClassInventory +public class VmLocalVolumeCacheInventory implements Serializable { + private String uuid; + private String volumeUuid; + private String poolUuid; + private String installPath; + private VmLocalVolumeCacheMode cacheMode; + private VmLocalVolumeCacheState state; + private Timestamp createDate; + private Timestamp lastOpDate; + + public static VmLocalVolumeCacheInventory valueOf(VmLocalVolumeCacheVO vo) { + VmLocalVolumeCacheInventory inv = new VmLocalVolumeCacheInventory(); + inv.setUuid(vo.getUuid()); + inv.setVolumeUuid(vo.getVolumeUuid()); + inv.setPoolUuid(vo.getPoolUuid()); + inv.setInstallPath(vo.getInstallPath()); + inv.setCacheMode(vo.getCacheMode()); + inv.setState(vo.getState()); + inv.setCreateDate(vo.getCreateDate()); + inv.setLastOpDate(vo.getLastOpDate()); + return inv; + } + + public static List valueOf(Collection vos) { + List invs = new ArrayList<>(); + for (VmLocalVolumeCacheVO vo : vos) { + invs.add(valueOf(vo)); + } + return invs; + } + + public String getUuid() { + return uuid; + } + + public void setUuid(String uuid) { + this.uuid = uuid; + } + + public String getVolumeUuid() { + return volumeUuid; + } + + public void setVolumeUuid(String volumeUuid) { + this.volumeUuid = volumeUuid; + } + + public String getPoolUuid() { + return poolUuid; + } + + public void setPoolUuid(String poolUuid) { + this.poolUuid = poolUuid; + } + + public String getInstallPath() { + return installPath; + } + + public void setInstallPath(String installPath) { + this.installPath = installPath; + } + + public VmLocalVolumeCacheMode getCacheMode() { + return cacheMode; + } + + public void setCacheMode(VmLocalVolumeCacheMode cacheMode) { + this.cacheMode = cacheMode; + } + + public VmLocalVolumeCacheState getState() { + return state; + } + + public void setState(VmLocalVolumeCacheState state) { + this.state = state; + } + + public Timestamp getCreateDate() { + return createDate; + } + + public void setCreateDate(Timestamp createDate) { + this.createDate = createDate; + } + + public Timestamp getLastOpDate() { + return lastOpDate; + } + + public void setLastOpDate(Timestamp lastOpDate) { + this.lastOpDate = lastOpDate; + } +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheMode.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheMode.java new file mode 100644 index 00000000000..736262d3433 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheMode.java @@ -0,0 +1,5 @@ +package org.zstack.header.localVolumeCache; + +public enum VmLocalVolumeCacheMode { + WriteBack, +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolInventory.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolInventory.java new file mode 100644 index 00000000000..67bc1beef8f --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolInventory.java @@ -0,0 +1,143 @@ +package org.zstack.header.localVolumeCache; + +import org.zstack.header.configuration.PythonClassInventory; +import org.zstack.header.search.Inventory; +import org.zstack.utils.gson.JSONObjectUtil; + +import java.io.Serializable; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.List; + +@Inventory(mappingVOClass = VmLocalVolumeCachePoolVO.class) +@PythonClassInventory +public class VmLocalVolumeCachePoolInventory implements Serializable { + private String uuid; + private String hostUuid; + private String name; + private String description; + private LinkedHashMap metadata; + private long totalCapacity; + private long availableCapacity; + private VmLocalVolumeCachePoolState state; + private VmLocalVolumeCachePoolStatus status; + private Timestamp createDate; + private Timestamp lastOpDate; + + public static VmLocalVolumeCachePoolInventory valueOf(VmLocalVolumeCachePoolVO vo) { + VmLocalVolumeCachePoolInventory inv = new VmLocalVolumeCachePoolInventory(); + inv.setUuid(vo.getUuid()); + inv.setHostUuid(vo.getHostUuid()); + inv.setName(vo.getName()); + inv.setDescription(vo.getDescription()); + if (vo.getMetadata() != null) { + inv.setMetadata(JSONObjectUtil.toObject(vo.getMetadata(), LinkedHashMap.class)); + } + inv.setTotalCapacity(vo.getTotalCapacity()); + inv.setAvailableCapacity(vo.getAvailableCapacity()); + inv.setState(vo.getState()); + inv.setStatus(vo.getStatus()); + inv.setCreateDate(vo.getCreateDate()); + inv.setLastOpDate(vo.getLastOpDate()); + return inv; + } + + public static List valueOf(Collection vos) { + List invs = new ArrayList<>(); + for (VmLocalVolumeCachePoolVO vo : vos) { + invs.add(valueOf(vo)); + } + return invs; + } + + public String getUuid() { + return uuid; + } + + public void setUuid(String uuid) { + this.uuid = uuid; + } + + public String getHostUuid() { + return hostUuid; + } + + public void setHostUuid(String hostUuid) { + this.hostUuid = hostUuid; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public LinkedHashMap getMetadata() { + return metadata; + } + + public void setMetadata(LinkedHashMap metadata) { + this.metadata = metadata; + } + + public long getTotalCapacity() { + return totalCapacity; + } + + public void setTotalCapacity(long totalCapacity) { + this.totalCapacity = totalCapacity; + } + + public long getAvailableCapacity() { + return availableCapacity; + } + + public void setAvailableCapacity(long availableCapacity) { + this.availableCapacity = availableCapacity; + } + + public VmLocalVolumeCachePoolState getState() { + return state; + } + + public void setState(VmLocalVolumeCachePoolState state) { + this.state = state; + } + + public VmLocalVolumeCachePoolStatus getStatus() { + return status; + } + + public void setStatus(VmLocalVolumeCachePoolStatus status) { + this.status = status; + } + + public Timestamp getCreateDate() { + return createDate; + } + + public void setCreateDate(Timestamp createDate) { + this.createDate = createDate; + } + + public Timestamp getLastOpDate() { + return lastOpDate; + } + + public void setLastOpDate(Timestamp lastOpDate) { + this.lastOpDate = lastOpDate; + } +} + diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolState.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolState.java new file mode 100644 index 00000000000..13f7aeb273e --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolState.java @@ -0,0 +1,7 @@ +package org.zstack.header.localVolumeCache; + +public enum VmLocalVolumeCachePoolState { + Enabled, + Disabled, +} + diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolStatus.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolStatus.java new file mode 100644 index 00000000000..6028d2c9121 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolStatus.java @@ -0,0 +1,8 @@ +package org.zstack.header.localVolumeCache; + +public enum VmLocalVolumeCachePoolStatus { + Connecting, + Connected, + Disconnected, +} + diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolVO.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolVO.java new file mode 100644 index 00000000000..bc31ceaa390 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolVO.java @@ -0,0 +1,158 @@ +package org.zstack.header.localVolumeCache; + +import org.zstack.header.host.HostEO; +import org.zstack.header.host.HostVO; +import org.zstack.header.vo.EntityGraph; +import org.zstack.header.vo.ForeignKey; +import org.zstack.header.vo.ResourceVO; +import org.zstack.header.vo.ToInventory; + +import javax.persistence.*; +import java.sql.Timestamp; +import java.util.Set; + +@Entity +@Table +@EntityGraph( + parents = { + @EntityGraph.Neighbour(type = HostVO.class, myField = "hostUuid", targetField = "uuid") + } +) +public class VmLocalVolumeCachePoolVO extends ResourceVO implements ToInventory { + + @Override + public VmLocalVolumeCachePoolInventory toInventory() { + return VmLocalVolumeCachePoolInventory.valueOf(this); + } + + + @Column + @ForeignKey(parentEntityClass = HostEO.class, onDeleteAction = ForeignKey.ReferenceOption.CASCADE) + private String hostUuid; + + @Column + private String name; + + @Column + private String description; + + @Column(length = 2048) + private String metadata; + + @Column + private long totalCapacity; + + @Column + private long availableCapacity; + + @Column + @Enumerated(EnumType.STRING) + private VmLocalVolumeCachePoolState state; + + @Column + @Enumerated(EnumType.STRING) + private VmLocalVolumeCachePoolStatus status; + + @OneToMany(fetch = FetchType.LAZY) + @JoinColumn(name = "poolUuid", insertable = false, updatable = false) + private Set caches; + + @Column + private Timestamp createDate; + + @Column + private Timestamp lastOpDate; + + @PreUpdate + private void preUpdate() { + lastOpDate = null; + } + + public String getHostUuid() { + return hostUuid; + } + + public void setHostUuid(String hostUuid) { + this.hostUuid = hostUuid; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getMetadata() { + return metadata; + } + + public void setMetadata(String metadata) { + this.metadata = metadata; + } + + public long getTotalCapacity() { + return totalCapacity; + } + + public void setTotalCapacity(long totalCapacity) { + this.totalCapacity = totalCapacity; + } + + public long getAvailableCapacity() { + return availableCapacity; + } + + public void setAvailableCapacity(long availableCapacity) { + this.availableCapacity = availableCapacity; + } + + public VmLocalVolumeCachePoolState getState() { + return state; + } + + public void setState(VmLocalVolumeCachePoolState state) { + this.state = state; + } + + public VmLocalVolumeCachePoolStatus getStatus() { + return status; + } + + public void setStatus(VmLocalVolumeCachePoolStatus status) { + this.status = status; + } + + public Set getCaches() { + return caches; + } + + public void setCaches(Set caches) { + this.caches = caches; + } + + public Timestamp getCreateDate() { + return createDate; + } + + public void setCreateDate(Timestamp createDate) { + this.createDate = createDate; + } + + public Timestamp getLastOpDate() { + return lastOpDate; + } + + public void setLastOpDate(Timestamp lastOpDate) { + this.lastOpDate = lastOpDate; + } +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolVO_.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolVO_.java new file mode 100644 index 00000000000..1c2e4cb4f16 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCachePoolVO_.java @@ -0,0 +1,20 @@ +package org.zstack.header.localVolumeCache; + +import javax.persistence.metamodel.SingularAttribute; +import javax.persistence.metamodel.StaticMetamodel; +import java.sql.Timestamp; + +@StaticMetamodel(VmLocalVolumeCachePoolVO.class) +public class VmLocalVolumeCachePoolVO_ { + public static volatile SingularAttribute uuid; + public static volatile SingularAttribute hostUuid; + public static volatile SingularAttribute name; + public static volatile SingularAttribute description; + public static volatile SingularAttribute metadata; + public static volatile SingularAttribute totalCapacity; + public static volatile SingularAttribute availableCapacity; + public static volatile SingularAttribute state; + public static volatile SingularAttribute status; + public static volatile SingularAttribute createDate; + public static volatile SingularAttribute lastOpDate; +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheState.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheState.java new file mode 100644 index 00000000000..ef4344ea151 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheState.java @@ -0,0 +1,7 @@ +package org.zstack.header.localVolumeCache; + +public enum VmLocalVolumeCacheState { + None, + Uninstantiated, + Instantiated, +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheVO.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheVO.java new file mode 100644 index 00000000000..d402102fc07 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheVO.java @@ -0,0 +1,116 @@ +package org.zstack.header.localVolumeCache; + +import org.zstack.header.vo.EntityGraph; +import org.zstack.header.vo.ForeignKey; +import org.zstack.header.vo.ResourceVO; +import org.zstack.header.vo.ToInventory; +import org.zstack.header.volume.VolumeEO; + +import javax.persistence.*; +import java.sql.Timestamp; + +@Entity +@Table(uniqueConstraints = { + @UniqueConstraint(columnNames = "volumeUuid") +}) +@EntityGraph( + parents = { + @EntityGraph.Neighbour(type = VolumeEO.class, myField = "volumeUuid", targetField = "uuid") + } +) +public class VmLocalVolumeCacheVO extends ResourceVO implements ToInventory { + + @Override + public VmLocalVolumeCacheInventory toInventory() { + return VmLocalVolumeCacheInventory.valueOf(this); + } + + @Column + @ForeignKey(parentEntityClass = VolumeEO.class, onDeleteAction = ForeignKey.ReferenceOption.CASCADE) + private String volumeUuid; + + /** + * Nullable: null means this cache entry has not been assigned to a pool yet. + * References VmLocalVolumeCachePoolVO in kvm plugin — no @ForeignKey to avoid cross-module dependency. + */ + @Column + private String poolUuid; + + @Column(length = 2048) + private String installPath; + + @Column + @Enumerated(EnumType.STRING) + private VmLocalVolumeCacheMode cacheMode; + + @Column + @Enumerated(EnumType.STRING) + private VmLocalVolumeCacheState state; + + @Column + private Timestamp createDate; + + @Column + private Timestamp lastOpDate; + + @PreUpdate + private void preUpdate() { + lastOpDate = null; + } + + public String getVolumeUuid() { + return volumeUuid; + } + + public void setVolumeUuid(String volumeUuid) { + this.volumeUuid = volumeUuid; + } + + public String getPoolUuid() { + return poolUuid; + } + + public void setPoolUuid(String poolUuid) { + this.poolUuid = poolUuid; + } + + public String getInstallPath() { + return installPath; + } + + public void setInstallPath(String installPath) { + this.installPath = installPath; + } + + public VmLocalVolumeCacheMode getCacheMode() { + return cacheMode; + } + + public void setCacheMode(VmLocalVolumeCacheMode cacheMode) { + this.cacheMode = cacheMode; + } + + public VmLocalVolumeCacheState getState() { + return state; + } + + public void setState(VmLocalVolumeCacheState state) { + this.state = state; + } + + public Timestamp getCreateDate() { + return createDate; + } + + public void setCreateDate(Timestamp createDate) { + this.createDate = createDate; + } + + public Timestamp getLastOpDate() { + return lastOpDate; + } + + public void setLastOpDate(Timestamp lastOpDate) { + this.lastOpDate = lastOpDate; + } +} diff --git a/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheVO_.java b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheVO_.java new file mode 100644 index 00000000000..8bf2989ca01 --- /dev/null +++ b/header/src/main/java/org/zstack/header/localVolumeCache/VmLocalVolumeCacheVO_.java @@ -0,0 +1,17 @@ +package org.zstack.header.localVolumeCache; + +import javax.persistence.metamodel.SingularAttribute; +import javax.persistence.metamodel.StaticMetamodel; +import java.sql.Timestamp; + +@StaticMetamodel(VmLocalVolumeCacheVO.class) +public class VmLocalVolumeCacheVO_ { + public static volatile SingularAttribute uuid; + public static volatile SingularAttribute volumeUuid; + public static volatile SingularAttribute poolUuid; + public static volatile SingularAttribute installPath; + public static volatile SingularAttribute cacheMode; + public static volatile SingularAttribute state; + public static volatile SingularAttribute createDate; + public static volatile SingularAttribute lastOpDate; +} diff --git a/header/src/main/java/org/zstack/header/vm/APICreateVmInstanceMsg.java b/header/src/main/java/org/zstack/header/vm/APICreateVmInstanceMsg.java index d6c0a4fd7a7..fff482f3f55 100755 --- a/header/src/main/java/org/zstack/header/vm/APICreateVmInstanceMsg.java +++ b/header/src/main/java/org/zstack/header/vm/APICreateVmInstanceMsg.java @@ -209,6 +209,21 @@ public class APICreateVmInstanceMsg extends APICreateMessage implements APIAudit @APIParam(required = false) private Boolean virtio; + @APIParam(required = false) + private Boolean enableRootVolumeCache; + + @APIParam(required = false, validValues = {"WriteBack"}) + private String cacheMode; + + @APIParam(required = false) + private String rootVolumeCachePoolUuid; + + @APIParam(required = false, validValues = {"WriteBack"}) + private String rootVolumeCacheMode; + + @APIParam(required = false) + private Map dataDiskCacheConfigOnIndex; + @PythonClassInventory public static class DiskAO { private boolean boot; @@ -223,6 +238,9 @@ public static class DiskAO { private String sourceUuid; private List systemTags; private String name; + private Boolean enableCache; + private String cachePoolUuid; + private String cacheMode; public boolean isBoot() { return boot; @@ -319,6 +337,51 @@ public String getName() { public void setName(String name) { this.name = name; } + + public Boolean getEnableCache() { + return enableCache; + } + + public void setEnableCache(Boolean enableCache) { + this.enableCache = enableCache; + } + + public String getCachePoolUuid() { + return cachePoolUuid; + } + + public void setCachePoolUuid(String cachePoolUuid) { + this.cachePoolUuid = cachePoolUuid; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } + } + + public static class VolumeCacheConfig { + private String cachePoolUuid; + private String cacheMode; + + public String getCachePoolUuid() { + return cachePoolUuid; + } + + public void setCachePoolUuid(String cachePoolUuid) { + this.cachePoolUuid = cachePoolUuid; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } } @APIParam(required = false) @@ -561,6 +624,46 @@ public void setVirtio(boolean virtio) { this.virtio = virtio; } + public Boolean getEnableRootVolumeCache() { + return enableRootVolumeCache; + } + + public void setEnableRootVolumeCache(Boolean enableRootVolumeCache) { + this.enableRootVolumeCache = enableRootVolumeCache; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } + + public String getRootVolumeCachePoolUuid() { + return rootVolumeCachePoolUuid; + } + + public void setRootVolumeCachePoolUuid(String rootVolumeCachePoolUuid) { + this.rootVolumeCachePoolUuid = rootVolumeCachePoolUuid; + } + + public String getRootVolumeCacheMode() { + return rootVolumeCacheMode; + } + + public void setRootVolumeCacheMode(String rootVolumeCacheMode) { + this.rootVolumeCacheMode = rootVolumeCacheMode; + } + + public Map getDataDiskCacheConfigOnIndex() { + return dataDiskCacheConfigOnIndex; + } + + public void setDataDiskCacheConfigOnIndex(Map dataDiskCacheConfigOnIndex) { + this.dataDiskCacheConfigOnIndex = dataDiskCacheConfigOnIndex; + } + public static APICreateVmInstanceMsg __example__() { APICreateVmInstanceMsg msg = new APICreateVmInstanceMsg(); msg.setName("vm1"); diff --git a/header/src/main/java/org/zstack/header/vm/CreateVmInstanceMsg.java b/header/src/main/java/org/zstack/header/vm/CreateVmInstanceMsg.java index dc364097a8f..056b9f0ebdb 100755 --- a/header/src/main/java/org/zstack/header/vm/CreateVmInstanceMsg.java +++ b/header/src/main/java/org/zstack/header/vm/CreateVmInstanceMsg.java @@ -38,6 +38,11 @@ public class CreateVmInstanceMsg extends NeedReplyMessage implements CreateVmIns private String guestOsType; private String architecture; private Boolean virtio; + private Boolean enableRootVolumeCache; + private String cacheMode; + private String rootVolumeCachePoolUuid; + private String rootVolumeCacheMode; + private Map dataDiskCacheConfigOnIndex; private List rootVolumeSystemTags; private List dataVolumeSystemTags; private Map> dataVolumeSystemTagsOnIndex; @@ -384,4 +389,44 @@ public boolean getVirtio() { public void setVirtio(boolean virtio) { this.virtio = virtio; } + + public Boolean getEnableRootVolumeCache() { + return enableRootVolumeCache; + } + + public void setEnableRootVolumeCache(Boolean enableRootVolumeCache) { + this.enableRootVolumeCache = enableRootVolumeCache; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } + + public String getRootVolumeCachePoolUuid() { + return rootVolumeCachePoolUuid; + } + + public void setRootVolumeCachePoolUuid(String rootVolumeCachePoolUuid) { + this.rootVolumeCachePoolUuid = rootVolumeCachePoolUuid; + } + + public String getRootVolumeCacheMode() { + return rootVolumeCacheMode; + } + + public void setRootVolumeCacheMode(String rootVolumeCacheMode) { + this.rootVolumeCacheMode = rootVolumeCacheMode; + } + + public Map getDataDiskCacheConfigOnIndex() { + return dataDiskCacheConfigOnIndex; + } + + public void setDataDiskCacheConfigOnIndex(Map dataDiskCacheConfigOnIndex) { + this.dataDiskCacheConfigOnIndex = dataDiskCacheConfigOnIndex; + } } diff --git a/header/src/main/java/org/zstack/header/vm/InstantiateNewCreatedVmInstanceMsg.java b/header/src/main/java/org/zstack/header/vm/InstantiateNewCreatedVmInstanceMsg.java index f27bebf9802..6be4a6dd569 100755 --- a/header/src/main/java/org/zstack/header/vm/InstantiateNewCreatedVmInstanceMsg.java +++ b/header/src/main/java/org/zstack/header/vm/InstantiateNewCreatedVmInstanceMsg.java @@ -47,6 +47,11 @@ public void setCandidatePrimaryStorageUuidsForDataVolume(List candidateP } private List diskAOs; + private Boolean enableRootVolumeCache; + private String cacheMode; + private String rootVolumeCachePoolUuid; + private String rootVolumeCacheMode; + private Map dataDiskCacheConfigOnIndex; public List getDiskAOs() { return diskAOs; @@ -56,6 +61,46 @@ public void setDiskAOs(List diskAOs) { this.diskAOs = diskAOs; } + public Boolean getEnableRootVolumeCache() { + return enableRootVolumeCache; + } + + public void setEnableRootVolumeCache(Boolean enableRootVolumeCache) { + this.enableRootVolumeCache = enableRootVolumeCache; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } + + public String getRootVolumeCachePoolUuid() { + return rootVolumeCachePoolUuid; + } + + public void setRootVolumeCachePoolUuid(String rootVolumeCachePoolUuid) { + this.rootVolumeCachePoolUuid = rootVolumeCachePoolUuid; + } + + public String getRootVolumeCacheMode() { + return rootVolumeCacheMode; + } + + public void setRootVolumeCacheMode(String rootVolumeCacheMode) { + this.rootVolumeCacheMode = rootVolumeCacheMode; + } + + public Map getDataDiskCacheConfigOnIndex() { + return dataDiskCacheConfigOnIndex; + } + + public void setDataDiskCacheConfigOnIndex(Map dataDiskCacheConfigOnIndex) { + this.dataDiskCacheConfigOnIndex = dataDiskCacheConfigOnIndex; + } + public List getSoftAvoidHostUuids() { return softAvoidHostUuids; } diff --git a/header/src/main/java/org/zstack/header/vm/VmInstanceSpec.java b/header/src/main/java/org/zstack/header/vm/VmInstanceSpec.java index 7007c592aea..23e2510bbd4 100755 --- a/header/src/main/java/org/zstack/header/vm/VmInstanceSpec.java +++ b/header/src/main/java/org/zstack/header/vm/VmInstanceSpec.java @@ -405,6 +405,11 @@ public void setCandidatePrimaryStorageUuidsForDataVolume(List candidateP private List disableL3Networks; private List diskAOs; + private Boolean enableRootVolumeCache; + private String cacheMode; + private String rootVolumeCachePoolUuid; + private String rootVolumeCacheMode; + private Map dataDiskCacheConfigOnIndex; public List getDiskAOs() { return diskAOs; @@ -414,6 +419,46 @@ public void setDiskAOs(List diskAOs) { this.diskAOs = diskAOs; } + public Boolean getEnableRootVolumeCache() { + return enableRootVolumeCache; + } + + public void setEnableRootVolumeCache(Boolean enableRootVolumeCache) { + this.enableRootVolumeCache = enableRootVolumeCache; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } + + public String getRootVolumeCachePoolUuid() { + return rootVolumeCachePoolUuid; + } + + public void setRootVolumeCachePoolUuid(String rootVolumeCachePoolUuid) { + this.rootVolumeCachePoolUuid = rootVolumeCachePoolUuid; + } + + public String getRootVolumeCacheMode() { + return rootVolumeCacheMode; + } + + public void setRootVolumeCacheMode(String rootVolumeCacheMode) { + this.rootVolumeCacheMode = rootVolumeCacheMode; + } + + public Map getDataDiskCacheConfigOnIndex() { + return dataDiskCacheConfigOnIndex; + } + + public void setDataDiskCacheConfigOnIndex(Map dataDiskCacheConfigOnIndex) { + this.dataDiskCacheConfigOnIndex = dataDiskCacheConfigOnIndex; + } + public boolean isSkipIpAllocation() { return skipIpAllocation; } diff --git a/plugin/kvm/src/main/java/org/zstack/kvm/CacheTO.java b/plugin/kvm/src/main/java/org/zstack/kvm/CacheTO.java new file mode 100644 index 00000000000..b6e98cf271b --- /dev/null +++ b/plugin/kvm/src/main/java/org/zstack/kvm/CacheTO.java @@ -0,0 +1,51 @@ +package org.zstack.kvm; + +import org.zstack.header.localVolumeCache.VmLocalVolumeCacheInventory; + +public class CacheTO extends BaseVirtualDeviceTO { + private String cacheUuid; + private String poolUuid; + private String installPath; + private String cacheMode; + + public String getCacheUuid() { + return cacheUuid; + } + + public void setCacheUuid(String cacheUuid) { + this.cacheUuid = cacheUuid; + } + + public String getPoolUuid() { + return poolUuid; + } + + public void setPoolUuid(String poolUuid) { + this.poolUuid = poolUuid; + } + + public String getInstallPath() { + return installPath; + } + + public void setInstallPath(String installPath) { + this.installPath = installPath; + } + + public String getCacheMode() { + return cacheMode; + } + + public void setCacheMode(String cacheMode) { + this.cacheMode = cacheMode; + } + + public static CacheTO valueOf(VmLocalVolumeCacheInventory inv) { + CacheTO to = new CacheTO(); + to.setCacheUuid(inv.getUuid()); + to.setPoolUuid(inv.getPoolUuid()); + to.setInstallPath(inv.getInstallPath()); + to.setCacheMode(inv.getCacheMode().name()); + return to; + } +} diff --git a/plugin/kvm/src/main/java/org/zstack/kvm/KVMAgentCommands.java b/plugin/kvm/src/main/java/org/zstack/kvm/KVMAgentCommands.java index a8a1378288b..af3f33541c9 100755 --- a/plugin/kvm/src/main/java/org/zstack/kvm/KVMAgentCommands.java +++ b/plugin/kvm/src/main/java/org/zstack/kvm/KVMAgentCommands.java @@ -8,6 +8,7 @@ import org.zstack.header.HasThreadContext; import org.zstack.header.agent.CancelCommand; import org.zstack.header.core.validation.Validation; +import org.zstack.header.host.HostBlockDeviceStruct; import org.zstack.header.host.HostNUMANode; import org.zstack.header.host.VmNicRedirectConfig; import org.zstack.header.log.NoLogging; @@ -5185,4 +5186,182 @@ public void setMemoryUsage(long memoryUsage) { } } + // ======================================================================== + // Local Volume Cache — Command Definitions + // ======================================================================== + + public static class InitPoolCmd extends AgentCommand { + public String poolUuid; + public String mountPoint; + public boolean force; + public List pvs; + } + + public static class ConnectPoolCmd extends AgentCommand { + public String poolUuid; + public String mountPoint; + public boolean force; + } + + public static class ExtendPoolCmd extends AgentCommand { + public String poolUuid; + public String mountPoint; + public boolean force; + public List pvs; + } + + public static class DeletePoolCmd extends AgentCommand { + public String poolUuid; + public String mountPoint; + public boolean force; + } + + public static class CheckPoolCmd extends AgentCommand { + public String poolUuid; + public String mountPoint; + public boolean force; + } + + public static class GetPoolCapacityCmd extends AgentCommand { + public String poolUuid; + public String mountPoint; + public boolean force; + } + + public static class GCPoolCmd extends AgentCommand { + public String poolUuid; + public String mountPoint; + public boolean force; + public List volumes; + } + + public static class AllocateCacheCmd extends AgentCommand { + public String poolUuid; + public VolumeTO volume; + } + + public static class DeleteCacheCmd extends AgentCommand { + public String poolUuid; + public VolumeTO volume; + } + + public static class FlushCacheCmd extends AgentCommand { + public String poolUuid; + public VolumeTO volume; + } + + public static class GetCacheCapacityCmd extends AgentCommand { + public String poolUuid; + public VolumeTO volume; + } + + public static class AttachVolumeCacheCmd extends AgentCommand { + public String instanceUuid; + public VolumeTO volume; + } + + public static class DetachVolumeCacheCmd extends AgentCommand implements HasThreadContext { + public String instanceUuid; + public VolumeTO volume; + } + + // ======================================================================== + // Local Volume Cache — Ref Structures + // ======================================================================== + + public static class PVRef { + public String pvUuid; + public String pvName; + public String pvDevicePath; + } + + public static class PVHealthRef extends PVRef { + public Boolean healthy; + } + + public static class VGRef { + public String vgUuid; + public String vgName; + } + + public static class LVRef { + public String lvUuid; + public String lvName; + public String lvPath; + } + + public static class FileSystemRef { + public String fsUuid; + public String fsType; + } + + public static class VolumeRef { + public String volumeUuid; + public String installPath; + public String deviceType; + public String format; + public Long size; + } + + // ======================================================================== + // Local Volume Cache — Response Definitions + // ======================================================================== + + public static class PoolRsp extends AgentResponse { + public String poolUuid; + public String mountPoint; + public List pvs; + public VGRef vg; + public LVRef lv; + public FileSystemRef filesystem; + } + + public static class PoolHealthRsp extends AgentResponse { + public Boolean healthy; + public List pvs; + public Boolean vg; + public Boolean lv; + public Boolean filesystem; + } + + public static class PoolCapacityRsp extends AgentResponse { + public Long total; + public Long used; + public Long available; + public Long allocated; + public Long dirty; + } + + public static class CacheRsp extends AgentResponse { + public String installPath; + public Long virtualSize; + public Long actualSize; + } + + public static class GCPoolRsp extends AgentResponse { + public List gcFiles; + public Integer gcCount; + } + + public static class AttachVolumeCacheRsp extends AgentResponse { + } + + public static class DetachVolumeCacheRsp extends AgentResponse { + } + + public static class GetBlockDevicesCmd extends AgentCommand { + } + + public static class GetBlockDevicesRsp extends AgentResponse { + private List blockDevices; + + public List getBlockDevices() { + return blockDevices; + } + + public void setBlockDevices(List blockDevices) { + this.blockDevices = blockDevices; + } + } + } diff --git a/plugin/kvm/src/main/java/org/zstack/kvm/KVMApiInterceptor.java b/plugin/kvm/src/main/java/org/zstack/kvm/KVMApiInterceptor.java index 93fd688935b..408cc0fb0bd 100755 --- a/plugin/kvm/src/main/java/org/zstack/kvm/KVMApiInterceptor.java +++ b/plugin/kvm/src/main/java/org/zstack/kvm/KVMApiInterceptor.java @@ -90,7 +90,6 @@ private void validate(APICreateVmUserDefinedXmlHookScriptMsg msg) { } } - private void validate(APIAddKVMHostMsg msg) { SimpleQuery q = dbf.createQuery(KVMHostVO.class); q.add(KVMHostVO_.managementIp, Op.EQ, msg.getManagementIp()); diff --git a/plugin/kvm/src/main/java/org/zstack/kvm/KVMConstant.java b/plugin/kvm/src/main/java/org/zstack/kvm/KVMConstant.java index 1b2df9f8f2a..ef2974bc6d8 100755 --- a/plugin/kvm/src/main/java/org/zstack/kvm/KVMConstant.java +++ b/plugin/kvm/src/main/java/org/zstack/kvm/KVMConstant.java @@ -89,6 +89,7 @@ public interface KVMConstant { String GET_VIRTUALIZER_INFO_PATH = "/vm/getvirtualizerinfo"; String KVM_SCAN_VM_PORT_STATUS = "/host/vm/scanport"; String GET_DEV_CAPACITY = "/host/dev/capacity"; + String KVM_GET_BLOCK_DEVICES_PATH = "/host/blockdevices"; String KVM_CONFIG_PRIMARY_VM_PATH = "/primary/vm/config"; String KVM_CONFIG_SECONDARY_VM_PATH = "/secondary/vm/config"; String KVM_START_COLO_SYNC_PATH = "/start/colo/sync"; @@ -96,6 +97,22 @@ public interface KVMConstant { String CLEAN_FIRMWARE_FLASH = "/clean/firmware/flash"; String FSTRIM_VM_PATH = "/vm/fstrim"; + String LOCAL_VOLUME_CACHE_INIT_POOL_PATH = "/localvolumecache/pool/init"; + String LOCAL_VOLUME_CACHE_CONNECT_POOL_PATH = "/localvolumecache/pool/connect"; + String LOCAL_VOLUME_CACHE_EXTEND_POOL_PATH = "/localvolumecache/pool/extend"; + String LOCAL_VOLUME_CACHE_DELETE_POOL_PATH = "/localvolumecache/pool/delete"; + String LOCAL_VOLUME_CACHE_CHECK_POOL_PATH = "/localvolumecache/pool/check"; + String LOCAL_VOLUME_CACHE_GET_POOL_CAPACITY_PATH = "/localvolumecache/pool/getcapacity"; + String LOCAL_VOLUME_CACHE_GC_POOL_PATH = "/localvolumecache/pool/gc"; + + String LOCAL_VOLUME_CACHE_CREATE_CACHE_PATH = "/localvolumecache/create"; + String LOCAL_VOLUME_CACHE_DELETE_CACHE_PATH = "/localvolumecache/delete"; + String LOCAL_VOLUME_CACHE_FLUSH_CACHE_PATH = "/localvolumecache/flush"; + String LOCAL_VOLUME_CACHE_GET_CACHE_CAPACITY_PATH = "/localvolumecache/getcapacity"; + + String KVM_ATTACH_VOLUME_CACHE_PATH = "/vm/volume/cache/attach"; + String KVM_DETACH_VOLUME_CACHE_PATH = "/vm/volume/cache/detach"; + String ISO_TO = "kvm.isoto"; String ANSIBLE_PLAYBOOK_NAME = "kvm.py"; String ANSIBLE_MODULE_PATH = "ansible/kvm"; diff --git a/plugin/kvm/src/main/java/org/zstack/kvm/KVMHost.java b/plugin/kvm/src/main/java/org/zstack/kvm/KVMHost.java index a245757517d..b0ea067e0be 100755 --- a/plugin/kvm/src/main/java/org/zstack/kvm/KVMHost.java +++ b/plugin/kvm/src/main/java/org/zstack/kvm/KVMHost.java @@ -215,6 +215,7 @@ public class KVMHost extends HostBase implements Host { private String getVirtualizerInfo; private String scanVmPortPath; private String getDevCapacityPath; + private String getBlockDevicesPath; private String configPrimaryVmPath; private String configSecondaryVmPath; private String startColoSyncPath; @@ -411,6 +412,10 @@ public KVMHost(KVMHostVO self, KVMHostContext context) { ub.path(KVMConstant.GET_DEV_CAPACITY); getDevCapacityPath = ub.build().toString(); + ub = UriComponentsBuilder.fromHttpUrl(baseUrl); + ub.path(KVMConstant.KVM_GET_BLOCK_DEVICES_PATH); + getBlockDevicesPath = ub.build().toString(); + ub = UriComponentsBuilder.fromHttpUrl(baseUrl); ub.path(KVMConstant.KVM_CONFIG_PRIMARY_VM_PATH); configPrimaryVmPath = ub.build().toString(); @@ -702,11 +707,36 @@ protected void handleLocalMessage(Message msg) { handle((RestartKvmAgentMsg) msg); } else if (msg instanceof UpdateVmConsolePasswordOnHypervisorMsg) { handle((UpdateVmConsolePasswordOnHypervisorMsg) msg); + } else if (msg instanceof GetBlockDevicesOnHostMsg) { + handle((GetBlockDevicesOnHostMsg) msg); } else { super.handleLocalMessage(msg); } } + private void handle(GetBlockDevicesOnHostMsg msg) { + GetBlockDevicesOnHostReply reply = new GetBlockDevicesOnHostReply(); + KVMAgentCommands.GetBlockDevicesCmd cmd = new KVMAgentCommands.GetBlockDevicesCmd(); + new Http<>(getBlockDevicesPath, cmd, KVMAgentCommands.GetBlockDevicesRsp.class) + .call(new ReturnValueCompletion(msg) { + @Override + public void success(KVMAgentCommands.GetBlockDevicesRsp rsp) { + if (!rsp.isSuccess()) { + reply.setError(operr("operation error, because:%s", rsp.getError())); + } else { + reply.setBlockDevices(rsp.getBlockDevices()); + } + bus.reply(msg, reply); + } + + @Override + public void fail(ErrorCode errorCode) { + reply.setError(errorCode); + bus.reply(msg, reply); + } + }); + } + private void handle(RestartKvmAgentMsg msg) { RestartKvmAgentReply reply = new RestartKvmAgentReply(); thdf.singleFlightSubmit(new SingleFlightTask(msg) diff --git a/plugin/kvm/src/main/java/org/zstack/kvm/VolumeTO.java b/plugin/kvm/src/main/java/org/zstack/kvm/VolumeTO.java index 2ea9238f167..e08118706a1 100644 --- a/plugin/kvm/src/main/java/org/zstack/kvm/VolumeTO.java +++ b/plugin/kvm/src/main/java/org/zstack/kvm/VolumeTO.java @@ -32,6 +32,7 @@ public class VolumeTO extends BaseVirtualDeviceTO { public static List exts; private String installPath; + private Long size; private int deviceId; private String deviceType = FILE; private String volumeUuid; @@ -52,6 +53,8 @@ public class VolumeTO extends BaseVirtualDeviceTO { private int ioThreadId; private String ioThreadPin; private int controllerIndex; + private CacheTO cache; + static { deviceTypes.put(VolumeProtocol.Vhost, VHOST); @@ -63,6 +66,7 @@ public VolumeTO() { public VolumeTO(VolumeTO other) { this.installPath = other.installPath; + this.size = other.size; this.deviceId = other.deviceId; this.deviceType = other.deviceType; this.volumeUuid = other.volumeUuid; @@ -81,6 +85,7 @@ public VolumeTO(VolumeTO other) { this.ioThreadId = other.ioThreadId; this.ioThreadPin = other.ioThreadPin; this.controllerIndex = other.controllerIndex; + this.cache = other.cache; } public static List valueOf(List vols, KVMHostInventory host) { @@ -99,6 +104,7 @@ public static VolumeTO valueOf(VolumeInventory vol, KVMHostInventory host, Strin VolumeTO to = new VolumeTO(); to.setResourceUuid(vol.getUuid()); to.setInstallPath(vol.getInstallPath()); + to.setSize(vol.getSize()); if (vol.getDeviceId() != null) { to.setDeviceId(vol.getDeviceId()); } @@ -202,6 +208,10 @@ public void setInstallPath(String installPath) { this.installPath = installPath; } + public Long getSize() { return size; } + + public void setSize(Long size) { this.size = size; } + public int getDeviceId() { return deviceId; } @@ -297,4 +307,12 @@ public int getControllerIndex() { public void setControllerIndex(int controllerIndex) { this.controllerIndex = controllerIndex; } + + public CacheTO getCache() { + return cache; + } + + public void setCache(CacheTO cache) { + this.cache = cache; + } } diff --git a/sdk/src/main/java/SourceClassMap.java b/sdk/src/main/java/SourceClassMap.java index 4bbd9238f98..9c9948250b3 100644 --- a/sdk/src/main/java/SourceClassMap.java +++ b/sdk/src/main/java/SourceClassMap.java @@ -264,6 +264,7 @@ public class SourceClassMap { put("org.zstack.header.flowMeter.NetworkRouterFlowMeterRefInventory", "org.zstack.sdk.NetworkRouterFlowMeterRefInventory"); put("org.zstack.header.host.AddHostFromFileResult", "org.zstack.sdk.AddHostFromFileResult"); put("org.zstack.header.host.CpuArchitecture", "org.zstack.sdk.CpuArchitecture"); + put("org.zstack.header.host.HostBlockDeviceStruct", "org.zstack.sdk.HostBlockDeviceStruct"); put("org.zstack.header.host.HostInventory", "org.zstack.sdk.HostInventory"); put("org.zstack.header.host.HostIpmiInventory", "org.zstack.sdk.HostIpmiInventory"); put("org.zstack.header.host.HostNUMANode", "org.zstack.sdk.HostNUMANode"); @@ -309,6 +310,12 @@ public class SourceClassMap { put("org.zstack.header.image.ImageGroupInventory", "org.zstack.sdk.ImageGroupInventory"); put("org.zstack.header.image.ImageGroupRefInventory", "org.zstack.sdk.ImageGroupRefInventory"); put("org.zstack.header.image.ImageInventory", "org.zstack.sdk.ImageInventory"); + put("org.zstack.header.localVolumeCache.VmLocalVolumeCacheInventory", "org.zstack.sdk.VmLocalVolumeCacheInventory"); + put("org.zstack.header.localVolumeCache.VmLocalVolumeCacheMode", "org.zstack.sdk.VmLocalVolumeCacheMode"); + put("org.zstack.header.localVolumeCache.VmLocalVolumeCachePoolInventory", "org.zstack.sdk.VmLocalVolumeCachePoolInventory"); + put("org.zstack.header.localVolumeCache.VmLocalVolumeCachePoolState", "org.zstack.sdk.VmLocalVolumeCachePoolState"); + put("org.zstack.header.localVolumeCache.VmLocalVolumeCachePoolStatus", "org.zstack.sdk.VmLocalVolumeCachePoolStatus"); + put("org.zstack.header.localVolumeCache.VmLocalVolumeCacheState", "org.zstack.sdk.VmLocalVolumeCacheState"); put("org.zstack.header.longjob.LongJobInventory", "org.zstack.sdk.LongJobInventory"); put("org.zstack.header.longjob.LongJobState", "org.zstack.sdk.LongJobState"); put("org.zstack.header.managementnode.ManagementNodeInventory", "org.zstack.sdk.ManagementNodeInventory"); @@ -480,6 +487,7 @@ public class SourceClassMap { put("org.zstack.ipsec.IPsecPeerCidrInventory", "org.zstack.sdk.IPsecPeerCidrInventory"); put("org.zstack.kvm.APIKvmRunShellEvent$ShellResult", "org.zstack.sdk.ShellResult"); put("org.zstack.kvm.BaseVirtualDeviceTO", "org.zstack.sdk.BaseVirtualDeviceTO"); + put("org.zstack.kvm.CacheTO", "org.zstack.sdk.CacheTO"); put("org.zstack.kvm.KVMAgentCommands$CdRomTO", "org.zstack.sdk.CdRomTO"); put("org.zstack.kvm.KVMAgentCommands$IsoTO", "org.zstack.sdk.IsoTO"); put("org.zstack.kvm.KVMAgentCommands$NicTO", "org.zstack.sdk.NicTO"); @@ -978,6 +986,7 @@ public class SourceClassMap { put("org.zstack.sdk.CCSCertificateUserRefInventory", "org.zstack.crypto.ccs.CCSCertificateUserRefInventory"); put("org.zstack.sdk.CCSCertificateUserState", "org.zstack.crypto.ccs.CCSCertificateUserState"); put("org.zstack.sdk.CSPSecretResourcePoolInventory", "org.zstack.crypto.securitymachine.thirdparty.csp.CSPSecretResourcePoolInventory"); + put("org.zstack.sdk.CacheTO", "org.zstack.kvm.CacheTO"); put("org.zstack.sdk.CasClientInventory", "org.zstack.sso.header.CasClientInventory"); put("org.zstack.sdk.CasState", "org.zstack.sso.header.CasState"); put("org.zstack.sdk.CbtTaskInventory", "org.zstack.header.cbt.CbtTaskInventory"); @@ -1097,6 +1106,7 @@ public class SourceClassMap { put("org.zstack.sdk.HardwareL2VxlanNetworkInventory", "org.zstack.sdnController.header.HardwareL2VxlanNetworkInventory"); put("org.zstack.sdk.HardwareL2VxlanNetworkPoolInventory", "org.zstack.sdnController.header.HardwareL2VxlanNetworkPoolInventory"); put("org.zstack.sdk.HbaDeviceInventory", "org.zstack.storage.device.hba.HbaDeviceInventory"); + put("org.zstack.sdk.HostBlockDeviceStruct", "org.zstack.header.host.HostBlockDeviceStruct"); put("org.zstack.sdk.HostConnectedStatus", "org.zstack.zops.HostConnectedStatus"); put("org.zstack.sdk.HostDiskCapacity", "org.zstack.storage.primary.local.APIGetLocalStorageHostDiskCapacityReply$HostDiskCapacity"); put("org.zstack.sdk.HostInventory", "org.zstack.header.host.HostInventory"); @@ -1533,6 +1543,12 @@ public class SourceClassMap { put("org.zstack.sdk.VmInstanceInventory", "org.zstack.header.vm.VmInstanceInventory"); put("org.zstack.sdk.VmInstanceMdevDeviceSpecRefInventory", "org.zstack.pciDevice.specification.mdev.VmInstanceMdevDeviceSpecRefInventory"); put("org.zstack.sdk.VmInstancePciDeviceSpecRefInventory", "org.zstack.pciDevice.specification.pci.VmInstancePciDeviceSpecRefInventory"); + put("org.zstack.sdk.VmLocalVolumeCacheInventory", "org.zstack.header.localVolumeCache.VmLocalVolumeCacheInventory"); + put("org.zstack.sdk.VmLocalVolumeCacheMode", "org.zstack.header.localVolumeCache.VmLocalVolumeCacheMode"); + put("org.zstack.sdk.VmLocalVolumeCachePoolInventory", "org.zstack.header.localVolumeCache.VmLocalVolumeCachePoolInventory"); + put("org.zstack.sdk.VmLocalVolumeCachePoolState", "org.zstack.header.localVolumeCache.VmLocalVolumeCachePoolState"); + put("org.zstack.sdk.VmLocalVolumeCachePoolStatus", "org.zstack.header.localVolumeCache.VmLocalVolumeCachePoolStatus"); + put("org.zstack.sdk.VmLocalVolumeCacheState", "org.zstack.header.localVolumeCache.VmLocalVolumeCacheState"); put("org.zstack.sdk.VmMemoryBillingInventory", "org.zstack.billing.generator.vm.memory.VmMemoryBillingInventory"); put("org.zstack.sdk.VmMemorySpendingDetails", "org.zstack.billing.spendingcalculator.vm.VmMemorySpendingDetails"); put("org.zstack.sdk.VmNicBandwidthSpendingDetails", "org.zstack.billing.spendingcalculator.vmnic.VmNicBandwidthSpendingDetails"); diff --git a/sdk/src/main/java/org/zstack/sdk/ApplicationDevelopmentServiceInventory.java b/sdk/src/main/java/org/zstack/sdk/ApplicationDevelopmentServiceInventory.java index 4c43e386e9d..2bf4b9169a5 100644 --- a/sdk/src/main/java/org/zstack/sdk/ApplicationDevelopmentServiceInventory.java +++ b/sdk/src/main/java/org/zstack/sdk/ApplicationDevelopmentServiceInventory.java @@ -12,14 +12,6 @@ public java.lang.String getDeploymentStatus() { return this.deploymentStatus; } - public java.lang.String packageVersion; - public void setPackageVersion(java.lang.String packageVersion) { - this.packageVersion = packageVersion; - } - public java.lang.String getPackageVersion() { - return this.packageVersion; - } - public ModelServiceInventory service; public void setService(ModelServiceInventory service) { this.service = service; diff --git a/sdk/src/main/java/org/zstack/sdk/CacheTO.java b/sdk/src/main/java/org/zstack/sdk/CacheTO.java new file mode 100644 index 00000000000..6439de03034 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/CacheTO.java @@ -0,0 +1,39 @@ +package org.zstack.sdk; + + + +public class CacheTO extends org.zstack.sdk.BaseVirtualDeviceTO { + + public java.lang.String cacheUuid; + public void setCacheUuid(java.lang.String cacheUuid) { + this.cacheUuid = cacheUuid; + } + public java.lang.String getCacheUuid() { + return this.cacheUuid; + } + + public java.lang.String poolUuid; + public void setPoolUuid(java.lang.String poolUuid) { + this.poolUuid = poolUuid; + } + public java.lang.String getPoolUuid() { + return this.poolUuid; + } + + public java.lang.String installPath; + public void setInstallPath(java.lang.String installPath) { + this.installPath = installPath; + } + public java.lang.String getInstallPath() { + return this.installPath; + } + + public java.lang.String cacheMode; + public void setCacheMode(java.lang.String cacheMode) { + this.cacheMode = cacheMode; + } + public java.lang.String getCacheMode() { + return this.cacheMode; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/ChangeVmLocalVolumeCachePoolStateAction.java b/sdk/src/main/java/org/zstack/sdk/ChangeVmLocalVolumeCachePoolStateAction.java new file mode 100644 index 00000000000..d664d85a80a --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/ChangeVmLocalVolumeCachePoolStateAction.java @@ -0,0 +1,107 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class ChangeVmLocalVolumeCachePoolStateAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.ChangeVmLocalVolumeCachePoolStateResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String uuid; + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String hostUuid; + + @Param(required = true, validValues = {"enable","disable"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String stateEvent; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.ChangeVmLocalVolumeCachePoolStateResult value = res.getResult(org.zstack.sdk.ChangeVmLocalVolumeCachePoolStateResult.class); + ret.value = value == null ? new org.zstack.sdk.ChangeVmLocalVolumeCachePoolStateResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "PUT"; + info.path = "/hosts/{hostUuid}/local-volume-cache-pools/{uuid}/actions"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "changeVmLocalVolumeCachePoolState"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/ChangeVmLocalVolumeCachePoolStateResult.java b/sdk/src/main/java/org/zstack/sdk/ChangeVmLocalVolumeCachePoolStateResult.java new file mode 100644 index 00000000000..d4f1c9d6b10 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/ChangeVmLocalVolumeCachePoolStateResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCachePoolInventory; + +public class ChangeVmLocalVolumeCachePoolStateResult { + public VmLocalVolumeCachePoolInventory inventory; + public void setInventory(VmLocalVolumeCachePoolInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCachePoolInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/CreateOvnControllerVmAction.java b/sdk/src/main/java/org/zstack/sdk/CreateOvnControllerVmAction.java index c7ccc7e2c19..0a74ea0e314 100644 --- a/sdk/src/main/java/org/zstack/sdk/CreateOvnControllerVmAction.java +++ b/sdk/src/main/java/org/zstack/sdk/CreateOvnControllerVmAction.java @@ -109,6 +109,21 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.Boolean virtio; + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.Boolean enableRootVolumeCache; + + @Param(required = false, validValues = {"WriteBack"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String cacheMode; + + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String rootVolumeCachePoolUuid; + + @Param(required = false, validValues = {"WriteBack"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String rootVolumeCacheMode; + + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.util.Map dataDiskCacheConfigOnIndex; + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.util.List diskAOs; diff --git a/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobAction.java b/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobAction.java index fc6298c7488..136ce6f6c10 100644 --- a/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobAction.java +++ b/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobAction.java @@ -34,7 +34,7 @@ public Result throwExceptionIfError() { @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.String targetResourceUuid; - @Param(required = true, validValues = {"startVm","stopVm","rebootVm","volumeSnapshot","volumeSnapshotGroup","volumeBackup","rootVolumeBackup","vmBackup","databaseBackup","localRaidSelfTest","runAutoScalingGroup","cancelIAM2ProjectLoginExpired","takeIAM2ProjectLoginExpired","baremetal2InstanceBackup","baremetal2RootVolumeBackup"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + @Param(required = true, validValues = {"startVm","stopVm","rebootVm","volumeSnapshot","volumeSnapshotGroup","volumeBackup","rootVolumeBackup","vmBackup","databaseBackup","localRaidSelfTest","runAutoScalingGroup","cancelIAM2ProjectLoginExpired","takeIAM2ProjectLoginExpired"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.String type; @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) diff --git a/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobGroupAction.java b/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobGroupAction.java index 170ed08742e..ca45d868565 100644 --- a/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobGroupAction.java +++ b/sdk/src/main/java/org/zstack/sdk/CreateSchedulerJobGroupAction.java @@ -31,7 +31,7 @@ public Result throwExceptionIfError() { @Param(required = false, maxLength = 2048, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.String description; - @Param(required = true, validValues = {"startVm","stopVm","rebootVm","volumeSnapshot","volumeSnapshotGroup","volumeBackup","rootVolumeBackup","vmBackup","databaseBackup","runAutoScalingGroup","cancelIAM2ProjectLoginExpired","takeIAM2ProjectLoginExpired","baremetal2InstanceBackup","baremetal2RootVolumeBackup"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + @Param(required = true, validValues = {"startVm","stopVm","rebootVm","volumeSnapshot","volumeSnapshotGroup","volumeBackup","rootVolumeBackup","vmBackup","databaseBackup","runAutoScalingGroup","cancelIAM2ProjectLoginExpired","takeIAM2ProjectLoginExpired"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.String type; @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) diff --git a/sdk/src/main/java/org/zstack/sdk/CreateVmInstanceAction.java b/sdk/src/main/java/org/zstack/sdk/CreateVmInstanceAction.java index a6c9c4cd2c4..51581e11e75 100644 --- a/sdk/src/main/java/org/zstack/sdk/CreateVmInstanceAction.java +++ b/sdk/src/main/java/org/zstack/sdk/CreateVmInstanceAction.java @@ -109,6 +109,21 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.Boolean virtio; + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.Boolean enableRootVolumeCache; + + @Param(required = false, validValues = {"WriteBack"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String cacheMode; + + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String rootVolumeCachePoolUuid; + + @Param(required = false, validValues = {"WriteBack"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String rootVolumeCacheMode; + + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.util.Map dataDiskCacheConfigOnIndex; + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.util.List diskAOs; diff --git a/sdk/src/main/java/org/zstack/sdk/CreateVmLocalVolumeCachePoolAction.java b/sdk/src/main/java/org/zstack/sdk/CreateVmLocalVolumeCachePoolAction.java new file mode 100644 index 00000000000..3c3283758a5 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/CreateVmLocalVolumeCachePoolAction.java @@ -0,0 +1,119 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class CreateVmLocalVolumeCachePoolAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.CreateVmLocalVolumeCachePoolResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String hostUuid; + + @Param(required = true, maxLength = 255, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String name; + + @Param(required = false, maxLength = 2048, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String description; + + @Param(required = true, nonempty = true, nullElements = false, emptyString = true, noTrim = false) + public java.util.List pvs; + + @Param(required = true, maxLength = 1024, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String mountPoint; + + @Param(required = false) + public java.lang.String resourceUuid; + + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.util.List tagUuids; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.CreateVmLocalVolumeCachePoolResult value = res.getResult(org.zstack.sdk.CreateVmLocalVolumeCachePoolResult.class); + ret.value = value == null ? new org.zstack.sdk.CreateVmLocalVolumeCachePoolResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "POST"; + info.path = "/hosts/{hostUuid}/local-volume-cache-pools"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "params"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/CreateVmLocalVolumeCachePoolResult.java b/sdk/src/main/java/org/zstack/sdk/CreateVmLocalVolumeCachePoolResult.java new file mode 100644 index 00000000000..f39fed20bae --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/CreateVmLocalVolumeCachePoolResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCachePoolInventory; + +public class CreateVmLocalVolumeCachePoolResult { + public VmLocalVolumeCachePoolInventory inventory; + public void setInventory(VmLocalVolumeCachePoolInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCachePoolInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/DeleteVmLocalVolumeCachePoolAction.java b/sdk/src/main/java/org/zstack/sdk/DeleteVmLocalVolumeCachePoolAction.java new file mode 100644 index 00000000000..31d24e83c4c --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/DeleteVmLocalVolumeCachePoolAction.java @@ -0,0 +1,104 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class DeleteVmLocalVolumeCachePoolAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.DeleteVmLocalVolumeCachePoolResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String uuid; + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String hostUuid; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.DeleteVmLocalVolumeCachePoolResult value = res.getResult(org.zstack.sdk.DeleteVmLocalVolumeCachePoolResult.class); + ret.value = value == null ? new org.zstack.sdk.DeleteVmLocalVolumeCachePoolResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "DELETE"; + info.path = "/hosts/{hostUuid}/local-volume-cache-pools/{uuid}"; + info.needSession = true; + info.needPoll = true; + info.parameterName = ""; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/DeleteVmLocalVolumeCachePoolResult.java b/sdk/src/main/java/org/zstack/sdk/DeleteVmLocalVolumeCachePoolResult.java new file mode 100644 index 00000000000..5449db3bcc0 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/DeleteVmLocalVolumeCachePoolResult.java @@ -0,0 +1,7 @@ +package org.zstack.sdk; + + + +public class DeleteVmLocalVolumeCachePoolResult { + +} diff --git a/sdk/src/main/java/org/zstack/sdk/DeployAppDevelopmentServiceAction.java b/sdk/src/main/java/org/zstack/sdk/DeployAppDevelopmentServiceAction.java index 0d4ef73088b..73ded5ce784 100644 --- a/sdk/src/main/java/org/zstack/sdk/DeployAppDevelopmentServiceAction.java +++ b/sdk/src/main/java/org/zstack/sdk/DeployAppDevelopmentServiceAction.java @@ -91,9 +91,6 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.Long rootDiskSize; - @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.String projectUuid; - @Param(required = false) public java.lang.String resourceUuid; diff --git a/sdk/src/main/java/org/zstack/sdk/DeployModelEvalServiceAction.java b/sdk/src/main/java/org/zstack/sdk/DeployModelEvalServiceAction.java index f29c06a748e..17b8d940062 100644 --- a/sdk/src/main/java/org/zstack/sdk/DeployModelEvalServiceAction.java +++ b/sdk/src/main/java/org/zstack/sdk/DeployModelEvalServiceAction.java @@ -142,9 +142,6 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.Long rootDiskSize; - @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.String projectUuid; - @Param(required = false) public java.lang.String resourceUuid; diff --git a/sdk/src/main/java/org/zstack/sdk/DeployModelServiceAction.java b/sdk/src/main/java/org/zstack/sdk/DeployModelServiceAction.java index 105e7083ae2..1b195ea5674 100644 --- a/sdk/src/main/java/org/zstack/sdk/DeployModelServiceAction.java +++ b/sdk/src/main/java/org/zstack/sdk/DeployModelServiceAction.java @@ -91,9 +91,6 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.Long rootDiskSize; - @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.String projectUuid; - @Param(required = false) public java.lang.String resourceUuid; diff --git a/sdk/src/main/java/org/zstack/sdk/DisableVolumeCacheAction.java b/sdk/src/main/java/org/zstack/sdk/DisableVolumeCacheAction.java new file mode 100644 index 00000000000..1a748074582 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/DisableVolumeCacheAction.java @@ -0,0 +1,101 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class DisableVolumeCacheAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.DisableVolumeCacheResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String volumeUuid; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.DisableVolumeCacheResult value = res.getResult(org.zstack.sdk.DisableVolumeCacheResult.class); + ret.value = value == null ? new org.zstack.sdk.DisableVolumeCacheResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "PUT"; + info.path = "/volumes/{volumeUuid}/local-volume-cache/actions"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "disableVolumeCache"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/DisableVolumeCacheResult.java b/sdk/src/main/java/org/zstack/sdk/DisableVolumeCacheResult.java new file mode 100644 index 00000000000..a0e0615ae44 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/DisableVolumeCacheResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCacheInventory; + +public class DisableVolumeCacheResult { + public VmLocalVolumeCacheInventory inventory; + public void setInventory(VmLocalVolumeCacheInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCacheInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/EnableVolumeCacheAction.java b/sdk/src/main/java/org/zstack/sdk/EnableVolumeCacheAction.java new file mode 100644 index 00000000000..9874412fb39 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/EnableVolumeCacheAction.java @@ -0,0 +1,104 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class EnableVolumeCacheAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.EnableVolumeCacheResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String volumeUuid; + + @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String poolUuid; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.EnableVolumeCacheResult value = res.getResult(org.zstack.sdk.EnableVolumeCacheResult.class); + ret.value = value == null ? new org.zstack.sdk.EnableVolumeCacheResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "PUT"; + info.path = "/volumes/{volumeUuid}/local-volume-cache/actions"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "enableVolumeCache"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/EnableVolumeCacheResult.java b/sdk/src/main/java/org/zstack/sdk/EnableVolumeCacheResult.java new file mode 100644 index 00000000000..855e7901cb2 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/EnableVolumeCacheResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCacheInventory; + +public class EnableVolumeCacheResult { + public VmLocalVolumeCacheInventory inventory; + public void setInventory(VmLocalVolumeCacheInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCacheInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/ExtendVmLocalVolumeCachePoolAction.java b/sdk/src/main/java/org/zstack/sdk/ExtendVmLocalVolumeCachePoolAction.java new file mode 100644 index 00000000000..4dbcb0b5a22 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/ExtendVmLocalVolumeCachePoolAction.java @@ -0,0 +1,107 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class ExtendVmLocalVolumeCachePoolAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.ExtendVmLocalVolumeCachePoolResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String uuid; + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String hostUuid; + + @Param(required = true, nonempty = true, nullElements = false, emptyString = true, noTrim = false) + public java.util.List pvs; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.ExtendVmLocalVolumeCachePoolResult value = res.getResult(org.zstack.sdk.ExtendVmLocalVolumeCachePoolResult.class); + ret.value = value == null ? new org.zstack.sdk.ExtendVmLocalVolumeCachePoolResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "PUT"; + info.path = "/hosts/{hostUuid}/local-volume-cache-pools/{uuid}/actions"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "extendVmLocalVolumeCachePool"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/ExtendVmLocalVolumeCachePoolResult.java b/sdk/src/main/java/org/zstack/sdk/ExtendVmLocalVolumeCachePoolResult.java new file mode 100644 index 00000000000..6812129c6d7 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/ExtendVmLocalVolumeCachePoolResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCachePoolInventory; + +public class ExtendVmLocalVolumeCachePoolResult { + public VmLocalVolumeCachePoolInventory inventory; + public void setInventory(VmLocalVolumeCachePoolInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCachePoolInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/GetBlockDevicesAction.java b/sdk/src/main/java/org/zstack/sdk/GetBlockDevicesAction.java new file mode 100644 index 00000000000..04a46543803 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/GetBlockDevicesAction.java @@ -0,0 +1,101 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class GetBlockDevicesAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.GetBlockDevicesResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = true, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String uuid; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.GetBlockDevicesResult value = res.getResult(org.zstack.sdk.GetBlockDevicesResult.class); + ret.value = value == null ? new org.zstack.sdk.GetBlockDevicesResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "GET"; + info.path = "/hosts/{uuid}/block-devices"; + info.needSession = true; + info.needPoll = true; + info.parameterName = ""; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/GetBlockDevicesResult.java b/sdk/src/main/java/org/zstack/sdk/GetBlockDevicesResult.java new file mode 100644 index 00000000000..2a0a7c3d6f0 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/GetBlockDevicesResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + + + +public class GetBlockDevicesResult { + public java.util.List blockDevices; + public void setBlockDevices(java.util.List blockDevices) { + this.blockDevices = blockDevices; + } + public java.util.List getBlockDevices() { + return this.blockDevices; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/GetMdevDeviceCandidatesAction.java b/sdk/src/main/java/org/zstack/sdk/GetMdevDeviceCandidatesAction.java index 2d83911f657..512a7682c84 100644 --- a/sdk/src/main/java/org/zstack/sdk/GetMdevDeviceCandidatesAction.java +++ b/sdk/src/main/java/org/zstack/sdk/GetMdevDeviceCandidatesAction.java @@ -37,9 +37,6 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.util.List types; - @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.Integer minAvailableDevicesPerHost; - @Param(required = false) public java.util.List systemTags; diff --git a/sdk/src/main/java/org/zstack/sdk/GpuAllocateStatus.java b/sdk/src/main/java/org/zstack/sdk/GpuAllocateStatus.java index c5340b8b24b..8ee453e7f55 100644 --- a/sdk/src/main/java/org/zstack/sdk/GpuAllocateStatus.java +++ b/sdk/src/main/java/org/zstack/sdk/GpuAllocateStatus.java @@ -3,5 +3,4 @@ public enum GpuAllocateStatus { Unallocated, Allocated, - Unallocatable, } diff --git a/sdk/src/main/java/org/zstack/sdk/GpuDeviceSpecInventory.java b/sdk/src/main/java/org/zstack/sdk/GpuDeviceSpecInventory.java index 55dca3a4d9d..e043f206e5b 100644 --- a/sdk/src/main/java/org/zstack/sdk/GpuDeviceSpecInventory.java +++ b/sdk/src/main/java/org/zstack/sdk/GpuDeviceSpecInventory.java @@ -28,12 +28,4 @@ public java.lang.Boolean getIsolated() { return this.isolated; } - public java.lang.String allocatorStrategy; - public void setAllocatorStrategy(java.lang.String allocatorStrategy) { - this.allocatorStrategy = allocatorStrategy; - } - public java.lang.String getAllocatorStrategy() { - return this.allocatorStrategy; - } - } diff --git a/sdk/src/main/java/org/zstack/sdk/HostBlockDeviceStruct.java b/sdk/src/main/java/org/zstack/sdk/HostBlockDeviceStruct.java new file mode 100644 index 00000000000..ee6bee169bb --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/HostBlockDeviceStruct.java @@ -0,0 +1,103 @@ +package org.zstack.sdk; + + + +public class HostBlockDeviceStruct { + + public java.lang.String wwid; + public void setWwid(java.lang.String wwid) { + this.wwid = wwid; + } + public java.lang.String getWwid() { + return this.wwid; + } + + public java.lang.String vendor; + public void setVendor(java.lang.String vendor) { + this.vendor = vendor; + } + public java.lang.String getVendor() { + return this.vendor; + } + + public java.lang.String model; + public void setModel(java.lang.String model) { + this.model = model; + } + public java.lang.String getModel() { + return this.model; + } + + public java.lang.String wwn; + public void setWwn(java.lang.String wwn) { + this.wwn = wwn; + } + public java.lang.String getWwn() { + return this.wwn; + } + + public java.lang.String serial; + public void setSerial(java.lang.String serial) { + this.serial = serial; + } + public java.lang.String getSerial() { + return this.serial; + } + + public java.lang.String hctl; + public void setHctl(java.lang.String hctl) { + this.hctl = hctl; + } + public java.lang.String getHctl() { + return this.hctl; + } + + public java.lang.String type; + public void setType(java.lang.String type) { + this.type = type; + } + public java.lang.String getType() { + return this.type; + } + + public java.lang.String path; + public void setPath(java.lang.String path) { + this.path = path; + } + public java.lang.String getPath() { + return this.path; + } + + public java.lang.Long size; + public void setSize(java.lang.Long size) { + this.size = size; + } + public java.lang.Long getSize() { + return this.size; + } + + public java.lang.String source; + public void setSource(java.lang.String source) { + this.source = source; + } + public java.lang.String getSource() { + return this.source; + } + + public java.lang.String transport; + public void setTransport(java.lang.String transport) { + this.transport = transport; + } + public java.lang.String getTransport() { + return this.transport; + } + + public java.lang.String targetIdentifier; + public void setTargetIdentifier(java.lang.String targetIdentifier) { + this.targetIdentifier = targetIdentifier; + } + public java.lang.String getTargetIdentifier() { + return this.targetIdentifier; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/MatchModelServiceTemplateWithModelAction.java b/sdk/src/main/java/org/zstack/sdk/MatchModelServiceTemplateWithModelAction.java index 7c0eca70894..6214024011c 100644 --- a/sdk/src/main/java/org/zstack/sdk/MatchModelServiceTemplateWithModelAction.java +++ b/sdk/src/main/java/org/zstack/sdk/MatchModelServiceTemplateWithModelAction.java @@ -100,9 +100,6 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.Long rootDiskSize; - @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.String projectUuid; - @Param(required = false) public java.lang.String resourceUuid; diff --git a/sdk/src/main/java/org/zstack/sdk/MdevDeviceSpecInventory.java b/sdk/src/main/java/org/zstack/sdk/MdevDeviceSpecInventory.java index 4bb5364a115..c3b2fc5b0ea 100644 --- a/sdk/src/main/java/org/zstack/sdk/MdevDeviceSpecInventory.java +++ b/sdk/src/main/java/org/zstack/sdk/MdevDeviceSpecInventory.java @@ -61,14 +61,6 @@ public java.lang.String getVendor() { return this.vendor; } - public java.lang.String allocatorStrategy; - public void setAllocatorStrategy(java.lang.String allocatorStrategy) { - this.allocatorStrategy = allocatorStrategy; - } - public java.lang.String getAllocatorStrategy() { - return this.allocatorStrategy; - } - public java.sql.Timestamp createDate; public void setCreateDate(java.sql.Timestamp createDate) { this.createDate = createDate; diff --git a/sdk/src/main/java/org/zstack/sdk/ModelService.java b/sdk/src/main/java/org/zstack/sdk/ModelService.java index 32cb11e9495..cc765e67495 100644 --- a/sdk/src/main/java/org/zstack/sdk/ModelService.java +++ b/sdk/src/main/java/org/zstack/sdk/ModelService.java @@ -204,14 +204,6 @@ public java.lang.Long getRootDiskSize() { return this.rootDiskSize; } - public java.lang.String projectUuid; - public void setProjectUuid(java.lang.String projectUuid) { - this.projectUuid = projectUuid; - } - public java.lang.String getProjectUuid() { - return this.projectUuid; - } - public SessionInventory session; public void setSession(SessionInventory session) { this.session = session; diff --git a/sdk/src/main/java/org/zstack/sdk/ModelServiceInventory.java b/sdk/src/main/java/org/zstack/sdk/ModelServiceInventory.java index 6d016f83c48..3b0d6495722 100644 --- a/sdk/src/main/java/org/zstack/sdk/ModelServiceInventory.java +++ b/sdk/src/main/java/org/zstack/sdk/ModelServiceInventory.java @@ -140,14 +140,6 @@ public java.lang.String getCondaVersion() { return this.condaVersion; } - public java.lang.String version; - public void setVersion(java.lang.String version) { - this.version = version; - } - public java.lang.String getVersion() { - return this.version; - } - public java.lang.String startCommand; public void setStartCommand(java.lang.String startCommand) { this.startCommand = startCommand; diff --git a/sdk/src/main/java/org/zstack/sdk/QueryVmLocalVolumeCachePoolAction.java b/sdk/src/main/java/org/zstack/sdk/QueryVmLocalVolumeCachePoolAction.java new file mode 100644 index 00000000000..0973b4128f2 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/QueryVmLocalVolumeCachePoolAction.java @@ -0,0 +1,75 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class QueryVmLocalVolumeCachePoolAction extends QueryAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.QueryVmLocalVolumeCachePoolResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.QueryVmLocalVolumeCachePoolResult value = res.getResult(org.zstack.sdk.QueryVmLocalVolumeCachePoolResult.class); + ret.value = value == null ? new org.zstack.sdk.QueryVmLocalVolumeCachePoolResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "GET"; + info.path = "/hosts/local-volume-cache-pools"; + info.needSession = true; + info.needPoll = false; + info.parameterName = ""; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/QueryVmLocalVolumeCachePoolResult.java b/sdk/src/main/java/org/zstack/sdk/QueryVmLocalVolumeCachePoolResult.java new file mode 100644 index 00000000000..1bbeb747635 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/QueryVmLocalVolumeCachePoolResult.java @@ -0,0 +1,22 @@ +package org.zstack.sdk; + + + +public class QueryVmLocalVolumeCachePoolResult { + public java.util.List inventories; + public void setInventories(java.util.List inventories) { + this.inventories = inventories; + } + public java.util.List getInventories() { + return this.inventories; + } + + public java.lang.Long total; + public void setTotal(java.lang.Long total) { + this.total = total; + } + public java.lang.Long getTotal() { + return this.total; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/ReconnectVmLocalVolumeCachePoolAction.java b/sdk/src/main/java/org/zstack/sdk/ReconnectVmLocalVolumeCachePoolAction.java new file mode 100644 index 00000000000..8e559b77031 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/ReconnectVmLocalVolumeCachePoolAction.java @@ -0,0 +1,104 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class ReconnectVmLocalVolumeCachePoolAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.ReconnectVmLocalVolumeCachePoolResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String uuid; + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String hostUuid; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.ReconnectVmLocalVolumeCachePoolResult value = res.getResult(org.zstack.sdk.ReconnectVmLocalVolumeCachePoolResult.class); + ret.value = value == null ? new org.zstack.sdk.ReconnectVmLocalVolumeCachePoolResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "PUT"; + info.path = "/hosts/{hostUuid}/local-volume-cache-pools/{uuid}/actions"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "reconnectVmLocalVolumeCachePool"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/ReconnectVmLocalVolumeCachePoolResult.java b/sdk/src/main/java/org/zstack/sdk/ReconnectVmLocalVolumeCachePoolResult.java new file mode 100644 index 00000000000..4bf7ed7fb4c --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/ReconnectVmLocalVolumeCachePoolResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCachePoolInventory; + +public class ReconnectVmLocalVolumeCachePoolResult { + public VmLocalVolumeCachePoolInventory inventory; + public void setInventory(VmLocalVolumeCachePoolInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCachePoolInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/SyncVmLocalVolumeCachePoolCapacityAction.java b/sdk/src/main/java/org/zstack/sdk/SyncVmLocalVolumeCachePoolCapacityAction.java new file mode 100644 index 00000000000..f040ecef8fb --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/SyncVmLocalVolumeCachePoolCapacityAction.java @@ -0,0 +1,104 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class SyncVmLocalVolumeCachePoolCapacityAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.SyncVmLocalVolumeCachePoolCapacityResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String uuid; + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String hostUuid; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.SyncVmLocalVolumeCachePoolCapacityResult value = res.getResult(org.zstack.sdk.SyncVmLocalVolumeCachePoolCapacityResult.class); + ret.value = value == null ? new org.zstack.sdk.SyncVmLocalVolumeCachePoolCapacityResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "PUT"; + info.path = "/hosts/{hostUuid}/local-volume-cache-pools/{uuid}/actions"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "syncVmLocalVolumeCachePoolCapacity"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/SyncVmLocalVolumeCachePoolCapacityResult.java b/sdk/src/main/java/org/zstack/sdk/SyncVmLocalVolumeCachePoolCapacityResult.java new file mode 100644 index 00000000000..4a0e7560833 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/SyncVmLocalVolumeCachePoolCapacityResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCachePoolInventory; + +public class SyncVmLocalVolumeCachePoolCapacityResult { + public VmLocalVolumeCachePoolInventory inventory; + public void setInventory(VmLocalVolumeCachePoolInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCachePoolInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/UpdateMdevDeviceSpecAction.java b/sdk/src/main/java/org/zstack/sdk/UpdateMdevDeviceSpecAction.java index 4e1dea256ec..15a6539ef83 100644 --- a/sdk/src/main/java/org/zstack/sdk/UpdateMdevDeviceSpecAction.java +++ b/sdk/src/main/java/org/zstack/sdk/UpdateMdevDeviceSpecAction.java @@ -37,9 +37,6 @@ public Result throwExceptionIfError() { @Param(required = false, validValues = {"Enabled","Disabled"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.String state; - @Param(required = false, validValues = {"Dispersed","Compact","FollowGlobal","NotSet"}, maxLength = 32, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.String allocatorStrategy; - @Param(required = false) public java.util.List systemTags; diff --git a/sdk/src/main/java/org/zstack/sdk/UpdateModelServiceInstanceGroupAction.java b/sdk/src/main/java/org/zstack/sdk/UpdateModelServiceInstanceGroupAction.java index 50aebded739..6e64701e11a 100644 --- a/sdk/src/main/java/org/zstack/sdk/UpdateModelServiceInstanceGroupAction.java +++ b/sdk/src/main/java/org/zstack/sdk/UpdateModelServiceInstanceGroupAction.java @@ -49,9 +49,6 @@ public Result throwExceptionIfError() { @Param(required = false, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.Integer serviceBootupTime; - @Param(required = false, maxLength = 255, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.String packageVersion; - @Param(required = false) public java.util.List systemTags; diff --git a/sdk/src/main/java/org/zstack/sdk/UpdatePciDeviceSpecAction.java b/sdk/src/main/java/org/zstack/sdk/UpdatePciDeviceSpecAction.java index e81e2fb7db6..e64f87dede8 100644 --- a/sdk/src/main/java/org/zstack/sdk/UpdatePciDeviceSpecAction.java +++ b/sdk/src/main/java/org/zstack/sdk/UpdatePciDeviceSpecAction.java @@ -46,9 +46,6 @@ public Result throwExceptionIfError() { @Param(required = false, validValues = {"Enabled","Disabled"}, nonempty = false, nullElements = false, emptyString = true, noTrim = false) public java.lang.String state; - @Param(required = false, validValues = {"Dispersed","Compact","FollowGlobal","NotSet"}, maxLength = 32, nonempty = false, nullElements = false, emptyString = true, noTrim = false) - public java.lang.String allocatorStrategy; - @Param(required = false) public java.util.List systemTags; diff --git a/sdk/src/main/java/org/zstack/sdk/UpdateVmLocalVolumeCachePoolAction.java b/sdk/src/main/java/org/zstack/sdk/UpdateVmLocalVolumeCachePoolAction.java new file mode 100644 index 00000000000..59bfc38e480 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/UpdateVmLocalVolumeCachePoolAction.java @@ -0,0 +1,110 @@ +package org.zstack.sdk; + +import java.util.HashMap; +import java.util.Map; +import org.zstack.sdk.*; + +public class UpdateVmLocalVolumeCachePoolAction extends AbstractAction { + + private static final HashMap parameterMap = new HashMap<>(); + + private static final HashMap nonAPIParameterMap = new HashMap<>(); + + public static class Result { + public ErrorCode error; + public org.zstack.sdk.UpdateVmLocalVolumeCachePoolResult value; + + public Result throwExceptionIfError() { + if (error != null) { + throw new ApiException( + String.format("error[code: %s, description: %s, details: %s, globalErrorCode: %s]", error.code, error.description, error.details, error.globalErrorCode) + ); + } + + return this; + } + } + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String uuid; + + @Param(required = true, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String hostUuid; + + @Param(required = false, maxLength = 255, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String name; + + @Param(required = false, maxLength = 2048, nonempty = false, nullElements = false, emptyString = true, noTrim = false) + public java.lang.String description; + + @Param(required = false) + public java.util.List systemTags; + + @Param(required = false) + public java.util.List userTags; + + @Param(required = false) + public String sessionId; + + @Param(required = false) + public String accessKeyId; + + @Param(required = false) + public String accessKeySecret; + + @Param(required = false) + public String requestIp; + + @NonAPIParam + public long timeout = -1; + + @NonAPIParam + public long pollingInterval = -1; + + + private Result makeResult(ApiResult res) { + Result ret = new Result(); + if (res.error != null) { + ret.error = res.error; + return ret; + } + + org.zstack.sdk.UpdateVmLocalVolumeCachePoolResult value = res.getResult(org.zstack.sdk.UpdateVmLocalVolumeCachePoolResult.class); + ret.value = value == null ? new org.zstack.sdk.UpdateVmLocalVolumeCachePoolResult() : value; + + return ret; + } + + public Result call() { + ApiResult res = ZSClient.call(this); + return makeResult(res); + } + + public void call(final Completion completion) { + ZSClient.call(this, new InternalCompletion() { + @Override + public void complete(ApiResult res) { + completion.complete(makeResult(res)); + } + }); + } + + protected Map getParameterMap() { + return parameterMap; + } + + protected Map getNonAPIParameterMap() { + return nonAPIParameterMap; + } + + protected RestInfo getRestInfo() { + RestInfo info = new RestInfo(); + info.httpMethod = "PUT"; + info.path = "/hosts/{hostUuid}/local-volume-cache-pools/{uuid}/actions"; + info.needSession = true; + info.needPoll = true; + info.parameterName = "updateVmLocalVolumeCachePool"; + return info; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/UpdateVmLocalVolumeCachePoolResult.java b/sdk/src/main/java/org/zstack/sdk/UpdateVmLocalVolumeCachePoolResult.java new file mode 100644 index 00000000000..e736da0650a --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/UpdateVmLocalVolumeCachePoolResult.java @@ -0,0 +1,14 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCachePoolInventory; + +public class UpdateVmLocalVolumeCachePoolResult { + public VmLocalVolumeCachePoolInventory inventory; + public void setInventory(VmLocalVolumeCachePoolInventory inventory) { + this.inventory = inventory; + } + public VmLocalVolumeCachePoolInventory getInventory() { + return this.inventory; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheInventory.java b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheInventory.java new file mode 100644 index 00000000000..cded043590a --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheInventory.java @@ -0,0 +1,72 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCacheMode; +import org.zstack.sdk.VmLocalVolumeCacheState; + +public class VmLocalVolumeCacheInventory { + + public java.lang.String uuid; + public void setUuid(java.lang.String uuid) { + this.uuid = uuid; + } + public java.lang.String getUuid() { + return this.uuid; + } + + public java.lang.String volumeUuid; + public void setVolumeUuid(java.lang.String volumeUuid) { + this.volumeUuid = volumeUuid; + } + public java.lang.String getVolumeUuid() { + return this.volumeUuid; + } + + public java.lang.String poolUuid; + public void setPoolUuid(java.lang.String poolUuid) { + this.poolUuid = poolUuid; + } + public java.lang.String getPoolUuid() { + return this.poolUuid; + } + + public java.lang.String installPath; + public void setInstallPath(java.lang.String installPath) { + this.installPath = installPath; + } + public java.lang.String getInstallPath() { + return this.installPath; + } + + public VmLocalVolumeCacheMode cacheMode; + public void setCacheMode(VmLocalVolumeCacheMode cacheMode) { + this.cacheMode = cacheMode; + } + public VmLocalVolumeCacheMode getCacheMode() { + return this.cacheMode; + } + + public VmLocalVolumeCacheState state; + public void setState(VmLocalVolumeCacheState state) { + this.state = state; + } + public VmLocalVolumeCacheState getState() { + return this.state; + } + + public java.sql.Timestamp createDate; + public void setCreateDate(java.sql.Timestamp createDate) { + this.createDate = createDate; + } + public java.sql.Timestamp getCreateDate() { + return this.createDate; + } + + public java.sql.Timestamp lastOpDate; + public void setLastOpDate(java.sql.Timestamp lastOpDate) { + this.lastOpDate = lastOpDate; + } + public java.sql.Timestamp getLastOpDate() { + return this.lastOpDate; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheMode.java b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheMode.java new file mode 100644 index 00000000000..d52c60dc1e5 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheMode.java @@ -0,0 +1,5 @@ +package org.zstack.sdk; + +public enum VmLocalVolumeCacheMode { + WriteBack, +} diff --git a/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolInventory.java b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolInventory.java new file mode 100644 index 00000000000..17d8852a30a --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolInventory.java @@ -0,0 +1,96 @@ +package org.zstack.sdk; + +import org.zstack.sdk.VmLocalVolumeCachePoolState; +import org.zstack.sdk.VmLocalVolumeCachePoolStatus; + +public class VmLocalVolumeCachePoolInventory { + + public java.lang.String uuid; + public void setUuid(java.lang.String uuid) { + this.uuid = uuid; + } + public java.lang.String getUuid() { + return this.uuid; + } + + public java.lang.String hostUuid; + public void setHostUuid(java.lang.String hostUuid) { + this.hostUuid = hostUuid; + } + public java.lang.String getHostUuid() { + return this.hostUuid; + } + + public java.lang.String name; + public void setName(java.lang.String name) { + this.name = name; + } + public java.lang.String getName() { + return this.name; + } + + public java.lang.String description; + public void setDescription(java.lang.String description) { + this.description = description; + } + public java.lang.String getDescription() { + return this.description; + } + + public java.util.LinkedHashMap metadata; + public void setMetadata(java.util.LinkedHashMap metadata) { + this.metadata = metadata; + } + public java.util.LinkedHashMap getMetadata() { + return this.metadata; + } + + public long totalCapacity; + public void setTotalCapacity(long totalCapacity) { + this.totalCapacity = totalCapacity; + } + public long getTotalCapacity() { + return this.totalCapacity; + } + + public long availableCapacity; + public void setAvailableCapacity(long availableCapacity) { + this.availableCapacity = availableCapacity; + } + public long getAvailableCapacity() { + return this.availableCapacity; + } + + public VmLocalVolumeCachePoolState state; + public void setState(VmLocalVolumeCachePoolState state) { + this.state = state; + } + public VmLocalVolumeCachePoolState getState() { + return this.state; + } + + public VmLocalVolumeCachePoolStatus status; + public void setStatus(VmLocalVolumeCachePoolStatus status) { + this.status = status; + } + public VmLocalVolumeCachePoolStatus getStatus() { + return this.status; + } + + public java.sql.Timestamp createDate; + public void setCreateDate(java.sql.Timestamp createDate) { + this.createDate = createDate; + } + public java.sql.Timestamp getCreateDate() { + return this.createDate; + } + + public java.sql.Timestamp lastOpDate; + public void setLastOpDate(java.sql.Timestamp lastOpDate) { + this.lastOpDate = lastOpDate; + } + public java.sql.Timestamp getLastOpDate() { + return this.lastOpDate; + } + +} diff --git a/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolState.java b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolState.java new file mode 100644 index 00000000000..0d21999167e --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolState.java @@ -0,0 +1,6 @@ +package org.zstack.sdk; + +public enum VmLocalVolumeCachePoolState { + Enabled, + Disabled, +} diff --git a/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolStatus.java b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolStatus.java new file mode 100644 index 00000000000..e0b5b46e695 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCachePoolStatus.java @@ -0,0 +1,7 @@ +package org.zstack.sdk; + +public enum VmLocalVolumeCachePoolStatus { + Connecting, + Connected, + Disconnected, +} diff --git a/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheState.java b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheState.java new file mode 100644 index 00000000000..540e0ca3358 --- /dev/null +++ b/sdk/src/main/java/org/zstack/sdk/VmLocalVolumeCacheState.java @@ -0,0 +1,7 @@ +package org.zstack.sdk; + +public enum VmLocalVolumeCacheState { + None, + Uninstantiated, + Instantiated, +} diff --git a/sdk/src/main/java/org/zstack/sdk/VolumeBackupInventory.java b/sdk/src/main/java/org/zstack/sdk/VolumeBackupInventory.java index 6f78f89e30f..6969f53176b 100644 --- a/sdk/src/main/java/org/zstack/sdk/VolumeBackupInventory.java +++ b/sdk/src/main/java/org/zstack/sdk/VolumeBackupInventory.java @@ -68,14 +68,6 @@ public java.lang.Long getSize() { return this.size; } - public java.lang.String hypervisorType; - public void setHypervisorType(java.lang.String hypervisorType) { - this.hypervisorType = hypervisorType; - } - public java.lang.String getHypervisorType() { - return this.hypervisorType; - } - public java.lang.String metadata; public void setMetadata(java.lang.String metadata) { this.metadata = metadata; diff --git a/sdk/src/main/java/org/zstack/sdk/VolumeTO.java b/sdk/src/main/java/org/zstack/sdk/VolumeTO.java index 84eb1d8518f..adaa44f8fe7 100644 --- a/sdk/src/main/java/org/zstack/sdk/VolumeTO.java +++ b/sdk/src/main/java/org/zstack/sdk/VolumeTO.java @@ -1,6 +1,6 @@ package org.zstack.sdk; - +import org.zstack.sdk.CacheTO; public class VolumeTO extends org.zstack.sdk.BaseVirtualDeviceTO { @@ -12,6 +12,14 @@ public java.lang.String getInstallPath() { return this.installPath; } + public java.lang.Long size; + public void setSize(java.lang.Long size) { + this.size = size; + } + public java.lang.Long getSize() { + return this.size; + } + public int deviceId; public void setDeviceId(int deviceId) { this.deviceId = deviceId; @@ -156,4 +164,12 @@ public int getControllerIndex() { return this.controllerIndex; } + public CacheTO cache; + public void setCache(CacheTO cache) { + this.cache = cache; + } + public CacheTO getCache() { + return this.cache; + } + } diff --git a/storage/src/main/java/org/zstack/storage/volume/VolumeApiInterceptor.java b/storage/src/main/java/org/zstack/storage/volume/VolumeApiInterceptor.java index d1485039388..8001dcd0613 100755 --- a/storage/src/main/java/org/zstack/storage/volume/VolumeApiInterceptor.java +++ b/storage/src/main/java/org/zstack/storage/volume/VolumeApiInterceptor.java @@ -78,7 +78,6 @@ import org.zstack.header.volume.VolumeType; import org.zstack.header.volume.VolumeVO; import org.zstack.header.volume.VolumeVO_; - import javax.persistence.Tuple; import java.util.ArrayList; import java.util.Arrays; diff --git a/utils/src/main/java/org/zstack/utils/clouderrorcode/CloudOperationsErrorCode.java b/utils/src/main/java/org/zstack/utils/clouderrorcode/CloudOperationsErrorCode.java index a0f09d4f1e9..eb28b525d24 100644 --- a/utils/src/main/java/org/zstack/utils/clouderrorcode/CloudOperationsErrorCode.java +++ b/utils/src/main/java/org/zstack/utils/clouderrorcode/CloudOperationsErrorCode.java @@ -15871,4 +15871,52 @@ public class CloudOperationsErrorCode { public static final String ORG_ZSTACK_CRYPTO_SECURITYMACHINE_THIRDPARTY_PLUGIN_10005 = "ORG_ZSTACK_CRYPTO_SECURITYMACHINE_THIRDPARTY_PLUGIN_10005"; public static final String ORG_ZSTACK_CRYPTO_SECURITYMACHINE_THIRDPARTY_PLUGIN_10006 = "ORG_ZSTACK_CRYPTO_SECURITYMACHINE_THIRDPARTY_PLUGIN_10006"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10001 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10001"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10002 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10002"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10003 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10003"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10004 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10004"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10005 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10005"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10006 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10006"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10007 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10007"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10008 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10008"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10009 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10009"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10010 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10010"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10011 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10011"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10012 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10012"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10013 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10013"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10014 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10014"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10015 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10015"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10016 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10016"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10017 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10017"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10018 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10018"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10019 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10019"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10020 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10020"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10021 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10021"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10022 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10022"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10023 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10023"; + + public static final String ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10024 = "ORG_ZSTACK_STORAGE_LOCALVOLUMECACHE_10024"; }