void reportNetworkOperationInProgress(Host host, VDS entity) { QueryReturnValue queryReturnValue = runQuery(QueryType.IsHostLockedOnNetworkOperation, new IdQueryParameters(entity.getId())); boolean inProgress = queryReturnValue != null && Boolean.TRUE.equals(queryReturnValue.getReturnValue()); host.setNetworkOperationInProgress(inProgress); } }
@Override public void onSuccess(QueryReturnValue returnValue) { Pair<List<GlusterVolumeSnapshotConfig>, List<GlusterVolumeSnapshotConfig>> configs = returnValue.getReturnValue(); if (configs != null) { List<GlusterVolumeSnapshotConfig> clusterConfigOptions = configs.getFirst(); Collections.sort(clusterConfigOptions, Comparator.comparing(GlusterVolumeSnapshotConfig::getParamName)); setModelItems(getClusterConfigOptions(), clusterConfigOptions, existingClusterConfigs); } else { getClusterConfigOptions().setItems(null); } }
@Override public GlusterHook get() { GlusterHook hook = performGet(QueryType.GetGlusterHookById, new GlusterHookQueryParameters(guid, true)); QueryReturnValue result = runQuery(QueryType.GetGlusterHookContent, new GlusterHookContentQueryParameters(guid)); if (result != null && result.getSucceeded() && result.getReturnValue() != null) { hook.setContent(result.getReturnValue()); } return hook; }
private void initNetworkFilterList(Version dcCompatibilityVersion) { Frontend.getInstance().runQuery(QueryType.GetAllSupportedNetworkFiltersByVersion, new VersionQueryParameters(dcCompatibilityVersion), new AsyncQuery<QueryReturnValue>(returnValue -> { List<NetworkFilter> networkFilters = new ArrayList((Collection<NetworkFilter>) returnValue.getReturnValue()); networkFilters.add(EMPTY_FILTER); getNetworkFilter().setItems(networkFilters); initSelectedNetworkFilter(); })); }
@Override public void onSuccess(QueryReturnValue returnValue) { List<Cluster> allClusters = returnValue.getReturnValue(); clusterArchitecturesInDataCenters = new HashMap<>(); for (Cluster cluster : allClusters) { if (cluster.supportsVirtService() && cluster.getArchitecture() != null) { addArchitecture(cluster.getStoragePoolId(), cluster.getArchitecture()); } } }
private Object getBackendParameter(final ConfigValues key) throws ServletException { final GetConfigurationValueParameters parameters = new GetConfigurationValueParameters(); parameters.setConfigValue(key); parameters.setVersion(ConfigCommon.defaultConfigurationVersion); QueryReturnValue value = backend.runPublicQuery(QueryType.GetConfigurationValue, parameters); if (!value.getSucceeded()) { throw new ServletException("Can't get value of backend parameter \"" + key + "\"."); } return value.getReturnValue(); }
private void initMigrationSupportMap() { Frontend.getInstance().runQuery(QueryType.GetArchitectureCapabilities, new ArchCapabilitiesParameters(ArchCapabilitiesVerb.GetMigrationSupport), new AsyncQuery<QueryReturnValue>(returnValue -> migrationSupport = returnValue.getReturnValue())); }
private void initDisplayTypes() { Frontend.getInstance().runQuery(QueryType.OsRepository, new OsQueryParameters(OsRepositoryVerb.GetDisplayTypes), new AsyncQuery<QueryReturnValue>(returnValue -> graphicsAndDisplays = returnValue.getReturnValue())); }
private ApplicationMode findApplicationMode(String sessionId) { GetConfigurationValueParameters parameters = new GetConfigurationValueParameters( ConfigValues.ApplicationMode, ConfigCommon.defaultConfigurationVersion ); parameters.setSessionId(sessionId); QueryReturnValue result = backend.runPublicQuery( QueryType.GetConfigurationValue, parameters); return ApplicationMode.from(result.getReturnValue()); }
private Map<Network, Set<Guid>> getAllNetworks() { IdQueryParameters parameters = new IdQueryParameters(asGuid(providerId)); QueryReturnValue result = runQuery(QueryType.GetAllExternalNetworksOnProvider, parameters); checkResultAndThrowExceptionIfFailed(result); Map<Network, Set<Guid>> networks = result.getReturnValue(); return networks; }
public static void serialize(SerializationStreamWriter streamWriter, QueryReturnValue instance) throws SerializationException { streamWriter.writeBoolean(instance.getSucceeded()); streamWriter.writeString(instance.getExceptionString()); ObjectSerializer.serialize(streamWriter, instance.getReturnValue()); }
private void updateDisplayProtocols() { Frontend.getInstance().runQuery(QueryType.GetGraphicsDevices, new IdQueryParameters(vm.getId()), new AsyncQuery<QueryReturnValue>(returnValue -> { boolean selectVnc = false; List<GraphicsDevice> graphicsDevices = returnValue.getReturnValue(); if (graphicsDevices.size() == 1 && graphicsDevices.get(0).getGraphicsType() == GraphicsType.VNC) { selectVnc = true; } getDisplayConsole_Vnc_IsSelected().setEntity(selectVnc); getDisplayConsole_Spice_IsSelected().setEntity(!selectVnc); })); }
public void setCertificateInfo(Vm model) { QueryReturnValue result = runQuery(QueryType.GetVdsCertificateSubjectByVmId, new IdQueryParameters(asGuid(model.getId()))); if (result != null && result.getSucceeded() && result.getReturnValue() != null) { if (!model.isSetDisplay()) { model.setDisplay(new Display()); } model.getDisplay().setCertificate(new Certificate()); model.getDisplay().getCertificate().setSubject(result.getReturnValue().toString()); } }
public void invokeClient() { Frontend.getInstance().runQuery(QueryType.SignString, new SignStringParameters(createConnectionString(host, port, useSsl)), new AsyncQuery<>((AsyncCallback<QueryReturnValue>) returnValue -> { String signedTicket = returnValue.getReturnValue(); invokeClientNative(signedTicket); })); }
@Override public ActionParametersBase getParameters(Disk incoming, org.ovirt.engine.core.common.businessentities.storage.Disk entity) { DiskVmElement dveFromDb = runQuery(QueryType.GetDiskVmElementById, new VmDeviceIdQueryParameters(new VmDeviceId(entity.getId(), vmId))).getReturnValue(); DiskVmElement updatedDve = updateDiskVmElementFromDisk(incoming, dveFromDb); return new VmDiskOperationParameterBase(updatedDve, map(incoming, entity)); } }
private void queryNetworkAttachments() { VDS vds = getEntity(); IdQueryParameters params = new IdQueryParameters(vds.getId()); params.setRefresh(false); // query for network attachments Frontend.getInstance().runQuery(QueryType.GetNetworkAttachmentsByHostId, params, new AsyncQuery<>((QueryReturnValue returnValue) -> { hostSetupNetworksParametersData.getNetworkAttachments().addAll((List<NetworkAttachment>) returnValue.getReturnValue()); initNetworkIdToExistingAttachmentMap(); // chain the vfsConfig query queryVfsConfig(); })); }
public void initUniqueOsNames() { Frontend.getInstance().runQuery(QueryType.OsRepository, new OsQueryParameters(OsRepositoryVerb.GetUniqueOsNames), new AsyncQuery<QueryReturnValue>(returnValue -> { uniqueOsNames = returnValue.getReturnValue(); // Initialize specific UI dependencies for search SimpleDependencyInjector.getInstance().bind(new OsValueAutoCompleter(uniqueOsNames)); })); }
private void updateDiskProfiles(StoragePool selectedItem) { StorageDomain storageDomain = getStorageDomain().getSelectedItem(); if (storageDomain == null) { return; } Frontend.getInstance().runQuery(QueryType.GetDiskProfilesByStorageDomainId, new IdQueryParameters(storageDomain.getId()), new AsyncQuery<QueryReturnValue>(value -> setDiskProfilesList((List<DiskProfile>) value.getReturnValue()))); }
public Boolean getGetImageTicketSupported() { if (getImageTicketSupported == null) { Frontend.getInstance().runQuery(QueryType.GetVdsByVdsId, new IdQueryParameters(getVdsId()), new AsyncQuery<QueryReturnValue>(returnValue -> { VDS vds = returnValue.getReturnValue(); setGetImageTicketSupported(AsyncDataProvider.getInstance().isGetImageTicketSupported( vds.getClusterCompatibilityVersion())); })); } return getImageTicketSupported; }
@Override protected void syncSearch() { if (getEntity() == null) { return; } IdQueryParameters params = new IdQueryParameters(getEntity().getId()); params.setRefresh(getIsQueryFirstTime()); Frontend.getInstance().runQuery(QueryType.GetVmsByVnicProfileId, params, new AsyncQuery<QueryReturnValue>( returnValue -> setItems((Collection<VM>) returnValue.getReturnValue()))); }