Updated existing PAP code to make use of new notification classes.
Change-Id: I4637ad92ac4f432f215cfc837e672c75074d88b5
Issue-ID: POLICY-1841
Signed-off-by: Jim Hahn <jrh3@att.com>
public static final String REG_PDP_MODIFY_LOCK = "lock:pdp";
public static final String REG_PDP_MODIFY_MAP = "object:pdp/modify/map";
public static final String REG_PDP_TRACKER = "object:pdp/tracker";
+ public static final String REG_POLICY_NOTIFIER = "object:policy/notifier";
public static final String REG_PAP_DAO_FACTORY = "object:pap/dao/factory";
// topic names
public static final String TOPIC_POLICY_PDP_PAP = "POLICY-PDP-PAP";
+ public static final String TOPIC_POLICY_NOTIFICATION = "POLICY-NOTIFICATION";
private PapConstants() {
super();
import org.onap.policy.pap.main.comm.msgdata.RequestListener;
import org.onap.policy.pap.main.comm.msgdata.StateChangeReq;
import org.onap.policy.pap.main.comm.msgdata.UpdateReq;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
import org.onap.policy.pap.main.parameters.PdpModifyRequestMapParams;
import org.onap.policy.pap.main.parameters.RequestParams;
import org.slf4j.Logger;
*/
private final PolicyModelsProviderFactoryWrapper daoFactory;
+ /**
+ * Used to notify when policy updates completes.
+ */
+ private final PolicyNotifier policyNotifier;
+
/**
* Constructs the object.
this.params = params;
this.modifyLock = params.getModifyLock();
this.daoFactory = params.getDaoFactory();
+ this.policyNotifier = params.getPolicyNotifier();
}
/**
.setMaxRetryCount(params.getParams().getUpdateParameters().getMaxRetryCount())
.setTimers(params.getUpdateTimers())
.setModifyLock(params.getModifyLock())
- .setPublisher(params.getPublisher())
+ .setPdpPublisher(params.getPdpPublisher())
.setResponseDispatcher(params.getResponseDispatcher());
// @formatter:on
.setMaxRetryCount(params.getParams().getStateChangeParameters().getMaxRetryCount())
.setTimers(params.getStateChangeTimers())
.setModifyLock(params.getModifyLock())
- .setPublisher(params.getPublisher())
+ .setPdpPublisher(params.getPdpPublisher())
.setResponseDispatcher(params.getResponseDispatcher());
// @formatter:on
* @return a new set of requests
*/
protected PdpRequests makePdpRequests(String pdpName) {
- return new PdpRequests(pdpName);
+ return new PdpRequests(pdpName, policyNotifier);
}
/**
*/
private void disablePdp(PdpRequests requests) {
+ policyNotifier.removePdp(requests.getPdpName());
+
// remove the requests from the map
if (!pdp2requests.remove(requests.getPdpName(), requests)) {
// don't have the info we need to disable it
import lombok.Getter;
import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.pap.main.comm.msgdata.Request;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Getter
private final String pdpName;
+ /**
+ * Notifier for policy update completions.
+ */
+ @Getter
+ private final PolicyNotifier notifier;
+
/**
* Index of request currently being published.
*/
*
* @param pdpName name of the PDP with which the requests are associated
*/
- public PdpRequests(String pdpName) {
+ public PdpRequests(String pdpName, PolicyNotifier notifier) {
this.pdpName = pdpName;
+ this.notifier = notifier;
}
/**
*/
public void addSingleton(Request request) {
+ request.setNotifier(notifier);
+
if (request.getMessage().getName() == null) {
throw new IllegalArgumentException("unexpected broadcast for " + pdpName);
}
singletons[priority] = request;
// stop publishing anything of a lower priority
- QueueToken<PdpMessage> token = stopPublishingLowerPriority(priority);
+
final QueueToken<PdpMessage> token = stopPublishingLowerPriority(priority);
// start publishing if nothing of higher priority
if (higherPrioritySingleton(priority)) {
import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.pap.main.comm.QueueToken;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
/**
* Request data, whose message may be changed at any point, possibly triggering a restart
*/
public void setListener(RequestListener listener);
+ /**
+ * Sets the notifier to track responses to the request.
+ *
+ * @param notifier notifier used to publish notifications
+ */
+ public void setNotifier(PolicyNotifier notifier);
+
/**
* Determines if this request is currently being published.
*
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.pap.main.comm.QueueToken;
import org.onap.policy.pap.main.comm.TimerManager;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
import org.onap.policy.pap.main.parameters.RequestParams;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Setter
private RequestListener listener;
+ /**
+ * Notifier for policy update completions.
+ */
+ @Getter
+ @Setter
+ private PolicyNotifier notifier;
+
/**
* Current retry count.
*/
// couldn't take the other's place - add our own token to the queue
token = new QueueToken<>(message);
- params.getPublisher().enqueue(token);
+ params.getPdpPublisher().enqueue(token);
}
/**
package org.onap.policy.pap.main.comm.msgdata;
-import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStateChange;
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.pap.main.parameters.RequestParams;
*
* @throws IllegalArgumentException if a required parameter is not set
*/
- public StateChangeReq(RequestParams params, String name, PdpMessage message) {
+ public StateChangeReq(RequestParams params, String name, PdpStateChange message) {
super(params, name, message);
}
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
-import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.models.pdp.concepts.PdpUpdate;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
*
* @throws IllegalArgumentException if a required parameter is not set
*/
- public UpdateReq(RequestParams params, String name, PdpMessage message) {
+ public UpdateReq(RequestParams params, String name, PdpUpdate message) {
super(params, name, message);
}
public String checkResponse(PdpStatus response) {
String reason = super.checkResponse(response);
if (reason != null) {
+ // response isn't for this PDP - don't generate notifications
return reason;
}
+ Set<ToscaPolicyIdentifier> actualSet = new HashSet<>(alwaysList(response.getPolicies()));
+ getNotifier().processResponse(getName(), actualSet);
+
PdpUpdate message = getMessage();
+
if (!StringUtils.equals(message.getPdpGroup(), response.getPdpGroup())) {
return "group does not match";
}
}
// see if the policies match
- Set<ToscaPolicyIdentifier> set1 = new HashSet<>(alwaysList(response.getPolicies()));
- Set<ToscaPolicyIdentifier> set2 = new HashSet<>(alwaysList(message.getPolicies()).stream()
+
+ Set<ToscaPolicyIdentifier> expectedSet = new HashSet<>(alwaysList(message.getPolicies()).stream()
.map(ToscaPolicy::getIdentifier).collect(Collectors.toSet()));
- if (!set1.equals(set2)) {
+ if (!actualSet.equals(expectedSet)) {
return "policies do not match";
}
import lombok.Getter;
import org.onap.policy.common.endpoints.listeners.RequestIdDispatcher;
+import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.pap.main.PolicyModelsProviderFactoryWrapper;
import org.onap.policy.pap.main.comm.Publisher;
import org.onap.policy.pap.main.comm.TimerManager;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
/**
*/
@Getter
public class PdpModifyRequestMapParams {
- private Publisher publisher;
+ private Publisher<PdpMessage> pdpPublisher;
private RequestIdDispatcher<PdpStatus> responseDispatcher;
private Object modifyLock;
private PdpParameters params;
private TimerManager updateTimers;
private TimerManager stateChangeTimers;
private PolicyModelsProviderFactoryWrapper daoFactory;
+ private PolicyNotifier policyNotifier;
public PdpModifyRequestMapParams setParams(PdpParameters params) {
this.params = params;
return this;
}
- public PdpModifyRequestMapParams setPublisher(Publisher publisher) {
- this.publisher = publisher;
+ public PdpModifyRequestMapParams setPolicyNotifier(PolicyNotifier policyNotifier) {
+ this.policyNotifier = policyNotifier;
+ return this;
+ }
+
+ public PdpModifyRequestMapParams setPdpPublisher(Publisher<PdpMessage> pdpPublisher) {
+ this.pdpPublisher = pdpPublisher;
return this;
}
* Validates the parameters.
*/
public void validate() {
- if (publisher == null) {
+ if (pdpPublisher == null) {
throw new IllegalArgumentException("missing publisher");
}
if (stateChangeTimers == null) {
throw new IllegalArgumentException("missing stateChangeTimers");
}
+
+ if (daoFactory == null) {
+ throw new IllegalArgumentException("missing DAO factory");
+ }
+
+ if (policyNotifier == null) {
+ throw new IllegalArgumentException("missing policy notifier");
+ }
}
}
import lombok.Getter;
import org.onap.policy.common.endpoints.listeners.RequestIdDispatcher;
+import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.pap.main.comm.Publisher;
import org.onap.policy.pap.main.comm.TimerManager;
*/
@Getter
public class RequestParams {
- private Publisher publisher;
+ private Publisher<PdpMessage> pdpPublisher;
private RequestIdDispatcher<PdpStatus> responseDispatcher;
private Object modifyLock;
private TimerManager timers;
private int maxRetryCount;
- public RequestParams setPublisher(Publisher publisher) {
- this.publisher = publisher;
+ public RequestParams setPdpPublisher(Publisher<PdpMessage> publisher) {
+ this.pdpPublisher = publisher;
return this;
}
* Validates the parameters.
*/
public void validate() {
- if (publisher == null) {
+ if (pdpPublisher == null) {
throw new IllegalArgumentException("missing publisher");
}
package org.onap.policy.pap.main.rest.depundep;
import java.util.Iterator;
-import java.util.function.BiFunction;
+import java.util.Set;
import java.util.function.Predicate;
+import java.util.stream.Collectors;
import javax.ws.rs.core.Response.Status;
import org.onap.policy.models.base.PfModelException;
+import org.onap.policy.models.pdp.concepts.Pdp;
import org.onap.policy.models.pdp.concepts.PdpGroup;
-import org.onap.policy.models.pdp.concepts.PdpSubGroup;
import org.onap.policy.models.pdp.enums.PdpState;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
* Returns a function that will remove the desired policy from a subgroup.
*/
@Override
- protected BiFunction<PdpGroup, PdpSubGroup, Boolean> makeUpdater(ToscaPolicy policy,
+ protected Updater makeUpdater(SessionData data, ToscaPolicy policy,
ToscaPolicyIdentifierOptVersion desiredIdent) {
// construct a matcher based on whether or not the version was specified
// return a function that will remove the policy from the subgroup
return (group, subgroup) -> {
+ Set<String> pdps = subgroup.getPdpInstances().stream().map(Pdp::getInstanceId).collect(Collectors.toSet());
+
boolean result = false;
Iterator<ToscaPolicyIdentifier> iter = subgroup.getPolicies().iterator();
iter.remove();
logger.info("remove policy {} {} from subgroup {} {} count={}", ident.getName(), ident.getVersion(),
group.getName(), subgroup.getPdpType(), subgroup.getPolicies().size());
+
+ data.trackUndeploy(ident, pdps);
}
}
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.function.BiFunction;
import java.util.function.Consumer;
+import java.util.stream.Collectors;
import javax.ws.rs.core.Response.Status;
import org.onap.policy.common.parameters.BeanValidationResult;
import org.onap.policy.common.parameters.ObjectValidationResult;
* @param dbgroup the group, as it appears within the DB
* @param group the group being updated
* @return {@code true} if a subgroup was removed, {@code false} otherwise
+ * @throws PfModelException if an error occurred
*/
- private boolean notifyPdpsDelSubGroups(SessionData data, PdpGroup dbgroup, PdpGroup group) {
+ private boolean notifyPdpsDelSubGroups(SessionData data, PdpGroup dbgroup, PdpGroup group) throws PfModelException {
boolean updated = false;
// subgroups, as they appear within the updated group
// this subgroup no longer appears - notify its PDPs
updated = true;
notifyPdpsDelSubGroup(data, subgrp);
+ trackPdpsDelSubGroup(data, subgrp);
}
}
}
}
+ /**
+ * Tracks PDP responses when their subgroup is removed.
+ *
+ * @param data session data
+ * @param subgrp subgroup that is being removed
+ * @throws PfModelException if an error occurred
+ */
+ private void trackPdpsDelSubGroup(SessionData data, PdpSubGroup subgrp) throws PfModelException {
+ Set<String> pdps = subgrp.getPdpInstances().stream().map(Pdp::getInstanceId).collect(Collectors.toSet());
+
+ for (ToscaPolicyIdentifier policyId : subgrp.getPolicies()) {
+ data.trackUndeploy(policyId, pdps);
+ }
+ }
+
/**
* Adds a new subgroup.
*
* @param data session data
- * @param subgrp the subgroup to be added, updated to fully qualified versions upon return
+ * @param subgrp the subgroup to be added, updated to fully qualified versions upon
+ * return
* @return the validation result
* @throws PfModelException if an error occurred
*/
* @param data session data
* @param dbgroup the group, from the DB, containing the subgroup
* @param dbsub the subgroup, from the DB
- * @param subgrp the subgroup to be updated, updated to fully qualified versions upon return
+ * @param subgrp the subgroup to be updated, updated to fully qualified versions upon
+ * return
* @param container container for additional validation results
* @return {@code true} if the subgroup content was changed, {@code false} if there
* were no changes
/*
* first, apply the changes about which the PDPs care
*/
- boolean updated = updateList(dbsub.getPolicies(), subgrp.getPolicies(), dbsub::setPolicies);
+ boolean updated = updatePolicies(data, dbsub, subgrp);
// publish any changes to the PDPs
if (updated) {
dbsub::setDesiredInstanceCount) || updated;
}
+ private boolean updatePolicies(SessionData data, PdpSubGroup dbsub, PdpSubGroup subgrp) throws PfModelException {
+ Set<ToscaPolicyIdentifier> undeployed = new HashSet<>(dbsub.getPolicies());
+ undeployed.removeAll(subgrp.getPolicies());
+
+ Set<ToscaPolicyIdentifier> deployed = new HashSet<>(subgrp.getPolicies());
+ deployed.removeAll(dbsub.getPolicies());
+
+ if (deployed.isEmpty() && undeployed.isEmpty()) {
+ // lists are identical
+ return false;
+ }
+
+
+ Set<String> pdps = subgrp.getPdpInstances().stream().map(Pdp::getInstanceId).collect(Collectors.toSet());
+
+ for (ToscaPolicyIdentifier policyId : deployed) {
+ data.trackDeploy(policyId, pdps);
+ }
+
+ for (ToscaPolicyIdentifier policyId : undeployed) {
+ data.trackUndeploy(policyId, pdps);
+ }
+
+ dbsub.setPolicies(new ArrayList<>(subgrp.getPolicies()));
+ return true;
+ }
+
/**
* Performs additional validations of a subgroup.
*
* @param data session data
* @param dbsub the subgroup, from the DB
- * @param subgrp the subgroup to be validated, updated to fully qualified versions upon return
+ * @param subgrp the subgroup to be validated, updated to fully qualified versions
+ * upon return
* @param container container for additional validation results
* @return {@code true} if the subgroup is valid, {@code false} otherwise
* @throws PfModelException if an error occurred
private ValidationResult validatePolicies(SessionData data, PdpSubGroup dbsub, PdpSubGroup subgrp)
throws PfModelException {
- // build a map of the DB data, from policy name to (fully qualified) policy version
+ // build a map of the DB data, from policy name to (fully qualified) policy
+ // version
Map<String, String> dbname2vers = new HashMap<>();
if (dbsub != null) {
dbsub.getPolicies().forEach(ident -> dbname2vers.put(ident.getName(), ident.getVersion()));
* Adds a policy to a subgroup, if it isn't there already.
*/
@Override
- protected BiFunction<PdpGroup, PdpSubGroup, Boolean> makeUpdater(ToscaPolicy policy,
+ protected Updater makeUpdater(SessionData data, ToscaPolicy policy,
ToscaPolicyIdentifierOptVersion requestedIdent) {
ToscaPolicyIdentifier desiredIdent = policy.getIdentifier();
logger.info("add policy {} {} to subgroup {} {} count={}", desiredIdent.getName(),
desiredIdent.getVersion(), group.getName(), subgroup.getPdpType(),
subgroup.getPolicies().size());
+
+ Set<String> pdps = subgroup.getPdpInstances().stream().map(Pdp::getInstanceId).collect(Collectors.toSet());
+ data.trackDeploy(desiredIdent, pdps);
+
return true;
};
}
package org.onap.policy.pap.main.rest.depundep;
import java.util.Collection;
-import java.util.Collections;
-import java.util.function.BiFunction;
import java.util.stream.Collectors;
import javax.ws.rs.core.Response.Status;
-import org.apache.commons.lang3.tuple.Pair;
import org.onap.policy.common.utils.services.Registry;
import org.onap.policy.models.base.PfModelException;
import org.onap.policy.models.base.PfModelRuntimeException;
import org.onap.policy.models.pdp.concepts.Pdp;
import org.onap.policy.models.pdp.concepts.PdpGroup;
-import org.onap.policy.models.pdp.concepts.PdpStateChange;
import org.onap.policy.models.pdp.concepts.PdpSubGroup;
import org.onap.policy.models.pdp.concepts.PdpUpdate;
import org.onap.policy.models.provider.PolicyModelsProvider;
import org.onap.policy.pap.main.PapConstants;
import org.onap.policy.pap.main.PolicyModelsProviderFactoryWrapper;
import org.onap.policy.pap.main.comm.PdpModifyRequestMap;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
private final PdpModifyRequestMap requestMap;
+ /**
+ * Generates policy notifications based on responses from PDPs.
+ */
+ private final PolicyNotifier notifier;
+
/**
* Factory for PAP DAO.
*/
this.updateLock = Registry.get(PapConstants.REG_PDP_MODIFY_LOCK, Object.class);
this.requestMap = Registry.get(PapConstants.REG_PDP_MODIFY_MAP, PdpModifyRequestMap.class);
this.daoFactory = Registry.get(PapConstants.REG_PAP_DAO_FACTORY, PolicyModelsProviderFactoryWrapper.class);
+ this.notifier = Registry.get(PapConstants.REG_POLICY_NOTIFIER, PolicyNotifier.class);
}
/**
protected <T> void process(T request, BiConsumerWithEx<SessionData, T> processor) throws PfModelException {
synchronized (updateLock) {
- // list of requests to be published to the PDPs
- Collection<Pair<PdpUpdate, PdpStateChange>> requests = Collections.emptyList();
+ SessionData data;
try (PolicyModelsProvider dao = daoFactory.create()) {
- SessionData data = new SessionData(dao);
+ data = new SessionData(dao);
processor.accept(data, request);
// make all of the DB updates
data.updateDb();
- requests = data.getPdpRequests();
-
} catch (PfModelException | PfModelRuntimeException e) {
logger.warn(DEPLOY_FAILED, e);
throw e;
throw new PfModelException(Status.INTERNAL_SERVER_ERROR, "request failed", e);
}
+ // track responses for notification purposes
+ data.getDeployData().forEach(notifier::addDeploymentData);
+ data.getUndeployData().forEach(notifier::addUndeploymentData);
// publish the requests
- requests.forEach(pair -> requestMap.addRequest(pair.getLeft(), pair.getRight()));
+ data.getPdpRequests().forEach(pair -> requestMap.addRequest(pair.getLeft(), pair.getRight()));
}
}
+ desiredPolicy.getName() + " " + desiredPolicy.getVersion());
}
- BiFunction<PdpGroup, PdpSubGroup, Boolean> updater = makeUpdater(policy, desiredPolicy);
+ Updater updater = makeUpdater(data, policy, desiredPolicy);
for (PdpGroup group : groups) {
upgradeGroup(data, group, updater);
* {@code true} if the subgroup was updated, {@code false} if no update was
* necessary/appropriate.
*
+ * @param data session data
* @param policy policy to be added to or removed from each subgroup
* @param desiredPolicy request policy
* @return a function to update a subgroup
*/
- protected abstract BiFunction<PdpGroup, PdpSubGroup, Boolean> makeUpdater(ToscaPolicy policy,
+ protected abstract Updater makeUpdater(SessionData data, ToscaPolicy policy,
ToscaPolicyIdentifierOptVersion desiredPolicy);
/**
* @param data session data
* @param group the original group, to be updated
* @param updater function to update a group
- * @throws PfModelRuntimeException if an error occurred
+ * @throws PfModelException if an error occurred
*/
- private void upgradeGroup(SessionData data, PdpGroup group, BiFunction<PdpGroup, PdpSubGroup, Boolean> updater) {
+ private void upgradeGroup(SessionData data, PdpGroup group, Updater updater) throws PfModelException {
boolean updated = false;
*/
void accept(F firstArg, S secondArg) throws PfModelException;
}
+
+ @FunctionalInterface
+ public static interface Updater {
+ boolean apply(PdpGroup group, PdpSubGroup subgroup) throws PfModelException;
+ }
}
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.apache.commons.lang3.tuple.Pair;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyFilter;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyFilter.ToscaPolicyFilterBuilder;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifierOptVersion;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
+import org.onap.policy.pap.main.notification.PolicyPdpNotificationData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
private final Map<ToscaPolicyTypeIdentifier, ToscaPolicyType> typeCache = new HashMap<>();
+ /**
+ * Policies to be deployed. This is just used to build up the data, which is then
+ * passed to the notifier once the update is "committed".
+ */
+ private final Map<ToscaPolicyIdentifier, PolicyPdpNotificationData> deploy = new HashMap<>();
+
+ /**
+ * Policies to be undeployed. This is just used to build up the data, which is then
+ * passed to the notifier once the update is "committed".
+ */
+ private final Map<ToscaPolicyIdentifier, PolicyPdpNotificationData> undeploy = new HashMap<>();
+
/**
* Constructs the object.
logger.info("deleting DB group {}", group.getName());
dao.deletePdpGroup(group.getName());
}
+
+ /**
+ * Adds policy deployment data.
+ *
+ * @param policyId ID of the policy being deployed
+ * @param pdps PDPs to which the policy is being deployed
+ * @throws PfModelException if an error occurred
+ */
+ protected void trackDeploy(ToscaPolicyIdentifier policyId, Collection<String> pdps) throws PfModelException {
+ trackDeploy(policyId, new HashSet<>(pdps));
+ }
+
+ /**
+ * Adds policy deployment data.
+ *
+ * @param policyId ID of the policy being deployed
+ * @param pdps PDPs to which the policy is being deployed
+ * @throws PfModelException if an error occurred
+ */
+ protected void trackDeploy(ToscaPolicyIdentifier policyId, Set<String> pdps) throws PfModelException {
+ addData(policyId, pdps, deploy, undeploy);
+ }
+
+ /**
+ * Adds policy undeployment data.
+ *
+ * @param policyId ID of the policy being undeployed
+ * @param pdps PDPs to which the policy is being undeployed
+ * @throws PfModelException if an error occurred
+ */
+ protected void trackUndeploy(ToscaPolicyIdentifier policyId, Collection<String> pdps) throws PfModelException {
+ trackUndeploy(policyId, new HashSet<>(pdps));
+ }
+
+ /**
+ * Adds policy undeployment data.
+ *
+ * @param policyId ID of the policy being undeployed
+ * @param pdps PDPs to which the policy is being undeployed
+ * @throws PfModelException if an error occurred
+ */
+ protected void trackUndeploy(ToscaPolicyIdentifier policyId, Set<String> pdps) throws PfModelException {
+ addData(policyId, pdps, undeploy, deploy);
+ }
+
+ /**
+ * Adds policy deployment/undeployment data.
+ *
+ * @param policyId ID of the policy being deployed/undeployed
+ * @param pdps PDPs to which the policy is being deployed/undeployed
+ * @param addMap map to which it should be added
+ * @param removeMap map from which it should be removed
+ * @throws PfModelException if an error occurred
+ */
+ private void addData(ToscaPolicyIdentifier policyId, Set<String> pdps,
+ Map<ToscaPolicyIdentifier, PolicyPdpNotificationData> addMap,
+ Map<ToscaPolicyIdentifier, PolicyPdpNotificationData> removeMap) throws PfModelException {
+
+ PolicyPdpNotificationData removeData = removeMap.get(policyId);
+ if (removeData != null) {
+ removeData.removeAll(pdps);
+ }
+
+ ToscaPolicyIdentifierOptVersion optid = new ToscaPolicyIdentifierOptVersion(policyId);
+ ToscaPolicyTypeIdentifier policyType = getPolicy(optid).getTypeIdentifier();
+
+ addMap.computeIfAbsent(policyId, key -> new PolicyPdpNotificationData(policyId, policyType)).addAll(pdps);
+ }
+
+ /**
+ * Gets the policies to be deployed.
+ *
+ * @return the policies to be deployed
+ */
+ public Collection<PolicyPdpNotificationData> getDeployData() {
+ return deploy.values();
+ }
+
+ /**
+ * Gets the policies to be undeployed.
+ *
+ * @return the policies to be undeployed
+ */
+ public Collection<PolicyPdpNotificationData> getUndeployData() {
+ return undeploy.values();
+ }
}
import org.onap.policy.common.parameters.ParameterService;
import org.onap.policy.common.utils.services.Registry;
import org.onap.policy.common.utils.services.ServiceManagerContainer;
+import org.onap.policy.models.pap.concepts.PolicyNotification;
+import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.models.pdp.enums.PdpMessageType;
import org.onap.policy.pap.main.PapConstants;
import org.onap.policy.pap.main.comm.PdpTracker;
import org.onap.policy.pap.main.comm.Publisher;
import org.onap.policy.pap.main.comm.TimerManager;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
import org.onap.policy.pap.main.parameters.PapParameterGroup;
import org.onap.policy.pap.main.parameters.PdpModifyRequestMapParams;
import org.onap.policy.pap.main.parameters.PdpParameters;
final Object pdpUpdateLock = new Object();
final PdpParameters pdpParams = papParameterGroup.getPdpParameters();
- final AtomicReference<Publisher> pdpPub = new AtomicReference<>();
+ final AtomicReference<Publisher<PdpMessage>> pdpPub = new AtomicReference<>();
+ final AtomicReference<Publisher<PolicyNotification>> notifyPub = new AtomicReference<>();
final AtomicReference<TimerManager> pdpUpdTimers = new AtomicReference<>();
final AtomicReference<TimerManager> pdpStChgTimers = new AtomicReference<>();
final AtomicReference<TimerManager> heartBeatTimers = new AtomicReference<>();
final AtomicReference<PolicyModelsProviderFactoryWrapper> daoFactory = new AtomicReference<>();
final AtomicReference<PdpModifyRequestMap> requestMap = new AtomicReference<>();
final AtomicReference<RestServer> restServer = new AtomicReference<>();
+ final AtomicReference<PolicyNotifier> notifier = new AtomicReference<>();
// @formatter:off
addAction("PAP parameters",
addAction("PDP publisher",
() -> {
- pdpPub.set(new Publisher(PapConstants.TOPIC_POLICY_PDP_PAP));
+ pdpPub.set(new Publisher<>(PapConstants.TOPIC_POLICY_PDP_PAP));
startThread(pdpPub.get());
},
() -> pdpPub.get().stop());
+ addAction("Policy Notification publisher",
+ () -> {
+ notifyPub.set(new Publisher<>(PapConstants.TOPIC_POLICY_NOTIFICATION));
+ startThread(notifyPub.get());
+ notifier.set(new PolicyNotifier(notifyPub.get()));
+ },
+ () -> notifyPub.get().stop());
+
+ addAction("Policy Notifier",
+ () -> Registry.register(PapConstants.REG_POLICY_NOTIFIER, notifier.get()),
+ () -> Registry.unregister(PapConstants.REG_POLICY_NOTIFIER));
+
addAction("PDP heart beat timers",
() -> {
long maxWaitHeartBeatMs = MAX_MISSED_HEARTBEATS * pdpParams.getHeartBeatMs();
.setDaoFactory(daoFactory.get())
.setModifyLock(pdpUpdateLock)
.setParams(pdpParams)
- .setPublisher(pdpPub.get())
+ .setPolicyNotifier(notifier.get())
+ .setPdpPublisher(pdpPub.get())
.setResponseDispatcher(reqIdDispatcher)
.setStateChangeTimers(pdpStChgTimers.get())
.setUpdateTimers(pdpUpdTimers.get())));
import org.onap.policy.pap.main.comm.msgdata.RequestListener;
import org.onap.policy.pap.main.comm.msgdata.StateChangeReq;
import org.onap.policy.pap.main.comm.msgdata.UpdateReq;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
import org.onap.policy.pap.main.parameters.PdpModifyRequestMapParams;
import org.onap.policy.pap.main.parameters.PdpParameters;
import org.onap.policy.pap.main.parameters.PdpStateChangeParameters;
protected static final int RETRIES = 1;
protected Publisher<PdpMessage> publisher;
+ protected PolicyNotifier notifier;
protected RequestIdDispatcher<PdpStatus> dispatcher;
protected Object lock;
protected TimerManager timers;
@SuppressWarnings("unchecked")
public void setUp() throws Exception {
publisher = mock(Publisher.class);
+ notifier = mock(PolicyNotifier.class);
dispatcher = mock(RequestIdDispatcher.class);
lock = new Object();
timers = mock(TimerManager.class);
when(updateParams.getMaxRetryCount()).thenReturn(RETRIES);
when(pdpParams.getUpdateParameters()).thenReturn(updateParams);
- reqParams = new RequestParams().setMaxRetryCount(RETRIES).setModifyLock(lock).setPublisher(publisher)
+ reqParams = new RequestParams().setMaxRetryCount(RETRIES).setModifyLock(lock).setPdpPublisher(publisher)
.setResponseDispatcher(dispatcher).setTimers(timers);
- mapParams = new PdpModifyRequestMapParams().setModifyLock(lock).setPublisher(publisher)
- .setResponseDispatcher(dispatcher).setDaoFactory(daoFactory).setUpdateTimers(timers)
- .setStateChangeTimers(timers).setParams(pdpParams);
+ mapParams = new PdpModifyRequestMapParams().setModifyLock(lock).setPdpPublisher(publisher)
+ .setPolicyNotifier(notifier).setResponseDispatcher(dispatcher).setDaoFactory(daoFactory)
+ .setUpdateTimers(timers).setStateChangeTimers(timers).setParams(pdpParams);
}
/**
// should have stopped publishing
verify(requests).stopPublishing();
+ // should have generated a notification
+ verify(notifier).removePdp(PDP1);
+
// should have published a new update
PdpMessage msg2 = getSingletons(3).get(1).getMessage();
assertNotNull(msg2);
update = makeUpdateReq(PDP1, MY_GROUP, MY_SUBGROUP);
change = makeStateChangeReq(PDP1, MY_STATE);
- data = new PdpRequests(PDP1);
+ data = new PdpRequests(PDP1, notifier);
}
@Test
public void testAddSingleton() {
data.addSingleton(update);
+ verify(update).setNotifier(notifier);
verify(update).startPublishing(any());
}
@Test
public void testResetRetryCount_testBumpRetryCount() {
- req = new MyRequest(new RequestParams().setMaxRetryCount(2).setModifyLock(lock).setPublisher(publisher)
+ req = new MyRequest(new RequestParams().setMaxRetryCount(2).setModifyLock(lock).setPdpPublisher(publisher)
.setResponseDispatcher(dispatcher).setTimers(timers), MY_REQ_NAME, msg);
req.setListener(listener);
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Set;
import java.util.stream.Collectors;
import org.junit.Before;
import org.junit.Test;
/**
* Sets up.
+ *
* @throws Exception if an error occurs
*/
@Before
update.getPolicies().stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList()));
data = new UpdateReq(reqParams, MY_REQ_NAME, update);
+ data.setNotifier(notifier);
}
@Test
@Test
public void testCheckResponse() {
assertNull(data.checkResponse(response));
+ verifyResponse();
// both policy lists null
update.setPolicies(null);
response.setName(null);
assertEquals("null PDP name", data.checkResponse(response));
+ verifyNoResponse();
}
@Test
update.setName(null);
assertEquals(null, data.checkResponse(response));
+ verifyResponse();
}
@Test
response.setPdpGroup(DIFFERENT);
assertEquals("group does not match", data.checkResponse(response));
+ verifyResponse();
}
@Test
response.setPdpSubgroup(DIFFERENT);
assertEquals("subgroup does not match", data.checkResponse(response));
+ verifyResponse();
}
@Test
response.setPolicies(policies.stream().map(ToscaPolicy::getIdentifier).collect(Collectors.toList()));
assertEquals("policies do not match", data.checkResponse(response));
+ verifyResponse();
}
@Test
update.setPolicies(null);
assertEquals("policies do not match", data.checkResponse(response));
+ verifyResponse();
}
@Test
response.setPolicies(null);
assertEquals("policies do not match", data.checkResponse(response));
+ verifyResponse();
}
@Test
assertTrue(data.getPriority() > new StateChangeReq(reqParams, MY_REQ_NAME, new PdpStateChange()).getPriority());
}
+ @SuppressWarnings("unchecked")
+ private void verifyResponse() {
+ verify(notifier).processResponse(any(), any(Set.class));
+ }
+
+ @SuppressWarnings("unchecked")
+ private void verifyNoResponse() {
+ verify(notifier, never()).processResponse(any(), any(Set.class));
+ }
+
/**
* Makes an update message.
*
import org.junit.Before;
import org.junit.Test;
import org.onap.policy.common.endpoints.listeners.RequestIdDispatcher;
+import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStatus;
+import org.onap.policy.pap.main.PolicyModelsProviderFactoryWrapper;
import org.onap.policy.pap.main.comm.Publisher;
import org.onap.policy.pap.main.comm.TimerManager;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
public class TestPdpModifyRequestMapParams {
private PdpModifyRequestMapParams params;
- private Publisher pub;
+ private Publisher<PdpMessage> pub;
private RequestIdDispatcher<PdpStatus> disp;
private Object lock;
private PdpParameters pdpParams;
private TimerManager updTimers;
private TimerManager stateTimers;
+ private PolicyModelsProviderFactoryWrapper dao;
+ private PolicyNotifier notifier;
/**
* Sets up the objects and creates an empty {@link #params}.
pdpParams = mock(PdpParameters.class);
updTimers = mock(TimerManager.class);
stateTimers = mock(TimerManager.class);
+ dao = mock(PolicyModelsProviderFactoryWrapper.class);
+ notifier = mock(PolicyNotifier.class);
- params = new PdpModifyRequestMapParams().setModifyLock(lock).setPublisher(pub).setResponseDispatcher(disp)
- .setParams(pdpParams).setStateChangeTimers(stateTimers).setUpdateTimers(updTimers);
+ params = new PdpModifyRequestMapParams().setModifyLock(lock).setPdpPublisher(pub).setResponseDispatcher(disp)
+ .setParams(pdpParams).setStateChangeTimers(stateTimers).setUpdateTimers(updTimers)
+ .setDaoFactory(dao).setPolicyNotifier(notifier);
}
@Test
public void testGettersSetters() {
- assertSame(pub, params.getPublisher());
+ assertSame(pub, params.getPdpPublisher());
assertSame(disp, params.getResponseDispatcher());
assertSame(lock, params.getModifyLock());
assertSame(pdpParams, params.getParams());
assertSame(updTimers, params.getUpdateTimers());
assertSame(stateTimers, params.getStateChangeTimers());
+ assertSame(dao, params.getDaoFactory());
+ assertSame(notifier, params.getPolicyNotifier());
}
@Test
@Test
public void testValidate_MissingPublisher() {
- assertThatIllegalArgumentException().isThrownBy(() -> params.setPublisher(null).validate())
+ assertThatIllegalArgumentException().isThrownBy(() -> params.setPdpPublisher(null).validate())
.withMessageContaining("publisher");
}
assertThatIllegalArgumentException().isThrownBy(() -> params.setUpdateTimers(null).validate())
.withMessageContaining("update");
}
+
+ @Test
+ public void testValidate_MissingDaoFactory() {
+ assertThatIllegalArgumentException().isThrownBy(() -> params.setDaoFactory(null).validate())
+ .withMessageContaining("DAO");
+ }
+
+ @Test
+ public void testValidate_MissingNotifier() {
+ assertThatIllegalArgumentException().isThrownBy(() -> params.setPolicyNotifier(null).validate())
+ .withMessageContaining("notifier");
+ }
}
import org.junit.Before;
import org.junit.Test;
import org.onap.policy.common.endpoints.listeners.RequestIdDispatcher;
+import org.onap.policy.models.pdp.concepts.PdpMessage;
import org.onap.policy.models.pdp.concepts.PdpStatus;
import org.onap.policy.pap.main.comm.Publisher;
import org.onap.policy.pap.main.comm.TimerManager;
private static final int RETRIES = 1;
private RequestParams params;
- private Publisher pub;
+ private Publisher<PdpMessage> pub;
private RequestIdDispatcher<PdpStatus> disp;
private Object lock;
private TimerManager timers;
lock = new Object();
timers = mock(TimerManager.class);
- params = new RequestParams().setModifyLock(lock).setPublisher(pub).setResponseDispatcher(disp).setTimers(timers)
- .setMaxRetryCount(RETRIES);
+ params = new RequestParams().setModifyLock(lock).setPdpPublisher(pub).setResponseDispatcher(disp)
+ .setTimers(timers).setMaxRetryCount(RETRIES);
}
@Test
public void testGettersSetters() {
- assertSame(params, params.setModifyLock(lock).setPublisher(pub).setResponseDispatcher(disp));
+ assertSame(params, params.setModifyLock(lock).setPdpPublisher(pub).setResponseDispatcher(disp));
- assertSame(pub, params.getPublisher());
+ assertSame(pub, params.getPdpPublisher());
assertSame(disp, params.getResponseDispatcher());
assertSame(lock, params.getModifyLock());
assertSame(timers, params.getTimers());
@Test
public void testValidate_MissingPublisher() {
- assertThatIllegalArgumentException().isThrownBy(() -> params.setPublisher(null).validate())
+ assertThatIllegalArgumentException().isThrownBy(() -> params.setPdpPublisher(null).validate())
.withMessageContaining("publisher");
}
import org.onap.policy.pap.main.PapConstants;
import org.onap.policy.pap.main.PolicyModelsProviderFactoryWrapper;
import org.onap.policy.pap.main.comm.PdpModifyRequestMap;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
/**
* Super class for TestPdpGroupDeployProviderXxx classes.
@Mock
protected PolicyModelsProvider dao;
+ @Mock
+ protected PolicyNotifier notifier;
+
/**
* Used to capture input to dao.updatePdpGroups() and dao.createPdpGroups().
Registry.register(PapConstants.REG_PDP_MODIFY_LOCK, lockit);
Registry.register(PapConstants.REG_PDP_MODIFY_MAP, reqmap);
Registry.register(PapConstants.REG_PAP_DAO_FACTORY, daofact);
+ Registry.register(PapConstants.REG_POLICY_NOTIFIER, notifier);
}
protected void assertGroup(List<PdpGroup> groups, String name) {
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import java.util.Arrays;
import java.util.List;
-import java.util.function.BiFunction;
+import java.util.Set;
import javax.ws.rs.core.Response.Status;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
import org.onap.policy.common.utils.services.Registry;
import org.onap.policy.models.base.PfModelException;
import org.onap.policy.models.pdp.concepts.PdpGroup;
import org.onap.policy.models.pdp.enums.PdpState;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifierOptVersion;
+import org.onap.policy.pap.main.rest.depundep.ProviderBase.Updater;
public class TestPdpGroupDeleteProvider extends ProviderSuper {
private static final String EXPECTED_EXCEPTION = "expected exception";
private static final String GROUP1_NAME = "groupA";
- private MyProvider prov;
+ @Mock
private SessionData session;
+
+ @Captor
+ private ArgumentCaptor<Set<String>> pdpCaptor;
+
+ private MyProvider prov;
private ToscaPolicyIdentifierOptVersion optIdent;
private ToscaPolicyIdentifierOptVersion fullIdent;
private ToscaPolicyIdentifier ident;
- private BiFunction<PdpGroup, PdpSubGroup, Boolean> updater;
+ private Updater updater;
@AfterClass
super.setUp();
- session = mock(SessionData.class);
ident = policy1.getIdentifier();
optIdent = new ToscaPolicyIdentifierOptVersion(ident.getName(), null);
fullIdent = new ToscaPolicyIdentifierOptVersion(ident.getName(), ident.getVersion());
prov = new MyProvider();
- updater = prov.makeUpdater(policy1, fullIdent);
+ updater = prov.makeUpdater(session, policy1, fullIdent);
}
@Test
}
@Test
- public void testMakeUpdater_WithVersion() {
+ public void testMakeUpdater_WithVersion() throws PfModelException {
/*
* this group has two matching policies and one policy with a different name.
*/
// identified policy should have been removed
assertEquals(origSize - 1, subgroup.getPolicies().size());
assertFalse(subgroup.getPolicies().contains(ident));
+
+ verify(session).trackUndeploy(eq(ident), pdpCaptor.capture());
+ assertEquals("[pdpA]", pdpCaptor.getValue().toString());
}
@Test
- public void testMakeUpdater_NullVersion() {
+ public void testMakeUpdater_NullVersion() throws PfModelException {
/*
* this group has two matching policies and one policy with a different name.
*/
int origSize = subgroup.getPolicies().size();
// invoke updater - matching the name, but with a null (i.e., wild-card) version
- updater = prov.makeUpdater(policy1, optIdent);
+ updater = prov.makeUpdater(session, policy1, optIdent);
assertTrue(updater.apply(group, subgroup));
// identified policy should have been removed
}
@Test
- public void testMakeUpdater_NotFound() {
+ public void testMakeUpdater_NotFound() throws PfModelException {
/*
* this group has one policy with a different name and one with a different
* version, but not the policy of interest.
import java.util.Collections;
import java.util.List;
import java.util.TreeMap;
+import java.util.TreeSet;
import java.util.stream.Collectors;
import javax.ws.rs.core.Response.Status;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import org.onap.policy.common.utils.services.Registry;
import org.onap.policy.models.base.PfModelException;
import org.onap.policy.models.base.PfModelRuntimeException;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
+import org.onap.policy.pap.main.notification.PolicyPdpNotificationData;
public class TestPdpGroupDeployProvider extends ProviderSuper {
private static final String EXPECTED_EXCEPTION = "expected exception";
assertEquals(newgrp.toString(), dbgroup.toString());
+ // no deployment notifications
+ verify(notifier, never()).addDeploymentData(any());
+
+ // should have notified of deleted subgroup's policies/PDPs
+ ArgumentCaptor<PolicyPdpNotificationData> captor = ArgumentCaptor.forClass(PolicyPdpNotificationData.class);
+ verify(notifier).addUndeploymentData(captor.capture());
+ assertDeploymentData(captor, policy1.getIdentifier(), "[pdpB, pdpD]");
+
// this requires a PDP UPDATE message
List<PdpUpdate> pdpUpdates = getUpdateRequests(2);
assertEquals(2, pdpUpdates.size());
@Test
public void testUpdateSubGroup_Policies() throws Exception {
- PdpGroups groups = loadPdpGroups("createGroups.json");
+ PdpGroups groups = loadPdpGroups("createGroupsDelPolicy.json");
PdpGroup newgrp = groups.getGroups().get(0);
PdpGroup group = new PdpGroup(newgrp);
when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
PdpSubGroup subgrp = newgrp.getPdpSubgroups().get(0);
- subgrp.getPolicies().add(new ToscaPolicyIdentifier(POLICY2_NAME, POLICY1_VERSION));
+
+ // delete second policy
+ subgrp.setPolicies(subgrp.getPolicies().subList(0, 1));
+
+ // add new policy
+ ToscaPolicyIdentifier policyId2 = new ToscaPolicyIdentifier(POLICY2_NAME, POLICY1_VERSION);
+ subgrp.getPolicies().add(policyId2);
when(dao.getFilteredPolicyList(any())).thenReturn(loadPolicies("createGroupNewPolicy.json"))
.thenReturn(loadPolicies("daoPolicyList.json"))
+ .thenReturn(loadPolicies("daoPolicyListDelPolicy.json"))
.thenReturn(loadPolicies("createGroupNewPolicy.json"));
prov.createOrUpdateGroups(groups);
assertEquals(newgrp.toString(), group.toString());
+ // should have notified of added policy/PDPs
+ ArgumentCaptor<PolicyPdpNotificationData> captor = ArgumentCaptor.forClass(PolicyPdpNotificationData.class);
+ verify(notifier).addDeploymentData(captor.capture());
+ assertDeploymentData(captor, policyId2, "[pdpA]");
+
+ // should have notified of deleted policy/PDPs
+ captor = ArgumentCaptor.forClass(PolicyPdpNotificationData.class);
+ verify(notifier).addUndeploymentData(captor.capture());
+ assertDeploymentData(captor, new ToscaPolicyIdentifier("ToBeDeleted", POLICY1_VERSION), "[pdpA]");
+
// this requires a PDP UPDATE message
assertGroupUpdate(group, subgrp);
}
+ @Test
+ public void testUpdateSubGroup_Unchanged() throws Exception {
+ PdpGroups groups = loadPdpGroups("createGroups.json");
+ PdpGroup newgrp = groups.getGroups().get(0);
+ PdpGroup group = new PdpGroup(newgrp);
+ when(dao.getPdpGroups(group.getName())).thenReturn(Arrays.asList(group));
+
+ prov.createOrUpdateGroups(groups);
+
+ Collections.sort(newgrp.getPdpSubgroups().get(0).getPolicies());
+ Collections.sort(group.getPdpSubgroups().get(0).getPolicies());
+
+ assertEquals(newgrp.toString(), group.toString());
+
+ // no notifications
+ verify(notifier, never()).addDeploymentData(any());
+ verify(notifier, never()).addUndeploymentData(any());
+
+ // no group updates
+ assertNoGroupAction();
+ }
+
@Test
public void testUpdateSubGroup_PolicyVersionMismatch() throws Exception {
PdpGroups groups = loadPdpGroups("createGroups.json");
List<PdpUpdate> requests = getUpdateRequests(2);
assertUpdate(requests, GROUP1_NAME, PDP2_TYPE, PDP2);
assertUpdate(requests, GROUP1_NAME, PDP4_TYPE, PDP4);
+
+ // should have notified of added policy/PDPs
+ ArgumentCaptor<PolicyPdpNotificationData> captor = ArgumentCaptor.forClass(PolicyPdpNotificationData.class);
+ verify(notifier).addDeploymentData(captor.capture());
+ assertDeploymentData(captor, policy1.getIdentifier(), "[pdpB, pdpD]");
+
+ // no undeployment notifications
+ verify(notifier, never()).addUndeploymentData(any());
}
@Test
assertEquals(Arrays.asList(group), updates);
}
+ private void assertDeploymentData(ArgumentCaptor<PolicyPdpNotificationData> captor, ToscaPolicyIdentifier policyId,
+ String expectedPdps) {
+ PolicyPdpNotificationData data = captor.getValue();
+ assertEquals(policyId, data.getPolicyId());
+ assertEquals(policy1.getTypeIdentifier(), data.getPolicyType());
+ assertEquals(expectedPdps, new TreeSet<>(data.getPdps()).toString());
+ }
+
/**
* Loads a standard request.
*
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
-import java.util.function.BiFunction;
+import java.util.TreeSet;
import javax.ws.rs.core.Response.Status;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import org.onap.policy.common.utils.services.Registry;
import org.onap.policy.models.base.PfModelException;
import org.onap.policy.models.base.PfModelRuntimeException;
import org.onap.policy.models.pap.concepts.PdpDeployPolicies;
import org.onap.policy.models.pdp.concepts.PdpGroup;
-import org.onap.policy.models.pdp.concepts.PdpSubGroup;
import org.onap.policy.models.pdp.concepts.PdpUpdate;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifierOptVersion;
+import org.onap.policy.pap.main.notification.PolicyPdpNotificationData;
import org.powermock.reflect.Whitebox;
public class TestProviderBase extends ProviderSuper {
assertGroup(getGroupUpdates(), GROUP1_NAME);
assertUpdate(getUpdateRequests(1), GROUP1_NAME, PDP1_TYPE, PDP1);
+
+ ArgumentCaptor<PolicyPdpNotificationData> captor = ArgumentCaptor.forClass(PolicyPdpNotificationData.class);
+ verify(notifier, times(2)).addDeploymentData(captor.capture());
+ assertNotifier(captor, PDP1, PDP3);
+
+ captor = ArgumentCaptor.forClass(PolicyPdpNotificationData.class);
+ verify(notifier, times(2)).addUndeploymentData(captor.capture());
+ assertNotifier(captor, PDP2, PDP4);
+ }
+
+ private void assertNotifier(ArgumentCaptor<PolicyPdpNotificationData> captor, String firstPdp, String secondPdp) {
+ assertEquals(1, captor.getAllValues().get(0).getPdps().size());
+ assertEquals(1, captor.getAllValues().get(1).getPdps().size());
+
+ // ensure the order by using a TreeSet
+ TreeSet<String> pdps = new TreeSet<>(captor.getAllValues().get(0).getPdps());
+ pdps.addAll(captor.getAllValues().get(1).getPdps());
+ assertEquals("[" + firstPdp + ", " + secondPdp + "]", pdps.toString());
}
@Test
}
@Override
- protected BiFunction<PdpGroup, PdpSubGroup, Boolean> makeUpdater(ToscaPolicy policy,
+ protected Updater makeUpdater(SessionData data, ToscaPolicy policy,
ToscaPolicyIdentifierOptVersion desiredPolicy) {
return (group, subgroup) -> {
if (shouldUpdate.remove()) {
// queue indicated that the update should succeed
subgroup.getPolicies().add(policy.getIdentifier());
+
+ data.trackDeploy(policy.getIdentifier(), Collections.singleton(PDP1));
+ data.trackUndeploy(policy.getIdentifier(), Collections.singleton(PDP2));
+
+ ToscaPolicyIdentifier ident2 = new ToscaPolicyIdentifier(POLICY1_NAME, "9.9.9");
+ data.trackDeploy(ident2, Collections.singleton(PDP3));
+ data.trackUndeploy(ident2, Collections.singleton(PDP4));
return true;
} else {
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
+import java.util.TreeSet;
+import java.util.function.Supplier;
import javax.ws.rs.core.Response.Status;
import org.apache.commons.lang3.tuple.Pair;
import org.junit.Before;
import org.onap.policy.models.pdp.concepts.PdpUpdate;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicy;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyFilter;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifierOptVersion;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyType;
import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
+import org.onap.policy.pap.main.notification.PolicyPdpNotificationData;
public class TestSessionData extends ProviderSuper {
private static final String GROUP_NAME = "groupA";
verify(dao).deletePdpGroup(group1.getName());
}
+ @Test
+ public void testTrackDeploy() throws PfModelException {
+ testTrack(session::getDeployData, session::getUndeployData, session::trackDeploy);
+ }
+
+ /**
+ * Tests trackDeploy() when there is something in the undeployed list.
+ *
+ * @throws PfModelException if an error occurs
+ */
+ @Test
+ public void testTrackDeployRemoveUndeploy() throws PfModelException {
+ testTrack(session::getDeployData, session::getUndeployData, session::trackUndeploy, session::trackDeploy);
+ }
+
+ @Test
+ public void testTrackUndeploy() throws PfModelException {
+ testTrack(session::getUndeployData, session::getDeployData, session::trackUndeploy);
+ }
+
+ /**
+ * Tests trackUndeploy() when there is something in the deployed list.
+ *
+ * @throws PfModelException if an error occurs
+ */
+ @Test
+ public void testTrackUndeployRemoveUndeploy() throws PfModelException {
+ testTrack(session::getUndeployData, session::getDeployData, session::trackDeploy, session::trackUndeploy);
+ }
+
+ protected void testTrack(Supplier<Collection<PolicyPdpNotificationData>> expected,
+ Supplier<Collection<PolicyPdpNotificationData>> unexpected, TrackEx... trackFuncs)
+ throws PfModelException {
+
+ ToscaPolicy policy = makePolicy(POLICY_NAME, POLICY_VERSION);
+ policy.setType(POLICY_TYPE);
+ policy.setTypeVersion(POLICY_TYPE_VERSION);
+
+ when(dao.getFilteredPolicyList(any())).thenReturn(Arrays.asList(policy));
+
+ ToscaPolicyIdentifier policyId = new ToscaPolicyIdentifier(POLICY_NAME, POLICY_VERSION);
+ List<String> pdps = Arrays.asList(PDP1, PDP2);
+
+ for (TrackEx trackFunc : trackFuncs) {
+ trackFunc.accept(policyId, pdps);
+ }
+
+ // "unexpected" list should be empty of any PDPs
+ Collection<PolicyPdpNotificationData> dataList = unexpected.get();
+ assertTrue(dataList.size() <= 1);
+ if (!dataList.isEmpty()) {
+ PolicyPdpNotificationData data = dataList.iterator().next();
+ assertTrue(data.getPdps().isEmpty());
+ }
+
+ dataList = expected.get();
+ assertEquals(1, dataList.size());
+
+ PolicyPdpNotificationData data = dataList.iterator().next();
+ assertEquals(policyId, data.getPolicyId());
+ assertEquals(type, data.getPolicyType());
+ assertEquals("[pdp_1, pdp_2]", new TreeSet<>(data.getPdps()).toString());
+ }
+
private PdpUpdate makeUpdate(String pdpName) {
PdpUpdate update = new PdpUpdate();
private String getName(Pair<PdpUpdate, PdpStateChange> pair) {
return (pair.getKey() != null ? pair.getKey().getName() : pair.getValue().getName());
}
+
+ @FunctionalInterface
+ private static interface TrackEx {
+ public void accept(ToscaPolicyIdentifier policyId, Collection<String> pdps) throws PfModelException;
+ }
}
import org.onap.policy.pap.main.PapConstants;
import org.onap.policy.pap.main.PolicyPapException;
import org.onap.policy.pap.main.comm.PdpModifyRequestMap;
+import org.onap.policy.pap.main.comm.PdpTracker;
+import org.onap.policy.pap.main.notification.PolicyNotifier;
import org.onap.policy.pap.main.parameters.CommonTestData;
import org.onap.policy.pap.main.parameters.PapParameterGroup;
import org.onap.policy.pap.main.parameters.PapParameterHandler;
assertNotNull(Registry.get(PapConstants.REG_PDP_MODIFY_LOCK, Object.class));
assertNotNull(Registry.get(PapConstants.REG_STATISTICS_MANAGER, PapStatisticsManager.class));
assertNotNull(Registry.get(PapConstants.REG_PDP_MODIFY_MAP, PdpModifyRequestMap.class));
+ assertNotNull(Registry.get(PapConstants.REG_PDP_TRACKER, PdpTracker.class));
+ assertNotNull(Registry.get(PapConstants.REG_POLICY_NOTIFIER, PolicyNotifier.class));
// repeat - should throw an exception
assertThatIllegalStateException().isThrownBy(() -> activator.start());
assertNull(Registry.getOrDefault(PapConstants.REG_PDP_MODIFY_LOCK, Object.class, null));
assertNull(Registry.getOrDefault(PapConstants.REG_STATISTICS_MANAGER, PapStatisticsManager.class, null));
assertNull(Registry.getOrDefault(PapConstants.REG_PDP_MODIFY_MAP, PdpModifyRequestMap.class, null));
+ assertNull(Registry.getOrDefault(PapConstants.REG_PDP_TRACKER, PdpTracker.class, null));
+ assertNull(Registry.getOrDefault(PapConstants.REG_POLICY_NOTIFIER, PolicyNotifier.class, null));
// repeat - should throw an exception
assertThatIllegalStateException().isThrownBy(() -> activator.stop());
"topic" : "POLICY-PDP-PAP",
"servers" : [ "message-router" ],
"topicCommInfrastructure" : "noop"
+ },{
+ "topic" : "POLICY-NOTIFICATION",
+ "servers" : [ "message-router" ],
+ "topicCommInfrastructure" : "noop"
}]
}
}
"topic" : "POLICY-PDP-PAP",
"servers" : [ "message-router" ],
"topicCommInfrastructure" : "noop"
+ },{
+ "topic" : "POLICY-NOTIFICATION",
+ "servers" : [ "message-router" ],
+ "topicCommInfrastructure" : "noop"
}]
}
}
"topic" : "POLICY-PDP-PAP",
"servers" : [ "message-router" ],
"topicCommInfrastructure" : "noop"
+ },{
+ "topic" : "POLICY-NOTIFICATION",
+ "servers" : [ "message-router" ],
+ "topicCommInfrastructure" : "noop"
}]
}
}
--- /dev/null
+{
+ "groups": [
+ {
+ "name": "groupA",
+ "version": "200.2.3",
+ "description": "my description",
+ "pdpGroupState": "ACTIVE",
+ "properties": {
+ "hello": "world"
+ },
+ "pdpSubgroups": [
+ {
+ "pdpType": "pdpTypeA",
+ "desiredInstanceCount": 1,
+ "properties": {
+ "abc": "def"
+ },
+ "supportedPolicyTypes": [
+ {
+ "name": "typeA",
+ "version": "100.2.3"
+ }
+ ],
+ "pdpInstances": [
+ {
+ "instanceId": "pdpA"
+ }
+ ],
+ "policies": [
+ {
+ "name": "policyA",
+ "version": "1.2.3"
+ },
+ {
+ "name": "ToBeDeleted",
+ "version": "1.2.3"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
--- /dev/null
+{
+ "policies": [
+ {
+ "name": "ToBeDeleted",
+ "version": "1.2.3",
+ "type": "typeA",
+ "type_version": "100.2.3"
+ }
+ ]
+}
Code Review / policy / pap.git / commitdiff