// TODO asynch event handler - design infra code to allow async events in segregated thread
public void onMomPolicyChange(@Observes @MomPolicyUpdate final VDSGroup cluster) {
if (cluster == null || cluster.getCompatibilityVersion().compareTo(Version.v3_4) < 0) return;
List<VDS> activeHostsInCluster =
vdsDao.getAllForVdsGroupWithStatus(cluster.getId(), VDSStatus.Up);
// collect all Active hosts into a callable list
List<Callable<Object>> callables = new LinkedList<>();
for (final VDS vds : activeHostsInCluster) {
callables.add(
new Callable<Object>() {
@Override
public Object call() {
try {
resourceManagerProvider
.get()
.runVdsCommand(
VDSCommandType.SetMOMPolicyParameters,
new MomPolicyVDSParameters(
vds,
cluster.isEnableBallooning(),
cluster.isEnableKsm(),
cluster.isKsmMergeAcrossNumaNodes()));
} catch (EngineException e) {
log.error("Could not update MoM policy on host '{}'", vds.getName());
}
return null;
}
});
}
// run all VDSCommands concurrently with executor
if (callables.size() > 0) ThreadPoolUtil.invokeAll(callables);
}
protected boolean validate() {
VM vm = parentCommand.getVm();
if (vm == null) {
parentCommand.addCanDoActionMessage(EngineMessage.ACTION_TYPE_FAILED_VM_NOT_FOUND);
return false;
} else {
targetCluster = DbFacade.getInstance().getVdsGroupDao().get(targetClusterId);
if (targetCluster == null) {
parentCommand.addCanDoActionMessage(EngineMessage.VM_CLUSTER_IS_NOT_VALID);
return false;
}
// Check that the target cluster is in the same data center.
if (!targetCluster.getStoragePoolId().equals(vm.getStoragePoolId())) {
parentCommand.addCanDoActionMessage(
EngineMessage.VM_CANNOT_MOVE_TO_CLUSTER_IN_OTHER_STORAGE_POOL);
return false;
}
List<VmNic> interfaces = DbFacade.getInstance().getVmNicDao().getAllForVm(vm.getId());
Version clusterCompatibilityVersion = targetCluster.getCompatibilityVersion();
if (!validateDestinationClusterContainsNetworks(interfaces)
|| !validateNics(interfaces, clusterCompatibilityVersion)) {
return false;
}
// Check if VM static parameters are compatible for new cluster.
boolean isCpuSocketsValid =
AddVmCommand.checkCpuSockets(
vm.getStaticData().getNumOfSockets(),
vm.getStaticData().getCpuPerSocket(),
vm.getStaticData().getThreadsPerCpu(),
clusterCompatibilityVersion.getValue(),
parentCommand.getReturnValue().getCanDoActionMessages());
if (!isCpuSocketsValid) {
return false;
}
// Check that the USB policy is legal
if (!VmHandler.isUsbPolicyLegal(
vm.getUsbPolicy(),
vm.getOs(),
targetCluster,
parentCommand.getReturnValue().getCanDoActionMessages())) {
return false;
}
// Check if the display type is supported
if (!VmHandler.isGraphicsAndDisplaySupported(
vm.getOs(),
VmDeviceUtils.getGraphicsTypesOfEntity(vm.getId()),
vm.getDefaultDisplayType(),
parentCommand.getReturnValue().getCanDoActionMessages(),
clusterCompatibilityVersion)) {
return false;
}
if (VmDeviceUtils.hasVirtioScsiController(vm.getId())) {
// Verify cluster compatibility
if (!FeatureSupported.virtIoScsi(targetCluster.getCompatibilityVersion())) {
return parentCommand.failCanDoAction(
EngineMessage.VIRTIO_SCSI_INTERFACE_IS_NOT_AVAILABLE_FOR_CLUSTER_LEVEL);
}
// Verify OS compatibility
if (!VmHandler.isOsTypeSupportedForVirtioScsi(
vm.getOs(),
targetCluster.getCompatibilityVersion(),
parentCommand.getReturnValue().getCanDoActionMessages())) {
return false;
}
}
// A existing VM cannot be changed into a cluster without a defined architecture
if (targetCluster.getArchitecture() == ArchitectureType.undefined) {
return parentCommand.failCanDoAction(
EngineMessage.ACTION_TYPE_FAILED_CLUSTER_UNDEFINED_ARCHITECTURE);
} else if (targetCluster.getArchitecture() != vm.getClusterArch()) {
return parentCommand.failCanDoAction(
EngineMessage.ACTION_TYPE_FAILED_VM_CLUSTER_DIFFERENT_ARCHITECTURES);
}
}
return true;
}