gerrit.onap Code Review - policy/drools-applications.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * policy-yaml
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.controlloop.compiler;
  22
  23 import com.google.common.collect.ImmutableList;
  24 import com.google.common.collect.ImmutableMap;
  25
  26 import java.io.InputStream;
  27 import java.io.Serializable;
  28 import java.util.Collections;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Map.Entry;
  33
  34 import org.jgrapht.DirectedGraph;
  35 import org.jgrapht.graph.ClassBasedEdgeFactory;
  36 import org.jgrapht.graph.DefaultEdge;
  37 import org.jgrapht.graph.DirectedMultigraph;
  38 import org.onap.policy.controlloop.policy.ControlLoop;
  39 import org.onap.policy.controlloop.policy.ControlLoopPolicy;
  40 import org.onap.policy.controlloop.policy.FinalResult;
  41 import org.onap.policy.controlloop.policy.Policy;
  42 import org.onap.policy.controlloop.policy.PolicyResult;
  43 import org.onap.policy.controlloop.policy.TargetType;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46 import org.yaml.snakeyaml.Yaml;
  47 import org.yaml.snakeyaml.constructor.Constructor;
  48
  49
  50 public class ControlLoopCompiler implements Serializable {
  51     private static final String OPERATION_POLICY = "Operation Policy ";
  52     private static final long serialVersionUID = 1L;
  53     private static final Logger LOGGER = LoggerFactory.getLogger(ControlLoopCompiler.class.getName());
  54
  55     /**
  56      * Compiles the policy from an object.
  57      */
  58     public static ControlLoopPolicy compile(ControlLoopPolicy policy,
  59                     ControlLoopCompilerCallback callback) throws CompilerException {
  60         //
  61         // Ensure the control loop is sane
  62         //
  63         validateControlLoop(policy.getControlLoop(), callback);
  64         //
  65         // Validate the policies
  66         //
  67         validatePolicies(policy, callback);
  68
  69         return policy;
  70     }
  71
  72     /**
  73      * Compiles the policy from an input stream.
  74      *
  75      * @param yamlSpecification the yaml input stream
  76      * @param callback method to callback during compilation
  77      * @return Control Loop object
  78      * @throws CompilerException throws any compile exception found
  79      */
  80     public static ControlLoopPolicy compile(InputStream yamlSpecification,
  81                     ControlLoopCompilerCallback callback) throws CompilerException {
  82         Yaml yaml = new Yaml(new Constructor(ControlLoopPolicy.class));
  83         Object obj = yaml.load(yamlSpecification);
  84         if (obj == null) {
  85             throw new CompilerException("Could not parse yaml specification.");
  86         }
  87         if (! (obj instanceof ControlLoopPolicy)) {
  88             throw new CompilerException("Yaml could not parse specification into required ControlLoopPolicy object");
  89         }
  90         return ControlLoopCompiler.compile((ControlLoopPolicy) obj, callback);
  91     }
  92
  93     private static void validateControlLoop(ControlLoop controlLoop,
  94                     ControlLoopCompilerCallback callback) throws CompilerException {
  95         if (controlLoop == null && callback != null) {
  96             callback.onError("controlLoop cannot be null");
  97         }
  98         if (controlLoop != null) {
  99             if ((controlLoop.getControlLoopName() == null || controlLoop.getControlLoopName().length() < 1)
 100                             && callback != null) {
 101                 callback.onError("Missing controlLoopName");
 102             }
 103             if ((!controlLoop.getVersion().contentEquals(ControlLoop.getCompilerVersion())) && callback != null) {
 104                 callback.onError("Unsupported version for this compiler");
 105             }
 106             if (controlLoop.getTrigger_policy() == null || controlLoop.getTrigger_policy().length() < 1) {
 107                 throw new CompilerException("trigger_policy is not valid");
 108             }
 109         }
 110     }
 111
 112     private static void validatePolicies(ControlLoopPolicy policy,
 113                     ControlLoopCompilerCallback callback) throws CompilerException {
 114         if (policy == null) {
 115             throw new CompilerException("policy cannot be null");
 116         }
 117         if (policy.getPolicies() == null) {
 118             callback.onWarning("controlLoop is an open loop.");
 119         } else {
 120             //
 121             // For this version we can use a directed multigraph, in the future we may not be able to
 122             //
 123             DirectedGraph<NodeWrapper, LabeledEdge> graph =
 124                             new DirectedMultigraph<>(new ClassBasedEdgeFactory<NodeWrapper,
 125                                             LabeledEdge>(LabeledEdge.class));
 126             //
 127             // Check to see if the trigger Event is for OpenLoop, we do so by
 128             // attempting to create a FinalResult object from it. If its a policy id, this should
 129             // return null.
 130             //
 131             FinalResult triggerResult = FinalResult.toResult(policy.getControlLoop().getTrigger_policy());
 132             TriggerNodeWrapper triggerNode;
 133             //
 134             // Did this turn into a FinalResult object?
 135             //
 136             if (triggerResult != null) {
 137                 validateOpenLoopPolicy(policy, triggerResult, callback);
 138                 return;
 139                 //
 140             } else {
 141                 validatePoliciesContainTriggerPolicyAndCombinedTimeoutIsOk(policy, callback);
 142                 triggerNode = new TriggerNodeWrapper(policy.getControlLoop().getControlLoopName());
 143             }
 144             //
 145             // Add in the trigger node
 146             //
 147             graph.addVertex(triggerNode);
 148             //
 149             // Add in our Final Result nodes. All paths should end to these nodes.
 150             //
 151             FinalResultNodeWrapper finalSuccess = new FinalResultNodeWrapper(FinalResult.FINAL_SUCCESS);
 152             FinalResultNodeWrapper finalFailure = new FinalResultNodeWrapper(FinalResult.FINAL_FAILURE);
 153             FinalResultNodeWrapper finalFailureTimeout = new FinalResultNodeWrapper(FinalResult.FINAL_FAILURE_TIMEOUT);
 154             FinalResultNodeWrapper finalFailureRetries = new FinalResultNodeWrapper(FinalResult.FINAL_FAILURE_RETRIES);
 155             FinalResultNodeWrapper finalFailureException =
 156                             new FinalResultNodeWrapper(FinalResult.FINAL_FAILURE_EXCEPTION);
 157             FinalResultNodeWrapper finalFailureGuard = new FinalResultNodeWrapper(FinalResult.FINAL_FAILURE_GUARD);
 158             graph.addVertex(finalSuccess);
 159             graph.addVertex(finalFailure);
 160             graph.addVertex(finalFailureTimeout);
 161             graph.addVertex(finalFailureRetries);
 162             graph.addVertex(finalFailureException);
 163             graph.addVertex(finalFailureGuard);
 164             //
 165             // Work through the policies and add them in as nodes.
 166             //
 167             Map<Policy, PolicyNodeWrapper> mapNodes = addPoliciesAsNodes(policy, graph, triggerNode, callback);
 168             //
 169             // last sweep to connect remaining edges for policy results
 170             //
 171             for (Policy operPolicy : policy.getPolicies()) {
 172                 PolicyNodeWrapper node = mapNodes.get(operPolicy);
 173                 //
 174                 // Just ensure this has something
 175                 //
 176                 if (node == null) {
 177                     continue;
 178                 }
 179                 addEdge(graph, mapNodes, operPolicy.getId(), operPolicy.getSuccess(), finalSuccess,
 180                                 PolicyResult.SUCCESS, node);
 181                 addEdge(graph, mapNodes, operPolicy.getId(), operPolicy.getFailure(), finalFailure,
 182                                 PolicyResult.FAILURE, node);
 183                 addEdge(graph, mapNodes, operPolicy.getId(), operPolicy.getFailure_timeout(), finalFailureTimeout,
 184                                 PolicyResult.FAILURE_TIMEOUT, node);
 185                 addEdge(graph, mapNodes, operPolicy.getId(), operPolicy.getFailure_retries(), finalFailureRetries,
 186                                 PolicyResult.FAILURE_RETRIES, node);
 187                 addEdge(graph, mapNodes, operPolicy.getId(), operPolicy.getFailure_exception(), finalFailureException,
 188                                 PolicyResult.FAILURE_EXCEPTION, node);
 189                 addEdge(graph, mapNodes, operPolicy.getId(), operPolicy.getFailure_guard(), finalFailureGuard,
 190                                 PolicyResult.FAILURE_GUARD, node);
 191             }
 192             validateNodesAndEdges(graph, callback);
 193         }
 194     }
 195
 196     private static void validateOpenLoopPolicy(ControlLoopPolicy policy, FinalResult triggerResult,
 197                     ControlLoopCompilerCallback callback) throws CompilerException {
 198         //
 199         // Ensure they didn't use some other FinalResult code
 200         //
 201         if (triggerResult != FinalResult.FINAL_OPENLOOP) {
 202             throw new CompilerException("Unexpected Final Result for trigger_policy, should only be "
 203         + FinalResult.FINAL_OPENLOOP.toString() + " or a valid Policy ID");
 204         }
 205         //
 206         // They really shouldn't have any policies attached.
 207         //
 208         if ((policy.getPolicies() != null || policy.getPolicies().isEmpty()) && callback != null ) {
 209             callback.onWarning("Open Loop policy contains policies. The policies will never be invoked.");
 210         }
 211     }
 212
 213     private static void validatePoliciesContainTriggerPolicyAndCombinedTimeoutIsOk(ControlLoopPolicy policy,
 214                     ControlLoopCompilerCallback callback) throws CompilerException {
 215         int sum = 0;
 216         boolean triggerPolicyFound = false;
 217         for (Policy operPolicy : policy.getPolicies()) {
 218             sum += operPolicy.getTimeout().intValue();
 219             if (policy.getControlLoop().getTrigger_policy().equals(operPolicy.getId())) {
 220                 triggerPolicyFound = true;
 221             }
 222         }
 223         if (policy.getControlLoop().getTimeout().intValue() < sum && callback != null) {
 224             callback.onError("controlLoop overall timeout is less than the sum of operational policy timeouts.");
 225         }
 226
 227         if (!triggerPolicyFound) {
 228             throw new CompilerException("Unexpected value for trigger_policy, should only be "
 229         + FinalResult.FINAL_OPENLOOP.toString() + " or a valid Policy ID");
 230         }
 231     }
 232
 233     private static Map<Policy, PolicyNodeWrapper> addPoliciesAsNodes(ControlLoopPolicy policy,
 234             DirectedGraph<NodeWrapper, LabeledEdge> graph, TriggerNodeWrapper triggerNode,
 235             ControlLoopCompilerCallback callback) {
 236         Map<Policy, PolicyNodeWrapper> mapNodes = new HashMap<>();
 237         for (Policy operPolicy : policy.getPolicies()) {
 238             //
 239             // Is it still ok to add?
 240             //
 241             if (!okToAdd(operPolicy, callback)) {
 242                 //
 243                 // Do not add it in
 244                 //
 245                 continue;
 246             }
 247             //
 248             // Create wrapper policy node and save it into our map so we can
 249             // easily retrieve it.
 250             //
 251             PolicyNodeWrapper node = new PolicyNodeWrapper(operPolicy);
 252             mapNodes.put(operPolicy, node);
 253             graph.addVertex(node);
 254             //
 255             // Is this the trigger policy?
 256             //
 257             if (operPolicy.getId().equals(policy.getControlLoop().getTrigger_policy())) {
 258                 //
 259                 // Yes add an edge from our trigger event node to this policy
 260                 //
 261                 graph.addEdge(triggerNode, node, new LabeledEdge(triggerNode, node, new TriggerEdgeWrapper("ONSET")));
 262             }
 263         }
 264         return mapNodes;
 265     }
 266
 267     private static void addEdge(DirectedGraph<NodeWrapper, LabeledEdge> graph, Map<Policy, PolicyNodeWrapper> mapNodes,
 268                     String policyId, String connectedPolicy,
 269                     FinalResultNodeWrapper finalResultNodeWrapper,
 270                     PolicyResult policyResult, NodeWrapper node) throws CompilerException {
 271         FinalResult finalResult = FinalResult.toResult(finalResultNodeWrapper.getId());
 272         if (FinalResult.isResult(connectedPolicy, finalResult)) {
 273             graph.addEdge(node, finalResultNodeWrapper, new LabeledEdge(node, finalResultNodeWrapper,
 274                             new FinalResultEdgeWrapper(finalResult)));
 275         } else {
 276             PolicyNodeWrapper toNode = findPolicyNode(mapNodes, connectedPolicy);
 277             if (toNode == null) {
 278                 throw new CompilerException(OPERATION_POLICY + policyId + " is connected to unknown policy "
 279             + connectedPolicy);
 280             } else {
 281                 graph.addEdge(node, toNode, new LabeledEdge(node, toNode, new PolicyResultEdgeWrapper(policyResult)));
 282             }
 283         }
 284     }
 285
 286     private static void validateNodesAndEdges(DirectedGraph<NodeWrapper, LabeledEdge> graph,
 287                     ControlLoopCompilerCallback callback) throws CompilerException {
 288         for (NodeWrapper node : graph.vertexSet()) {
 289             if (node instanceof TriggerNodeWrapper) {
 290                 validateTriggerNodeWrapper(graph, node);
 291             } else if (node instanceof FinalResultNodeWrapper) {
 292                 validateFinalResultNodeWrapper(graph, node);
 293             } else if (node instanceof PolicyNodeWrapper) {
 294                 validatePolicyNodeWrapper(graph, node, callback);
 295             }
 296             for (LabeledEdge edge : graph.outgoingEdgesOf(node)) {
 297                 LOGGER.info("{} invokes {} upon {}", edge.from.getId(), edge.to.getId(), edge.edge.getId());
 298             }
 299         }
 300     }
 301
 302     private static void validateTriggerNodeWrapper(DirectedGraph<NodeWrapper, LabeledEdge> graph,
 303                     NodeWrapper node) throws CompilerException {
 304         if (LOGGER.isDebugEnabled()) {
 305             LOGGER.info("Trigger Node {}", node);
 306         }
 307         if (graph.inDegreeOf(node) > 0 ) {
 308             //
 309             // Really should NEVER get here unless someone messed up the code above.
 310             //
 311             throw new CompilerException("No inputs to event trigger");
 312         }
 313         //
 314         // Should always be 1, except in the future we may support multiple events
 315         //
 316         if (graph.outDegreeOf(node) > 1) {
 317             throw new CompilerException("The event trigger should only go to ONE node");
 318         }
 319     }
 320
 321     private static void validateFinalResultNodeWrapper(DirectedGraph<NodeWrapper, LabeledEdge> graph,
 322                     NodeWrapper node) throws CompilerException {
 323         if (LOGGER.isDebugEnabled()) {
 324             LOGGER.info("FinalResult Node {}", node);
 325         }
 326         //
 327         // FinalResult nodes should NEVER have an out edge
 328         //
 329         if (graph.outDegreeOf(node) > 0) {
 330             throw new CompilerException("FinalResult nodes should never have any out edges.");
 331         }
 332     }
 333
 334     private static void validatePolicyNodeWrapper(DirectedGraph<NodeWrapper, LabeledEdge> graph,
 335                     NodeWrapper node, ControlLoopCompilerCallback callback) throws CompilerException {
 336         if (LOGGER.isDebugEnabled()) {
 337             LOGGER.info("Policy Node {}", node);
 338         }
 339         //
 340         // All Policy Nodes should have the 5 out degrees defined.
 341         //
 342         if (graph.outDegreeOf(node) != 6) {
 343             throw new CompilerException("Policy node should ALWAYS have 6 out degrees.");
 344         }
 345         //
 346         // All Policy Nodes should have at least 1 in degrees
 347         //
 348         if (graph.inDegreeOf(node) == 0 && callback != null) {
 349             callback.onWarning("Policy " + node.getId() + " is not reachable.");
 350         }
 351     }
 352
 353     private static boolean okToAdd(Policy operPolicy, ControlLoopCompilerCallback callback) {
 354         boolean isOk = isPolicyIdOk(operPolicy, callback);
 355         if (! isActorOk(operPolicy, callback)) {
 356             isOk = false;
 357         }
 358         if (! isRecipeOk(operPolicy, callback)) {
 359             isOk = false;
 360         }
 361         if (! isTargetOk(operPolicy, callback) ) {
 362             isOk = false;
 363         }
 364         if (! arePolicyResultsOk(operPolicy, callback) ) {
 365             isOk = false;
 366         }
 367         return isOk;
 368     }
 369
 370     private static boolean isPolicyIdOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 371         boolean isOk = true;
 372         if (operPolicy.getId() == null || operPolicy.getId().length() < 1) {
 373             if (callback != null) {
 374                 callback.onError("Operational Policy has an bad ID");
 375             }
 376             isOk = false;
 377         } else {
 378             //
 379             // Check if they decided to make the ID a result object
 380             //
 381             if (PolicyResult.toResult(operPolicy.getId()) != null) {
 382                 if (callback != null) {
 383                     callback.onError("Policy id is set to a PolicyResult " + operPolicy.getId());
 384                 }
 385                 isOk = false;
 386             }
 387             if (FinalResult.toResult(operPolicy.getId()) != null) {
 388                 if (callback != null) {
 389                     callback.onError("Policy id is set to a FinalResult " + operPolicy.getId());
 390                 }
 391                 isOk = false;
 392             }
 393         }
 394         return isOk;
 395     }
 396
 397     private static boolean isActorOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 398         boolean isOk = true;
 399         if (operPolicy.getActor() == null) {
 400             if (callback != null) {
 401                 callback.onError("Policy actor is null");
 402             }
 403             isOk = false;
 404         }
 405         //
 406         // Construct a list for all valid actors
 407         //
 408         ImmutableList<String> actors = ImmutableList.of("APPC", "AOTS", "MSO", "SDNO", "SDNR", "AAI");
 409         //
 410         if (operPolicy.getActor() != null && (!actors.contains(operPolicy.getActor())) ) {
 411             if (callback != null) {
 412                 callback.onError("Policy actor is invalid");
 413             }
 414             isOk = false;
 415         }
 416         return isOk;
 417     }
 418
 419     private static boolean isRecipeOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 420         boolean isOk = true;
 421         if (operPolicy.getRecipe() == null) {
 422             if (callback != null) {
 423                 callback.onError("Policy recipe is null");
 424             }
 425             isOk = false;
 426         }
 427         //
 428         // NOTE: We need a way to find the acceptable recipe values (either Enum or a database that has these)
 429         //
 430         ImmutableMap<String, List<String>> recipes = new ImmutableMap.Builder<String, List<String>>()
 431                 .put("APPC", ImmutableList.of("Restart", "Rebuild", "Migrate", "ModifyConfig"))
 432                 .put("AOTS", ImmutableList.of("checkMaintenanceWindow",
 433                                 "checkENodeBTicketHours",
 434                                 "checkEquipmentStatus",
 435                                 "checkEimStatus",
 436                                 "checkEquipmentMaintenance"))
 437                 .put("MSO", ImmutableList.of("VF Module Create"))
 438                 .put("SDNO", ImmutableList.of("health-diagnostic-type",
 439                                 "health-diagnostic",
 440                                 "health-diagnostic-history",
 441                                 "health-diagnostic-commands",
 442                                 "health-diagnostic-aes"))
 443                 .put("SDNR", ImmutableList.of("Restart", "Reboot"))
 444                 .build();
 445         //
 446         if (operPolicy.getRecipe() != null
 447                         && (!recipes.getOrDefault(operPolicy.getActor(),
 448                                         Collections.emptyList()).contains(operPolicy.getRecipe()))) {
 449             if (callback != null) {
 450                 callback.onError("Policy recipe is invalid");
 451             }
 452             isOk = false;
 453         }
 454         return isOk;
 455     }
 456
 457     private static boolean isTargetOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 458         boolean isOk = true;
 459         if (operPolicy.getTarget() == null) {
 460             if (callback != null) {
 461                 callback.onError("Policy target is null");
 462             }
 463             isOk = false;
 464         }
 465         if (operPolicy.getTarget() != null
 466                         && operPolicy.getTarget().getType() != TargetType.VM
 467                         && operPolicy.getTarget().getType() != TargetType.VFC
 468                         && operPolicy.getTarget().getType() != TargetType.PNF) {
 469             if (callback != null) {
 470                 callback.onError("Policy target is invalid");
 471             }
 472             isOk = false;
 473         }
 474         return isOk;
 475     }
 476
 477     private static boolean arePolicyResultsOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 478         //
 479         // Check that policy results are connected to either default final * or another policy
 480         //
 481         boolean isOk = isSuccessPolicyResultOk(operPolicy, callback);
 482         if (! isFailurePolicyResultOk(operPolicy, callback) ) {
 483             isOk = false;
 484         }
 485         if (! isFailureRetriesPolicyResultOk(operPolicy, callback) ) {
 486             isOk = false;
 487         }
 488         if (! isFailureTimeoutPolicyResultOk(operPolicy, callback) ) {
 489             isOk = false;
 490         }
 491         if (! isFailureExceptionPolicyResultOk(operPolicy, callback) ) {
 492             isOk = false;
 493         }
 494         if (! isFailureGuardPolicyResultOk(operPolicy, callback) ) {
 495             isOk = false;
 496         }
 497         return isOk;
 498     }
 499
 500     private static boolean isSuccessPolicyResultOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 501         boolean isOk = true;
 502         if (FinalResult.toResult(operPolicy.getSuccess()) != null
 503                         && !operPolicy.getSuccess().equals(FinalResult.FINAL_SUCCESS.toString())) {
 504             if (callback != null) {
 505                 callback.onError("Policy success is neither another policy nor FINAL_SUCCESS");
 506             }
 507             isOk = false;
 508         }
 509         return isOk;
 510     }
 511
 512     private static boolean isFailurePolicyResultOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 513         boolean isOk = true;
 514         if (FinalResult.toResult(operPolicy.getFailure()) != null
 515                         && !operPolicy.getFailure().equals(FinalResult.FINAL_FAILURE.toString())) {
 516             if (callback != null) {
 517                 callback.onError("Policy failure is neither another policy nor FINAL_FAILURE");
 518             }
 519             isOk = false;
 520         }
 521         return isOk;
 522     }
 523
 524     private static boolean isFailureRetriesPolicyResultOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 525         boolean isOk = true;
 526         if (FinalResult.toResult(operPolicy.getFailure_retries()) != null
 527                         && !operPolicy.getFailure_retries().equals(FinalResult.FINAL_FAILURE_RETRIES.toString())) {
 528             if (callback != null) {
 529                 callback.onError("Policy failure retries is neither another policy nor FINAL_FAILURE_RETRIES");
 530             }
 531             isOk = false;
 532         }
 533         return isOk;
 534     }
 535
 536     private static boolean isFailureTimeoutPolicyResultOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 537         boolean isOk = true;
 538         if (FinalResult.toResult(operPolicy.getFailure_timeout()) != null
 539                         && !operPolicy.getFailure_timeout().equals(FinalResult.FINAL_FAILURE_TIMEOUT.toString())) {
 540             if (callback != null) {
 541                 callback.onError("Policy failure timeout is neither another policy nor FINAL_FAILURE_TIMEOUT");
 542             }
 543             isOk = false;
 544         }
 545         return isOk;
 546     }
 547
 548     private static boolean isFailureExceptionPolicyResultOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 549         boolean isOk = true;
 550         if (FinalResult.toResult(operPolicy.getFailure_exception()) != null
 551                         && !operPolicy.getFailure_exception().equals(FinalResult.FINAL_FAILURE_EXCEPTION.toString())) {
 552             if (callback != null) {
 553                 callback.onError("Policy failure exception is neither another policy nor FINAL_FAILURE_EXCEPTION");
 554             }
 555             isOk = false;
 556         }
 557         return isOk;
 558     }
 559
 560     private static boolean isFailureGuardPolicyResultOk(Policy operPolicy, ControlLoopCompilerCallback callback) {
 561         boolean isOk = true;
 562         if (FinalResult.toResult(operPolicy.getFailure_guard()) != null
 563                         && !operPolicy.getFailure_guard().equals(FinalResult.FINAL_FAILURE_GUARD.toString())) {
 564             if (callback != null) {
 565                 callback.onError("Policy failure guard is neither another policy nor FINAL_FAILURE_GUARD");
 566             }
 567             isOk = false;
 568         }
 569         return isOk;
 570     }
 571
 572     private static PolicyNodeWrapper findPolicyNode(Map<Policy, PolicyNodeWrapper> mapNodes, String id) {
 573         for (Entry<Policy, PolicyNodeWrapper> entry : mapNodes.entrySet()) {
 574             if (entry.getKey().getId().equals(id)) {
 575                 return entry.getValue();
 576             }
 577         }
 578         return null;
 579     }
 580
 581     @FunctionalInterface
 582     private interface NodeWrapper extends Serializable {
 583         public String   getId();
 584     }
 585
 586     private static class TriggerNodeWrapper implements NodeWrapper {
 587         private static final long serialVersionUID = -187644087811478349L;
 588         private String closedLoopControlName;
 589
 590         public TriggerNodeWrapper(String closedLoopControlName) {
 591             this.closedLoopControlName = closedLoopControlName;
 592         }
 593
 594         @Override
 595         public String toString() {
 596             return "TriggerNodeWrapper [closedLoopControlName=" + closedLoopControlName + "]";
 597         }
 598
 599         @Override
 600         public String getId() {
 601             return closedLoopControlName;
 602         }
 603
 604     }
 605
 606     private static class FinalResultNodeWrapper implements NodeWrapper {
 607         private static final long serialVersionUID = 8540008796302474613L;
 608         private FinalResult result;
 609
 610         public FinalResultNodeWrapper(FinalResult result) {
 611             this.result = result;
 612         }
 613
 614         @Override
 615         public String toString() {
 616             return "FinalResultNodeWrapper [result=" + result + "]";
 617         }
 618
 619         @Override
 620         public String getId() {
 621             return result.toString();
 622         }
 623     }
 624
 625     private static class PolicyNodeWrapper implements NodeWrapper {
 626         private static final long serialVersionUID = 8170162175653823082L;
 627         private transient Policy policy;
 628
 629         public PolicyNodeWrapper(Policy operPolicy) {
 630             this.policy = operPolicy;
 631         }
 632
 633         @Override
 634         public String toString() {
 635             return "PolicyNodeWrapper [policy=" + policy + "]";
 636         }
 637
 638         @Override
 639         public String getId() {
 640             return policy.getId();
 641         }
 642     }
 643
 644     @FunctionalInterface
 645     private interface EdgeWrapper extends Serializable {
 646         public String getId();
 647
 648     }
 649
 650     private static class TriggerEdgeWrapper implements EdgeWrapper {
 651         private static final long serialVersionUID = 2678151552623278863L;
 652         private String trigger;
 653
 654         public TriggerEdgeWrapper(String trigger) {
 655             this.trigger = trigger;
 656         }
 657
 658         @Override
 659         public String getId() {
 660             return trigger;
 661         }
 662
 663         @Override
 664         public String toString() {
 665             return "TriggerEdgeWrapper [trigger=" + trigger + "]";
 666         }
 667
 668     }
 669
 670     private static class PolicyResultEdgeWrapper implements EdgeWrapper {
 671         private static final long serialVersionUID = 6078569477021558310L;
 672         private PolicyResult policyResult;
 673
 674         public PolicyResultEdgeWrapper(PolicyResult policyResult) {
 675             super();
 676             this.policyResult = policyResult;
 677         }
 678
 679         @Override
 680         public String toString() {
 681             return "PolicyResultEdgeWrapper [policyResult=" + policyResult + "]";
 682         }
 683
 684         @Override
 685         public String getId() {
 686             return policyResult.toString();
 687         }
 688
 689
 690     }
 691
 692     private static class FinalResultEdgeWrapper implements EdgeWrapper {
 693         private static final long serialVersionUID = -1486381946896779840L;
 694         private FinalResult finalResult;
 695
 696         public FinalResultEdgeWrapper(FinalResult result) {
 697             this.finalResult = result;
 698         }
 699
 700         @Override
 701         public String toString() {
 702             return "FinalResultEdgeWrapper [finalResult=" + finalResult + "]";
 703         }
 704
 705         @Override
 706         public String getId() {
 707             return finalResult.toString();
 708         }
 709     }
 710
 711
 712     private static class LabeledEdge extends DefaultEdge {
 713         private static final long serialVersionUID = 579384429573385524L;
 714
 715         private NodeWrapper from;
 716         private NodeWrapper to;
 717         private EdgeWrapper edge;
 718
 719         public LabeledEdge(NodeWrapper from, NodeWrapper to, EdgeWrapper edge) {
 720             this.from = from;
 721             this.to = to;
 722             this.edge = edge;
 723         }
 724
 725         @SuppressWarnings("unused")
 726         public NodeWrapper from() {
 727             return from;
 728         }
 729
 730         @SuppressWarnings("unused")
 731         public NodeWrapper to() {
 732             return to;
 733         }
 734
 735         @SuppressWarnings("unused")
 736         public EdgeWrapper edge() {
 737             return edge;
 738         }
 739
 740         @Override
 741         public String toString() {
 742             return "LabeledEdge [from=" + from + ", to=" + to + ", edge=" + edge + "]";
 743         }
 744     }
 745
 746 }