ONAP-XACML/src/main/java/org/onap/policy/xacml/std/pap/StdPDPGroupStatus.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-XACML
   4  * ================================================================================
   5  * Copyright (C) 2017 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 package org.onap.policy.xacml.std.pap;
  21
  22 import java.util.Collections;
  23 import java.util.HashSet;
  24 import java.util.Set;
  25
  26 import com.att.research.xacml.api.pap.PDP;
  27 import com.att.research.xacml.api.pap.PDPGroupStatus;
  28 import com.att.research.xacml.api.pap.PDPPIPConfig;
  29 import com.att.research.xacml.api.pap.PDPPolicy;
  30 import com.fasterxml.jackson.annotation.JsonIgnore;
  31
  32 public class StdPDPGroupStatus implements PDPGroupStatus {
  33
  34         private Status status = Status.UNKNOWN;
  35
  36         private Set<String>     loadErrors = new HashSet<>();
  37
  38         private Set<String> loadWarnings = new HashSet<>();
  39
  40         private Set<PDPPolicy> loadedPolicies = new HashSet<>();
  41
  42         private Set<PDPPolicy> failedPolicies = new HashSet<>();
  43
  44         private Set<PDPPIPConfig>       loadedPIPConfigs = new HashSet<>();
  45
  46         private Set<PDPPIPConfig>       failedPIPConfigs = new HashSet<>();
  47
  48         private Set<PDP>                        inSynchPDPs = new HashSet<>();
  49
  50         private Set<PDP>                        outOfSynchPDPs = new HashSet<>();
  51
  52         private Set<PDP>                        failedPDPs = new HashSet<>();
  53
  54         private Set<PDP>                        updatingPDPs = new HashSet<>();
  55
  56         private Set<PDP>                        lastUpdateFailedPDPs = new HashSet<>();
  57
  58         private Set<PDP>                        unknownPDPs = new HashSet<>();
  59
  60
  61         // Constructor needed for JSON deserialization
  62         public StdPDPGroupStatus() {
  63
  64         }
  65
  66         public StdPDPGroupStatus(Status status) {
  67                 this.status = status;
  68         }
  69
  70         public StdPDPGroupStatus(PDPGroupStatus stat) {
  71                 this.status = stat.getStatus();
  72                 this.failedPDPs.clear(); this.failedPDPs.addAll(stat.getFailedPDPs());
  73                 this.failedPIPConfigs.clear(); this.failedPIPConfigs.addAll(stat.getFailedPipConfigs());
  74                 this.failedPolicies.clear(); this.failedPolicies.addAll(stat.getFailedPolicies());
  75                 this.inSynchPDPs.clear(); this.inSynchPDPs.addAll(stat.getInSynchPDPs());
  76                 this.lastUpdateFailedPDPs.clear(); this.lastUpdateFailedPDPs.addAll(stat.getLastUpdateFailedPDPs());
  77                 this.loadedPIPConfigs.clear(); this.loadedPIPConfigs.addAll(stat.getLoadedPipConfigs());
  78                 this.loadedPolicies.clear(); this.loadedPolicies.addAll(stat.getLoadedPolicies());
  79                 this.loadErrors.clear(); this.loadErrors.addAll(stat.getLoadErrors());
  80                 this.loadWarnings.clear(); this.loadWarnings.addAll(stat.getLoadWarnings());
  81                 this.outOfSynchPDPs.clear(); this.outOfSynchPDPs.addAll(stat.getOutOfSynchPDPs());
  82                 this.unknownPDPs.clear(); this.unknownPDPs.addAll(stat.getUpdatingPDPs());
  83                 this.updatingPDPs.clear(); this.updatingPDPs.addAll(stat.getUpdatingPDPs());
  84         }
  85
  86         public Set<PDPPIPConfig> getLoadedPIPConfigs() {
  87                 return loadedPIPConfigs;
  88         }
  89         public void setLoadedPIPConfigs(Set<PDPPIPConfig> loadedPIPConfigs) {
  90                 this.loadedPIPConfigs = loadedPIPConfigs;
  91         }
  92         public Set<PDPPIPConfig> getFailedPIPConfigs() {
  93                 return failedPIPConfigs;
  94         }
  95         public void setFailedPIPConfigs(Set<PDPPIPConfig> failedPIPConfigs) {
  96                 this.failedPIPConfigs = failedPIPConfigs;
  97         }
  98         public Set<PDP> getUnknownPDPs() {
  99                 return unknownPDPs;
 100         }
 101         public void setUnknownPDPs(Set<PDP> unknownPDPs) {
 102                 this.unknownPDPs = unknownPDPs;
 103         }
 104         public void setLoadErrors(Set<String> loadErrors) {
 105                 this.loadErrors = loadErrors;
 106         }
 107         public void setLoadWarnings(Set<String> loadWarnings) {
 108                 this.loadWarnings = loadWarnings;
 109         }
 110         public void setLoadedPolicies(Set<PDPPolicy> loadedPolicies) {
 111                 this.loadedPolicies = loadedPolicies;
 112         }
 113         public void setFailedPolicies(Set<PDPPolicy> failedPolicies) {
 114                 this.failedPolicies = failedPolicies;
 115         }
 116         public void setInSynchPDPs(Set<PDP> inSynchPDPs) {
 117                 this.inSynchPDPs = inSynchPDPs;
 118         }
 119         public void setOutOfSynchPDPs(Set<PDP> outOfSynchPDPs) {
 120                 this.outOfSynchPDPs = outOfSynchPDPs;
 121         }
 122         public void setFailedPDPs(Set<PDP> failedPDPs) {
 123                 this.failedPDPs = failedPDPs;
 124         }
 125         public void setUpdatingPDPs(Set<PDP> updatingPDPs) {
 126                 this.updatingPDPs = updatingPDPs;
 127         }
 128         public void setLastUpdateFailedPDPs(Set<PDP> lastUpdateFailedPDPs) {
 129                 this.lastUpdateFailedPDPs = lastUpdateFailedPDPs;
 130         }
 131
 132
 133         @Override
 134         public Status getStatus() {
 135                 return status;
 136         }
 137
 138         public void setStatus(Status status) {
 139                 this.status = status;
 140         }
 141
 142         @Override
 143         public Set<String> getLoadErrors() {
 144                 return Collections.unmodifiableSet(this.loadErrors);
 145         }
 146
 147         public void addLoadError(String error) {
 148                 this.loadErrors.add(error);
 149         }
 150
 151         @Override
 152         public Set<String> getLoadWarnings() {
 153                 return Collections.unmodifiableSet(this.loadWarnings);
 154         }
 155
 156         public void addLoadWarning(String warning) {
 157                 this.loadWarnings.add(warning);
 158         }
 159
 160         @Override
 161         public Set<PDPPolicy> getLoadedPolicies() {
 162                 return Collections.unmodifiableSet(this.loadedPolicies);
 163         }
 164
 165         public void addLoadedPolicy(PDPPolicy policy) {
 166                 this.loadedPolicies.add(policy);
 167         }
 168
 169         @Override
 170         public Set<PDPPolicy> getFailedPolicies() {
 171                 return Collections.unmodifiableSet(this.failedPolicies);
 172         }
 173
 174         public void addFailedPolicy(PDPPolicy policy) {
 175                 this.failedPolicies.add(policy);
 176         }
 177
 178         @Override
 179         public boolean policiesOK() {
 180                 if (this.failedPolicies.size() > 0) {
 181                         return false;
 182                 }
 183                 return true;
 184         }
 185
 186         @Override
 187         public Set<PDPPIPConfig> getLoadedPipConfigs() {
 188                 return Collections.unmodifiableSet(this.loadedPIPConfigs);
 189         }
 190
 191         public void addLoadedPipConfig(PDPPIPConfig config) {
 192                 this.loadedPIPConfigs.add(config);
 193         }
 194
 195         @Override
 196         public Set<PDPPIPConfig> getFailedPipConfigs() {
 197                 return Collections.unmodifiableSet(this.failedPIPConfigs);
 198         }
 199
 200         public void addFailedPipConfig(PDPPIPConfig config) {
 201                 this.failedPIPConfigs.add(config);
 202         }
 203
 204         @Override
 205         public boolean pipConfigOK() {
 206                 if (this.failedPIPConfigs.size() > 0) {
 207                         return false;
 208                 }
 209                 return true;
 210         }
 211
 212         @Override
 213         public Set<PDP> getInSynchPDPs() {
 214                 return Collections.unmodifiableSet(this.inSynchPDPs);
 215         }
 216
 217         public void addInSynchPDP(PDP pdp) {
 218                 this.inSynchPDPs.add(pdp);
 219         }
 220
 221         @Override
 222         public Set<PDP> getOutOfSynchPDPs() {
 223                 return Collections.unmodifiableSet(this.outOfSynchPDPs);
 224         }
 225
 226         public void addOutOfSynchPDP(PDP pdp) {
 227                 this.outOfSynchPDPs.add(pdp);
 228         }
 229
 230         @Override
 231         public Set<PDP> getFailedPDPs() {
 232                 return Collections.unmodifiableSet(this.failedPDPs);
 233         }
 234
 235         public void addFailedPDP(PDP pdp) {
 236                 this.failedPDPs.add(pdp);
 237         }
 238
 239         @Override
 240         public Set<PDP> getUpdatingPDPs() {
 241                 return Collections.unmodifiableSet(this.updatingPDPs);
 242         }
 243
 244         public void addUpdatingPDP(PDP pdp) {
 245                 this.updatingPDPs.add(pdp);
 246         }
 247
 248         @Override
 249         public Set<PDP> getLastUpdateFailedPDPs() {
 250                 return Collections.unmodifiableSet(this.lastUpdateFailedPDPs);
 251         }
 252
 253         public void addLastUpdateFailedPDP(PDP pdp) {
 254                 this.lastUpdateFailedPDPs.add(pdp);
 255         }
 256
 257         @Override
 258         @JsonIgnore
 259         public Set<PDP> getUnknownStatusPDPs() {
 260                 return Collections.unmodifiableSet(this.unknownPDPs);
 261         }
 262
 263         public void addUnknownPDP(PDP pdp) {
 264                 this.unknownPDPs.add(pdp);
 265         }
 266
 267         @Override
 268         public boolean pdpsOK() {
 269                 if (this.outOfSynchPDPs.size() > 0) {
 270                         return false;
 271                 }
 272                 if (this.failedPDPs.size() > 0) {
 273                         return false;
 274                 }
 275                 if (this.lastUpdateFailedPDPs.size() > 0) {
 276                         return false;
 277                 }
 278                 if (this.unknownPDPs.size() > 0) {
 279                         return false;
 280                 }
 281                 return true;
 282         }
 283
 284         @Override
 285         @JsonIgnore
 286         public boolean isGroupOk() {
 287                 if (this.policiesOK() == false) {
 288                         return false;
 289                 }
 290                 if (this.pipConfigOK() == false) {
 291                         return false;
 292                 }
 293                 if (this.pdpsOK() == false) {
 294                         return false;
 295                 }
 296                 if (this.loadErrors.isEmpty() == false) {
 297                         return false;
 298                 }
 299                 return (this.status == Status.OK);
 300         }
 301
 302         public void reset() {
 303                 this.status = Status.OK;
 304
 305                 this.loadErrors.clear();
 306                 this.loadWarnings.clear();
 307                 this.loadedPolicies.clear();
 308                 this.failedPolicies.clear();
 309                 this.loadedPIPConfigs.clear();
 310                 this.failedPIPConfigs.clear();
 311                 this.inSynchPDPs.clear();
 312                 this.outOfSynchPDPs.clear();
 313                 this.failedPDPs.clear();
 314                 this.updatingPDPs.clear();
 315                 this.lastUpdateFailedPDPs.clear();
 316                 this.unknownPDPs.clear();
 317         }
 318
 319         @Override
 320         public int hashCode() {
 321                 final int prime = 31;
 322                 int result = 1;
 323                 result = prime * result
 324                                 + (failedPDPs.hashCode());
 325                 result = prime
 326                                 * result
 327                                 + (failedPIPConfigs.hashCode());
 328                 result = prime * result
 329                                 + (failedPolicies.hashCode());
 330                 result = prime * result
 331                                 + (inSynchPDPs.hashCode());
 332                 result = prime
 333                                 * result
 334                                 + (lastUpdateFailedPDPs.hashCode());
 335                 result = prime * result
 336                                 + (loadErrors.hashCode());
 337                 result = prime * result
 338                                 + (loadWarnings.hashCode());
 339                 result = prime
 340                                 * result
 341                                 + (loadedPIPConfigs.hashCode());
 342                 result = prime * result
 343                                 + (loadedPolicies.hashCode());
 344                 result = prime * result
 345                                 + (outOfSynchPDPs.hashCode());
 346                 result = prime * result + (status.hashCode());
 347                 result = prime * result
 348                                 + (unknownPDPs.hashCode());
 349                 result = prime * result
 350                                 + (updatingPDPs.hashCode());
 351                 return result;
 352         }
 353
 354         @Override
 355         public boolean equals(Object obj) {
 356                 if (this == obj)
 357                         return true;
 358                 if (obj == null)
 359                         return false;
 360                 if (getClass() != obj.getClass())
 361                         return false;
 362                 StdPDPGroupStatus other = (StdPDPGroupStatus) obj;
 363                 if (!failedPDPs.equals(other.failedPDPs))
 364                         return false;
 365                 if (!failedPIPConfigs.equals(other.failedPIPConfigs))
 366                         return false;
 367                 if (!failedPolicies.equals(other.failedPolicies))
 368                         return false;
 369                 if (!inSynchPDPs.equals(other.inSynchPDPs))
 370                         return false;
 371                 if (!lastUpdateFailedPDPs.equals(other.lastUpdateFailedPDPs))
 372                         return false;
 373                 if (!loadErrors.equals(other.loadErrors))
 374                         return false;
 375                 if (!loadWarnings.equals(other.loadWarnings))
 376                         return false;
 377                 if (!loadedPIPConfigs.equals(other.loadedPIPConfigs))
 378                         return false;
 379                 if (!loadedPolicies.equals(other.loadedPolicies))
 380                         return false;
 381                 if (!outOfSynchPDPs.equals(other.outOfSynchPDPs))
 382                         return false;
 383                 if (status != other.status)
 384                         return false;
 385                 if (!unknownPDPs.equals(other.unknownPDPs))
 386                         return false;
 387                 if (!updatingPDPs.equals(other.updatingPDPs))
 388                         return false;
 389                 return true;
 390         }
 391
 392         @Override
 393         public String toString() {
 394                 return "StdPDPGroupStatus [status=" + status + ", loadErrors="
 395                                 + loadErrors + ", loadWarnings=" + loadWarnings
 396                                 + ", loadedPolicies=" + loadedPolicies + ", failedPolicies="
 397                                 + failedPolicies + ", loadedPIPConfigs=" + loadedPIPConfigs
 398                                 + ", failedPIPConfigs=" + failedPIPConfigs + ", inSynchPDPs="
 399                                 + inSynchPDPs + ", outOfSynchPDPs=" + outOfSynchPDPs
 400                                 + ", failedPDPs=" + failedPDPs + ", updatingPDPs="
 401                                 + updatingPDPs + ", lastUpdateFailedPDPs="
 402                                 + lastUpdateFailedPDPs + ", unknownPDPs=" + unknownPDPs + "]";
 403         }
 404
 405 }