package org.onap.cps.ncmp.api.impl;
import static org.onap.cps.ncmp.api.impl.utils.YangDataConverter.convertYangModelCmHandleToNcmpServiceCmHandle;
+import static org.onap.cps.spi.FetchDescendantsOption.FETCH_DIRECT_CHILDREN_ONLY;
import static org.onap.cps.spi.FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS;
import static org.onap.cps.utils.CmHandleQueryRestParametersValidator.validateCpsPathConditionProperties;
import static org.onap.cps.utils.CmHandleQueryRestParametersValidator.validateModuleNameConditionProperties;
*/
@Override
public Set<NcmpServiceCmHandle> queryCmHandles(
- final CmHandleQueryServiceParameters cmHandleQueryServiceParameters) {
+ final CmHandleQueryServiceParameters cmHandleQueryServiceParameters) {
if (cmHandleQueryServiceParameters.getCmHandleQueryParameters().isEmpty()) {
return getAllCmHandles();
}
final Map<String, NcmpServiceCmHandle> combinedQueryResult = executeInventoryQueries(
- cmHandleQueryServiceParameters);
+ cmHandleQueryServiceParameters);
return new HashSet<>(combineWithModuleNameQuery(cmHandleQueryServiceParameters, combinedQueryResult).values());
}
*/
@Override
public Set<String> queryCmHandleIds(
- final CmHandleQueryServiceParameters cmHandleQueryServiceParameters) {
+ final CmHandleQueryServiceParameters cmHandleQueryServiceParameters) {
if (cmHandleQueryServiceParameters.getCmHandleQueryParameters().isEmpty()) {
return getAllCmHandleIds();
}
final Map<String, NcmpServiceCmHandle> combinedQueryResult = executeInventoryQueries(
- cmHandleQueryServiceParameters);
+ cmHandleQueryServiceParameters);
final Collection<String> moduleNamesForQuery =
- getModuleNamesForQuery(cmHandleQueryServiceParameters.getCmHandleQueryParameters());
+ getModuleNamesForQuery(cmHandleQueryServiceParameters.getCmHandleQueryParameters());
if (moduleNamesForQuery.isEmpty()) {
return combinedQueryResult.keySet();
}
}
private Map<String, NcmpServiceCmHandle> combineWithModuleNameQuery(
- final CmHandleQueryServiceParameters cmHandleQueryServiceParameters,
- final Map<String, NcmpServiceCmHandle> previousQueryResult) {
+ final CmHandleQueryServiceParameters cmHandleQueryServiceParameters,
+ final Map<String, NcmpServiceCmHandle> previousQueryResult) {
final Collection<String> moduleNamesForQuery =
- getModuleNamesForQuery(cmHandleQueryServiceParameters.getCmHandleQueryParameters());
+ getModuleNamesForQuery(cmHandleQueryServiceParameters.getCmHandleQueryParameters());
if (moduleNamesForQuery.isEmpty()) {
return previousQueryResult;
}
}
private Map<String, NcmpServiceCmHandle> executeInventoryQueries(
- final CmHandleQueryServiceParameters cmHandleQueryServiceParameters) {
+ final CmHandleQueryServiceParameters cmHandleQueryServiceParameters) {
final Map<String, String> cpsPath = getCpsPath(cmHandleQueryServiceParameters.getCmHandleQueryParameters());
if (!validateCpsPathConditionProperties(cpsPath)) {
return Collections.emptyMap();
} else {
try {
cpsPathQueryResult = cmHandleQueries.queryCmHandleDataNodesByCpsPath(
- cpsPath.get("cpsPath"), INCLUDE_ALL_DESCENDANTS)
- .stream().map(this::createNcmpServiceCmHandle)
- .collect(Collectors.toMap(NcmpServiceCmHandle::getCmHandleId,
- Function.identity()));
+ cpsPath.get("cpsPath"), INCLUDE_ALL_DESCENDANTS)
+ .stream().map(this::createNcmpServiceCmHandle)
+ .collect(Collectors.toMap(NcmpServiceCmHandle::getCmHandleId,
+ Function.identity()));
} catch (final PathParsingException pathParsingException) {
throw new DataValidationException(pathParsingException.getMessage(), pathParsingException.getDetails(),
- pathParsingException);
+ pathParsingException);
}
if (cpsPathQueryResult.isEmpty()) {
return Collections.emptyMap();
}
final Map<String, String> publicPropertyQueryPairs =
- getPublicPropertyPairs(cmHandleQueryServiceParameters.getCmHandleQueryParameters());
+ getPublicPropertyPairs(cmHandleQueryServiceParameters.getCmHandleQueryParameters());
final Map<String, NcmpServiceCmHandle> propertiesQueryResult = publicPropertyQueryPairs.isEmpty()
- ? NO_QUERY_TO_EXECUTE : cmHandleQueries.queryCmHandlePublicProperties(publicPropertyQueryPairs);
+ ? NO_QUERY_TO_EXECUTE : cmHandleQueries.queryCmHandlePublicProperties(publicPropertyQueryPairs);
return cmHandleQueries.combineCmHandleQueries(cpsPathQueryResult, propertiesQueryResult);
}
private Map<String, String> getCpsPath(final List<ConditionProperties> conditionProperties) {
final Map<String, String> result = new HashMap<>();
getConditions(conditionProperties, ValidQueryProperties.WITH_CPS_PATH.getQueryProperty()).forEach(
- result::putAll);
+ result::putAll);
return result;
}
private Map<String, String> getPublicPropertyPairs(final List<ConditionProperties> conditionProperties) {
final Map<String, String> result = new HashMap<>();
getConditions(conditionProperties,
- ValidQueryProperties.HAS_ALL_PROPERTIES.getQueryProperty()).forEach(result::putAll);
+ ValidQueryProperties.HAS_ALL_PROPERTIES.getQueryProperty()).forEach(result::putAll);
return result;
}
private Set<NcmpServiceCmHandle> getAllCmHandles() {
return inventoryPersistence.getDataNode("/dmi-registry")
- .getChildDataNodes().stream().map(this::createNcmpServiceCmHandle).collect(Collectors.toSet());
+ .getChildDataNodes().stream().map(this::createNcmpServiceCmHandle).collect(Collectors.toSet());
}
private Set<String> getAllCmHandleIds() {
- return inventoryPersistence.getDataNode("/dmi-registry")
- .getChildDataNodes().stream().map(dataNode -> dataNode.getLeaves().get("id").toString())
- .collect(Collectors.toSet());
+ return inventoryPersistence.getDataNode("/dmi-registry", FETCH_DIRECT_CHILDREN_ONLY)
+ .getChildDataNodes().stream().map(dataNode -> dataNode.getLeaves().get("id").toString())
+ .collect(Collectors.toSet());
}
private NcmpServiceCmHandle createNcmpServiceCmHandle(final DataNode dataNode) {
return convertYangModelCmHandleToNcmpServiceCmHandle(YangDataConverter
- .convertCmHandleToYangModel(dataNode, dataNode.getLeaves().get("id").toString()));
+ .convertCmHandleToYangModel(dataNode, dataNode.getLeaves().get("id").toString()));
}
}
import java.util.Collection;
import java.util.Map;
import org.onap.cps.ncmp.api.impl.yangmodels.YangModelCmHandle;
+import org.onap.cps.spi.FetchDescendantsOption;
import org.onap.cps.spi.model.Anchor;
import org.onap.cps.spi.model.DataNode;
import org.onap.cps.spi.model.ModuleDefinition;
*/
DataNode getDataNode(String xpath);
+ /**
+ * Get data node via xpath.
+ *
+ * @param xpath xpath
+ * @param fetchDescendantsOption fetch descendants option
+ * @return data node
+ */
+ DataNode getDataNode(String xpath, FetchDescendantsOption fetchDescendantsOption);
+
/**
* Get data node of given cm handle.
*
@Override
public CompositeState getCmHandleState(final String cmHandleId) {
final DataNode stateAsDataNode = cpsDataService.getDataNode(NCMP_DATASPACE_NAME, NCMP_DMI_REGISTRY_ANCHOR,
- String.format(CM_HANDLE_XPATH_TEMPLATE, cmHandleId) + "/state",
- FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS);
+ String.format(CM_HANDLE_XPATH_TEMPLATE, cmHandleId) + "/state",
+ FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS);
return new CompositeStateBuilder().fromDataNode(stateAsDataNode).build();
}
@Override
public void saveCmHandleState(final String cmHandleId, final CompositeState compositeState) {
final String cmHandleJsonData = String.format("{\"state\":%s}",
- jsonObjectMapper.asJsonString(compositeState));
+ jsonObjectMapper.asJsonString(compositeState));
cpsDataService.updateDataNodeAndDescendants(NCMP_DATASPACE_NAME, NCMP_DMI_REGISTRY_ANCHOR,
- String.format(CM_HANDLE_XPATH_TEMPLATE, cmHandleId),
- cmHandleJsonData, OffsetDateTime.now());
+ String.format(CM_HANDLE_XPATH_TEMPLATE, cmHandleId),
+ cmHandleJsonData, OffsetDateTime.now());
}
@Override
@Override
public DataNode getDataNode(final String xpath) {
+ return getDataNode(xpath, INCLUDE_ALL_DESCENDANTS);
+ }
+
+ @Override
+ public DataNode getDataNode(final String xpath, final FetchDescendantsOption fetchDescendantsOption) {
return cpsDataPersistenceService.getDataNode(NCMP_DATASPACE_NAME, NCMP_DMI_REGISTRY_ANCHOR,
- xpath, INCLUDE_ALL_DESCENDANTS);
+ xpath, fetchDescendantsOption);
}
@Override
@Override
public Collection<Anchor> queryAnchors(final Collection<String> moduleNamesForQuery) {
- return cpsAdminPersistenceService.queryAnchors(NFP_OPERATIONAL_DATASTORE_DATASPACE_NAME, moduleNamesForQuery);
+ return cpsAdminPersistenceService.queryAnchors(NFP_OPERATIONAL_DATASTORE_DATASPACE_NAME, moduleNamesForQuery);
}
@Override
def 'Retrieve cm handles when the query is empty.'() {
given: 'We use an empty query'
def cmHandleQueryParameters = new CmHandleQueryServiceParameters()
- and: 'the inventory persistence returns the dmi registry datanode'
+ and: 'the inventory persistence returns the dmi registry datanode with just ids'
+ inventoryPersistence.getDataNode("/dmi-registry", FetchDescendantsOption.FETCH_DIRECT_CHILDREN_ONLY) >> dmiRegistry
+ and: 'the inventory persistence returns the dmi registry datanode with data'
inventoryPersistence.getDataNode("/dmi-registry") >> dmiRegistry
when: 'the query is executed for both cm handle ids and details'
def returnedCmHandlesJustIds = objectUnderTest.queryCmHandleIds(cmHandleQueryParameters)
package org.onap.cps.spi.impl;
-import static org.onap.cps.spi.FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS;
-
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import java.util.ArrayList;
@Override
public void addMultipleLists(final String dataspaceName, final String anchorName, final String parentNodeXpath,
- final Collection<Collection<DataNode>> newLists) {
+ final Collection<Collection<DataNode>> newLists) {
final Collection<String> failedXpaths = new HashSet<>();
newLists.forEach(newList -> {
try {
}
private void addNewChildDataNode(final String dataspaceName, final String anchorName,
- final String parentNodeXpath, final DataNode newChild) {
+ final String parentNodeXpath, final DataNode newChild) {
final FragmentEntity parentFragmentEntity = getFragmentByXpath(dataspaceName, anchorName, parentNodeXpath);
final FragmentEntity newChildAsFragmentEntity =
convertToFragmentWithAllDescendants(parentFragmentEntity.getDataspace(),
}
private void addChildrenDataNodes(final String dataspaceName, final String anchorName, final String parentNodeXpath,
- final Collection<DataNode> newChildren) {
+ final Collection<DataNode> newChildren) {
final FragmentEntity parentFragmentEntity = getFragmentByXpath(dataspaceName, anchorName, parentNodeXpath);
final List<FragmentEntity> fragmentEntities = new ArrayList<>(newChildren.size());
try {
}
private void retrySavingEachChildIndividually(final String dataspaceName, final String anchorName,
- final String parentNodeXpath, final Collection<DataNode> newChildren) {
+ final String parentNodeXpath,
+ final Collection<DataNode> newChildren) {
final Collection<String> failedXpaths = new HashSet<>();
for (final DataNode newChild : newChildren) {
try {
* @return a Fragment built from current DataNode
*/
private FragmentEntity convertToFragmentWithAllDescendants(final DataspaceEntity dataspaceEntity,
- final AnchorEntity anchorEntity, final DataNode dataNodeToBeConverted) {
+ final AnchorEntity anchorEntity,
+ final DataNode dataNodeToBeConverted) {
final FragmentEntity parentFragment = toFragmentEntity(dataspaceEntity, anchorEntity, dataNodeToBeConverted);
final Builder<FragmentEntity> childFragmentsImmutableSetBuilder = ImmutableSet.builder();
for (final DataNode childDataNode : dataNodeToBeConverted.getChildDataNodes()) {
final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
final AnchorEntity anchorEntity = anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
if (isRootXpath(xpath)) {
- return fragmentRepository.findFirstRootByDataspaceAndAnchor(dataspaceEntity, anchorEntity);
+ return fragmentRepository.findFirstRootByDataspaceAndAnchor(
+ dataspaceEntity, anchorEntity);
} else {
final String normalizedXpath;
try {
throw new CpsPathException(e.getMessage());
}
- return fragmentRepository.getByDataspaceAndAnchorAndXpath(dataspaceEntity, anchorEntity, normalizedXpath);
+ return fragmentRepository.getByDataspaceAndAnchorAndXpath(
+ dataspaceEntity, anchorEntity, normalizedXpath);
}
}
private List<DataNode> getChildDataNodes(final FragmentEntity fragmentEntity,
final FetchDescendantsOption fetchDescendantsOption) {
- if (fetchDescendantsOption == INCLUDE_ALL_DESCENDANTS) {
+ if (fetchDescendantsOption.hasNext()) {
return fragmentEntity.getChildFragments().stream()
- .map(childFragmentEntity -> toDataNode(childFragmentEntity, fetchDescendantsOption))
- .collect(Collectors.toUnmodifiableList());
+ .map(childFragmentEntity -> toDataNode(childFragmentEntity, fetchDescendantsOption.next()))
+ .collect(Collectors.toList());
}
return Collections.emptyList();
}
final List<DataNode> dataNodes) {
final Map<DataNode, FragmentEntity> dataNodeFragmentEntityMap = dataNodes.stream()
- .collect(Collectors.toMap(
- dataNode -> dataNode, dataNode -> getFragmentByXpath(dataspaceName, anchorName, dataNode.getXpath())));
+ .collect(Collectors.toMap(
+ dataNode -> dataNode,
+ dataNode -> getFragmentByXpath(dataspaceName, anchorName, dataNode.getXpath())));
dataNodeFragmentEntityMap.forEach(
- (dataNode, fragmentEntity) -> updateFragmentEntityAndDescendantsWithDataNode(fragmentEntity, dataNode));
+ (dataNode, fragmentEntity) -> updateFragmentEntityAndDescendantsWithDataNode(fragmentEntity, dataNode));
try {
fragmentRepository.saveAll(dataNodeFragmentEntityMap.values());
} catch (final StaleStateException staleStateException) {
}
private void retryUpdateDataNodesIndividually(final String dataspaceName, final String anchorName,
- final Collection<FragmentEntity> fragmentEntities) {
+ final Collection<FragmentEntity> fragmentEntities) {
final Collection<String> failedXpaths = new HashSet<>();
fragmentEntities.forEach(dataNodeFragment -> {
/*
* ============LICENSE_START=======================================================
* Copyright (C) 2021 Pantheon.tech
+ * Copyright (C) 2022 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
package org.onap.cps.spi;
-public enum FetchDescendantsOption {
- OMIT_DESCENDANTS,
- INCLUDE_ALL_DESCENDANTS
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+public class FetchDescendantsOption {
+
+ public static final FetchDescendantsOption FETCH_DIRECT_CHILDREN_ONLY = new FetchDescendantsOption(1);
+ public static final FetchDescendantsOption OMIT_DESCENDANTS = new FetchDescendantsOption(0);
+ public static final FetchDescendantsOption INCLUDE_ALL_DESCENDANTS = new FetchDescendantsOption(-1);
+
+ private final int depth;
+
+ /**
+ * Has next depth.
+ *
+ * @return true if next level of depth is available
+ * @throws IllegalArgumentException when depth less than -1
+ */
+ public boolean hasNext() {
+ validateDepth(depth);
+ return depth > 0 || this.depth == INCLUDE_ALL_DESCENDANTS.depth;
+ }
+
+ /**
+ * Next fetch descendants option.
+ *
+ * @return the next fetch descendants option
+ * @throws IllegalArgumentException when depth less than -1 or 0
+ */
+ public FetchDescendantsOption next() {
+ if (depth == 0) {
+ throw new IllegalArgumentException("Do not use next() method with zero depth");
+ }
+ final FetchDescendantsOption nextDescendantsOption = this.depth == INCLUDE_ALL_DESCENDANTS.depth
+ ? INCLUDE_ALL_DESCENDANTS : new FetchDescendantsOption(depth - 1);
+ validateDepth(nextDescendantsOption.depth);
+ return nextDescendantsOption;
+ }
+
+ private static void validateDepth(final int depth) {
+ if (depth < -1) {
+ throw new IllegalArgumentException("A depth of less than minus one is not allowed");
+ }
+ }
+
}
expect: 'service returns same data if uses same parameters'
objectUnderTest.getDataNode(dataspaceName, anchorName, xpath, fetchDescendantsOption) == dataNode
where: 'all fetch options are supported'
- fetchDescendantsOption << FetchDescendantsOption.values()
+ fetchDescendantsOption << [FetchDescendantsOption.OMIT_DESCENDANTS, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS]
}
def 'Get data node with option invalid #scenario.'() {
/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2021 Nordix Foundation
+ * Copyright (C) 2021-2022 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
then: 'the persistence service is called once with the correct parameters'
1 * mockCpsDataPersistenceService.queryDataNodes(dataspaceName, anchorName, cpsPath, fetchDescendantsOption)
where: 'all fetch descendants options are supported'
- fetchDescendantsOption << FetchDescendantsOption.values()
+ fetchDescendantsOption << [FetchDescendantsOption.OMIT_DESCENDANTS, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS]
}
def 'Query data nodes by cps path with invalid #scenario.'() {
--- /dev/null
+/*
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2022 Nordix Foundation
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.cps.spi
+
+
+import spock.lang.Specification
+
+class FetchDescendantsOptionSpec extends Specification {
+ def 'Check has next descendant for fetch descendant option: #scenario'() {
+ when: 'fetch descendant option with #depth depth'
+ def fetchDescendantsOption = new FetchDescendantsOption(depth)
+ then: 'next level descendants available: #expectedHasNext'
+ fetchDescendantsOption.hasNext() == expectedHasNext
+ where: 'following parameters are used'
+ scenario | depth || expectedHasNext
+ 'omit descendants' | 0 || false
+ 'first child' | 1 || true
+ 'second child' | 2 || true
+ 'include all descendants' | -1 || true
+ }
+
+ def 'Check has next descendant for fetch descendant option: invalid depth'() {
+ given: 'fetch descendant option with -2 depth'
+ def fetchDescendantsOption = new FetchDescendantsOption(-2)
+ when: 'next level descendants not available'
+ fetchDescendantsOption.hasNext()
+ then: 'exception thrown'
+ thrown IllegalArgumentException
+ }
+
+ def 'Get next descendant for fetch descendant option: #scenario'() {
+ when: 'fetch descendant option with #depth depth'
+ def fetchDescendantsOption = new FetchDescendantsOption(depth)
+ then: 'the next level of depth is as expected'
+ fetchDescendantsOption.next().depth == depth - 1
+ where: 'following parameters are used'
+ scenario | depth
+ 'first child' | 1
+ 'second child' | 2
+ }
+
+ def 'Get next descendant for fetch descendant option: include all descendants'() {
+ when: 'fetch descendant option with -1 depth'
+ def fetchDescendantsOption = new FetchDescendantsOption(-1)
+ then: 'the next level of depth is as expected'
+ fetchDescendantsOption.next().depth == -1
+ }
+
+ def 'Get next descendant for fetch descendant option: omit descendants'() {
+ given: 'fetch descendant option with 0 depth'
+ def fetchDescendantsOption = new FetchDescendantsOption(0)
+ when: 'the next level of depth is not allowed'
+ fetchDescendantsOption.next()
+ then: 'exception thrown'
+ thrown IllegalArgumentException
+ }
+}
Code Review / cps.git / commitdiff