* ============LICENSE_START=======================================================
* Copyright (c) 2021 Bell Canada.
* Modification Copyright (C) 2021 Pantheon.tech
+ * Modification Copyright (C) 2023 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
-import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
-import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.provisioning.InMemoryUserDetailsManager;
+import org.springframework.security.web.SecurityFilterChain;
/**
* Configuration class to implement application security.
*/
@Configuration
@EnableWebSecurity
-public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
+public class WebSecurityConfig {
private static final String USER_ROLE = "USER";
this.password = password;
}
- @Override
+ /**
+ * Return the configuration for secure access to the modules REST end points.
+ *
+ * @param http the HTTP security settings.
+ * @return the HTTP security settings.
+ */
+ @Bean
// The team decided to disable default CSRF Spring protection and not implement CSRF tokens validation.
// CPS is a stateless REST API that is not as vulnerable to CSRF attacks as web applications running in
// web browsers are. CPS does not manage sessions, each request requires the authentication token in the header.
// See https://docs.spring.io/spring-security/site/docs/5.3.8.RELEASE/reference/html5/#csrf
@SuppressWarnings("squid:S4502")
- protected void configure(final HttpSecurity http) throws Exception {
+ public SecurityFilterChain filterChain(final HttpSecurity http) throws Exception {
http
- .csrf().disable()
- .authorizeRequests()
- .antMatchers(permitUris).permitAll()
- .anyRequest().authenticated()
- .and().httpBasic();
+ .httpBasic()
+ .and()
+ .authorizeRequests()
+ .antMatchers(permitUris).permitAll()
+ .anyRequest().authenticated()
+ .and()
+ .csrf().disable();
+
+ return http.build();
}
- @Override
- protected void configure(final AuthenticationManagerBuilder auth) throws Exception {
- auth.inMemoryAuthentication().withUser(username).password("{noop}" + password).roles(USER_ROLE);
+ /**
+ * In memory user authentication details.
+ *
+ * @return in memory authetication
+ */
+ @Bean
+ public InMemoryUserDetailsManager userDetailsService() {
+ final UserDetails user = User.builder()
+ .username(username)
+ .password("{noop}" + password)
+ .roles(USER_ROLE)
+ .build();
+ return new InMemoryUserDetailsManager(user);
}
}
package org.onap.cps.rest.controller
+import org.onap.cps.config.WebSecurityConfig
+import org.springframework.context.annotation.Import
+
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import org.springframework.beans.factory.annotation.Autowired
import spock.lang.Specification
@WebMvcTest(TestController)
+@Import(WebSecurityConfig)
class ControllerSecuritySpec extends Specification {
@Autowired
import java.io.Serializable;
import java.util.Collection;
-import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
private SubscriptionEventResponse toSubscriptionEventResponse(
final List<Collection<Serializable>> cmHandleIdToStatus, final String subscriptionClientId,
final String subscriptionName) {
- final Map<String, SubscriptionStatus> cmHandleIdToStatusMap = new HashMap<>();
+ final Map<String, SubscriptionStatus> cmHandleIdToStatusMap =
+ DataNodeHelper.getCmHandleIdToStatusMap(cmHandleIdToStatus);
+
final SubscriptionEventResponse subscriptionEventResponse = new SubscriptionEventResponse();
subscriptionEventResponse.setClientId(subscriptionClientId);
subscriptionEventResponse.setSubscriptionName(subscriptionName);
-
- for (final Collection<Serializable> cmHandleToStatusBucket: cmHandleIdToStatus) {
- final Iterator<Serializable> bucketIterator = cmHandleToStatusBucket.iterator();
- while (bucketIterator.hasNext()) {
- final String item = (String) bucketIterator.next();
- if ("PENDING".equals(item)) {
- cmHandleIdToStatusMap.put((String) bucketIterator.next(),
- SubscriptionStatus.PENDING);
- }
- if ("REJECTED".equals(item)) {
- cmHandleIdToStatusMap.put((String) bucketIterator.next(),
- SubscriptionStatus.REJECTED);
- }
- if ("ACCEPTED".equals(item)) {
- cmHandleIdToStatusMap.put((String) bucketIterator.next(),
- SubscriptionStatus.ACCEPTED);
- }
- }
- }
subscriptionEventResponse.setCmHandleIdToStatus(cmHandleIdToStatusMap);
return subscriptionEventResponse;
* @return the DataNode as collection.
*/
Collection<DataNode> getDataNodesForSubscriptionEvent();
+
+ /**
+ * Get data nodes by xpath.
+ *
+ * @return the DataNode as collection.
+ */
+ Collection<DataNode> getCmHandlesForSubscriptionEvent(String clientId, String subscriptionName);
}
import static org.onap.cps.ncmp.api.impl.constants.DmiRegistryConstants.NO_TIMESTAMP;
+import java.io.Serializable;
+import java.util.Arrays;
import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
import java.util.Optional;
+import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.onap.cps.api.CpsDataService;
+import org.onap.cps.ncmp.api.impl.utils.DataNodeHelper;
import org.onap.cps.ncmp.api.impl.yangmodels.YangModelSubscriptionEvent;
import org.onap.cps.spi.FetchDescendantsOption;
import org.onap.cps.spi.model.DataNode;
private static final String SUBSCRIPTION_DATASPACE_NAME = "NCMP-Admin";
private static final String SUBSCRIPTION_ANCHOR_NAME = "AVC-Subscriptions";
private static final String SUBSCRIPTION_REGISTRY_PARENT = "/subscription-registry";
-
private final JsonObjectMapper jsonObjectMapper;
private final CpsDataService cpsDataService;
@Override
public void saveSubscriptionEvent(final YangModelSubscriptionEvent yangModelSubscriptionEvent) {
- final String subscriptionEventJsonData =
- createSubscriptionEventJsonData(jsonObjectMapper.asJsonString(yangModelSubscriptionEvent));
+ final String clientId = yangModelSubscriptionEvent.getClientId();
+ final String subscriptionName = yangModelSubscriptionEvent.getSubscriptionName();
+
final Collection<DataNode> dataNodes = cpsDataService.getDataNodes(SUBSCRIPTION_DATASPACE_NAME,
SUBSCRIPTION_ANCHOR_NAME, SUBSCRIPTION_REGISTRY_PARENT, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS);
+
+ if (isSubscriptionRegistryEmptyOrNonExist(dataNodes, clientId, subscriptionName)) {
+ saveSubscriptionEventYangModel(createSubscriptionEventJsonData(
+ jsonObjectMapper.asJsonString(yangModelSubscriptionEvent)));
+ } else {
+ findDeltaCmHandlesAddOrUpdateInDatabase(yangModelSubscriptionEvent, clientId, subscriptionName, dataNodes);
+ }
+ }
+
+ private void findDeltaCmHandlesAddOrUpdateInDatabase(final YangModelSubscriptionEvent yangModelSubscriptionEvent,
+ final String clientId, final String subscriptionName,
+ final Collection<DataNode> dataNodes) {
+ final Map<String, SubscriptionStatus> cmHandleIdsFromYangModel =
+ extractCmHandleFromYangModelAsMap(yangModelSubscriptionEvent);
+ final Map<String, SubscriptionStatus> cmHandleIdsFromDatabase =
+ extractCmHandleFromDbAsMap(dataNodes);
+
+ final Map<String, SubscriptionStatus> newCmHandles =
+ mapDifference(cmHandleIdsFromYangModel, cmHandleIdsFromDatabase);
+ traverseCmHandleList(newCmHandles, clientId, subscriptionName, true);
+
+ final Map<String, SubscriptionStatus> existingCmHandles =
+ mapDifference(cmHandleIdsFromYangModel, newCmHandles);
+ traverseCmHandleList(existingCmHandles, clientId, subscriptionName, false);
+ }
+
+ private boolean isSubscriptionRegistryEmptyOrNonExist(final Collection<DataNode> dataNodes,
+ final String clientId, final String subscriptionName) {
final Optional<DataNode> dataNodeFirst = dataNodes.stream().findFirst();
- final boolean isCreateOperation =
- dataNodeFirst.isPresent() && dataNodeFirst.get().getChildDataNodes().isEmpty();
- saveOrUpdateSubscriptionEventYangModel(subscriptionEventJsonData, isCreateOperation);
+ return ((dataNodeFirst.isPresent() && dataNodeFirst.get().getChildDataNodes().isEmpty())
+ || getCmHandlesForSubscriptionEvent(clientId, subscriptionName).isEmpty());
+ }
+
+ private void traverseCmHandleList(final Map<String, SubscriptionStatus> cmHandleMap,
+ final String clientId,
+ final String subscriptionName,
+ final boolean isAddListElementOperation) {
+ final List<YangModelSubscriptionEvent.TargetCmHandle> cmHandleList =
+ targetCmHandlesAsList(cmHandleMap);
+ for (final YangModelSubscriptionEvent.TargetCmHandle targetCmHandle : cmHandleList) {
+ final String targetCmHandleAsJson =
+ createTargetCmHandleJsonData(jsonObjectMapper.asJsonString(targetCmHandle));
+ addOrReplaceCmHandlePredicateListElement(targetCmHandleAsJson, clientId, subscriptionName,
+ isAddListElementOperation);
+ }
}
- private void saveOrUpdateSubscriptionEventYangModel(final String subscriptionEventJsonData,
- final boolean isCreateOperation) {
- if (isCreateOperation) {
- log.info("SubscriptionEventJsonData to be saved into DB {}", subscriptionEventJsonData);
- cpsDataService.saveListElements(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
- SUBSCRIPTION_REGISTRY_PARENT, subscriptionEventJsonData, NO_TIMESTAMP);
+ private void addOrReplaceCmHandlePredicateListElement(final String targetCmHandleAsJson,
+ final String clientId,
+ final String subscriptionName,
+ final boolean isAddListElementOperation) {
+ if (isAddListElementOperation) {
+ log.info("targetCmHandleAsJson to be added into DB {}", targetCmHandleAsJson);
+ cpsDataService.saveListElements(SUBSCRIPTION_DATASPACE_NAME,
+ SUBSCRIPTION_ANCHOR_NAME, createCmHandleXpathPredicates(clientId, subscriptionName),
+ targetCmHandleAsJson, NO_TIMESTAMP);
} else {
- log.info("SubscriptionEventJsonData to be updated into DB {}", subscriptionEventJsonData);
- cpsDataService.updateDataNodeAndDescendants(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
- SUBSCRIPTION_REGISTRY_PARENT, subscriptionEventJsonData, NO_TIMESTAMP);
+ log.info("targetCmHandleAsJson to be updated into DB {}", targetCmHandleAsJson);
+ cpsDataService.updateNodeLeaves(SUBSCRIPTION_DATASPACE_NAME,
+ SUBSCRIPTION_ANCHOR_NAME, createCmHandleXpathPredicates(clientId, subscriptionName),
+ targetCmHandleAsJson, NO_TIMESTAMP);
}
}
+ private void saveSubscriptionEventYangModel(final String subscriptionEventJsonData) {
+ log.info("SubscriptionEventJsonData to be saved into DB {}", subscriptionEventJsonData);
+ cpsDataService.saveListElements(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
+ SUBSCRIPTION_REGISTRY_PARENT, subscriptionEventJsonData, NO_TIMESTAMP);
+ }
+
@Override
public Collection<DataNode> getDataNodesForSubscriptionEvent() {
return cpsDataService.getDataNodes(SUBSCRIPTION_DATASPACE_NAME,
FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS);
}
+ @Override
+ public Collection<DataNode> getCmHandlesForSubscriptionEvent(final String clientId, final String subscriptionName) {
+ return cpsDataService.getDataNodesForMultipleXpaths(SUBSCRIPTION_DATASPACE_NAME,
+ SUBSCRIPTION_ANCHOR_NAME, Arrays.asList(createCmHandleXpath(clientId, subscriptionName)),
+ FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS);
+ }
+
+ private static Map<String, SubscriptionStatus> extractCmHandleFromDbAsMap(final Collection<DataNode> dataNodes) {
+ final List<Map<String, Serializable>> dataNodeLeaves = DataNodeHelper.getDataNodeLeaves(dataNodes);
+ final List<Collection<Serializable>> cmHandleIdToStatus = DataNodeHelper.getCmHandleIdToStatus(dataNodeLeaves);
+ return DataNodeHelper.getCmHandleIdToStatusMap(cmHandleIdToStatus);
+ }
+
+ private static Map<String, SubscriptionStatus> extractCmHandleFromYangModelAsMap(
+ final YangModelSubscriptionEvent yangModelSubscriptionEvent) {
+ return yangModelSubscriptionEvent.getPredicates().getTargetCmHandles()
+ .stream().collect(Collectors.toMap(
+ YangModelSubscriptionEvent.TargetCmHandle::getCmHandleId,
+ YangModelSubscriptionEvent.TargetCmHandle::getStatus));
+ }
+
+ private static List<YangModelSubscriptionEvent.TargetCmHandle> targetCmHandlesAsList(
+ final Map<String, SubscriptionStatus> newCmHandles) {
+ return newCmHandles.entrySet().stream().map(entry ->
+ new YangModelSubscriptionEvent.TargetCmHandle(entry.getKey(),
+ entry.getValue())).collect(Collectors.toList());
+ }
+
private static String createSubscriptionEventJsonData(final String yangModelSubscriptionAsJson) {
return "{\"subscription\":[" + yangModelSubscriptionAsJson + "]}";
}
+
+ private static String createTargetCmHandleJsonData(final String targetCmHandleAsJson) {
+ return "{\"targetCmHandles\":[" + targetCmHandleAsJson + "]}";
+ }
+
+ private static String createCmHandleXpathPredicates(final String clientId, final String subscriptionName) {
+ return "/subscription-registry/subscription[@clientID='" + clientId
+ + "' and @subscriptionName='" + subscriptionName + "']/predicates";
+ }
+
+ private static String createCmHandleXpath(final String clientId, final String subscriptionName) {
+ return "/subscription-registry/subscription[@clientID='" + clientId
+ + "' and @subscriptionName='" + subscriptionName + "']";
+ }
+
+ private static <K, V> Map<K, V> mapDifference(final Map<? extends K, ? extends V> left,
+ final Map<? extends K, ? extends V> right) {
+ final Map<K, V> difference = new HashMap<>();
+ difference.putAll(left);
+ difference.putAll(right);
+ difference.entrySet().removeAll(right.entrySet());
+ return difference;
+ }
}
package org.onap.cps.ncmp.api.impl.subscriptions;
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Map;
+
public enum SubscriptionStatus {
ACCEPTED,
REJECTED,
- PENDING
+ PENDING;
+
+
+ /**
+ * Populates a map with a key of cm handle id and a value of subscription status.
+ *
+ * @param resultMap the map is being populated
+ * @param bucketIterator to iterate over the collection
+ */
+ public static void populateCmHandleToSubscriptionStatusMap(final Map<String, SubscriptionStatus> resultMap,
+ final Iterator<Serializable> bucketIterator) {
+ final String item = (String) bucketIterator.next();
+ if ("PENDING".equals(item)) {
+ resultMap.put((String) bucketIterator.next(),
+ SubscriptionStatus.PENDING);
+ }
+ if ("REJECTED".equals(item)) {
+ resultMap.put((String) bucketIterator.next(),
+ SubscriptionStatus.REJECTED);
+ }
+ if ("ACCEPTED".equals(item)) {
+ resultMap.put((String) bucketIterator.next(),
+ SubscriptionStatus.ACCEPTED);
+ }
+ }
}
import java.io.Serializable;
import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
+import org.onap.cps.ncmp.api.impl.subscriptions.SubscriptionStatus;
import org.onap.cps.spi.model.DataNode;
@NoArgsConstructor(access = AccessLevel.PRIVATE)
|| col.contains("REJECTED"))
.collect(Collectors.toList());
}
+
+ /**
+ * The cm handle and status is returned as a map.
+ *
+ * @param cmHandleIdToStatus as a list of collection
+ * @return a map of cm handle id to status
+ */
+ public static Map<String, SubscriptionStatus> getCmHandleIdToStatusMap(
+ final List<Collection<Serializable>> cmHandleIdToStatus) {
+ final Map<String, SubscriptionStatus> resultMap = new HashMap<>();
+ for (final Collection<Serializable> cmHandleToStatusBucket: cmHandleIdToStatus) {
+ final Iterator<Serializable> bucketIterator = cmHandleToStatusBucket.iterator();
+ while (bucketIterator.hasNext()) {
+ SubscriptionStatus.populateCmHandleToSubscriptionStatusMap(resultMap, bucketIterator);
+ }
+ }
+ return resultMap;
+ }
}
private static final String SUBSCRIPTION_DATASPACE_NAME = "NCMP-Admin";
private static final String SUBSCRIPTION_ANCHOR_NAME = "AVC-Subscriptions";
private static final String SUBSCRIPTION_REGISTRY_PARENT = "/subscription-registry";
+ private static final String SUBSCRIPTION_REGISTRY_PREDICATES_XPATH = "/subscription-registry/subscription[@clientID='some-client-id' and @subscriptionName='some-subscription-name']/predicates";
def jsonObjectMapper = new JsonObjectMapper(new ObjectMapper())
def mockCpsDataService = Mock(CpsDataService)
def yangModelSubscriptionEvent = new YangModelSubscriptionEvent(clientId: 'some-client-id',
subscriptionName: 'some-subscription-name', tagged: true, topic: 'some-topic', predicates: predicates)
- def 'save a subscription event' () {
- given: 'a data node that does not exist in db'
+ def 'save a subscription event as yang model into db for the #scenarios' () {
+ given: 'a blank data node that exist in db'
def blankDataNode = new DataNodeBuilder().withDataspace('NCMP-Admin')
.withAnchor('AVC-Subscriptions').withXpath('/subscription-registry').build()
- and: 'cps data service return non existing data node'
+ and: 'cps data service return an empty data node'
mockCpsDataService.getDataNodes(*_) >> [blankDataNode]
when: 'the yangModelSubscriptionEvent is saved into db'
objectUnderTest.saveSubscriptionEvent(yangModelSubscriptionEvent)
NO_TIMESTAMP)
}
- def 'update a subscription event' () {
- given: 'a data node exist in db'
+ def 'add or replace cm handle list element into db' () {
+ given: 'a data node with child node exist in db'
+ def leaves1 = [status:'PENDING', cmHandleId:'cmhandle1'] as Map
def childDataNode = new DataNodeBuilder().withDataspace('NCMP-Admin')
- .withAnchor('AVC-Subscriptions').withXpath('/subscription-registry/subscription').build()
+ .withAnchor('AVC-Subscriptions').withXpath('/subscription-registry/subscription')
+ .withLeaves(leaves1).build()
def engagedDataNode = new DataNodeBuilder().withDataspace('NCMP-Admin')
.withAnchor('AVC-Subscriptions').withXpath('/subscription-registry')
.withChildDataNodes([childDataNode]).build()
- and: 'cps data service return existing data node'
+ and: 'cps data service return data node including a child data node'
mockCpsDataService.getDataNodes(*_) >> [engagedDataNode]
- when: 'the yangModelSubscriptionEvent is saved into db'
+ and: 'cps data service return data node for querying by xpaths'
+ mockCpsDataService.getDataNodesForMultipleXpaths(*_) >> [engagedDataNode]
+ when: 'the yang model subscription event is saved into db'
objectUnderTest.saveSubscriptionEvent(yangModelSubscriptionEvent)
- then: 'the cpsDataService update operation is called with the correct data'
- 1 * mockCpsDataService.updateDataNodeAndDescendants(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
- SUBSCRIPTION_REGISTRY_PARENT,
- '{"subscription":[{' +
- '"topic":"some-topic",' +
- '"predicates":{"datastore":"some-datastore","targetCmHandles":[{"cmHandleId":"cmhandle1","status":"PENDING"},{"cmHandleId":"cmhandle2","status":"PENDING"}]},' +
- '"clientID":"some-client-id","subscriptionName":"some-subscription-name","isTagged":true}]}',
+ then: 'the cpsDataService save non-existing cm handle with the correct data'
+ 1 * mockCpsDataService.saveListElements(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
+ SUBSCRIPTION_REGISTRY_PREDICATES_XPATH, '{"targetCmHandles":[{"cmHandleId":"cmhandle2","status":"PENDING"}]}',
+ NO_TIMESTAMP)
+ and: 'the cpsDataService update existing cm handle with the correct data'
+ 1 * mockCpsDataService.updateNodeLeaves(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
+ SUBSCRIPTION_REGISTRY_PREDICATES_XPATH, '{"targetCmHandles":[{"cmHandleId":"cmhandle1","status":"PENDING"}]}',
NO_TIMESTAMP)
}
package org.onap.cps.ncmp.api.impl.utils
+import org.onap.cps.ncmp.api.impl.subscriptions.SubscriptionStatus
import org.onap.cps.spi.model.DataNodeBuilder
class DataNodeHelperSpec extends DataNodeBaseSpec {
and: 'the nested data node is flatten and retrieves the leaves '
def leaves = DataNodeHelper.getDataNodeLeaves([dataNode])
when:'cm handle id to status is retrieved'
- def result = DataNodeHelper.getCmHandleIdToStatus(leaves);
+ def result = DataNodeHelper.getCmHandleIdToStatus(leaves)
then: 'the result list size is 3'
result.size() == 3
+ and: 'the result contains expected values'
+ result[0] as List == ['PENDING', 'CMHandle3']
+ result[1] as List == ['ACCEPTED', 'CMHandle2']
+ result[2] as List == ['REJECTED', 'CMHandle1']
+ }
+
+ def 'Get cm handle id to status map as expected from list of collection' () {
+ given: 'a list of collection'
+ def cmHandleCollection = [['PENDING', 'CMHandle3'], ['ACCEPTED', 'CMHandle2'], ['REJECTED', 'CMHandle1']]
+ when: 'the map is formed up with a method call'
+ def result = DataNodeHelper.getCmHandleIdToStatusMap(cmHandleCollection)
+ then: 'the map values are as expected'
+ result.keySet() == ['CMHandle3', 'CMHandle2', 'CMHandle1'] as Set
+ result.values() as List == [SubscriptionStatus.PENDING, SubscriptionStatus.ACCEPTED, SubscriptionStatus.REJECTED]
}
}
recordAndAssertPerformance("Read datatrees with ${scenario}", durationLimit, durationInMillis)
where: 'the following parameters are used'
scenario | fetchDescendantsOption | anchor || durationLimit | expectedNumberOfDataNodes
- 'no descendants' | OMIT_DESCENDANTS | 'openroadm1' || 100 | 1
- 'direct descendants' | DIRECT_CHILDREN_ONLY | 'openroadm2' || 150 | 1 + 50
- 'all descendants' | INCLUDE_ALL_DESCENDANTS | 'openroadm3' || 600 | 1 + 50 * 86
+ 'no descendants' | OMIT_DESCENDANTS | 'openroadm1' || 50 | 1
+ 'direct descendants' | DIRECT_CHILDREN_ONLY | 'openroadm2' || 100 | 1 + 50
+ 'all descendants' | INCLUDE_ALL_DESCENDANTS | 'openroadm3' || 200 | 1 + 50 * 86
}
def 'Read data trees for multiple xpaths'() {
assert countDataNodesInTree(result) == 50 * 86
def durationInMillis = stopWatch.getTotalTimeMillis()
then: 'all data is read within 500 ms'
- recordAndAssertPerformance("Read datatrees for multiple xpaths", 500, durationInMillis)
+ recordAndAssertPerformance("Read datatrees for multiple xpaths", 200, durationInMillis)
}
def 'Read complete data trees using #scenario.'() {
recordAndAssertPerformance("Read datatrees using ${scenario}", durationLimit, durationInMillis)
where: 'the following xpaths are used'
scenario | anchorPrefix | xpath || durationLimit | expectedNumberOfDataNodes
- 'bookstore root' | 'bookstore' | '/' || 300 | 78
- 'bookstore top element' | 'bookstore' | '/bookstore' || 300 | 78
- 'openroadm root' | 'openroadm' | '/' || 1200 | 1 + 50 * 86
- 'openroadm top element' | 'openroadm' | '/openroadm-devices' || 1200 | 1 + 50 * 86
+ 'bookstore root' | 'bookstore' | '/' || 200 | 78
+ 'bookstore top element' | 'bookstore' | '/bookstore' || 200 | 78
+ 'openroadm root' | 'openroadm' | '/' || 600 | 1 + 50 * 86
+ 'openroadm top element' | 'openroadm' | '/openroadm-devices' || 600 | 1 + 50 * 86
}
}
recordAndAssertPerformance("Query 1 anchor ${scenario}", durationLimit, durationInMillis)
where: 'the following parameters are used'
scenario | anchor | cpsPath || durationLimit | expectedNumberOfDataNodes
- 'top element' | 'openroadm1' | '/openroadm-devices' || 500 | 50 * 86 + 1
- 'leaf condition' | 'openroadm2' | '//openroadm-device[@ne-state="inservice"]' || 500 | 50 * 86
- 'ancestors' | 'openroadm3' | '//openroadm-device/ancestor::openroadm-devices' || 500 | 50 * 86 + 1
- 'leaf condition + ancestors' | 'openroadm4' | '//openroadm-device[@status="success"]/ancestor::openroadm-devices' || 500 | 50 * 86 + 1
+ 'top element' | 'openroadm1' | '/openroadm-devices' || 200 | 50 * 86 + 1
+ 'leaf condition' | 'openroadm2' | '//openroadm-device[@ne-state="inservice"]' || 250 | 50 * 86
+ 'ancestors' | 'openroadm3' | '//openroadm-device/ancestor::openroadm-devices' || 200 | 50 * 86 + 1
+ 'leaf condition + ancestors' | 'openroadm4' | '//openroadm-device[@status="success"]/ancestor::openroadm-devices' || 200 | 50 * 86 + 1
}
def 'Query complete data trees across all anchors with #scenario.'() {
recordAndAssertPerformance("Query across anchors ${scenario}", durationLimit, durationInMillis)
where: 'the following parameters are used'
scenario | cpspath || durationLimit | expectedNumberOfDataNodes
- 'top element' | '/openroadm-devices' || 2000 | 5 * (50 * 86 + 1)
- 'leaf condition' | '//openroadm-device[@ne-state="inservice"]' || 2000 | 5 * (50 * 86)
- 'ancestors' | '//openroadm-device/ancestor::openroadm-devices' || 2000 | 5 * (50 * 86 + 1)
- 'leaf condition + ancestors' | '//openroadm-device[@status="success"]/ancestor::openroadm-devices' || 2000 | 5 * (50 * 86 + 1)
+ 'top element' | '/openroadm-devices' || 600 | 5 * (50 * 86 + 1)
+ 'leaf condition' | '//openroadm-device[@ne-state="inservice"]' || 1000 | 5 * (50 * 86)
+ 'ancestors' | '//openroadm-device/ancestor::openroadm-devices' || 600 | 5 * (50 * 86 + 1)
+ 'leaf condition + ancestors' | '//openroadm-device[@status="success"]/ancestor::openroadm-devices' || 600 | 5 * (50 * 86 + 1)
}
def 'Query with leaf condition and #scenario.'() {
recordAndAssertPerformance("Query with ${scenario}", durationLimit, durationInMillis)
where: 'the following parameters are used'
scenario | fetchDescendantsOption | anchor || durationLimit | expectedNumberOfDataNodes
- 'no descendants' | OMIT_DESCENDANTS | 'openroadm1' || 100 | 50
- 'direct descendants' | DIRECT_CHILDREN_ONLY | 'openroadm2' || 200 | 50 * 2
- 'all descendants' | INCLUDE_ALL_DESCENDANTS | 'openroadm3' || 500 | 50 * 86
+ 'no descendants' | OMIT_DESCENDANTS | 'openroadm1' || 60 | 50
+ 'direct descendants' | DIRECT_CHILDREN_ONLY | 'openroadm2' || 120 | 50 * 2
+ 'all descendants' | INCLUDE_ALL_DESCENDANTS | 'openroadm3' || 200 | 50 * 86
}
def 'Query ancestors with #scenario.'() {
recordAndAssertPerformance("Query ancestors with ${scenario}", durationLimit, durationInMillis)
where: 'the following parameters are used'
scenario | fetchDescendantsOption | anchor || durationLimit | expectedNumberOfDataNodes
- 'no descendants' | OMIT_DESCENDANTS | 'openroadm1' || 100 | 1
- 'direct descendants' | DIRECT_CHILDREN_ONLY | 'openroadm2' || 200 | 1 + 50
- 'all descendants' | INCLUDE_ALL_DESCENDANTS | 'openroadm3' || 500 | 1 + 50 * 86
+ 'no descendants' | OMIT_DESCENDANTS | 'openroadm1' || 60 | 1
+ 'direct descendants' | DIRECT_CHILDREN_ONLY | 'openroadm2' || 120 | 1 + 50
+ 'all descendants' | INCLUDE_ALL_DESCENDANTS | 'openroadm3' || 200 | 1 + 50 * 86
}
}
stopWatch.stop()
def updateDurationInMillis = stopWatch.getTotalTimeMillis()
then: 'update duration is under 1000 milliseconds'
- recordAndAssertPerformance('Update 1 data node', 1000, updateDurationInMillis)
+ recordAndAssertPerformance('Update 1 data node', 600, updateDurationInMillis)
}
def 'Batch update 10 data nodes with descendants'() {
stopWatch.stop()
def updateDurationInMillis = stopWatch.getTotalTimeMillis()
then: 'update duration is under 5000 milliseconds'
- recordAndAssertPerformance('Update 10 data nodes', 5000, updateDurationInMillis)
+ recordAndAssertPerformance('Update 10 data nodes', 4000, updateDurationInMillis)
}
}
stopWatch.stop()
def durationInMillis = stopWatch.getTotalTimeMillis()
then: 'the required operations are performed within 1200 ms'
- recordAndAssertPerformance("CpsPath Registry attributes Query", 1200, durationInMillis)
+ recordAndAssertPerformance("CpsPath Registry attributes Query", 500, durationInMillis)
and: 'all but 1 (other node) are returned'
result.size() == 999
and: 'the tree contains all the expected descendants too'
Code Review / cps.git / commitdiff