Have PAP compare the returned list against the delta deployment list instead of comparing against the full list of policies as is the current behaviour. Any references to "get" or "set" policies methods have also been removed
Issue-ID: POLICY-3263
Change-Id: I0efe03e835db3c4b2136f7e742bba0e78dc2ac44
Signed-off-by: waynedunican <wayne.dunican@est.tech>
Signed-off-by: WayneDunican <wayne.dunican@est.tech>
}
protected PdpUpdate createPdpUpdateMessage(final String pdpGroupName, final PdpSubGroup subGroup,
- final String pdpInstanceId, final List<ToscaPolicy> policies,
+ final String pdpInstanceId,
final List<ToscaPolicy> policiesToBeDeployed,
final List<ToscaConceptIdentifier> policiesToBeUndeployed) {
update.setName(pdpInstanceId);
update.setPdpGroup(pdpGroupName);
update.setPdpSubgroup(subGroup.getPdpType());
- update.setPolicies(policies);
update.setPoliciesToBeDeployed(policiesToBeDeployed);
update.setPoliciesToBeUndeployed(policiesToBeUndeployed);
update.setPdpHeartbeatIntervalMs(heartBeatMs);
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019-2020 Nordix Foundation.
+ * Copyright (C) 2019-2021 Nordix Foundation.
* Modifications Copyright (C) 2019-2021 AT&T Intellectual Property.
* Modifications Copyright (C) 2021 Bell Canada. All rights reserved.
* ================================================================================
throws PfModelException {
final List<ToscaPolicy> polsToBeDeployed = new LinkedList<>(policiesToBeDeployed.values());
final var pdpUpdatemessage =
- createPdpUpdateMessage(pdpGroupName, subGroup, pdpInstanceId, policies,
+ createPdpUpdateMessage(pdpGroupName, subGroup, pdpInstanceId,
polsToBeDeployed, policiesToBeUndeployed);
final var pdpStateChangeMessage =
createPdpStateChangeMessage(pdpGroupName, subGroup, pdpInstanceId, pdpState);
updateDeploymentStatus(pdpGroupName, subGroup.getPdpType(), pdpInstanceId, pdpStateChangeMessage.getState(),
- databaseProvider, pdpUpdatemessage.getPolicies());
+ databaseProvider, pdpUpdatemessage.getPoliciesToBeDeployed());
requestMap.addRequest(pdpUpdatemessage, pdpStateChangeMessage);
LOGGER.debug("Sent PdpUpdate message - {}", pdpUpdatemessage);
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
import org.onap.policy.pap.main.parameters.RequestParams;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
*/
public class UpdateReq extends RequestImpl {
+ private static final Logger logger = LoggerFactory.getLogger(RequestImpl.class);
+
/**
* Policies to be undeployed if the request fails.
*/
}
Set<ToscaConceptIdentifier> actualSet = new HashSet<>(alwaysList(response.getPolicies()));
- Set<ToscaConceptIdentifier> expectedSet = new HashSet<>(alwaysList(message.getPolicies()).stream()
+ Set<ToscaConceptIdentifier> expectedSet = new HashSet<>(alwaysList(message.getPoliciesToBeDeployed()).stream()
.map(ToscaPolicy::getIdentifier).collect(Collectors.toSet()));
getNotifier().processResponse(response.getName(), message.getPdpGroup(), expectedSet, actualSet);
- // see if the policies match
+ Set<ToscaConceptIdentifier> expectedUndeploySet =
+ new HashSet<>(alwaysList(message.getPoliciesToBeUndeployed()));
+
+ if (actualSet.stream().anyMatch(expectedUndeploySet::contains)) {
+ logger.info("some policies have failed to undeploy");
+ }
- if (!actualSet.equals(expectedSet)) {
+ if (!actualSet.containsAll(expectedSet)) {
// need to undeploy the policies that are expected, but missing from the
// response
undeployPolicies = expectedSet;
Map<ToscaConceptIdentifier, ToscaPolicy> newDeployMap = update.getPoliciesToBeDeployed().stream()
.collect(Collectors.toMap(ToscaPolicy::getIdentifier, policy -> policy));
- // Merge full lists
- final List<ToscaPolicy> fullPolicies = update.getPolicies();
-
// Merge undpeloy lists
Set<ToscaConceptIdentifier> policiesToBeUndeployedSet = new HashSet<>(getMessage().getPoliciesToBeUndeployed());
policiesToBeUndeployedSet.removeAll(newDeployMap.keySet());
final List<ToscaConceptIdentifier> policiestoBeUndeployed = new LinkedList<>(policiesToBeUndeployedSet);
// Merge deploy lists
- final List<ToscaPolicy> policiesToBeDeployed;
- if (update.getPoliciesToBeDeployed() == update.getPolicies()) {
- policiesToBeDeployed = update.getPoliciesToBeDeployed();
- } else {
- Map<ToscaConceptIdentifier, ToscaPolicy> policiesToBeDeployedMap = getMessage().getPoliciesToBeDeployed()
- .stream().collect(Collectors.toMap(ToscaPolicy::getIdentifier, policy -> policy));
- policiesToBeDeployedMap.keySet().removeAll(update.getPoliciesToBeUndeployed());
- policiesToBeDeployedMap.putAll(newDeployMap);
- policiesToBeDeployed = new LinkedList<>(policiesToBeDeployedMap.values());
- }
+ Map<ToscaConceptIdentifier, ToscaPolicy> policiesToBeDeployedMap = getMessage().getPoliciesToBeDeployed()
+ .stream().collect(Collectors.toMap(ToscaPolicy::getIdentifier, policy -> policy));
+ policiesToBeDeployedMap.keySet().removeAll(update.getPoliciesToBeUndeployed());
+ policiesToBeDeployedMap.putAll(newDeployMap);
+ final List<ToscaPolicy> policiesToBeDeployed = new LinkedList<>(policiesToBeDeployedMap.values());
// Set lists in update
- update.setPolicies(fullPolicies);
update.setPoliciesToBeDeployed(policiesToBeDeployed);
update.setPoliciesToBeUndeployed(policiestoBeUndeployed);
}
// see if the policies are the same
- Set<ToscaPolicy> set1 = new HashSet<>(alwaysList(first.getPolicies()));
- Set<ToscaPolicy> set2 = new HashSet<>(alwaysList(second.getPolicies()));
+ Set<ToscaPolicy> set1 = new HashSet<>(alwaysList(first.getPoliciesToBeDeployed()));
+ Set<ToscaPolicy> set2 = new HashSet<>(alwaysList(second.getPoliciesToBeDeployed()));
if (!(set1.equals(set2))) {
return false;
}
- Map<ToscaConceptIdentifier, ToscaPolicy> dep1 = first.getPolicies().stream()
- .collect(Collectors.toMap(ToscaPolicy::getIdentifier, p -> p));
- Map<ToscaConceptIdentifier, ToscaPolicy> dep2 = second.getPoliciesToBeDeployed()
- .stream().collect(Collectors.toMap(ToscaPolicy::getIdentifier, p -> p));
-
- if (!(dep1.equals(dep2))) {
- return false;
- }
-
- HashSet<ToscaConceptIdentifier> undep1 = new HashSet<>(alwaysList(first.getPoliciesToBeUndeployed()));
- HashSet<ToscaConceptIdentifier> undep2 = new HashSet<>(alwaysList(second.getPoliciesToBeUndeployed()));
+ Set<ToscaConceptIdentifier> undep1 = new HashSet<>(alwaysList(first.getPoliciesToBeUndeployed()));
+ Set<ToscaConceptIdentifier> undep2 = new HashSet<>(alwaysList(second.getPoliciesToBeUndeployed()));
return undep1.equals(undep2);
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2019 Nordix Foundation.
+ * Copyright (C) 2019-2021 Nordix Foundation.
* Modifications Copyright (C) 2019-2021 AT&T Intellectual Property.
* Modifications Copyright (C) 2021 Bell Canada. All rights reserved.
* ================================================================================
String pdpInstanceId = pdp.getInstanceId();
final var pdpUpdatemessage =
createPdpUpdateMessage(pdpGroup.getName(), subGroup, pdp.getInstanceId(),
- policies, policies, null);
+ policies, null);
final var pdpStateChangeMessage =
createPdpStateChangeMessage(pdpGroupName, subGroup, pdpInstanceId, pdpState);
updateDeploymentStatus(pdpGroupName, subGroup.getPdpType(), pdpInstanceId,
- pdpStateChangeMessage.getState(), databaseProvider, pdpUpdatemessage.getPolicies());
+ pdpStateChangeMessage.getState(), databaseProvider, pdpUpdatemessage.getPoliciesToBeDeployed());
requestMap.addRequest(pdpUpdatemessage, pdpStateChangeMessage);
LOGGER.debug("Sent PdpUpdate message - {}", pdpUpdatemessage);
LOGGER.debug("Sent PdpStateChange message - {}", pdpStateChangeMessage);
update.setDescription(group.getDescription());
update.setPdpGroup(group.getName());
update.setPdpSubgroup(subgroup.getPdpType());
- update.setPolicies(subgroup.getPolicies().stream().map(ToscaConceptIdentifierOptVersion::new)
- .map(ident -> getPolicy(data, ident)).collect(Collectors.toList()));
update.setPoliciesToBeDeployed(data.getPoliciesToBeDeployed());
update.setPoliciesToBeUndeployed(data.getPoliciesToBeUndeployed());
}
logger.info("add update and state-change {} {} {} policies={}", update.getName(), update.getPdpGroup(),
- update.getPdpSubgroup(), update.getPolicies().size());
+ update.getPdpSubgroup(), update.getPoliciesToBeDeployed().size());
pdpRequests.put(update.getName(), Pair.of(update, change));
}
*/
public void addUpdate(PdpUpdate update) {
logger.info("add update {} {} {} policies={}", update.getName(), update.getPdpGroup(), update.getPdpSubgroup(),
- update.getPolicies().size());
+ update.getPoliciesToBeDeployed().size());
pdpRequests.compute(update.getName(), (name, data) -> Pair.of(update, (data == null ? null : data.getRight())));
}
* ONAP PAP
* ================================================================================
* Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2021 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
PdpUpdate message = new PdpUpdate();
message.setName(pdpName);
- message.setPolicies(Collections.emptyList());
+ message.setPoliciesToBeDeployed(Collections.emptyList());
+ message.setPoliciesToBeUndeployed(Collections.emptyList());
message.setPdpGroup(group);
message.setPdpSubgroup(subgroup);
PdpStatusMessageHandler handler = new PdpStatusMessageHandler(params);
PdpUpdate update10 = handler.createPdpUpdateMessage(
status3.getPdpGroup(), new PdpSubGroup(), "pdp_2",
- policies, policies, polsUndep);
- assertSame(update10.getPolicies(), policies);
+ policies, polsUndep);
assertSame(update10.getPoliciesToBeDeployed(), policies);
assertSame(update10.getPoliciesToBeUndeployed(), polsUndep);
assertThat(update10.getPoliciesToBeDeployed()).isInstanceOf(List.class);
when(policy.getIdentifier()).thenReturn(ident);
// add some policies to the update
- update.setPolicies(Arrays.asList(policy));
+ update.setPoliciesToBeDeployed(Arrays.asList(policy));
map.addRequest(update);
doAnswer(ans -> {
PdpUpdate update2 = new PdpUpdate(update);
- update2.setPolicies(Collections.emptyList());
+ update2.setPoliciesToBeDeployed(Collections.emptyList());
+ update2.setPoliciesToBeUndeployed(Arrays.asList(policy.getIdentifier()));
assertTrue(req.reconfigure(update2));
throw makeException();
}).when(undeployer).undeploy(any(), any(), any());
when(policy.getIdentifier()).thenReturn(ident);
// add some policies to the update
- update.setPolicies(Arrays.asList(policy));
+ update.setPoliciesToBeDeployed(Arrays.asList(policy));
map.addRequest(update);
* ONAP PAP
* ================================================================================
* Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2021 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
response.setPdpGroup(update.getPdpGroup());
response.setPdpSubgroup(update.getPdpSubgroup());
response.setPolicies(
- update.getPolicies().stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList()));
+ update.getPoliciesToBeDeployed().stream().map(ToscaPolicy::getIdentifier)
+ .collect(Collectors.toList()));
data = new UpdateReq(reqParams, MY_REQ_NAME, update);
data.setNotifier(notifier);
verifyResponse();
// both policy lists null
- update.setPolicies(null);
+ update.setPoliciesToBeDeployed(null);
response.setPolicies(null);
assertNull(data.checkResponse(response));
assertTrue(data.getUndeployPolicies().isEmpty());
@Test
public void testUpdateReqCheckResponse_MismatchedPolicies() {
- ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPolicies());
+ ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPoliciesToBeDeployed());
policies.set(0, makePolicy(DIFFERENT, "10.0.0"));
response.setPolicies(policies.stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList()));
verifyResponse();
// the first policy from the original update is all that should be undeployed
- assertEquals(Collections.singleton(update.getPolicies().get(0).getIdentifier()).toString(),
+ assertEquals(Collections.singleton(update.getPoliciesToBeDeployed().get(0).getIdentifier()).toString(),
data.getUndeployPolicies().toString());
}
@Test
public void testUpdateReqCheckResponse_MismatchedPolicies_Null_NotNull() {
- update.setPolicies(null);
+ update.setPoliciesToBeDeployed(null);
- assertEquals("policies do not match", data.checkResponse(response));
+ assertEquals(null, data.checkResponse(response));
assertTrue(data.getUndeployPolicies().isEmpty());
verifyResponse();
}
verifyResponse();
// all policies in the update should be undeployed
- assertEquals(update.getPolicies().stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList())
+ assertEquals(update.getPoliciesToBeDeployed().stream().map(ToscaPolicy::getIdentifier)
+ .collect(Collectors.toList())
.toString(), new TreeSet<>(data.getUndeployPolicies()).toString());
}
@Test
public void testReconfigureIsFullSameAsDeployList() {
PdpUpdate msg2 = new PdpUpdate(update);
- ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPolicies());
+ ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPoliciesToBeDeployed());
- msg2.setPolicies(policies);
msg2.setPoliciesToBeDeployed(policies);
assertTrue(data.reconfigure(msg2));
- assertThat(data.getMessage().getPolicies()).containsAll(msg2.getPolicies());
+ assertThat(data.getMessage().getPoliciesToBeDeployed()).containsAll(msg2.getPoliciesToBeDeployed());
}
@Test
public void testListsNewVsResult() {
PdpUpdate msg2 = new PdpUpdate(update);
- ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPolicies());
+ ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPoliciesToBeDeployed());
// some items in both deploy and newMessage.deploy
msg2.setPoliciesToBeDeployed(policies);
policies.remove(0);
- data.getMessage().setPolicies(policies);
+ data.getMessage().setPoliciesToBeDeployed(policies);
assertTrue(data.reconfigure(msg2));
assertThat(data.getMessage().getPoliciesToBeDeployed()).containsAll(msg2.getPoliciesToBeDeployed());
data.getMessage().setPoliciesToBeDeployed(policies);
policies.clear();
- policies = new ArrayList<>(update.getPolicies());
+ policies = new ArrayList<>(update.getPoliciesToBeDeployed());
List<ToscaConceptIdentifier> polsToUndep = policies.parallelStream()
.map(ToscaPolicy::getIdentifier)
.collect(Collectors.toList());
assertTrue(data.reconfigure(msg2));
- assertThat(data.getMessage().getPoliciesToBeDeployed()).isEmpty();
-
// some items only in deploy
- policies = new ArrayList<>(update.getPolicies());
+ policies = new ArrayList<>(update.getPoliciesToBeDeployed());
msg2.setPoliciesToBeDeployed(policies);
data.getMessage().setPoliciesToBeDeployed(new LinkedList<>());
assertTrue(data.reconfigure(msg2));
List<ToscaConceptIdentifier> pols = policies.stream().map(ToscaPolicy::getIdentifier)
.collect(Collectors.toList());
msg2.setPoliciesToBeUndeployed(pols);
- pols.remove(0);
+ pols.add(makePolicy("policy-zz-1", "1.1.0").getIdentifier());
data.getMessage().setPoliciesToBeUndeployed(pols);
assertTrue(data.reconfigure(msg2));
assertThat(data.getMessage().getPoliciesToBeUndeployed()).containsAll(msg2.getPoliciesToBeUndeployed());
// some items in both undeploy and newMessage.deploy
- policies = new ArrayList<>(update.getPolicies());
+ policies = new ArrayList<>(update.getPoliciesToBeDeployed());
List<ToscaConceptIdentifier> polsToUndep2 = policies.parallelStream()
.map(ToscaPolicy::getIdentifier)
.collect(Collectors.toList());
PdpUpdate msg2 = new PdpUpdate(update);
msg2.setName("world");
- assertFalse(data.isSameContent(msg2));
+ update.setPoliciesToBeDeployed(null);
+ List<ToscaPolicy> polsToDep2 = new LinkedList<>();
+ polsToDep2.add(makePolicy("policy-m-1", "1.0.0"));
+ polsToDep2.add(makePolicy("policy-n-1", "1.0.0"));
+ msg2.setPoliciesToBeDeployed(polsToDep2);
+ assertThat(data.isSameContent(msg2)).isFalse();
// both policy lists null
- update.setPolicies(null);
- msg2.setPolicies(null);
- assertEquals(data.getMessage().getPolicies(), msg2.getPolicies());
+ msg2.setPoliciesToBeDeployed(null);
+ assertEquals(data.getMessage().getPoliciesToBeDeployed(), msg2.getPoliciesToBeDeployed());
}
@Test
public void testIsSameContent_DiffPolicies() {
PdpUpdate msg2 = new PdpUpdate(update);
- ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPolicies());
+ ArrayList<ToscaPolicy> policies = new ArrayList<>(update.getPoliciesToBeDeployed());
policies.set(0, makePolicy(DIFFERENT, "10.0.0"));
- msg2.setPolicies(policies);
+ msg2.setPoliciesToBeDeployed(policies);
assertFalse(data.isSameContent(msg2));
}
@Test
public void testIsSameContent_DiffPolicies_NotNull_Null() {
PdpUpdate msg2 = new PdpUpdate(update);
- msg2.setPolicies(null);
+ msg2.setPoliciesToBeDeployed(null);
assertFalse(data.isSameContent(msg2));
}
@Test
public void testIsSameContent_DiffPolicies_Null_NotNull() {
- PdpUpdate msg2 = new PdpUpdate(update);
+ final PdpUpdate msg2 = new PdpUpdate(update);
- update.setPolicies(null);
+ update.setPoliciesToBeDeployed(null);
+ List<ToscaPolicy> polsToDep2 = new LinkedList<>();
+ polsToDep2.add(makePolicy("policy-m-1", "1.0.0"));
+ polsToDep2.add(makePolicy("policy-n-1", "1.0.0"));
+ msg2.setPoliciesToBeDeployed(polsToDep2);
- assertFalse(data.isSameContent(msg2));
+ assertThat(data.isSameContent(msg2)).isFalse();
}
@SuppressWarnings("unchecked")
ToscaPolicy policy1 = makePolicy("policy-1-a", "1.0.0");
ToscaPolicy policy2 = makePolicy("policy-2-a", "1.1.0");
- upd.setPolicies(Arrays.asList(policy1, policy2));
+ upd.setPoliciesToBeDeployed(Arrays.asList(policy1, policy2));
+ upd.setPoliciesToBeUndeployed(Collections.emptyList());
return upd;
}
assertEquals(groupName, update.getPdpGroup());
assertEquals(pdpType, update.getPdpSubgroup());
assertEquals(pdpName, update.getName());
- assertTrue(update.getPolicies().contains(policy1));
+ assertTrue(update.getPoliciesToBeDeployed().contains(policy1));
}
private void assertNoGroupAction() throws Exception {
assertEquals("pdpA", req.getName());
assertEquals(GROUP1_NAME, req.getPdpGroup());
assertEquals("pdpTypeA", req.getPdpSubgroup());
- assertEquals(Arrays.asList(policy1, policy1), req.getPolicies());
+ assertEquals(Arrays.asList(policy1.getIdentifier()), req.getPoliciesToBeUndeployed());
}
@Test
package org.onap.policy.pap.main.rest;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.Assert.assertEquals;
assertEquals(groupName, update.getPdpGroup());
assertEquals(pdpType, update.getPdpSubgroup());
assertEquals(pdpName, update.getName());
- assertTrue(update.getPolicies().contains(policy1));
+ assertThat(update.getPoliciesToBeDeployed()).contains(policy1);
}
private void assertNoGroupAction() throws Exception {
assertEquals(subgrp.getPdpType(), pdpUpdate.getPdpSubgroup());
List<ToscaConceptIdentifier> pdpPolicies =
- pdpUpdate.getPolicies().stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList());
+ pdpUpdate.getPoliciesToBeDeployed().stream().map(ToscaPolicy::getIdentifier)
+ .collect(Collectors.toList());
Collections.sort(pdpPolicies);
- assertEquals(subgrp.getPolicies().toString(), pdpPolicies.toString());
+ assertThat(subgrp.getPolicies()).containsAll(pdpPolicies);
List<PdpGroup> updates = getGroupUpdates();
assertEquals(Arrays.asList(group), updates);
assertEquals(groupName, update.getPdpGroup());
assertEquals(pdpType, update.getPdpSubgroup());
assertEquals(pdpName, update.getName());
- assertTrue(update.getPolicies().contains(policy1));
+ assertTrue(update.getPoliciesToBeDeployed().contains(policy1));
}
/**