Merge "Updated the push policy script"

1 files changed, 1227 insertions, 0 deletions

diff --git a/config/pe/ClosedLoopControlName.drl b/config/pe/ClosedLoopControlName.drl
new file mode 100644
index 00000000..c1af5cb1
--- /dev/null
+++ b/config/pe/ClosedLoopControlName.drl
@@ -0,0 +1,1227 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2017 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.controlloop;
+
+import org.onap.policy.controlloop.VirtualControlLoopEvent;
+import org.onap.policy.controlloop.VirtualControlLoopNotification;
+import org.onap.policy.controlloop.ControlLoopEventStatus;
+import org.onap.policy.controlloop.ControlLoopNotificationType;
+import org.onap.policy.controlloop.ControlLoopLogger;
+import org.onap.policy.controlloop.policy.PolicyResult;
+import org.onap.policy.controlloop.policy.ControlLoopPolicy;
+import org.onap.policy.controlloop.policy.Policy;
+import org.onap.policy.controlloop.eventmanager.ControlLoopEventManager;
+import org.onap.policy.controlloop.eventmanager.ControlLoopEventManager.NEW_EVENT_STATUS;
+import org.onap.policy.controlloop.eventmanager.ControlLoopOperationManager;
+import org.onap.policy.controlloop.actor.so.SOActorServiceProvider;
+import org.onap.policy.appc.Request;
+import org.onap.policy.appc.Response;
+import org.onap.policy.appc.CommonHeader;
+import org.onap.policy.appclcm.LCMRequestWrapper;
+import org.onap.policy.appclcm.LCMResponseWrapper;
+import org.onap.policy.appclcm.LCMRequest;
+import org.onap.policy.appclcm.LCMResponse;
+import org.onap.policy.appclcm.LCMCommonHeader;
+import org.onap.policy.vfc.VFCRequest;
+import org.onap.policy.vfc.VFCResponse;
+import org.onap.policy.vfc.VFCManager;
+import org.onap.policy.so.SOManager;
+import org.onap.policy.so.SORequest;
+import org.onap.policy.so.SORequestStatus;
+import org.onap.policy.so.SORequestDetails;
+import org.onap.policy.so.SOModelInfo;
+import org.onap.policy.so.SOCloudConfiguration;
+import org.onap.policy.so.SORequestInfo;
+import org.onap.policy.so.SORequestParameters;
+import org.onap.policy.so.SORelatedInstanceListElement;
+import org.onap.policy.so.SORelatedInstance;
+import org.onap.policy.so.SOResponse;
+import org.onap.policy.guard.PolicyGuard;
+import org.onap.policy.guard.PolicyGuard.LockResult;
+import org.onap.policy.guard.TargetLock;
+import org.onap.policy.guard.GuardResult;
+import org.onap.policy.guard.PolicyGuardRequest;
+import org.onap.policy.guard.PolicyGuardResponse;
+import org.onap.policy.guard.PolicyGuardXacmlRequestAttributes;
+import org.onap.policy.guard.PolicyGuardXacmlHelper;
+
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+import org.slf4j.LoggerFactory;
+import org.slf4j.Logger;
+
+import java.time.Instant;
+import java.util.LinkedList;
+import java.util.Iterator;
+
+import org.onap.policy.drools.system.PolicyEngine;
+
+declare Params
+  closedLoopControlName : String
+  controlLoopYaml : String
+end
+
+
+declare OperationTimer
+  closedLoopControlName : String
+  requestID : String
+  delay : String
+end
+
+declare ControlLoopTimer
+  closedLoopControlName : String
+  requestID : String
+  delay : String
+end
+
+/*
+*
+* Called once and only once to insert the parameters into working memory for this Closed Loop policy.
+*
+*/
+rule "${policyName}.SETUP"
+    when
+    then
+    
+    Params params = new Params();
+    params.setClosedLoopControlName("${closedLoopControlName}");
+    params.setControlLoopYaml("${controlLoopYaml}");
+    insert(params);
+
+    // Note: globals have bad behavior when persistence is used,
+    //       hence explicitly getting the logger vs using a global
+    
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {} : YAML=[{}]", params.getClosedLoopControlName(), drools.getRule().getName(), params.getControlLoopYaml());
+    
+    String sqlDbUsername = PolicyEngine.manager.getEnvironmentProperty("sql.db.username");
+    String sqlDbPassword = PolicyEngine.manager.getEnvironmentProperty("sql.db.password");
+    
+    String aaiUrl = PolicyEngine.manager.getEnvironmentProperty("aai.url");
+    String aaiUsername = PolicyEngine.manager.getEnvironmentProperty("aai.username");
+    String aaiPassword = PolicyEngine.manager.getEnvironmentProperty("aai.password");
+    
+    String soUrl =PolicyEngine.manager.getEnvironmentProperty("so.url");
+    String soUsername = PolicyEngine.manager.getEnvironmentProperty("so.username");
+    String soPassword = PolicyEngine.manager.getEnvironmentProperty("so.password");
+    
+    String vfcUrl =PolicyEngine.manager.getEnvironmentProperty("vfc.url");
+    String vfcUsername = PolicyEngine.manager.getEnvironmentProperty("vfc.username");
+    String vfcPassword = PolicyEngine.manager.getEnvironmentProperty("vfc.password");
+    
+    String guardUrl = PolicyEngine.manager.getEnvironmentProperty("guard.url");
+    String guardUsername = PolicyEngine.manager.getEnvironmentProperty("guard.username");
+    String guardPassword = PolicyEngine.manager.getEnvironmentProperty("guard.password");
+    String guardJdbcUrl = PolicyEngine.manager.getEnvironmentProperty("guard.jdbc.url");
+    
+    logger.info("{}: {} : AAI=[{}:{}]", params.getClosedLoopControlName(), drools.getRule().getName(), aaiUrl, aaiUsername);
+    logger.info("{}: {} : SO=[{}:{}]", params.getClosedLoopControlName(), drools.getRule().getName(), soUrl, soUsername);
+    logger.info("{}: {} : VFC=[{}:{}]", params.getClosedLoopControlName(), drools.getRule().getName(), vfcUrl, vfcUsername);
+    logger.info("{}: {} : GUARD=[{}:{}:{}]", params.getClosedLoopControlName(), drools.getRule().getName(), guardUrl, guardUsername, guardJdbcUrl);
+    logger.info("{}: {} : DB=[{}:{}]", params.getClosedLoopControlName(), drools.getRule().getName(), sqlDbUsername, sqlDbPassword);
+end
+
+/*
+*
+* This rule responds to DCAE Events where there is no manager yet. Either it is
+* the first ONSET, or a subsequent badly formed Event (i.e. Syntax error, or is-closed-loop-disabled)
+*
+*/
+rule "${policyName}.EVENT"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName() )
+        not ( ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID ) )
+    then
+ 
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    
+    try {
+      
+        //
+        // Check the event, because we need it to not be null when
+        // we create the ControlLoopEventManager. The ControlLoopEventManager
+        // will do extra syntax checking as well check if the closed loop is disabled.
+        //
+        if ($event.requestID == null) {
+            VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+            notification.notification = ControlLoopNotificationType.REJECTED;
+            notification.from = "policy";
+            notification.message = "Missing requestID";
+            notification.policyName = drools.getRule().getName();
+            notification.policyScope = "${policyScope}";
+            notification.policyVersion = "${policyVersion}";
+            
+            //
+            // Let interested parties know
+            //
+            PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+            
+            //
+            // Retract it from memory
+            //
+            retract($event);
+        } else {
+            //
+            // Create an EventManager
+            //
+            ControlLoopEventManager manager = new ControlLoopEventManager($params.getClosedLoopControlName(), $event.requestID);
+            //
+            // Determine if EventManager can actively process the event (i.e. syntax, is_closed_loop_disabled checks etc.)
+            //
+            VirtualControlLoopNotification notification = manager.activate($params.getControlLoopYaml(), $event);
+            notification.from = "pdp-0001-controller=controlloop"; // Engine.getInstanceName()
+            notification.policyName = drools.getRule().getName();
+            notification.policyScope = "${policyScope}";
+            notification.policyVersion = "${policyVersion}";
+            //
+            // Are we actively pursuing this event?
+            //
+            if (notification.notification == ControlLoopNotificationType.ACTIVE) {
+                //
+                // Insert Event Manager into memory, this will now kick off processing.
+                //
+                insert(manager);
+                //
+                // Let interested parties know
+                //
+                PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+                //
+                // Setup the Overall Control Loop timer
+                //
+                ControlLoopTimer clTimer = new ControlLoopTimer();
+                clTimer.setClosedLoopControlName($event.closedLoopControlName);
+                clTimer.setRequestID($event.requestID.toString());
+                clTimer.setDelay(manager.getControlLoopTimeout(1500) + "s");
+                //
+                // Insert it
+                //
+                insert(clTimer);
+            } else {
+                //
+                // Let interested parties know
+                //
+                PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+                //
+                // Retract it from memory
+                //
+                retract($event);
+            }
+            
+            //
+            // Now that the manager is inserted into Drools working memory, we'll wait for
+            // another rule to fire in order to continue processing. This way we can also
+            // then screen for additional ONSET and ABATED events for this RequestID.
+            //
+        }
+    } catch (Exception e) {
+        logger.warn("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName(), e);
+        
+        VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+        notification.notification = ControlLoopNotificationType.REJECTED;
+        notification.message = "Exception occurred " + e.getMessage();
+        notification.policyName = drools.getRule().getName();
+        notification.policyScope = "${policyScope}";
+        notification.policyVersion = "${policyVersion}";
+        //
+        //
+        //
+        PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+        //
+        // Retract the event
+        //
+        retract($event);
+    }
+end
+
+/*
+*
+* This rule happens when we got a valid ONSET, closed loop is enabled and an Event Manager
+* is now created. We can start processing the yaml specification via the Event Manager.
+*
+*/
+rule "${policyName}.EVENT.MANAGER"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName() )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $clTimer : ControlLoopTimer ( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString() )
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}: event={} manager={} clTimer={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(),
+                $event, $manager, $clTimer);
+    //
+    // Check which event this is.
+    //
+    ControlLoopEventManager.NEW_EVENT_STATUS eventStatus = $manager.onNewEvent($event);
+
+    //
+    // Check what kind of event this is
+    //
+    if (eventStatus == NEW_EVENT_STATUS.SUBSEQUENT_ONSET) {
+        //
+        // We don't care about subsequent onsets
+        //
+        logger.info("{}: {}: subsequent onset", 
+                    $params.getClosedLoopControlName(), drools.getRule().getName());
+        retract($event);
+        return;
+    }
+    if (eventStatus == NEW_EVENT_STATUS.SYNTAX_ERROR) {
+        //
+        // Ignore any bad syntax events
+        //
+        logger.warn("{}: {}: syntax error", 
+                    $params.getClosedLoopControlName(), drools.getRule().getName());
+        retract($event);
+        return;
+    }
+    //
+    // We only want the initial ONSET event in memory,
+    // all the other events need to be retracted to support
+    // cleanup and avoid the other rules being fired for this event.
+    //
+    if (eventStatus != NEW_EVENT_STATUS.FIRST_ONSET) {
+        logger.warn("{}: {}: no first onset", 
+                    $params.getClosedLoopControlName(), drools.getRule().getName());
+        retract($event);
+    }
+    
+    logger.debug("{}: {}: target={}", $params.getClosedLoopControlName(), 
+                 drools.getRule().getName(), $event.target);
+    //
+    // Now start seeing if we need to process this event
+    //
+    try {
+        //
+        // Check if this is a Final Event
+        //
+        VirtualControlLoopNotification notification = $manager.isControlLoopFinal();
+    
+    
+        if (notification != null) {
+            //
+            // Its final, but are we waiting for abatement?
+            //
+            if ($manager.getNumAbatements() > 0) {
+                logger.info("{}: {}: abatement received for {}.  Closing the control loop", 
+                            $params.getClosedLoopControlName(), drools.getRule().getName(), 
+                            $event.requestID);
+                notification.from = "policy";
+                notification.policyName = drools.getRule().getName();
+                notification.policyScope = "${policyScope}";
+                notification.policyVersion = "${policyVersion}";
+                //
+                // In this case, we are done
+                //
+                PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+                //
+                // Unlock the target
+                //
+                TargetLock lock = $manager.unlockCurrentOperation();
+                if (lock != null) {
+                    logger.debug("{}: {}: retracting lock=", $params.getClosedLoopControlName(), 
+                                 drools.getRule().getName(), lock);
+                    retract(lock);
+                }
+                //
+                // Retract everything from memory
+                //
+                logger.info("{}: {}: retracting onset, manager, and timer", 
+                            $params.getClosedLoopControlName(), drools.getRule().getName());
+                
+                retract($manager.getOnsetEvent());
+                retract($manager);
+                retract($clTimer);
+                //
+                // TODO - what if we get subsequent Events for this RequestID?
+                // By default, it will all start over again. May be confusing for Ruby.
+                // Or, we could track this and then subsequently ignore the events
+                //
+            } else {
+                //
+                // Check whether we need to wait for abatement
+                //
+                if ($manager.getProcessor().getControlLoop().getAbatement() == true && notification.notification == ControlLoopNotificationType.FINAL_SUCCESS) {
+                  logger.info("{}: {}: waiting for abatement ..", 
+                              $params.getClosedLoopControlName(), drools.getRule().getName());
+                } else {
+                  logger.info("{}: {}: no abatement expect for {}.  Closing the control loop", 
+                              $params.getClosedLoopControlName(), drools.getRule().getName(), 
+                              $event.requestID);
+                  
+                  notification.from = "policy";
+                  notification.policyName = drools.getRule().getName();
+                  notification.policyScope = "${policyScope}";
+                  notification.policyVersion = "${policyVersion}";
+                  
+                  //
+                  // In this case, we are done
+                  //
+                  PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+                  //
+                  // Unlock the target
+                  //
+                  TargetLock lock = $manager.unlockCurrentOperation();
+                  if (lock != null) {
+                      logger.debug("{}: {}: retracting lock=", $params.getClosedLoopControlName(), 
+                                  drools.getRule().getName(), lock);
+                      retract(lock);
+                  }
+                  //
+                  // Retract everything from memory
+                  //
+                  logger.info("{}: {}: retracting onset, manager, and timer", 
+                              $params.getClosedLoopControlName(), drools.getRule().getName());
+                  
+                  retract($manager.getOnsetEvent());
+                  retract($manager);
+                  retract($clTimer);
+                }
+            }
+        } else {
+            //
+            // NOT final, so let's ask for the next operation
+            //
+            ControlLoopOperationManager operation = $manager.processControlLoop();
+            if (operation != null) {
+              logger.info("{}: {}: starting operation={}", 
+                          $params.getClosedLoopControlName(), drools.getRule().getName(), 
+                          operation);
+              //
+              // insert into memory
+              //
+              insert(operation);
+              //
+              // insert operation timeout object
+              //
+              OperationTimer opTimer = new OperationTimer();
+              opTimer.setClosedLoopControlName($event.closedLoopControlName);
+              opTimer.setRequestID($event.requestID.toString());
+              opTimer.setDelay(operation.getOperationTimeout().toString() + "s");
+              insert(opTimer);
+      
+              //
+              // Let's ask for a lock right away
+              //
+              LockResult<GuardResult, TargetLock> result = $manager.lockCurrentOperation();
+              if (result.getA().equals(GuardResult.LOCK_ACQUIRED)) {
+                logger.info("{}: {}: guard lock acquired={}", 
+                            $params.getClosedLoopControlName(), drools.getRule().getName(), 
+                            result.getB());
+                
+                //
+                // Insert into memory
+                //
+                insert(result.getB());
+              }
+            } else {
+                //
+                // Probably waiting for abatement
+                //
+              logger.info("{}: {}: no operation, probably waiting for abatement", 
+                          $params.getClosedLoopControlName(), drools.getRule().getName());
+            }
+        }
+    } catch (Exception e) {
+      logger.warn("{}: {}: unexpected", 
+                  $params.getClosedLoopControlName(), 
+                  drools.getRule().getName(), e);
+
+      //
+      // TODO should we abort if we get an exception?
+      //
+    }
+        
+end
+
+
+
+/*
+*
+* 
+*
+*/
+rule "${policyName}.EVENT.MANAGER.OPERATION.NOT_LOCKED.TIMEOUT"
+    timer (int: 5s 5s)
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName() )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID )
+        not ( TargetLock (requestID == $event.requestID) )
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}: event={} manager={} operation={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(),
+                $event, $manager, $operation);
+    
+    //
+    // Need to ask for a Lock
+    //
+    LockResult<GuardResult, TargetLock> result = $manager.lockCurrentOperation();
+    if (result.getA().equals(GuardResult.LOCK_ACQUIRED)) {
+      logger.info("{}: {}: guard lock acquired={}", 
+                  $params.getClosedLoopControlName(), drools.getRule().getName(), 
+                  result.getB());
+      
+        //
+        // Insert into memory
+        //
+        insert(result.getB());
+    }
+    
+end
+
+/*
+*
+* Guard Permitted, let's send request to the actor.
+*
+*/
+rule "${policyName}.EVENT.MANAGER.OPERATION.LOCKED.GUARD_PERMITTED"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName() )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID, getGuardApprovalStatus() == "Permit" )
+        $lock : TargetLock (requestID == $event.requestID)
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}: event={} manager={} operation={} lock={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(),
+                $event, $manager, $operation, $lock);    
+
+    Object request = $operation.getOperationRequest();
+    
+    if (request != null) {
+      logger.debug("{}: {}: starting operation ..", 
+                   $params.getClosedLoopControlName(), drools.getRule().getName());
+      //
+      // Tell interested parties we are performing this Operation
+      //
+      VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+      notification.notification = ControlLoopNotificationType.OPERATION;
+      notification.message = $operation.getOperationMessage();
+      notification.history = $operation.getHistory();
+      notification.from = "policy";
+      notification.policyName = drools.getRule().getName();
+      notification.policyScope = "${policyScope}";
+      notification.policyVersion = "${policyVersion}";
+      
+      PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+      
+      switch ($operation.policy.getActor()){
+          
+          case "APPC":
+      
+              if (request instanceof Request) {
+                  PolicyEngine.manager.deliver("APPC-CL", request);
+              }
+              else if (request instanceof LCMRequestWrapper) {
+                  PolicyEngine.manager.deliver("APPC-LCM-READ", request);
+              }
+              break;
+          case "SO":
+              // at this point the AAI named query request should have already been made, the response recieved and used
+              // in the construction of the SO Request which is stored in operationRequest
+              
+              if(request instanceof SORequest) {
+                  // Call SO. The response will be inserted into memory once it's received 
+                  SOActorServiceProvider.sendRequest(drools.getWorkingMemory(), request);                        
+              }
+              break;
+          case "VFC":
+              if (request instanceof VFCRequest) {
+                  // Start VFC thread
+                  Thread t = new Thread(new VFCManager(drools.getWorkingMemory(), (VFCRequest)request));
+                  t.start();
+              }          
+              break;
+      }
+    } else {
+      //
+      // What happens if its null?
+      //
+      logger.warn("{}: {}: unexpected null operation request", 
+                  $params.getClosedLoopControlName(), 
+                  drools.getRule().getName());
+    }
+end
+
+
+/*
+*
+* We were able to acquire a lock so now let's ask Xacml Guard whether 
+* we are allowed to proceed with the request to the actor.
+*
+*/
+rule "${policyName}.EVENT.MANAGER.OPERATION.LOCKED.GUARD_NOT_YET_QUERIED"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName() )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID, getGuardApprovalStatus() == "NONE" )
+        $lock : TargetLock (requestID == $event.requestID)
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}: event={} manager={} operation={} lock={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(),
+                $event, $manager, $operation, $lock);
+
+    //
+    // We are starting the operation but the actor won't be contacted until Guard is queried and permitted.
+    //
+    $operation.startOperation($event);
+    
+    //
+    // Sending notification that we are about to query Guard ("DB write - start operation")
+    //
+    VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+    notification.notification = ControlLoopNotificationType.OPERATION;
+    notification.message = $operation.getOperationMessage();
+    notification.history = $operation.getHistory();
+    notification.from = "policy";
+    notification.policyName = drools.getRule().getName();
+    notification.policyScope = "${policyScope}";
+    notification.policyVersion = "${policyVersion}";
+    
+    PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+        
+    //
+    // Now send Guard Request to XACML Guard. In order to bypass the call to Guard, 
+    // just change guardEnabled to false.
+    // 
+    // In order to use REST XACML, provide a URL instead of "" as a second argument 
+    // to the CallGuardTask() and set the first argument to null 
+    // (instead of XacmlPdpEngine).
+    //
+    boolean guardEnabled = false;
+    
+    if(guardEnabled){
+    
+        Thread t = new Thread(new org.onap.policy.guard.CallGuardTask(
+                                                        PolicyEngine.manager.getEnvironmentProperty("guard.url"), 
+                                                        drools.getWorkingMemory(),
+                                                        $event.closedLoopControlName,
+                                                        $operation.policy.getActor().toString(),
+                                                        $operation.policy.getRecipe(),
+                                                        $manager.getTargetInstance($operation.policy),
+                                                        //$event.target,
+                                                        $event.requestID.toString()
+                                                        ));
+        t.start();
+    }
+    else{
+        insert(new PolicyGuardResponse("Permit", $event.requestID, $operation.policy.getRecipe()));
+    }
+
+end
+
+//
+// This rule will be triggered when a thread talking to the XACML Guard inserts a 
+// guardResponse object into the working memory
+//
+rule "${policyName}.GUARD.RESPONSE"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName(), closedLoopEventStatus == ControlLoopEventStatus.ONSET )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID ) 
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID )
+        $lock : TargetLock (requestID == $event.requestID)
+        $opTimer : OperationTimer( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString() )
+        $guardResponse : PolicyGuardResponse(requestID == $event.requestID, $operation.policy.recipe == operation)
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}: event={} manager={} operation={} lock={} opTimer={} guardResponse={}", 
+                 $params.getClosedLoopControlName(), drools.getRule().getName(),
+                 $event, $manager, $operation, $lock, $opTimer, $guardResponse);
+        
+        
+    //we will permit the operation if there was no Guard for it
+    if("Indeterminate".equals($guardResponse.result)){
+        $guardResponse.result = "Permit";
+    }
+    
+    //
+    // This notification has Guard result in "message". ("DB write - end operation in case of Guard Deny")
+    //
+    VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+    notification.notification = ControlLoopNotificationType.OPERATION;
+    notification.message = $operation.getOperationMessage($guardResponse.result);
+    notification.history = $operation.getHistory();
+    notification.from = "policy";
+    notification.policyName = drools.getRule().getName();
+    notification.policyScope = "${policyScope}";
+    notification.policyVersion = "${policyVersion}";
+    
+    PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+    
+    if("Permit".equals($guardResponse.result)){
+    
+        modify($operation){setGuardApprovalStatus($guardResponse.result)};
+    }
+    else {
+        //This is the Deny case
+        $operation.setOperationHasGuardDeny();
+        retract($opTimer);
+        retract($operation);
+        modify($manager) {finishOperation($operation)};
+    }
+    
+    retract($guardResponse);
+            
+end
+
+/*
+*
+* This rule responds to APPC Response Events
+*
+* I would have like to be consistent and write the Response like this:
+* $response : Response( CommonHeader.RequestID == $onset.requestID )
+*
+* However, no compile error was given. But a runtime error was given. I think
+* because drools is confused between the classname CommonHeader vs the property CommonHeader.
+*
+*/
+rule "${policyName}.APPC.RESPONSE"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName(), closedLoopEventStatus == ControlLoopEventStatus.ONSET ) 
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID )
+        $opTimer : OperationTimer( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString() )
+        $lock : TargetLock (requestID == $event.requestID)
+        $response : Response( getCommonHeader().RequestID == $event.requestID )
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    logger.debug("{}: {}: event={} manager={} operation={} lock={} opTimer={} response={}", 
+                 $params.getClosedLoopControlName(), drools.getRule().getName(),
+                 $event, $manager, $operation, $lock, $opTimer, $response);
+    //
+    // Get the result of the operation
+    //
+    PolicyResult policyResult = $operation.onResponse($response);
+    if (policyResult != null) {
+        logger.debug("{}: {}: operation finished - result={}", 
+                    $params.getClosedLoopControlName(), drools.getRule().getName(),
+                    policyResult);
+        //
+        // This Operation has completed, construct a notification showing our results. (DB write - end operation)
+        //
+        VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+        notification.from = "policy";
+        notification.policyName = drools.getRule().getName();
+        notification.policyScope = "${policyScope}";
+        notification.policyVersion = "${policyVersion}";
+        notification.message = $operation.getOperationHistory();
+        notification.history = $operation.getHistory();
+        if (policyResult.equals(PolicyResult.SUCCESS)) {
+            notification.notification = ControlLoopNotificationType.OPERATION_SUCCESS;
+            //
+            // Let interested parties know
+            //
+            PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+        } else {
+            notification.notification = ControlLoopNotificationType.OPERATION_FAILURE;
+            //
+            // Let interested parties know
+            //
+            PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+        }
+        //
+        // Ensure the operation is complete
+        //
+        if ($operation.isOperationComplete() == true) {
+            //
+            // It is complete, remove it from memory
+            //
+            retract($operation);
+            //
+            // We must also retract the timer object
+            // NOTE: We could write a Rule to do this
+            //
+            retract($opTimer);
+            //
+            // Complete the operation
+            //
+            modify($manager) {finishOperation($operation)};
+        } else {
+            //
+            // Just doing this will kick off the LOCKED rule again
+            //
+            modify($operation) {};
+        }
+    } else {
+        //
+        // Its not finished yet (i.e. expecting more Response objects)
+        //
+        // Or possibly it is a leftover response that we timed the request out previously
+        //
+    }
+    //
+    // We are going to retract these objects from memory
+    //
+    retract($response);
+end
+
+/*
+*
+* The problem with Responses is that they don't have a controlLoopControlName
+* field in them, so the only way to attach them is via RequestID. If we have multiple
+* control loop .drl's loaded in the same container, we need to be sure the cleanup
+* rules don't remove Responses for other control loops.
+*
+*/
+rule "${policyName}.APPC.RESPONSE.CLEANUP"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $response : Response($id : getCommonHeader().RequestID )
+        not ( VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName(), requestID == $id, closedLoopEventStatus == ControlLoopEventStatus.ONSET ) ) 
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    logger.debug("{}: {}: orphan appc response={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(), $id);
+        
+    //
+    // Retract it
+    //
+    retract($response);
+end
+
+/*
+*
+* This rule responds to APPC Response Events using the new LCM interface provided by appc
+*
+*/
+rule "${policyName}.APPC.LCM.RESPONSE"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName(), closedLoopEventStatus == ControlLoopEventStatus.ONSET ) 
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID )
+        $opTimer : OperationTimer( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString() )
+        $lock : TargetLock (requestID == $event.requestID)
+        $response : LCMResponseWrapper( getBody().getCommonHeader().getRequestId() == $event.requestID )
+    then
+
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    logger.debug("{}: {}: event={} manager={} operation={} lock={} opTimer={} response={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(),
+                $event, $manager, $operation, $lock, $operation, $opTimer, $response);
+    
+    //
+    // Get the result of the operation
+    //
+    PolicyResult policyResult = $operation.onResponse($response);
+    if (policyResult != null) {
+      logger.debug("{}: {}: operation finished - result={}", 
+                  $params.getClosedLoopControlName(), drools.getRule().getName(),
+                  policyResult);
+      
+      //
+      // This Operation has completed, construct a notification showing our results. (DB write - end operation)
+      //
+      VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+      notification.from = "policy";
+      notification.policyName = drools.getRule().getName();
+      notification.policyScope = "${policyScope}";
+      notification.policyVersion = "${policyVersion}";
+      notification.message = $operation.getOperationHistory();
+      notification.history = $operation.getHistory();
+      if (policyResult.equals(PolicyResult.SUCCESS)) {
+          notification.notification = ControlLoopNotificationType.OPERATION_SUCCESS;
+      } else {
+          notification.notification = ControlLoopNotificationType.OPERATION_FAILURE;
+      }
+      PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+      //
+      // Ensure the operation is complete
+      //
+      if ($operation.isOperationComplete() == true) {
+          //
+          // It is complete, remove it from memory
+          //
+          retract($operation);
+          //
+          // We must also retract the timer object
+          // NOTE: We could write a Rule to do this
+          //
+          retract($opTimer);
+          //
+          // Complete the operation
+          //
+          modify($manager) {finishOperation($operation)};
+      } else {
+          //
+          // Just doing this will kick off the LOCKED rule again
+          //
+          modify($operation) {};
+      }
+    } else {
+        //
+        // Its not finished yet (i.e. expecting more Response objects)
+        //
+        // Or possibly it is a leftover response that we timed the request out previously
+        //
+    }
+    //
+    // We are going to retract these objects from memory
+    //
+    retract($response);
+end
+
+/*
+*
+* Clean Up any lingering LCM reponses
+*
+*/
+rule "${policyName}.APPC.LCM.RESPONSE.CLEANUP"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $response : LCMResponseWrapper($id : getBody().getCommonHeader().getRequestId )
+        not ( VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName(), requestID == $id, closedLoopEventStatus == ControlLoopEventStatus.ONSET ) ) 
+    then
+    
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    logger.debug("{}: {}: orphan appc response={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(), $id);
+    //
+    // Retract it
+    //
+    retract($response);
+end
+
+/*
+*
+* This rule responds to SO Response Events
+*
+*/
+rule "${policyName}.SO.RESPONSE"
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName(), closedLoopEventStatus == ControlLoopEventStatus.ONSET )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName )
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID )
+        $opTimer : OperationTimer( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString() )
+        $lock : TargetLock (requestID == $event.requestID)
+        $response : SOResponse( request.requestId == $event.requestID.toString() )  
+    then
+        
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    logger.debug("{}: {}: event={} manager={} operation={} lock={} opTimer={} response={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(),
+                $event, $manager, $operation, $lock, $operation, $opTimer, $response);
+        
+    // Get the result of the operation
+    //
+    PolicyResult policyResult = $operation.onResponse($response);
+    if (policyResult != null) {
+        logger.debug("{}: {}: operation finished - result={}", 
+                    $params.getClosedLoopControlName(), drools.getRule().getName(),
+                    policyResult);
+      
+        //
+        // This Operation has completed, construct a notification showing our results
+        //
+        VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+        notification.from = "policy";
+        notification.policyName = drools.getRule().getName();
+        notification.policyScope = "${policyScope}";
+        notification.policyVersion = "${policyVersion}";
+        notification.message = $operation.getOperationHistory();
+        notification.history = $operation.getHistory();
+        if (policyResult.equals(PolicyResult.SUCCESS)) {
+            notification.notification = ControlLoopNotificationType.OPERATION_SUCCESS;
+        } else {
+            notification.notification = ControlLoopNotificationType.OPERATION_FAILURE;
+
+        }
+        PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+        //
+        // Ensure the operation is complete
+        //
+        if ($operation.isOperationComplete() == true) {
+            //
+            // It is complete, remove it from memory
+            //
+            retract($operation);
+            //
+            // We must also retract the timer object
+            // NOTE: We could write a Rule to do this
+            //
+            retract($opTimer);
+            //
+            // Complete the operation
+            //
+            modify($manager) {finishOperation($operation)};
+        } else {
+            //
+            // Just doing this will kick off the LOCKED rule again
+            //
+            modify($operation) {};
+        }
+    } else {
+        //
+        // Its not finished yet (i.e. expecting more Response objects)
+        //
+        // Or possibly it is a leftover response that we timed the request out previously
+        //
+    }
+    //
+    // We are going to retract these objects from memory
+    //
+    retract($response);
+
+end
+
+/*
+*
+* This rule responds to VFC Response Events
+*
+*/
+rule "${policyName}.VFC.RESPONSE"
+	when
+		$params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+		$event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName(), closedLoopEventStatus == ControlLoopEventStatus.ONSET )
+		$manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName )
+		$operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID )
+		$opTimer : OperationTimer( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString() )
+        $lock : TargetLock (requestID == $event.requestID)
+		$response : VFCResponse( requestId.toString() == $event.requestID.toString() )	
+	then
+		Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    	logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    	logger.debug("{}: {}: event={} manager={} operation={} lock={} opTimer={} response={}", 
+                	$params.getClosedLoopControlName(), drools.getRule().getName(),
+                	$event, $manager, $operation, $lock, $operation, $opTimer, $response);
+		
+		// Get the result of the operation
+		//
+		PolicyResult policyResult = $operation.onResponse($response);
+		if (policyResult != null) {
+			//
+			// This Operation has completed, construct a notification showing our results
+			//
+			VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+			notification.from = "policy";
+			notification.policyName = drools.getRule().getName();
+			notification.policyScope = "${policyScope}";
+			notification.policyVersion = "${policyVersion}";
+			notification.message = $operation.getOperationHistory();
+			notification.history = $operation.getHistory();
+			//
+			// Ensure the operation is complete
+			//
+			if ($operation.isOperationComplete() == true) {
+				//
+				// It is complete, remove it from memory
+				//
+				retract($operation);
+				//
+				// We must also retract the timer object
+				// NOTE: We could write a Rule to do this
+				//
+				retract($opTimer);
+				//
+				// Complete the operation
+				//
+				modify($manager) {finishOperation($operation)};
+			} else {
+				//
+				// Just doing this will kick off the LOCKED rule again
+				//
+				modify($operation) {};
+			}
+		} else {
+			//
+			// Its not finished yet (i.e. expecting more Response objects)
+			//
+			// Or possibly it is a leftover response that we timed the request out previously
+			//
+		}
+		//
+		// We are going to retract these objects from memory
+		//
+		retract($response);
+
+end
+
+/*
+*
+* This is the timer that manages the timeout for an individual operation.
+*
+*/
+rule "${policyName}.EVENT.MANAGER.OPERATION.TIMEOUT"
+    timer (expr: $to )
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName() )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $operation : ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID )
+        $opTimer : OperationTimer( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString(), $to : getDelay() )
+        $lock : TargetLock (requestID == $event.requestID)
+    then
+    
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+    logger.debug("{}: {}: event={} manager={} operation={} lock={} opTimer={}", 
+                $params.getClosedLoopControlName(), drools.getRule().getName(),
+                $event, $manager, $operation, $lock, $operation, $opTimer);
+    
+    //
+    // Tell it its timed out
+    //
+    $operation.setOperationHasTimedOut();
+    //
+    // Create a notification for it ("DB Write - end operation")
+    //
+    VirtualControlLoopNotification notification = new VirtualControlLoopNotification($event);
+    notification.from = "policy";
+    notification.policyName = drools.getRule().getName();
+    notification.policyScope = "${policyScope}";
+    notification.policyVersion = "${policyVersion}";
+    notification.notification = ControlLoopNotificationType.OPERATION_FAILURE;
+    notification.message = $operation.getOperationHistory();
+    notification.history = $operation.getHistory();
+    //
+    // Let interested parties know
+    //
+    PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+    //
+    // Get rid of the timer
+    //
+    retract($opTimer);
+    //
+    // Ensure the operation is complete
+    //
+    if ($operation.isOperationComplete() == true) {
+        //
+        // It is complete, remove it from memory
+        //
+        retract($operation);
+        //
+        // Complete the operation
+        //
+        modify($manager) {finishOperation($operation)};
+    } else {
+        //
+        // Just doing this will kick off the LOCKED rule again
+        //
+        modify($operation) {};
+    }
+end
+
+/*
+*
+* This is the timer that manages the overall control loop timeout.
+*
+*/
+rule "${policyName}.EVENT.MANAGER.TIMEOUT"
+    timer (expr: $to )
+    when
+        $params : Params( getClosedLoopControlName() == "${closedLoopControlName}" )
+        $event : VirtualControlLoopEvent( closedLoopControlName == $params.getClosedLoopControlName() )
+        $manager : ControlLoopEventManager( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID )
+        $clTimer : ControlLoopTimer ( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString(), $to : getDelay() )
+        $operations : LinkedList()
+                        from collect( ControlLoopOperationManager( onset.closedLoopControlName == $event.closedLoopControlName, onset.requestID == $event.requestID ) )
+        $opTimers : LinkedList()
+                        from collect( OperationTimer( closedLoopControlName == $event.closedLoopControlName, requestID == $event.requestID.toString() ) )
+        $locks : LinkedList()
+                        from collect( TargetLock (requestID == $event.requestID) )
+    then
+    
+    Logger logger = LoggerFactory.getLogger(drools.getRule().getPackage());
+    logger.info("{}: {}", $params.getClosedLoopControlName(), drools.getRule().getName());
+
+    if ($operations == null) {
+      logger.debug("{}: {}: event={} manager={} clTimer={} operations=0", 
+                  $params.getClosedLoopControlName(), drools.getRule().getName(),
+                  $event, $manager, $clTimer);
+    } else {
+      logger.debug("{}: {}: event={} manager={} clTimer={} operations={}", 
+                  $params.getClosedLoopControlName(), drools.getRule().getName(),
+                  $event, $manager, $clTimer, $operations.size());
+    }
+    //
+    // Tell the Event Manager it has timed out
+    //
+    VirtualControlLoopNotification notification = $manager.setControlLoopTimedOut();
+    if (notification != null) {
+        notification.from = "policy";
+        notification.policyName = drools.getRule().getName();
+        notification.policyScope = "${policyScope}";
+        notification.policyVersion = "${policyVersion}";
+        //
+        // Let interested parties know
+        //
+        PolicyEngine.manager.deliver("POLICY-CL-MGT", notification);
+    }
+    //
+    // Retract EVERYTHING
+    //
+    retract($event);
+    retract($manager);
+    retract($clTimer);
+    if ($operations != null && $operations.size() > 0) {
+        Iterator<ControlLoopOperationManager> iter = $operations.iterator();
+        while (iter.hasNext()) {
+            ControlLoopOperationManager manager = iter.next();
+            retract(manager);
+        }
+    }
+    if ($opTimers != null && $opTimers.size() > 0) {
+        Iterator<OperationTimer> iter = $opTimers.iterator();
+        while (iter.hasNext()) {
+            OperationTimer opTimer = iter.next();
+            retract(opTimer);
+        }
+    }
+    if ($locks != null && $locks.size() > 0) {
+        Iterator<TargetLock> iter = $locks.iterator();
+        while (iter.hasNext()) {
+            TargetLock lock = iter.next();
+            //
+            // Ensure we release the lock
+            //
+            PolicyGuard.unlockTarget(lock);
+            //
+            //
+            //
+            retract(lock);
+        }
+    }
+end
\ No newline at end of file