private void updateDatacenters() {
boolean isInVm = getVm() != null;
getDataCenter().setIsAvailable(!isInVm);
setMessage(""); // $NON-NLS-1$
if (isInVm) {
AsyncDataProvider.getInstance()
.getDataCenterById(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object target, Object returnValue) {
AbstractDiskModel diskModel = (AbstractDiskModel) target;
StoragePool dataCenter = (StoragePool) returnValue;
ArrayList<StoragePool> dataCenters = new ArrayList<>();
if (isDatacenterAvailable(dataCenter)) {
dataCenters.add(dataCenter);
}
diskModel
.getDataCenter()
.setItems(dataCenters, Linq.firstOrNull(dataCenters));
if (dataCenters.isEmpty()) {
diskModel.setMessage(constants.relevantDCnotActive());
}
}
}),
getVm().getStoragePoolId());
updateBootableDiskAvailable();
} else {
AsyncDataProvider.getInstance()
.getDataCenterList(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object target, Object returnValue) {
AbstractDiskModel diskModel = (AbstractDiskModel) target;
ArrayList<StoragePool> dataCenters = (ArrayList<StoragePool>) returnValue;
ArrayList<StoragePool> filteredDataCenters = new ArrayList<>();
for (StoragePool dataCenter : dataCenters) {
if (isDatacenterAvailable(dataCenter)) {
filteredDataCenters.add(dataCenter);
}
}
diskModel.getDataCenter().setItems(filteredDataCenters);
if (filteredDataCenters.isEmpty()) {
diskModel.setMessage(constants.noActiveDataCenters());
}
}
}));
}
}
protected void doLoadAttachableDisks(
GetDisksCallback imageCallback,
GetDisksCallback lunCallback,
GetDisksCallback cinderCallback) {
AsyncDataProvider.getInstance()
.getAllAttachableDisks(
new AsyncQuery(this, imageCallback), getVm().getStoragePoolId(), getVm().getId());
AsyncDataProvider.getInstance()
.getAllAttachableDisks(new AsyncQuery(this, lunCallback), null, getVm().getId());
AsyncDataProvider.getInstance()
.getAllAttachableDisks(
new AsyncQuery(this, cinderCallback), getVm().getStoragePoolId(), getVm().getId());
}
private void fetchDcClusters(final Guid dcId, final Network network, final boolean publicUse) {
if (dcClusters.containsKey(dcId)) {
attachNetworkToClusters(network, dcClusters.get(dcId), publicUse);
} else {
AsyncDataProvider.getClusterList(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object model, Object returnValue) {
Collection<VDSGroup> clusters =
Linq.where(
(Collection<VDSGroup>) returnValue,
new IPredicate<VDSGroup>() {
@Override
public boolean match(VDSGroup source) {
return (Boolean)
AsyncDataProvider.getConfigValuePreConverted(
ConfigurationValues.SupportCustomDeviceProperties,
source.getcompatibility_version().getValue());
}
});
dcClusters.put(dcId, clusters);
attachNetworkToClusters(network, clusters, publicUse);
}
}),
dcId);
}
}
private void Edit() {
if (getWindow() != null) {
return;
}
VmInterfaceModel model = new VmInterfaceModel();
setWindow(model);
model.setTitle("Edit Network Interface");
AsyncDataProvider.GetClusterNetworkList(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void OnSuccess(Object target, Object returnValue) {
TemplateInterfaceListModel vmInterfaceListModel =
(TemplateInterfaceListModel) target;
java.util.ArrayList<network> network_list =
returnValue != null
? (java.util.ArrayList<network>) returnValue
: new java.util.ArrayList<network>();
vmInterfaceListModel.PostGetClusterNetworkList_Edit(network_list);
}
}),
getEntityStronglyTyped().getvds_group_id());
}
// Create a list of ActionGroups associated with the user by retrieving each role's ActionGroups
// (and proceed to Step4).
// Use only as 'Step3' of 'UpdateIsENGINEUser'
public void UpdateUserActionGroups(Object targetObject, java.util.ArrayList<Guid> roleIdList) {
for (Guid roleID : roleIdList) {
AsyncDataProvider.GetRoleActionGroupsByRoleId(
new AsyncQuery(
targetObject,
new INewAsyncCallback() {
@Override
public void OnSuccess(Object target, Object returnValue) {
UserPortalLoginModel loginModel = (UserPortalLoginModel) target;
java.util.ArrayList<ActionGroup> roleActionGroupList =
(java.util.ArrayList<ActionGroup>) returnValue;
for (ActionGroup actionGroup : roleActionGroupList) {
if (!loginModel.getLoggedUserActionGroupList().contains(actionGroup)) {
loginModel.getLoggedUserActionGroupList().add(actionGroup);
}
}
loginModel.setRolesCounter(loginModel.getRolesCounter() - 1);
if (loginModel.getRolesCounter() == 0) {
CheckIsENGINEUser(loginModel);
}
}
}),
roleID);
}
}
public TimeZoneType getTimeZoneType() {
// can be null as a consequence of setItems on ListModel
Integer vmOsType = getModel().getOSType().getSelectedItem();
return AsyncDataProvider.getInstance().isWindowsOsType(vmOsType)
? TimeZoneType.WINDOWS_TIMEZONE
: TimeZoneType.GENERAL_TIMEZONE;
}
public void Manage() {
if (getWindow() != null) {
return;
}
Guid storagePoolId =
(getEntity().getstorage_pool_id() != null)
? getEntity().getstorage_pool_id().getValue()
: Guid.Empty;
AsyncQuery _asyncQuery = new AsyncQuery();
_asyncQuery.setModel(this);
_asyncQuery.asyncCallback =
new INewAsyncCallback() {
public void OnSuccess(Object model, Object result) {
ClusterNetworkListModel clusterNetworkListModel = (ClusterNetworkListModel) model;
java.util.ArrayList<network> networkList = (java.util.ArrayList<network>) result;
ListModel listModel = new ListModel();
clusterNetworkListModel.setWindow(listModel);
listModel.setTitle("Assign/Detach Networks");
listModel.setHashName("assign_networks");
clusterNetworkListModel.PostManage(networkList, listModel);
}
};
AsyncDataProvider.GetNetworkList(_asyncQuery, storagePoolId);
}
void updateHost() {
if (getDataCenter().getItems() == null) {
return;
}
if (getCurrentStorageItem() == null) {
return;
}
StoragePool dataCenter = getDataCenter().getSelectedItem();
boolean localFsOnly = getCurrentStorageItem() instanceof LocalStorageModel;
Guid dataCenterId = dataCenter == null ? null : dataCenter.getId();
AsyncDataProvider.getInstance()
.getHostsForStorageOperation(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object model, Object returnValue) {
StorageModel storageModel = (StorageModel) model;
Collection<VDS> hosts = (Collection<VDS>) returnValue;
storageModel.postUpdateHost(hosts);
}
}),
dataCenterId,
localFsOnly);
}
public StorageModel(StorageModelBehavior behavior) {
this.behavior = behavior;
this.behavior.setModel(this);
setName(new EntityModel<String>());
setDescription(new EntityModel<String>());
setComment(new EntityModel<String>());
setDataCenterAlert(new EntityModel<String>());
setDataCenter(new ListModel<StoragePool>());
getDataCenter().getSelectedItemChangedEvent().addListener(this);
setHost(new ListModel<VDS>());
getHost().getSelectedItemChangedEvent().addListener(this);
setFormat(new ListModel<StorageFormatType>());
setAvailableStorageTypeItems(new ListModel<StorageType>());
getAvailableStorageTypeItems().getSelectedItemChangedEvent().addListener(this);
getAvailableStorageTypeItems().getItemsChangedEvent().addListener(this);
setAvailableStorageDomainTypeItems(new ListModel<StorageDomainType>());
getAvailableStorageDomainTypeItems().getSelectedItemChangedEvent().addListener(this);
setWarningLowSpaceIndicator(new EntityModel<Integer>());
getWarningLowSpaceIndicator().setEntity(getWarningLowSpaceIndicatorValue());
setWarningLowSpaceSize(new EntityModel<String>());
getWarningLowSpaceSize().setIsAvailable(false);
setCriticalSpaceActionBlocker(new EntityModel<Integer>());
getCriticalSpaceActionBlocker().setEntity(getCriticalSpaceThresholdValue());
setActivateDomain(new EntityModel<Boolean>(true));
getActivateDomain().setIsAvailable(false);
setWipeAfterDelete(new EntityModel<>(false));
localFSPath =
(String)
AsyncDataProvider.getInstance()
.getConfigValuePreConverted(ConfigurationValues.RhevhLocalFSPath);
}
protected void setupTemplate(Guid templateId, final boolean useLatest) {
AsyncDataProvider.getInstance()
.getTemplateById(
new AsyncQuery(
getModel(),
new INewAsyncCallback() {
@Override
public void onSuccess(Object target, Object returnValue) {
UnitVmModel model = (UnitVmModel) target;
VmTemplate template = (VmTemplate) returnValue;
if (useLatest) {
template = createLatestTemplate(template);
}
setupBaseTemplate(template.getBaseTemplateId());
model.getTemplate().setItems(Collections.singletonList(template));
model.getTemplate().setSelectedItem(template);
model.getTemplate().setIsChangable(false);
if (!template.getId().equals(Guid.Empty)) {
getModel().getVmInitModel().init(template);
}
}
},
getModel().getHash()),
templateId);
}
protected void updateDatacentersForVmwareProvider() {
AsyncDataProvider.getInstance()
.getDataCenterList(
new AsyncQuery(
new INewAsyncCallback() {
@Override
public void onSuccess(Object model, Object returnValue) {
final List<StoragePool> dataCenters = (List<StoragePool>) returnValue;
StoragePool prevDataCenter = getPreviousDataCenter(dataCenters);
Collections.sort(dataCenters, new NameableComparator());
dataCenters.add(0, null); // any data center
getDataCenter().setItems(dataCenters);
getDataCenter().setSelectedItem(prevDataCenter);
if (getDataCenter().getSelectedItem() == null) {
getVmwarePropertiesModel().disableProxyHost();
}
}
private StoragePool getPreviousDataCenter(List<StoragePool> dataCenters) {
Guid previousDataCenterId = getVmwarePropertiesModel().getLastStoragePoolId();
for (StoragePool dataCenter : dataCenters) {
if (dataCenter.getId().equals(previousDataCenterId)) {
return dataCenter;
}
}
return null;
}
}));
}
public void editConsoleKey(ICommandTarget target) {
setTitle(ConstantsManager.getInstance().getConstants().consolePublicKeyTitle());
setHashName("edit_public_key"); // $NON-NLS-1$
setHelpTag(HelpTag.edit_public_key);
getCommands().add(UICommand.createDefaultOkUiCommand("OnSetConsoleKey", target)); // $NON-NLS-1$
getCommands().add(UICommand.createCancelUiCommand("Cancel", target)); // $NON-NLS-1$
startProgress();
AsyncDataProvider.getInstance()
.getUserProfile(
new AsyncQuery(
target,
new INewAsyncCallback() {
@Override
public void onSuccess(Object target, Object returnValue) {
UserProfile profile = ((VdcQueryReturnValue) returnValue).getReturnValue();
if (profile != null) {
getTextInput().setEntity(profile.getSshPublicKey());
}
stopProgress();
}
}));
}
@Override
protected void onExportChanged() {
boolean externalNetwork = getExport().getEntity();
getExternalProviders().setIsChangeable(externalNetwork);
getIsVmNetwork()
.setIsChangeable(
!externalNetwork
&& isSupportBridgesReportByVDSM()
&& ApplicationModeHelper.isModeSupported(ApplicationMode.VirtOnly));
if (externalNetwork) {
getIsVmNetwork().setEntity(true);
}
Iterable<NetworkClusterModel> networkClusters = getNetworkClusterList().getItems();
if (networkClusters != null) {
for (NetworkClusterModel networkCluster : networkClusters) {
if (!(Boolean)
AsyncDataProvider.getInstance()
.getConfigValuePreConverted(
ConfigurationValues.SupportCustomDeviceProperties,
networkCluster.getEntity().getCompatibilityVersion().getValue())) {
networkCluster.setIsChangeable(!externalNetwork);
networkCluster.setAttached(!externalNetwork);
}
networkCluster.setRequired(!externalNetwork);
}
}
super.onExportChanged();
}
private boolean isPlugAvailableByDisks(boolean plug) {
ArrayList<Disk> disks =
getSelectedItems() != null ? Linq.<Disk>cast(getSelectedItems()) : new ArrayList<Disk>();
for (Disk disk : disks) {
boolean isLocked =
disk.getDiskStorageType() == DiskStorageType.IMAGE
&& ((DiskImage) disk).getImageStatus() == ImageStatus.LOCKED;
boolean isDiskHotpluggableInterface = false;
if (getEntity() != null) {
isDiskHotpluggableInterface =
AsyncDataProvider.getInstance()
.getDiskHotpluggableInterfaces(
getEntity().getOs(), getEntity().getVdsGroupCompatibilityVersion())
.contains(disk.getDiskInterface());
}
if (disk.getPlugged() == plug || isLocked || (!isDiskHotpluggableInterface && !isVmDown())) {
return false;
}
}
return true;
}
protected void updateCinderVolumeTypes() {
StorageDomain storageDomain = getStorageDomain().getSelectedItem();
if (storageDomain == null || storageDomain.getStorageType() != StorageType.CINDER) {
return;
}
AsyncDataProvider.getInstance()
.getCinderVolumeTypesList(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object target, Object returnValue) {
AbstractDiskModel diskModel = (AbstractDiskModel) target;
List<CinderVolumeType> cinderVolumeTypes =
(ArrayList<CinderVolumeType>) returnValue;
List<String> volumeTypesNames = new ArrayList<>();
for (CinderVolumeType cinderVolumeType : cinderVolumeTypes) {
volumeTypesNames.add(cinderVolumeType.getName());
}
diskModel.getCinderVolumeType().setItems(volumeTypesNames);
}
}),
storageDomain.getId());
}
public void New() {
if (getWindow() != null) {
return;
}
ClusterNetworkModel clusterModel = new ClusterNetworkModel();
setWindow(clusterModel);
clusterModel.setTitle("New Logical Network");
clusterModel.setHashName("new_logical_network");
clusterModel.setIsNew(true);
if (getEntity().getstorage_pool_id() != null) {
AsyncQuery _asyncQuery = new AsyncQuery();
_asyncQuery.setModel(clusterModel);
_asyncQuery.asyncCallback =
new INewAsyncCallback() {
public void OnSuccess(Object model, Object result) {
ClusterNetworkModel clusterNetworkModel = (ClusterNetworkModel) model;
storage_pool dataCenter = (storage_pool) result;
clusterNetworkModel.setDataCenterName(dataCenter.getname());
}
};
AsyncDataProvider.GetDataCenterById(_asyncQuery, getEntity().getstorage_pool_id().getValue());
}
UICommand tempVar = new UICommand("OnSave", this);
tempVar.setTitle("OK");
tempVar.setIsDefault(true);
clusterModel.getCommands().add(tempVar);
UICommand tempVar2 = new UICommand("Cancel", this);
tempVar2.setTitle("Cancel");
tempVar2.setIsCancel(true);
clusterModel.getCommands().add(tempVar2);
}
private void updateActionAvailability() {
VM entity = (VM) getItem().getEntity();
getItem().getTakeVmCommand().setIsAvailable(false);
ArrayList<VM> entities = new ArrayList<VM>();
entities.add(entity);
getItem()
.getRunCommand()
.setIsExecutionAllowed(VdcActionUtils.canExecute(entities, VM.class, VdcActionType.RunVm));
getItem()
.getPauseCommand()
.setIsExecutionAllowed(
VdcActionUtils.canExecute(entities, VM.class, VdcActionType.HibernateVm)
&& AsyncDataProvider.canVmsBePaused(entities));
getItem()
.getShutdownCommand()
.setIsExecutionAllowed(
VdcActionUtils.canExecute(entities, VM.class, VdcActionType.ShutdownVm));
getItem()
.getStopCommand()
.setIsExecutionAllowed(VdcActionUtils.canExecute(entities, VM.class, VdcActionType.StopVm));
getItem()
.getRebootCommand()
.setIsExecutionAllowed(AsyncDataProvider.isRebootCommandExecutionAllowed(entities));
// Check whether a VM is from the manual pool.
if (entity.getVmPoolId() != null) {
AsyncDataProvider.getPoolById(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object target, Object returnValue) {
VmItemBehavior behavior = (VmItemBehavior) target;
VmPool pool = (VmPool) returnValue;
boolean isManualPool = pool.getVmPoolType() == VmPoolType.Manual;
behavior.updateCommandsAccordingToPoolType(isManualPool);
}
}),
entity.getVmPoolId());
} else {
updateCommandsAccordingToPoolType(true);
}
}
private void addParameter() {
if (getWindow() != null) {
return;
}
GlusterVolumeEntity volume = getEntity();
if (volume == null) {
return;
}
VolumeParameterModel volumeParameterModel = new VolumeParameterModel();
volumeParameterModel.setTitle(ConstantsManager.getInstance().getConstants().addOptionVolume());
volumeParameterModel.setHelpTag(HelpTag.add_option);
volumeParameterModel.setHashName("add_option"); // $NON-NLS-1$
setWindow(volumeParameterModel);
volumeParameterModel.startProgress();
AsyncQuery _asyncQuery = new AsyncQuery();
_asyncQuery.setModel(this);
_asyncQuery.setHandleFailure(true);
_asyncQuery.asyncCallback =
new INewAsyncCallback() {
@Override
public void onSuccess(Object model, Object result) {
VolumeParameterListModel volumeParameterListModel = (VolumeParameterListModel) model;
VolumeParameterModel innerParameterModel = (VolumeParameterModel) getWindow();
ArrayList<GlusterVolumeOptionInfo> optionInfoList =
new ArrayList<GlusterVolumeOptionInfo>();
VdcQueryReturnValue returnValue = (VdcQueryReturnValue) result;
if (!returnValue.getSucceeded()) {
innerParameterModel.setMessage(
ConstantsManager.getInstance().getConstants().errorInFetchingVolumeOptionList());
} else {
optionInfoList =
new ArrayList<GlusterVolumeOptionInfo>(
(Set<GlusterVolumeOptionInfo>) returnValue.getReturnValue());
optionInfoList.add(getCifsVolumeOption());
}
innerParameterModel.getKeyList().setItems(optionInfoList);
innerParameterModel.stopProgress();
UICommand command =
UICommand.createDefaultOkUiCommand(
"OnSetParameter", volumeParameterListModel); // $NON-NLS-1$
innerParameterModel.getCommands().add(command);
innerParameterModel
.getCommands()
.add(
UICommand.createCancelUiCommand(
"OnCancel", volumeParameterListModel)); // $NON-NLS-1$
}
};
AsyncDataProvider.getInstance()
.getGlusterVolumeOptionInfoList(_asyncQuery, volume.getClusterId());
}
private int getCriticalSpaceThresholdValue() {
if (isNewStorage()) {
return (Integer)
AsyncDataProvider.getInstance()
.getConfigValuePreConverted(ConfigurationValues.CriticalSpaceActionBlocker);
}
return getStorage().getCriticalSpaceActionBlocker();
}
private int getWarningLowSpaceIndicatorValue() {
if (isNewStorage()) {
return (Integer)
AsyncDataProvider.getInstance()
.getConfigValuePreConverted(ConfigurationValues.WarningLowSpaceIndicator);
}
return getStorage().getWarningLowSpaceIndicator();
}
private boolean isRngDeviceSupported(UnitVmModel model) {
Version clusterVersion = clusterVersionOrNull(model);
return clusterVersion == null
? false
: (Boolean)
AsyncDataProvider.getInstance()
.getConfigValuePreConverted(
ConfigurationValues.VirtIoRngDeviceSupported, clusterVersion.getValue());
}
protected void postInitStorageDomains() {
if (getModel().getDisks() == null) {
return;
}
ActionGroup actionGroup =
getModel().isCreateInstanceOnly() ? ActionGroup.CREATE_INSTANCE : ActionGroup.CREATE_VM;
StoragePool dataCenter = getModel().getSelectedDataCenter();
AsyncDataProvider.getInstance()
.getPermittedStorageDomainsByStoragePoolId(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object target, Object returnValue) {
VmModelBehaviorBase behavior = (VmModelBehaviorBase) target;
ArrayList<StorageDomain> storageDomains =
(ArrayList<StorageDomain>) returnValue;
ArrayList<StorageDomain> activeStorageDomains =
filterStorageDomains(storageDomains);
boolean provisioning = behavior.getModel().getProvisioning().getEntity();
ArrayList<DiskModel> disks =
(ArrayList<DiskModel>) behavior.getModel().getDisks();
Collections.sort(activeStorageDomains, new NameableComparator());
for (DiskModel diskModel : disks) {
ArrayList<StorageDomain> availableDiskStorageDomains;
diskModel.getQuota().setItems(behavior.getModel().getQuota().getItems());
ArrayList<Guid> storageIds =
((DiskImage) diskModel.getDisk()).getStorageIds();
// Active storage domains that the disk resides on
ArrayList<StorageDomain> activeDiskStorageDomains =
Linq.getStorageDomainsByIds(storageIds, activeStorageDomains);
// Set target storage domains
availableDiskStorageDomains =
provisioning ? activeStorageDomains : activeDiskStorageDomains;
Collections.sort(availableDiskStorageDomains, new NameableComparator());
diskModel.getStorageDomain().setItems(availableDiskStorageDomains);
diskModel
.getStorageDomain()
.setChangeProhibitionReason(
constants.noActiveTargetStorageDomainAvailableMsg());
diskModel
.getStorageDomain()
.setIsChangable(!availableDiskStorageDomains.isEmpty());
}
}
},
getModel().getHash()),
dataCenter.getId(),
actionGroup);
}
protected void updateVirtioScsiAvailability() {
VDSGroup cluster = getModel().getSelectedCluster();
boolean isVirtioScsiEnabled =
(Boolean)
AsyncDataProvider.getInstance()
.getConfigValuePreConverted(
ConfigurationValues.VirtIoScsiEnabled,
cluster.getcompatibility_version().getValue());
getModel().getIsVirtioScsiEnabled().setIsAvailable(isVirtioScsiEnabled);
}
/**
* In case of a blank template, use the proper value for the default OS.
*
* @param VmBase
* @param ArchitectureType
*/
protected void setSelectedOSType(VmBase vmBase, ArchitectureType architectureType) {
if (vmBase.getId().equals(Guid.Empty)) {
Integer osId = AsyncDataProvider.getInstance().getDefaultOs(architectureType);
if (osId != null) {
setSelectedOSTypeById(osId.intValue());
}
} else {
setSelectedOSTypeById(vmBase.getOsId());
}
}
public void updateInterface(final Version clusterVersion) {
if (getVm() != null) {
AsyncDataProvider.getInstance()
.isVirtioScsiEnabledForVm(
new AsyncQuery(
this,
new INewAsyncCallback() {
@Override
public void onSuccess(Object model, Object returnValue1) {
getIsVirtioScsiEnabled().setEntity(Boolean.TRUE.equals(returnValue1));
updateInterfaceList(clusterVersion);
}
}),
getVm().getId());
} else {
setInterfaces(AsyncDataProvider.getInstance().getDiskInterfaceList());
}
}
@Override
protected void build(UnitVmModel model, VmBase vm) {
super.build(model, vm);
vm.setAllowConsoleReconnect(model.getAllowConsoleReconnect().getEntity());
vm.setVmType(model.getVmType().getSelectedItem());
vm.setVdsGroupId(
model.getSelectedCluster() != null ? model.getSelectedCluster().getId() : null);
vm.setTimeZone(
model.getTimeZone().getIsAvailable() && model.getTimeZone().getSelectedItem() != null
? model.getTimeZone().getSelectedItem().getTimeZoneKey()
: ""); //$NON-NLS-1$
vm.setIsoPath(
model.getCdImage().getIsChangable()
? model.getCdImage().getSelectedItem()
: ""); //$NON-NLS-1$
vm.setDeleteProtected(model.getIsDeleteProtected().getEntity());
vm.setOsId(model.getOSType().getSelectedItem());
Guid largeIconId = IconCache.getInstance().getId(model.getIcon().getEntity().getIcon());
vm.setLargeIconId(largeIconId);
vm.setSmallIconId(
model.getIcon().getEntity().getSmallIconId() != null
? model.getIcon().getEntity().getSmallIconId()
: AsyncDataProvider.getInstance().isCustomIconId(largeIconId)
? null
: AsyncDataProvider.getInstance().getSmallByLargeOsDefaultIconId(largeIconId));
vm.setVncKeyboardLayout(model.getVncKeyboardLayout().getSelectedItem());
vm.setSerialNumberPolicy(model.getSerialNumberPolicy().getSelectedSerialNumberPolicy());
vm.setCustomSerialNumber(model.getSerialNumberPolicy().getCustomSerialNumber().getEntity());
vm.setBootMenuEnabled(model.getBootMenuEnabled().getEntity());
vm.setSpiceFileTransferEnabled(
Boolean.TRUE.equals(model.getSpiceFileTransferEnabled().getEntity()));
vm.setSpiceCopyPasteEnabled(Boolean.TRUE.equals(model.getSpiceCopyPasteEnabled().getEntity()));
vm.setAutoConverge(model.getAutoConverge().getSelectedItem());
vm.setMigrateCompressed(model.getMigrateCompressed().getSelectedItem());
vm.setCustomProperties(model.getCustomPropertySheet().serialize());
vm.setConsoleDisconnectAction(model.getConsoleDisconnectAction().getSelectedItem());
if (model.getCpuSharesAmount().getIsAvailable()
&& model.getCpuSharesAmount().getEntity() != null) {
vm.setCpuShares(model.getCpuSharesAmount().getEntity());
}
vm.setCustomCompatibilityVersion(model.getCustomCompatibilityVersion().getSelectedItem());
}
private void viewHook() {
if (getWindow() != null) {
return;
}
GlusterHookEntity hookEntity = getSelectedItem();
if (hookEntity == null) {
return;
}
GlusterHookContentModel contentModel = new GlusterHookContentModel();
contentModel.setTitle(
ConstantsManager.getInstance().getConstants().viewContentGlusterHookTitle());
contentModel.setHelpTag(HelpTag.view_gluster_hook);
contentModel.setHashName("view_gluster_hook"); // $NON-NLS-1$
setWindow(contentModel);
contentModel.startProgress();
AsyncDataProvider.getInstance()
.getGlusterHookContent(
new AsyncQuery(
contentModel,
new INewAsyncCallback() {
@Override
public void onSuccess(Object model, Object returnValue) {
String content = (String) returnValue;
GlusterHookContentModel localModel = (GlusterHookContentModel) model;
localModel.getContent().setEntity(content);
if (content == null) {
localModel.getContent().setIsAvailable(false);
localModel.setMessage(
ConstantsManager.getInstance()
.getConstants()
.viewContentErrorGlusterHook());
} else if (content.length() == 0) {
localModel.getContent().setIsAvailable(false);
localModel.setMessage(
ConstantsManager.getInstance()
.getConstants()
.viewContentEmptyGlusterHook());
}
localModel.stopProgress();
}
}),
hookEntity.getId(),
null);
UICommand command = new UICommand("Cancel", this); // $NON-NLS-1$
command.setTitle(ConstantsManager.getInstance().getConstants().close());
command.setIsCancel(true);
contentModel.getCommands().add(command);
}
private void updateShareableDiskEnabled(StoragePool datacenter) {
boolean isShareableDiskEnabled =
(Boolean)
AsyncDataProvider.getInstance()
.getConfigValuePreConverted(
ConfigurationValues.ShareableDiskEnabled,
datacenter.getCompatibilityVersion().getValue());
getIsShareable().setChangeProhibitionReason(constants.shareableDiskNotSupported());
getIsShareable().setIsChangeable(isShareableDiskEnabled && isEditEnabled());
}
protected void updateIsDiskHotPlugAvailable() {
VM vm = getEntity();
Version clusterCompatibilityVersion = vm.getVdsGroupCompatibilityVersion();
if (clusterCompatibilityVersion == null) {
setIsDiskHotPlugSupported(false);
} else {
setIsDiskHotPlugSupported(
!AsyncDataProvider.getInstance()
.getDiskHotpluggableInterfaces(getEntity().getOs(), clusterCompatibilityVersion)
.isEmpty());
}
}
private void initManagement() {
AsyncDataProvider.getInstance()
.isManagementNetwork(
new AsyncQuery<>(
new AsyncCallback<Boolean>() {
@Override
public void onSuccess(Boolean returnValue) {
management = returnValue;
}
}),
getNetwork().getId());
}