diff options
Diffstat (limited to 'src/main/java')
3 files changed, 100 insertions, 26 deletions
diff --git a/src/main/java/org/onap/clamp/loop/components/external/ExternalComponent.java b/src/main/java/org/onap/clamp/loop/components/external/ExternalComponent.java index a8aae2038..2be707fe4 100644 --- a/src/main/java/org/onap/clamp/loop/components/external/ExternalComponent.java +++ b/src/main/java/org/onap/clamp/loop/components/external/ExternalComponent.java @@ -28,9 +28,7 @@ import com.google.gson.annotations.Expose; import org.apache.camel.Exchange; /** - * - * SHould be abstract but Gson can't instantiate it if it's an abstract - * + * Should be abstract but Gson can't instantiate it if it's an abstract. */ public class ExternalComponent { @Expose @@ -49,7 +47,7 @@ public class ExternalComponent { } public ExternalComponentState computeState(Exchange camelExchange) { - return new ExternalComponentState("INIT", "no desc"); + return new ExternalComponentState("INIT", "no desc", 0); } public ExternalComponent(ExternalComponentState initialState) { diff --git a/src/main/java/org/onap/clamp/loop/components/external/ExternalComponentState.java b/src/main/java/org/onap/clamp/loop/components/external/ExternalComponentState.java index 6a723c24e..a220ee1d4 100644 --- a/src/main/java/org/onap/clamp/loop/components/external/ExternalComponentState.java +++ b/src/main/java/org/onap/clamp/loop/components/external/ExternalComponentState.java @@ -29,18 +29,26 @@ import com.google.gson.annotations.Expose; * This is a transient state reflecting the deployment status of a component. It * can be Policy, DCAE, or whatever... This is object is generic. Clamp is now * stateless, so it triggers the different components at runtime, the status per - * component is stored here. + * component is stored here. The state level is used to re-compute the global + * state when multiple sub states are required for that computation (generally + * provided sequentially to the method computeState from the camel routes. * */ -public class ExternalComponentState { +public class ExternalComponentState implements Comparable<ExternalComponentState> { @Expose private String stateName; @Expose private String description; + private int stateLevel; - public ExternalComponentState(String stateName, String description) { + public ExternalComponentState(String stateName, String description, int level) { this.stateName = stateName; this.description = description; + this.stateLevel = level; + } + + public ExternalComponentState(String stateName, String description) { + this(stateName, description, 0); } public ExternalComponentState() { @@ -58,4 +66,50 @@ public class ExternalComponentState { public String toString() { return stateName; } + + public int getLevel() { + return stateLevel; + } + + public void setLevel(int priority) { + this.stateLevel = priority; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((stateName == null) ? 0 : stateName.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + ExternalComponentState other = (ExternalComponentState) obj; + if (stateName == null) { + if (other.stateName != null) + return false; + } else if (!stateName.equals(other.stateName)) + return false; + return true; + } + + /** + * This method compares this object by using the level of them. + * + * @param stateToCompare The state to compare to the current object + * @return If the one given in input has a higher level than the current object + * it returns -1, 1 otherwise and 0 if equals. + */ + @Override + public int compareTo(ExternalComponentState stateToCompare) { + return Integer.compare(this.getLevel(), stateToCompare.getLevel()); + } + } diff --git a/src/main/java/org/onap/clamp/loop/components/external/PolicyComponent.java b/src/main/java/org/onap/clamp/loop/components/external/PolicyComponent.java index acd6115fe..68d598b5f 100644 --- a/src/main/java/org/onap/clamp/loop/components/external/PolicyComponent.java +++ b/src/main/java/org/onap/clamp/loop/components/external/PolicyComponent.java @@ -44,17 +44,22 @@ public class PolicyComponent extends ExternalComponent { @Transient private static final EELFLogger logger = EELFManager.getInstance().getLogger(PolicyComponent.class); + public static final ExternalComponentState IN_ERROR = new ExternalComponentState("IN_ERROR", + "There was an error during the sending to policy, the policy engine may be corrupted or inconsistent", 100); public static final ExternalComponentState NOT_SENT = new ExternalComponentState("NOT_SENT", - "The policies defined have NOT yet been created on the policy engine"); + "The policies defined have NOT yet been created on the policy engine", 90); public static final ExternalComponentState SENT = new ExternalComponentState("SENT", - "The policies defined have been created but NOT deployed on the policy engine"); + "The policies defined have been created but NOT deployed on the policy engine", 50); public static final ExternalComponentState SENT_AND_DEPLOYED = new ExternalComponentState("SENT_AND_DEPLOYED", - "The policies defined have been created and deployed on the policy engine"); - public static final ExternalComponentState IN_ERROR = new ExternalComponentState("IN_ERROR", - "There was an error during the sending to policy, the policy engine may be corrupted or inconsistent"); + "The policies defined have been created and deployed on the policy engine", 10); public PolicyComponent() { - super(NOT_SENT); + /* + * We assume it's good by default as we will receive the state for each policy + * on by one, each time we increase the level we can't decrease it anymore. + * That's why it starts with the lowest one SENT_AND_DEPLOYED. + */ + super(SENT_AND_DEPLOYED); } @Override @@ -103,21 +108,38 @@ public class PolicyComponent extends ExternalComponent { return policyNamesList; } + private static ExternalComponentState findNewState(boolean found, boolean deployed) { + + ExternalComponentState newState = NOT_SENT; + if (found && deployed) { + newState = SENT_AND_DEPLOYED; + } else if (found) { + newState = SENT; + } else if (deployed) { + newState = IN_ERROR; + } + return newState; + } + + private static ExternalComponentState mergeStates(ExternalComponentState oldState, + ExternalComponentState newState) { + return (oldState.compareTo(newState) < 0) ? newState : oldState; + } + + /** + * This is a method that expect the results of the queries getPolicy and + * getPolicyDeployed for a unique policy (op,guard, config, etc ...). It + * re-computes the global policy state for each policy results given. Therefore + * this method is called multiple times from the camel route and must be reset + * for a new global policy state retrieval. The state to compute the global + * policy state is stored in this class. + * + */ @Override public ExternalComponentState computeState(Exchange camelExchange) { - boolean oneNotFound = (boolean) camelExchange.getIn().getExchange().getProperty("atLeastOnePolicyNotFound"); - boolean oneNotDeployed = (boolean) camelExchange.getIn().getExchange() - .getProperty("atLeastOnePolicyNotDeployed"); - - if (oneNotFound && oneNotDeployed) { - this.setState(NOT_SENT); - } else if (!oneNotFound && oneNotDeployed) { - this.setState(SENT); - } else if (!oneNotFound && !oneNotDeployed) { - this.setState(SENT_AND_DEPLOYED); - } else { - this.setState(IN_ERROR); - } + this.setState(mergeStates(this.getState(), + findNewState((boolean) camelExchange.getIn().getExchange().getProperty("policyFound"), + (boolean) camelExchange.getIn().getExchange().getProperty("policyDeployed")))); return this.getState(); } } |