diff options
Diffstat (limited to 'controlloop/m2/base/src')
10 files changed, 1757 insertions, 0 deletions
diff --git a/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Actor.java b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Actor.java new file mode 100644 index 000000000..00eb181fc --- /dev/null +++ b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Actor.java @@ -0,0 +1,52 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import org.onap.policy.controlloop.ControlLoopEvent; +import org.onap.policy.controlloop.policy.Policy; + +/** + * This is the 'Actor' interface -- objects implementing this interface + * are placed within the 'nameToActor' table within class 'Transaction'. + * All of the instances are created and inserted in the table at initialization + * time, and are located using the 'Policy.actor' field as a key. + */ +public interface Actor { + /** + * Return the name associated with this Actor. + * + * @return the name associated with this Actor (as it appears in the 'yaml') + */ + String getName(); + + /** + * Create an operation for this actor, based on the supplied policy. + * + * @param transaction the transaction the operation is running under + * @param policy the policy associated with this operation + * @param onset the initial onset event that triggered the transaction + * @param attempt this value starts at 1, and is incremented for each retry + * @return the Operation instance + */ + Operation createOperation( + Transaction transaction, Policy policy, ControlLoopEvent onset, + int attempt); +} diff --git a/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/GuardAdjunct.java b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/GuardAdjunct.java new file mode 100644 index 000000000..34397e2b9 --- /dev/null +++ b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/GuardAdjunct.java @@ -0,0 +1,123 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import java.io.Serializable; + +import org.onap.policy.controlloop.ControlLoopOperation; +import org.onap.policy.controlloop.policy.Policy; +import org.onap.policy.guard.GuardContext; + +/** + * This adjunct class provides a way of accessing 'GuardContext' for any + * operations that use 'guard'. It needs to be created and inserted into the + * transaction 'adjunct' list prior to creating any operations that use it. + * + * <p>TBD: Serialization will need to factor in the fact that 'GuardContext' + * is a shared object. + */ +public class GuardAdjunct implements Transaction.Adjunct, Serializable { + private static final long serialVersionUID = 1L; + + // the associated transaction + private Transaction transaction = null; + + // the 'GuardContext' instance + private GuardContext context = null; + + /** + * Constructor -- just in case 'getInstance()' is used to create this + * instance (in which case 'guard' will not be used). + */ + public GuardAdjunct() { + // This comment is here to keep SONAR from getting upset + } + + /** + * This method is called to create the adjunct, and insert it into the + * transaction. + * + * @param transaction the associated transaction + * @param context the GuardContext derived from the controller properties + */ + public static void create(Transaction transaction, GuardContext context) { + GuardAdjunct ga = new GuardAdjunct(); + ga.transaction = transaction; + ga.context = context; + transaction.putAdjunct(ga); + } + + /** + * Return the GuardContext instance. + * + * @return the GuardContext instance + */ + public GuardContext get() { + return context; + } + + /** + * Do an asynchronous 'guard' query, and place the result in Drools memory. + * + * @param policy the policy associated with the operation + * @param target the target in a form meaningful to 'guard' + * @param requestId the transaction's request id + * @return 'true' if we have a 'GuardContext', and a response is expected, + * 'false' if 'guard' was not used, and should be skipped + */ + public boolean asyncQuery(Policy policy, String target, String requestId) { + if (context != null) { + // note that we still return 'true' as long as we have a + // 'GuardContext', even when 'guard.disabled' is set -- as long + // as there is an asynchronous response coming + context.asyncQuery(transaction.getWorkingMemory(), + policy.getActor(), + policy.getRecipe(), + target, + requestId, + transaction.getClosedLoopControlName()); + return true; + } + return false; + } + + /** + * Create a DB entry describing this operation. + * + * @param op the history entry associated with the operation + * @param target the same target that was passed on the 'asyncQuery' call + */ + public void asyncCreateDbEntry(ControlLoopOperation op, String target) { + if (context != null) { + context.asyncCreateDbEntry( + op.getStart(), + op.getEnd(), + transaction.getClosedLoopControlName(), + op.getActor(), + op.getOperation(), + target, + transaction.getRequestId().toString(), + op.getSubRequestId(), + op.getMessage(), + op.getOutcome()); + } + } +} diff --git a/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/OnsetAdapter.java b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/OnsetAdapter.java new file mode 100644 index 000000000..37a999f06 --- /dev/null +++ b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/OnsetAdapter.java @@ -0,0 +1,156 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import java.io.Serializable; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import org.onap.policy.controlloop.ControlLoopEvent; +import org.onap.policy.controlloop.ControlLoopNotification; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/* + * This class maps the class of an incoming ONSET message into the + * appropriate adapter. The default adapter is included here as well. + */ +public class OnsetAdapter implements Serializable { + private static final long serialVersionUID = 1L; + private static Logger logger = LoggerFactory.getLogger(OnsetAdapter.class); + + // table mapping onset message class to 'OnsetAdapter' instance + private static Map<Class,OnsetAdapter> map = new ConcurrentHashMap<>(); + + /** + * This method is called to add an entry to the table. + * + * @param clazz the class of the ONSET message + * @param value an instance of 'OnsetAdapter' that should be + * associated with 'clazz' + */ + public static void register(Class clazz, OnsetAdapter value) { + // only create an entry if one doesn't already exist + map.putIfAbsent(clazz, value); + } + + /** + * Map an incoming event's class into the appropriate 'OnsetAdapter' + * to use. + * + * @param event this is the onset event + * @return an adapter appropriate for the 'event' + */ + public static OnsetAdapter get(ControlLoopEvent event) { + Class<?> clazz = event.getClass(); + OnsetAdapter rval = map.get(clazz); + if (rval != null) { + return rval; + } + + // This algorithm below is generic, in the sense that it can be used + // to find a "best match" for any class out of a set of classes + // using the class inheritance relationships. In the general case, + // it is possible that there could be multiple best matches, but this + // can only happen if all of the matching keys are interfaces, + // except perhaps one. If there are multiple matches, + // one will be chosen "at random". + + // we need to look for the best match of 'clazz' + HashSet<Class> matches = new HashSet<>(); + Class chosenMatch = null; + synchronized (map) { + for (Class<?> possibleMatch : map.keySet()) { + if (possibleMatch.isAssignableFrom(clazz)) { + // we have a match -- see if it is the best match + boolean add = true; + for (Class<?> match : new ArrayList<Class>(matches)) { + if (match.isAssignableFrom(possibleMatch)) { + // 'possibleMatch' is a better match than 'match' + matches.remove(match); + } else if (possibleMatch.isAssignableFrom(match)) { + // we already have a better match + add = false; + break; + } + } + if (add) { + matches.add(possibleMatch); + } + } + } + if (!matches.isEmpty()) { + // we have at least one match + chosenMatch = matches.iterator().next(); + rval = map.get(chosenMatch); + + // add this entry back into the table -- this means we can + // now use this cached entry, and don't have to run through + // the algorithm again for this class + map.put(clazz, rval); + } + } + + if (matches.isEmpty()) { + logger.error("no matches for {}", clazz); + } else if (matches.size() != 1) { + logger.warn("multiple matches for {}: {} -- chose {}", + clazz, matches, chosenMatch); + } + + return rval; + } + + /* ============================================================ */ + + // the following code creates an initial entry in the table + private static OnsetAdapter instance = new OnsetAdapter(); + + static { + register(ControlLoopEvent.class, instance); + } + + // the new 'ControlLoopNotification' is abstract + public static class BaseControlLoopNotification extends ControlLoopNotification { + BaseControlLoopNotification(ControlLoopEvent event) { + super(event); + } + } + + /** + * This method is what all of the fuss is about -- we want to create + * a 'ControlLoopNotification' instance compatible with the type of the + * 'event' argument. This is the default implementation -- subclasses of + * 'ControlLoopEvent' may have entries in the table that are specialized + * generate objects that are a subclass of 'ControlLoopNotification' + * appropriate for the transaction type. + * + * @param event this is the event in question + * @return a 'ControlLoopNotification' instance based upon this event + */ + public ControlLoopNotification createNotification(ControlLoopEvent event) { + return new BaseControlLoopNotification(event); + } +} diff --git a/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Operation.java b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Operation.java new file mode 100644 index 000000000..5ca62fa82 --- /dev/null +++ b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Operation.java @@ -0,0 +1,125 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import java.io.Serializable; + +import org.onap.policy.controlloop.ControlLoopException; +import org.onap.policy.controlloop.ControlLoopOperation; +import org.onap.policy.controlloop.policy.Policy; +import org.onap.policy.controlloop.policy.PolicyResult; + +/** + * This is the 'Operation' interface -- each object implementing this + * interface exists for the duration of a single operation. + * + * <p>An operation typically includes some of the following steps: + * 1) Acquiring locks + * 2) 'Guard' query to see if the operation should proceed (some operations) + * 3) Outgoing request (usually using DMAAP or UEB, but possibly HTTP or HTTPS) + * 4) Incoming response + */ +public interface Operation extends Serializable { + /** + * This method is used as part of sending out the request. In the case of + * DMAAP or UEB interfaces, the method returns the message to be sent, + * but leaves it to the Drools code to do the actual sending. In the case + * of HTTP or HTTPS (e.g. AOTS), the method itself may run the operation in + * a different thread. + * + * @return an object containing the message + * @throws ControlLoopException if it occurs + */ + Object getRequest() throws ControlLoopException; + + /** + * Return the 'Policy' instance associated with this operation. + * + * @return the 'Policy' instance associated with this operation + */ + Policy getPolicy(); + + /** + * The 'state' of an operation is also the state of the 'Transaction' + * instance, while that operation is active. The state is often referenced + * in the 'when' clause of Drools rules, with the rules resembling state + * transition routines (state + event -> operation). In order to avoid + * confusion, the state names should be unique across all operations -- + * this is managed by having each state name begin with 'ACTOR.', where + * 'ACTOR' is the actor associated with the operation. + * + * @return a string value indicating the state of the operation + */ + String getState(); + + /** + * This is set to '1' for the initial attempt, and is incremented by one + * for each retry. Note that a new 'Operation' instance is created for + * each attempt. + * + * @return '1' for the initial attempt of an operation, and incremented + * for each retry + */ + int getAttempt(); + + /** + * Return the result of the operation. + * + * @return the result of the operation + * ('null' if the operation is still in progress) + */ + PolicyResult getResult(); + + /** + * Return the message associated with the completed operation. + * + * @return the message associated with the completed operation + * ('null' if the operation is still in progress) + */ + String getMessage(); + + /** + * An incoming message is being delivered to the operation. The type of + * the message is operation-dependent, and an operation will typically + * understand only one or two message types, and ignore the rest. The + * calling Drools code is written to assume that the transaction has been + * modified -- frequently, a state transition occurs as a result of + * the message. + * + * @param object the incoming message + */ + void incomingMessage(Object object); + + /** + * The operation has timed out. This typically results in the operation + * completing, but that is not enforced. + */ + void timeout(); + + /** + * This method is called on every operation right after its history + * entry has been completed. It gives the operation a chance to do some + * processing based on this entry (e.g. create a 'guard' entry in the DB). + * + * @param histEntry the history entry for this particular operation + */ + default void histEntryCompleted(ControlLoopOperation histEntry) {} +} diff --git a/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Transaction.java b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Transaction.java new file mode 100644 index 000000000..65bff684d --- /dev/null +++ b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Transaction.java @@ -0,0 +1,717 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import java.io.Serializable; +import java.time.Instant; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.ServiceLoader; +import java.util.UUID; + +import lombok.Getter; +import org.drools.core.WorkingMemory; +import org.kie.api.runtime.rule.FactHandle; + +import org.onap.policy.controlloop.ControlLoopEvent; +import org.onap.policy.controlloop.ControlLoopNotification; +import org.onap.policy.controlloop.ControlLoopNotificationType; +import org.onap.policy.controlloop.ControlLoopOperation; +import org.onap.policy.controlloop.policy.ControlLoopPolicy; +import org.onap.policy.controlloop.policy.FinalResult; +import org.onap.policy.controlloop.policy.Policy; +import org.onap.policy.controlloop.policy.PolicyResult; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/* + * Each instance of this class corresonds to a transaction that is in + * progress. While active, it resides within Drools memory. + */ + +public class Transaction implements Serializable { + + private static Logger logger = LoggerFactory.getLogger(Transaction.class); + + // This table maps 'actor' names to objects implementing the + // 'Actor' interface. 'ServiceLoader' is used to locate and create + // these objects, and populate the table. + private static Map<String,Actor> nameToActor = new HashMap<>(); + + static { + // use 'ServiceLoader' to locate all of the 'Actor' implementations + for (Actor actor : + ServiceLoader.load(Actor.class, Actor.class.getClassLoader())) { + logger.debug("Actor: " + actor.getName() + ", " + + actor.getClass()); + nameToActor.put(actor.getName(), actor); + } + } + + private static final long serialVersionUID = 4389211793631707360L; + + // Drools working memory containing this transaction + @Getter + private transient WorkingMemory workingMemory; + + // a service-identifier specified on the associated onset message + @Getter + private String closedLoopControlName; + + // identifies this transaction + @Getter + private UUID requestId; + + // the decoded YAML file for the policy + private ControlLoopPolicy policy; + + // the initial incoming event + private ControlLoopEvent onset = null; + + // operations specific to the type of 'event' + private OnsetAdapter onsetAdapter = null; + + // the current (or most recent) policy in effect + @Getter + private Policy currentPolicy = null; + + // the operation currently in progress + @Getter + private Operation currentOperation = null; + + // a history entry being constructed that is associated with the + // currently running operation + private ControlLoopOperation histEntry = null; + + // a list of completed history entries + @Getter + private List<ControlLoopOperation> history = new LinkedList<>(); + + // when the transaction completes, this is the final transaction result + @Getter + private FinalResult finalResult = null; + + //message, if any, associated with the result of this operation + private String message = null; + + // this table maps a class name into the associated adjunct + private Map<Class, Adjunct> adjuncts = new HashMap<>(); + + /** + * Constructor - initialize a 'Transaction' instance + * (typically invoked from 'Drools'). + * + * @param workingMemory Drools working memory containing this Transaction + * @param closedLoopControlName a string identifying the associated service + * @param requestId uniquely identifies this transaction + * @param policy decoded YAML file containing the policy + */ + public Transaction( + WorkingMemory workingMemory, + String closedLoopControlName, + UUID requestId, + ControlLoopPolicy policy) { + + logger.info("Transaction constructor"); + this.workingMemory = workingMemory; + this.closedLoopControlName = closedLoopControlName; + this.requestId = requestId; + this.policy = policy; + } + + /** + * Return a string indicating the current state of this transaction. + * If there is an operation in progress, the state indicates the operation + * state. Otherwise, the state is 'COMPLETE'. + * + * @return a string indicating the current state of this transaction + */ + public String getState() { + return currentOperation == null + ? "COMPLETE" : currentOperation.getState(); + } + + /** + * Return 'true' if the transaction has completed, and the final result + * indicates failure. + * + * @return 'true' if the transaction has completed, and the final result + * indicates failure + */ + public boolean finalResultFailure() { + return FinalResult.FINAL_SUCCESS != finalResult + && FinalResult.FINAL_OPENLOOP != finalResult + && finalResult != null; + } + + /** + * Return the overall policy timeout value as a String that can be used + * in a Drools timer. + * + * @return the overall policy timeout value as a String that can be used + * in a Drools timer + */ + public String getTimeout() { + return String.valueOf(policy.getControlLoop().getTimeout()) + "s"; + } + + /** + * Return the current operation timeout value as a String that can be used + * in a Drools timer. + * + * @return the current operation timeout value as a String that can be used + * in a Drools timer + */ + public String getOperationTimeout() { + return String.valueOf(currentPolicy.getTimeout()) + "s"; + } + + /** + * Let Drools know the transaction has been modified. + * + * <p>It is not necessary for Java code to call this method when an incoming + * message is received for an operation, or an operation timeout occurs -- + * the Drools code has been written with the assumption that the transaction + * is modified in these cases. Instead, this method should be called when + * some type of internal occurrence results in a state change, such as when + * an operation acquires a lock after initially being blocked. + */ + public void modify() { + FactHandle handle = workingMemory.getFactHandle(this); + if (handle != null) { + workingMemory.update(handle, this); + } + } + + /** + * Set the initial 'onset' event that started this transaction. + * + * @param event the initial 'onset' event + */ + public void setControlLoopEvent(ControlLoopEvent event) { + if (onset != null) { + logger.error("'Transaction' received unexpected event"); + return; + } + + onset = event; + + // fetch associated 'OnsetAdapter' + onsetAdapter = OnsetAdapter.get(onset); + + // check trigger policy type + if (isOpenLoop(policy.getControlLoop().getTrigger_policy())) { + // no operation is needed for open loops + finalResult = FinalResult.FINAL_OPENLOOP; + modify(); + } else { + // fetch current policy + setPolicyId(policy.getControlLoop().getTrigger_policy()); + } + } + + /** + * Validates the onset by ensuring fields that are required + * for processing are included in the onset. The fields needed + * include the requestId, targetType, and target. + * + * @param onset the initial message that triggers processing + */ + public boolean isControlLoopEventValid(ControlLoopEvent onset) { + if (onset.getRequestId() == null) { + this.message = "No requestID"; + return false; + } else if (onset.getTargetType() == null) { + this.message = "No targetType"; + return false; + } else if (onset.getTarget() == null || onset.getTarget().isEmpty()) { + this.message = "No target field"; + return false; + } + return true; + } + + /** + * Create a 'ControlLoopNotification' from the specified event. Note thet + * the type of the initial 'onset' event is used to determine the type + * of the 'ControlLoopNotification', rather than the event passed to the + * method. + * + * @param event the event used to generate the notification + * (if 'null' is passed, the 'onset' event is used) + * @return the created 'ControlLoopNotification' (or subclass) instance + */ + public ControlLoopNotification getNotification(ControlLoopEvent event) { + ControlLoopNotification notification = + onsetAdapter.createNotification(event == null ? this.onset : event); + + // include entire history + notification.setHistory(new ArrayList<ControlLoopOperation>(history)); + + return notification; + } + + /** + * This method is called when additional incoming messages are received + * for the transaction. Messages are routed to the current operation, + * any results are processed, and a notification may be returned to + * the caller. + * + * @param object an incoming message, which should be meaningful to the + * operation currently in progress + * @return a notification message if the operation completed, + * or 'null' if it is still in progress + */ + public ControlLoopNotification incomingMessage(Object object) { + ControlLoopNotification notification = null; + if (currentOperation != null) { + currentOperation.incomingMessage(object); + notification = processResult(currentOperation.getResult()); + } else { + logger.error("'Transaction' received unexpected message: " + + object); + } + return notification; + } + + /** + * This method is called from Drools when the current operation times out. + * + * @return a notification message if there is an operation in progress, + * or 'null' if not + */ + public ControlLoopNotification timeout() { + ControlLoopNotification notification = null; + if (currentOperation != null) { + // notify the current operation + currentOperation.timeout(); + + // process the timeout within the transaction + notification = processResult(currentOperation.getResult()); + } else { + logger.error("'Transaction' received unexpected timeout"); + } + return notification; + } + + /** + * This method is called from Drools during a control loop timeout + * to ensure the correct final notification is sent. + */ + public void clTimeout() { + this.finalResult = FinalResult.FINAL_FAILURE_TIMEOUT; + message = "Control Loop timed out"; + currentOperation = null; + } + + /** + * This method is called from Drools to generate a notification message + * when an operation is started. + * + * @return an initial notification message if there is an operation in + * progress, or 'null' if not + */ + public ControlLoopNotification initialOperationNotification() { + if (currentOperation == null || histEntry == null) { + return null; + } + + ControlLoopNotification notification = + onsetAdapter.createNotification(onset); + notification.setNotification(ControlLoopNotificationType.OPERATION); + notification.setMessage(histEntry.toHistory()); + notification.setHistory(new LinkedList<ControlLoopOperation>()); + for (ControlLoopOperation clo : history) { + if (histEntry.getOperation().equals(clo.getOperation()) + && histEntry.getActor().equals(clo.getActor())) { + notification.getHistory().add(clo); + } + } + return notification; + } + + /** + * Return a final notification message for the entire transaction. + * + * @return a final notification message for the entire transaction, + * or 'null' if we don't have a final result yet + */ + public ControlLoopNotification finalNotification() { + if (finalResult == null) { + return null; + } + + ControlLoopNotification notification = + onsetAdapter.createNotification(onset); + switch (finalResult) { + case FINAL_SUCCESS: + notification.setNotification( + ControlLoopNotificationType.FINAL_SUCCESS); + break; + case FINAL_OPENLOOP: + notification.setNotification( + ControlLoopNotificationType.FINAL_OPENLOOP); + break; + default: + notification.setNotification( + ControlLoopNotificationType.FINAL_FAILURE); + notification.setMessage(this.message); + break; + } + notification.setHistory(history); + return notification; + } + + /** + * Return a 'ControlLoopNotification' instance describing the current operation error. + * + * @return a 'ControlLoopNotification' instance describing the current operation error + */ + public ControlLoopNotification processError() { + ControlLoopNotification notification = null; + if (currentOperation != null) { + // process the error within the transaction + notification = processResult(currentOperation.getResult()); + } + return notification; + } + + /** + * Update the state of the transaction based upon the result of an operation. + * + * @param result if not 'null', this is the result of the current operation + * (if 'null', the operation is still in progress, + * and no changes are made) + * @return if not 'null', this is a notification message that should be + * sent to RUBY + */ + private ControlLoopNotification processResult(PolicyResult result) { + if (result == null) { + modify(); + return null; + } + String nextPolicy = null; + + ControlLoopOperation saveHistEntry = histEntry; + completeHistEntry(result); + + final ControlLoopNotification notification = processResult_HistEntry(saveHistEntry, result); + + // If there is a message from the operation then we set it to be + // used by the control loop notifications + message = currentOperation.getMessage(); + + // set the value 'nextPolicy' based upon the result of the operation + switch (result) { + case SUCCESS: + nextPolicy = currentPolicy.getSuccess(); + break; + + case FAILURE: + nextPolicy = processResult_Failure(); + break; + + case FAILURE_TIMEOUT: + nextPolicy = currentPolicy.getFailure_timeout(); + message = "Operation timed out"; + break; + + case FAILURE_RETRIES: + nextPolicy = currentPolicy.getFailure_retries(); + message = "Control Loop reached failure retry limit"; + break; + + case FAILURE_EXCEPTION: + nextPolicy = currentPolicy.getFailure_exception(); + break; + + case FAILURE_GUARD: + nextPolicy = currentPolicy.getFailure_guard(); + break; + + default: + break; + } + + if (nextPolicy != null) { + finalResult = FinalResult.toResult(nextPolicy); + if (finalResult == null) { + // it must be the next state + logger.debug("advancing to next operation"); + setPolicyId(nextPolicy); + } else { + logger.debug("moving to COMPLETE state"); + currentOperation = null; + } + } else { + logger.debug("doing retry with current actor"); + } + + modify(); + return notification; + } + + // returns a notification message based on the history entry + private ControlLoopNotification processResult_HistEntry(ControlLoopOperation hist, PolicyResult result) { + if (hist == null) { + return null; + } + + // generate notification, containing operation history + ControlLoopNotification notification = onsetAdapter.createNotification(onset); + notification.setNotification( + result == PolicyResult.SUCCESS + ? ControlLoopNotificationType.OPERATION_SUCCESS + : ControlLoopNotificationType.OPERATION_FAILURE); + notification.setMessage(hist.toHistory()); + + // include the subset of history that pertains to this + // actor and operation + notification.setHistory(new LinkedList<ControlLoopOperation>()); + for (ControlLoopOperation clo : history) { + if (hist.getOperation().equals(clo.getOperation()) + && hist.getActor().equals(clo.getActor())) { + notification.getHistory().add(clo); + } + } + + return notification; + } + + // returns the next policy if the current operation fails + private String processResult_Failure() { + String nextPolicy = null; + int attempt = currentOperation.getAttempt(); + if (attempt <= currentPolicy.getRetry()) { + // operation failed, but there are retries left + Actor actor = nameToActor.get(currentPolicy.getActor()); + if (actor != null) { + attempt += 1; + logger.debug("found Actor, attempt " + attempt); + currentOperation = + actor.createOperation(this, currentPolicy, onset, attempt); + createHistEntry(); + } else { + logger.error("'Transaction' can't find actor " + + currentPolicy.getActor()); + } + } else { + // operation failed, and no retries (or no retries left) + nextPolicy = (attempt == 1 + ? currentPolicy.getFailure() + : currentPolicy.getFailure_retries()); + logger.debug("moving to policy " + nextPolicy); + } + return nextPolicy; + } + + /** + * Create a history entry at the beginning of an operation, and store it + * in the 'histEntry' instance variable. + */ + private void createHistEntry() { + histEntry = new ControlLoopOperation(); + histEntry.setActor(currentPolicy.getActor()); + histEntry.setOperation(currentPolicy.getRecipe()); + histEntry.setTarget(currentPolicy.getTarget().toString()); + histEntry.setSubRequestId(String.valueOf(currentOperation.getAttempt())); + + // histEntry.end - we will set this one later + // histEntry.outcome - we will set this one later + // histEntry.message - we will set this one later + } + + /** + * Finish up the history entry at the end of an operation, and add it + * to the history list. + * + * @param result this is the result of the operation, which can't be 'null' + */ + private void completeHistEntry(PolicyResult result) { + if (histEntry == null) { + return; + } + + // append current entry to history + histEntry.setEnd(Instant.now()); + histEntry.setOutcome(result.toString()); + histEntry.setMessage(currentOperation.getMessage()); + history.add(histEntry); + + // give current operation a chance to act on it + currentOperation.histEntryCompleted(histEntry); + logger.debug("histEntry = {}", histEntry); + histEntry = null; + } + + /** + * Look up the identifier for the next policy, and prepare to start that + * operation. + * + * @param id this is the identifier associated with the policy + */ + private void setPolicyId(String id) { + currentPolicy = null; + currentOperation = null; + + // search through the policies for a matching 'id' + for (Policy tmp : policy.getPolicies()) { + if (id.equals(tmp.getId())) { + // found a match + currentPolicy = tmp; + break; + } + } + + if (currentPolicy != null) { + // locate the 'Actor' associated with 'currentPolicy' + Actor actor = nameToActor.get(currentPolicy.getActor()); + if (actor != null) { + // found the associated 'Actor' instance + currentOperation = + actor.createOperation(this, currentPolicy, onset, 1); + createHistEntry(); + } else { + logger.error("'Transaction' can't find actor " + + currentPolicy.getActor()); + } + } else { + logger.error("Transaction' can't find policy " + id); + } + + if (currentOperation == null) { + + // either we couldn't find the actor or the operation -- + // the transaction fails + finalResult = FinalResult.FINAL_FAILURE; + } + } + + private boolean isOpenLoop(String policyId) { + return FinalResult.FINAL_OPENLOOP.name().equalsIgnoreCase(policyId); + } + + /** + * This method sets the message for a control loop notification + * in the case where a custom message wants to be sent due to + * error processing, etc. + * + * @param message the message to be set for the control loop notification + */ + public void setNotificationMessage(String message) { + this.message = message; + } + + /** + * Return the notification message of this transaction. + * + * @return the notification message of this transaction + */ + public String getNotificationMessage() { + return this.message; + } + + /* ============================================================ */ + + /** + * Subclasses of 'Adjunct' provide data and methods to support one or + * more Actors/Operations, but are stored within the 'Transaction' + * instance. + */ + public static interface Adjunct extends Serializable { + /** + * Called when an adjunct is automatically created as a result of + * a 'getAdjunct' call. + * + * @param transaction the transaction containing the adjunct + */ + public default void init(Transaction transaction) {} + + /** + * Called for each adjunct when the transaction completes, and is + * removed from Drools memory. Any adjunct-specific cleanup can be + * done at this point (e.g. freeing locks). + */ + public default void cleanup(Transaction transaction) {} + } + + /** + * This is a method of class 'Transaction', and returns an adjunct of + * the specified class (it is created if it doesn't exist). + * + * @param clazz this is the class of the adjunct + * @return an adjunct of the specified class ('null' may be returned if + * the 'newInstance' method is unable to create the adjunct) + */ + public <T extends Adjunct> T getAdjunct(final Class<T> clazz) { + return clazz.cast(adjuncts.computeIfAbsent(clazz, cl -> { + T adjunct = null; + try { + // create the adjunct (may trigger an exception) + adjunct = clazz.newInstance(); + + // initialize the adjunct (may also trigger an exception */ + adjunct.init(Transaction.this); + } catch (Exception e) { + logger.error("Transaction can't create adjunct of {}", cl, e); + } + return adjunct; + })); + } + + /** + * Explicitly create an adjunct -- this is useful when the adjunct + * initialization requires that some parameters be passed. + * + * @param adjunct this is the adjunct to insert into the table + * @return 'true' if successful + * ('false' is returned if an adjunct with this class already exists) + */ + public boolean putAdjunct(Adjunct adjunct) { + return adjuncts.putIfAbsent(adjunct.getClass(), adjunct) == null; + } + + /** + * This method needs to be called when the transaction completes, which + * is typically right after it is removed from Drools memory. + */ + public void cleanup() { + // create a list containing all of the adjuncts (in no particular order) + List<Adjunct> values; + synchronized (adjuncts) { + values = new LinkedList<>(adjuncts.values()); + } + + // iterate over the list + for (Adjunct a : values) { + try { + // call the 'cleanup' method on the adjunct + a.cleanup(this); + } catch (Exception e) { + logger.error("Transaction.cleanup exception", e); + } + } + } +} diff --git a/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Util.java b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Util.java new file mode 100644 index 000000000..8e6d98bf7 --- /dev/null +++ b/controlloop/m2/base/src/main/java/org/onap/policy/m2/base/Util.java @@ -0,0 +1,62 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import java.util.List; + +import org.onap.policy.common.endpoints.event.comm.TopicEndpointManager; +import org.onap.policy.common.endpoints.event.comm.TopicSink; +import org.onap.policy.drools.core.PolicyContainer; +import org.onap.policy.drools.core.PolicySession; +import org.onap.policy.drools.system.PolicyController; +import org.onap.policy.drools.system.PolicyControllerConstants; +import org.onap.policy.drools.system.PolicyEngineConstants; + +/** + * This class contains static utility methods. + */ +public class Util { + /** + * Find the PolicyController associated with the specified PolicySession. + * + * @param session the current PolicySession + * @return the associated PolicyController (or 'null' if not found) + */ + public static PolicyController getPolicyController(PolicySession session) { + PolicyContainer container = session.getPolicyContainer(); + return PolicyControllerConstants.getFactory().get( + container.getGroupId(), container.getArtifactId()); + } + + /** + * Send a UEB/DMAAP message to the specified topic, using the specified + * PolicyController. + * + * @param topic UEB/DMAAP topic + * @param event the message to encode, and send + * @return 'true' if successful, 'false' if delivery failed + * @throws IllegalStateException if the topic can't be found, + * or there are multiple topics with the same name + */ + public static boolean deliver(String topic, Object event) { + return PolicyEngineConstants.getManager().deliver(topic, event); + } +} diff --git a/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/ActorOperationTest.java b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/ActorOperationTest.java new file mode 100644 index 000000000..4cbd05e03 --- /dev/null +++ b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/ActorOperationTest.java @@ -0,0 +1,116 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import org.junit.Test; + +import org.onap.policy.controlloop.ControlLoopEvent; +import org.onap.policy.controlloop.ControlLoopException; +import org.onap.policy.controlloop.policy.Policy; +import org.onap.policy.controlloop.policy.PolicyResult; + +public class ActorOperationTest { + + public static final String ACTOR_NAME = "test"; + public static final String STATE = "COMPLETE"; + + public static class TestOperation implements Operation { + + @Override + public Object getRequest() throws ControlLoopException { + return "request"; + } + + @Override + public Policy getPolicy() { + return null; + } + + @Override + public String getState() { + return STATE; + } + + @Override + public int getAttempt() { + return 0; + } + + @Override + public PolicyResult getResult() { + return PolicyResult.SUCCESS; + } + + @Override + public String getMessage() { + return "success"; + } + + @Override + public void incomingMessage(Object object) { + return; + } + + @Override + public void timeout() { + return; + } + + } + + public static class TestActor implements Actor { + + @Override + public String getName() { + return ACTOR_NAME; + } + + @Override + public Operation createOperation(Transaction transaction, Policy policy, ControlLoopEvent onset, int attempt) { + return new TestOperation(); + } + + } + + @Test + public void getNameTest() { + Actor actor = new TestActor(); + assertEquals(ACTOR_NAME, actor.getName()); + } + + @Test + public void operationTest() throws ControlLoopException { + Actor actor = new TestActor(); + Operation operation = actor.createOperation(null, null, null, 0); + assertNotNull(operation); + assertEquals("request", operation.getRequest()); + assertNull(operation.getPolicy()); + assertEquals(STATE, operation.getState()); + assertEquals(0, operation.getAttempt()); + assertEquals(PolicyResult.SUCCESS, operation.getResult()); + assertEquals("success", operation.getMessage()); + } + +} diff --git a/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/GuardAdjunctTest.java b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/GuardAdjunctTest.java new file mode 100644 index 000000000..eacfc8f6f --- /dev/null +++ b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/GuardAdjunctTest.java @@ -0,0 +1,103 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.time.Instant; +import java.util.UUID; + +import org.junit.BeforeClass; +import org.junit.Test; + +import org.onap.policy.controlloop.ControlLoopOperation; +import org.onap.policy.controlloop.policy.Policy; +import org.onap.policy.guard.GuardContext; +import org.powermock.reflect.Whitebox; + +public class GuardAdjunctTest { + private static final String ADJUNCT_CONTEXT_FIELD = "context"; + private static final String ADJUNCT_TRANSACTION_FIELD = "transaction"; + + private static GuardAdjunct adjunct; + private static Transaction transaction; + private static GuardContext context; + + /** + * Class-level initialization. + */ + @BeforeClass + public static void setup() { + transaction = new Transaction(null, "testCL", UUID.randomUUID(), null); + context = mock(GuardContext.class); + + GuardAdjunct.create(transaction, context); + adjunct = transaction.getAdjunct(GuardAdjunct.class); + } + + @Test + public void createGuardAdjunctTest() { + assertEquals(context, adjunct.get()); + } + + @Test + public void asyncQueryTest() { + Policy policy = new Policy(); + policy.setActor("APPCLCM"); + policy.setRecipe("test"); + + assertTrue(adjunct.asyncQuery(policy, "testTarget", UUID.randomUUID().toString())); + + GuardContext savedContext = Whitebox.getInternalState(adjunct, ADJUNCT_CONTEXT_FIELD); + Whitebox.setInternalState(adjunct, ADJUNCT_CONTEXT_FIELD, (GuardContext)null); + + try { + assertFalse(adjunct.asyncQuery(policy, "testTarget", UUID.randomUUID().toString())); + } finally { + Whitebox.setInternalState(adjunct, ADJUNCT_CONTEXT_FIELD, savedContext); + } + } + + @Test + public void asyncCreateDbEntryTest() { + ControlLoopOperation op = new ControlLoopOperation(); + op.setStart(Instant.now().minusSeconds(1)); + op.setEnd(Instant.now()); + op.setActor("testActor"); + op.setOperation("testOperation"); + op.setSubRequestId("0"); + op.setMessage("test"); + op.setOutcome("success"); + + adjunct.asyncCreateDbEntry(op, "testTarget"); + verify(context, times(1)).asyncCreateDbEntry(op.getStart(), op.getEnd(), + transaction.getClosedLoopControlName(), op.getActor(), + op.getOperation(), "testTarget", transaction.getRequestId().toString(), + op.getSubRequestId(), op.getMessage(), op.getOutcome()); + + } +} diff --git a/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/TransactionTest.java b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/TransactionTest.java new file mode 100644 index 000000000..3c186ce6d --- /dev/null +++ b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/TransactionTest.java @@ -0,0 +1,230 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.time.Instant; +import java.util.LinkedList; +import java.util.UUID; + +import org.drools.core.WorkingMemory; +import org.drools.core.impl.StatefulKnowledgeSessionImpl; +import org.junit.Ignore; +import org.junit.Test; + +import org.onap.policy.controlloop.ControlLoopEventStatus; +import org.onap.policy.controlloop.ControlLoopNotification; +import org.onap.policy.controlloop.ControlLoopTargetType; +import org.onap.policy.controlloop.VirtualControlLoopEvent; +import org.onap.policy.controlloop.policy.ControlLoop; +import org.onap.policy.controlloop.policy.ControlLoopPolicy; +import org.onap.policy.controlloop.policy.FinalResult; +import org.onap.policy.controlloop.policy.Policy; + +public class TransactionTest { + + private VirtualControlLoopEvent setControlLoopEvent(UUID requestId, String closedLoopControlName, + Instant eventStart, String targetType, String target) { + + VirtualControlLoopEvent event = new VirtualControlLoopEvent(); + event.setClosedLoopControlName(closedLoopControlName); + event.setClosedLoopEventStatus(ControlLoopEventStatus.ONSET); + event.setRequestId(requestId); + event.setClosedLoopAlarmStart(eventStart); + event.setTarget(target); + event.setTargetType(targetType); + event.getAai().put("vserver.is-closed-loop-disabled", "false"); + event.getAai().put("complex.state", "NJ"); + event.getAai().put("vserver.l-interface.interface-name", "89ee9ee6-1e96-4063-b690-aa5ca9f73b32"); + event.getAai().put("vserver.l-interface.l3-interface-ipv4-address-list.l3-inteface-ipv4-address", + "135.144.3.49"); + event.getAai().put("vserver.l-interface.l3-interface-ipv6-address-list.l3-inteface-ipv6-address", null); + event.getAai().put("vserver.in-maint", "N"); + event.getAai().put("complex.city", "AAIDefault"); + event.getAai().put("vserver.vserver-id", "aa7a24f9-8791-491f-b31a-c8ba5ad9e2aa"); + event.getAai().put("vserver.l-interface.network-name", "vUSP_DPA3_OAM_3750"); + event.getAai().put("vserver.vserver-name", "ctsf0002vm013"); + event.getAai().put("generic-vnf.vnf-name", "ctsf0002v"); + event.getAai().put("generic-vnf.service-id", "e433710f-9217-458d-a79d-1c7aff376d89"); + event.getAai().put("vserver.selflink", "https://compute-aic.dpa3.cci.att.com:8774/v2/d0719b845a804b368f8ac0bba39e188b/servers/aa7a24f9-8791-491f-b31a-c8ba5ad9e2aa"); + event.getAai().put("generic-vnf.vnf-type", "vUSP - vCTS"); + event.getAai().put("tenant.tenant-id", "d0719b845a804b368f8ac0bba39e188b"); + event.getAai().put("cloud-region.identity-url", ""); + event.getAai().put("vserver.prov-status", "PROV"); + event.getAai().put("complex.physical-location-id", "LSLEILAA"); + + return event; + } + + private ControlLoopPolicy createControlLoop() { + + ControlLoop controlLoop = new ControlLoop(); + controlLoop.setControlLoopName("cltest"); + controlLoop.setTrigger_policy("testid"); + controlLoop.setTimeout(15); + + Policy policy = new Policy(); + policy.setActor("APPCLCM"); + policy.setId("testid"); + policy.setName("policytest"); + policy.setRecipe("restart"); + policy.setRetry(1); + policy.setTimeout(10); + policy.setSuccess(FinalResult.FINAL_SUCCESS.toString()); + policy.setFailure(FinalResult.FINAL_FAILURE.toString()); + policy.setFailure_exception(FinalResult.FINAL_FAILURE_EXCEPTION.toString()); + policy.setFailure_guard(FinalResult.FINAL_FAILURE_GUARD.toString()); + policy.setFailure_retries(FinalResult.FINAL_FAILURE_RETRIES.toString()); + policy.setFailure_timeout(FinalResult.FINAL_FAILURE_TIMEOUT.toString()); + + LinkedList<Policy> policies = new LinkedList<>(); + policies.add(policy); + + ControlLoopPolicy controlLoopPolicy = new ControlLoopPolicy(); + controlLoopPolicy.setControlLoop(controlLoop); + controlLoopPolicy.setPolicies(policies); + + return controlLoopPolicy; + } + + @Test + public void validControlLoopEventTest() { + VirtualControlLoopEvent event = setControlLoopEvent(UUID.randomUUID(), + "cltest", Instant.now(), ControlLoopTargetType.VM, "vserver.vserver-name"); + Transaction transaction = new Transaction(null, "clvusptest", event.getRequestId(), createControlLoop()); + assertTrue(transaction.isControlLoopEventValid(event)); + } + + @Test + public void noRequestIdControlLoopEventTest() { + VirtualControlLoopEvent event = setControlLoopEvent(null, + "cltest", Instant.now(), ControlLoopTargetType.VM, "vserver.vserver-name"); + Transaction transaction = new Transaction(null, "clvusptest", event.getRequestId(), createControlLoop()); + assertFalse(transaction.isControlLoopEventValid(event)); + assertEquals("No requestID", transaction.getNotificationMessage()); + } + + @Test + public void noTargetTypeControlLoopEventTest() { + VirtualControlLoopEvent event = setControlLoopEvent(UUID.randomUUID(), + "cltest", Instant.now(), null, "vserver.vserver-name"); + Transaction transaction = new Transaction(null, "clvusptest", event.getRequestId(), createControlLoop()); + assertFalse(transaction.isControlLoopEventValid(event)); + assertEquals("No targetType", transaction.getNotificationMessage()); + } + + @Test + public void noTargetControlLoopEventTest() { + VirtualControlLoopEvent event = setControlLoopEvent(UUID.randomUUID(), + "cltest", Instant.now(), ControlLoopTargetType.VM, null); + Transaction transaction = new Transaction(null, "clvusptest", event.getRequestId(), createControlLoop()); + assertFalse(transaction.isControlLoopEventValid(event)); + assertEquals("No target field", transaction.getNotificationMessage()); + } + + @Test + public void getClosedLoopControlNameTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + assertEquals("clvusptest", transaction.getClosedLoopControlName()); + } + + @Test + public void getRequestIdTest() { + UUID requestId = UUID.randomUUID(); + Transaction transaction = new Transaction(null, "clvusptest", requestId, createControlLoop()); + assertEquals(requestId, transaction.getRequestId()); + } + + @Test + public void getWorkingMemoryTest() { + // Create mock working session + StatefulKnowledgeSessionImpl mockWorkingMemory = mock(StatefulKnowledgeSessionImpl.class); + Transaction transaction = new Transaction(mockWorkingMemory, "clvusptest", + UUID.randomUUID(), createControlLoop()); + assertEquals(mockWorkingMemory, transaction.getWorkingMemory()); + } + + @Test + public void getStateCompleteTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + assertEquals("COMPLETE", transaction.getState()); + } + + @Test + public void getFinalResultTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + assertEquals(null, transaction.getFinalResult()); + } + + @Test + public void finalResultFailureTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + assertFalse(transaction.finalResultFailure()); + } + + @Test + public void getTimeoutTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + assertEquals("15s", transaction.getTimeout()); + } + + @Test + public void getOperationTimeoutTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + VirtualControlLoopEvent onset = setControlLoopEvent(UUID.randomUUID(), + "cltest", null, ControlLoopTargetType.VM, "vserver.vserver-name"); + transaction.setControlLoopEvent(onset); + assertEquals("10s", transaction.getOperationTimeout()); + } + + @Test + public void getCurrentPolicy() { + ControlLoopPolicy controlLoopPolicy = createControlLoop(); + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), controlLoopPolicy); + VirtualControlLoopEvent onset = setControlLoopEvent(UUID.randomUUID(), + "cltest", null, ControlLoopTargetType.VM, "vserver.vserver-name"); + transaction.setControlLoopEvent(onset); + assertEquals(controlLoopPolicy.getPolicies().get(0), transaction.getCurrentPolicy()); + } + + @Test + public void getOperationTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + assertEquals(null, transaction.getCurrentOperation()); + } + + @Test + public void getNotificationTest() { + Transaction transaction = new Transaction(null, "clvusptest", UUID.randomUUID(), createControlLoop()); + VirtualControlLoopEvent onset = setControlLoopEvent(UUID.randomUUID(), + "cltest", null, ControlLoopTargetType.VM, "vserver.vserver-name"); + transaction.setControlLoopEvent(onset); + ControlLoopNotification notification = transaction.getNotification(onset); + assertEquals(onset.getClosedLoopControlName(), notification.getClosedLoopControlName()); + assertEquals(onset.getRequestId(), notification.getRequestId()); + assertEquals(onset.getTarget(), notification.getTarget()); + } +} diff --git a/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/UtilTest.java b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/UtilTest.java new file mode 100644 index 000000000..53d97209b --- /dev/null +++ b/controlloop/m2/base/src/test/java/org/onap/policy/m2/base/UtilTest.java @@ -0,0 +1,73 @@ +/*- + * ============LICENSE_START======================================================= + * m2/base + * ================================================================================ + * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.m2.base; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.Properties; + +import org.junit.BeforeClass; +import org.junit.Test; +import org.onap.policy.common.endpoints.event.comm.TopicEndpointManager; +import org.onap.policy.drools.core.PolicyContainer; +import org.onap.policy.drools.core.PolicySession; +import org.onap.policy.drools.system.PolicyController; + +public class UtilTest { + + private static PolicySession session; + + /** + * Class-level initialization. + */ + @BeforeClass + public static void setup() { + PolicyContainer container = mock(PolicyContainer.class); + when(container.getGroupId()).thenReturn("org.onap.policy"); + when(container.getArtifactId()).thenReturn("test"); + when(container.getVersion()).thenReturn("1.0.0"); + + session = mock(PolicySession.class); + when(session.getPolicyContainer()).thenReturn(container); + } + + @Test + public void deliverTest() { + Properties prop = new Properties(); + prop.put("noop.sink.topics", "testTopic"); + TopicEndpointManager.getManager().addTopicSinks(prop); + + // throws an exception: + // java.lang.IllegalStateException: Policy Engine is stopped + // if policy engine is started, it still throws an exception: + // java.lang.IllegalArgumentException: no reverse coder has been found + //assertTrue(Util.deliver("testTopic", "test")); + } + + @Test(expected = IllegalStateException.class) + public void deliverNoTopicTest() { + Util.deliver("noTopic", "test"); + } +} |