Sonar cleanup and remove duplicate code
[policy/engine.git] / ONAP-XACML / src / main / java / org / onap / policy / xacml / std / pap / StdPDPGroup.java
1 /*-
2  * ============LICENSE_START=======================================================
3  * ONAP-XACML
4  * ================================================================================
5  * Copyright (C) 2017-2019 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.xacml.std.pap;
22
23 import com.att.research.xacml.api.pap.PAPException;
24 import com.att.research.xacml.api.pap.PDP;
25 import com.att.research.xacml.api.pap.PDPGroupStatus;
26 import com.att.research.xacml.api.pap.PDPGroupStatus.Status;
27 import com.att.research.xacml.api.pap.PDPPIPConfig;
28 import com.att.research.xacml.api.pap.PDPPolicy;
29 import com.att.research.xacml.util.XACMLProperties;
30 import com.fasterxml.jackson.annotation.JsonIgnore;
31 import com.google.common.base.Joiner;
32 import com.google.common.base.Splitter;
33 import com.google.common.io.ByteStreams;
34
35 import java.io.FileInputStream;
36 import java.io.IOException;
37 import java.io.InputStream;
38 import java.io.OutputStream;
39 import java.io.Serializable;
40 import java.nio.file.Files;
41 import java.nio.file.Path;
42 import java.nio.file.Paths;
43 import java.util.ArrayList;
44 import java.util.Collections;
45 import java.util.Enumeration;
46 import java.util.HashSet;
47 import java.util.List;
48 import java.util.Properties;
49 import java.util.Set;
50 import java.util.TreeSet;
51 import lombok.EqualsAndHashCode;
52 import lombok.ToString;
53 import org.apache.commons.logging.Log;
54 import org.apache.commons.logging.LogFactory;
55 import org.onap.policy.common.logging.eelf.MessageCodes;
56 import org.onap.policy.common.logging.eelf.PolicyLogger;
57 import org.onap.policy.xacml.api.XACMLErrorConstants;
58 import org.onap.policy.xacml.api.pap.OnapPDP;
59 import org.onap.policy.xacml.api.pap.OnapPDPGroup;
60 import org.onap.policy.xacml.std.pap.StdPDPItemSetChangeNotifier.StdItemSetChangeListener;
61
62 @EqualsAndHashCode(callSuper = false)
63 @ToString
64 public class StdPDPGroup extends StdPDPItemSetChangeNotifier
65         implements OnapPDPGroup, StdItemSetChangeListener, Comparable<Object>, Serializable {
66
67     private static final long serialVersionUID = 1L;
68     private static final String MSG_GROUPNOTEXIST = "Group directory does NOT exist";
69     private static final String MSG_LOADFAILURE = "Failed to load group policy properties file: ";
70     private static final String STR_APPEND_NAME = ".name";
71     private static final String STR_APPEND_DESCRIPTION = ".description";
72     private static final String STR_APPEND_PDPS = ".pdps";
73     private static final String STR_CLASS = "StdPDPGroup";
74     private static final String PROPS_POLICY = "xacml.policy.properties";
75     private static final String PROPS_PIP = "xacml.pip.properties";
76
77     private static Log logger = LogFactory.getLog(StdPDPGroup.class);
78
79     private String id;
80
81     private boolean isDefault = false;
82
83     private String name;
84
85     private String description;
86
87     private transient StdPDPGroupStatus status = new StdPDPGroupStatus(Status.UNKNOWN);
88
89     private transient Set<OnapPDP> pdps = new HashSet<>();
90
91     private transient Set<PDPPolicy> policies = new HashSet<>();
92
93     private transient Set<PDPPolicy> selectedPolicies = new HashSet<>();
94
95     private transient Set<PDPPIPConfig> pipConfigs = new HashSet<>();
96
97     private String operation;
98
99     @JsonIgnore
100     private transient Path directory;
101
102     @JsonIgnore
103     private Integer jmxport;
104
105     public StdPDPGroup() {
106         //
107         // Methods needed for JSON deserialization
108         //
109     }
110
111     /**
112      * StdPDPGroup constructor.
113      *
114      * @param group OnapPDPGroup
115      */
116     public StdPDPGroup(OnapPDPGroup group) {
117         this.id = group.getId();
118         this.name = group.getName();
119         this.description = group.getDescription();
120         this.isDefault = group.isDefaultGroup();
121         this.pdps = group.getOnapPdps();
122         this.policies = group.getPolicies();
123         this.pipConfigs = group.getPipConfigs();
124     }
125
126     public StdPDPGroup(String id, Path directory) {
127         this.id = id;
128         this.directory = directory;
129     }
130
131     public StdPDPGroup(String id, boolean isDefault, Path directory) {
132         this(id, directory);
133         this.isDefault = isDefault;
134     }
135
136     /**
137      * StdPDPGroup.
138      *
139      * @param id String
140      * @param isDefault boolean
141      * @param name String
142      * @param description String
143      * @param directory Path
144      */
145     public StdPDPGroup(String id, boolean isDefault, String name, String description, Path directory) {
146         this(id, isDefault, directory);
147         this.name = name;
148         // force all policies to have a name
149         if (name == null) {
150             this.name = id;
151         }
152         this.description = description;
153     }
154
155     public StdPDPGroup(String id, String name, String description, Path directory) {
156         this(id, false, name, description, directory);
157         this.resetStatus();
158     }
159
160     /**
161      * StdPDPGroup.
162      *
163      * @param id String
164      * @param isDefault boolean
165      * @param properties Properties
166      * @param directory Path
167      * @throws PAPException PAPException
168      */
169     public StdPDPGroup(String id, boolean isDefault, Properties properties, Path directory) throws PAPException {
170         this(id, isDefault, directory);
171         this.initialize(properties, directory);
172         this.resetStatus();
173     }
174
175     private void initialize(Properties properties, Path directory) throws PAPException {
176         if (this.id == null || this.id.length() == 0) {
177             logger.warn("Cannot initialize with a null or zero length id");
178             return;
179         }
180         //
181         // Pull the group's properties
182         //
183         for (Object key : properties.keySet()) {
184             if (key.toString().startsWith(this.id + ".")) {
185                 if (key.toString().endsWith(STR_APPEND_NAME)) {
186                     this.name = properties.getProperty(key.toString());
187                 } else if (key.toString().endsWith(STR_APPEND_DESCRIPTION)) {
188                     this.description = properties.getProperty(key.toString());
189                 } else if (key.toString().endsWith(STR_APPEND_PDPS)) {
190                     String pdpList = properties.getProperty(key.toString());
191                     if (pdpList != null && pdpList.length() > 0) {
192                         for (String pdpId : Splitter.on(',').omitEmptyStrings().trimResults().split(pdpList)) {
193                             StdPDP pdp = new StdPDP(pdpId, properties);
194                             pdp.addItemSetChangeListener(this);
195                             this.pdps.add(pdp);
196                         }
197                     }
198                 }
199             }
200             // force all policies to have a name
201             if (this.name == null) {
202                 this.name = this.id;
203             }
204         }
205         //
206         // Validate our directory
207         //
208         if (! directory.toFile().exists()) {
209             logger.warn("Group directory does NOT exist: " + directory.toString());
210             try {
211                 Files.createDirectory(directory);
212                 this.status.addLoadWarning(MSG_GROUPNOTEXIST);
213             } catch (IOException e) {
214                 PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, MSG_GROUPNOTEXIST);
215                 this.status.addLoadError(MSG_GROUPNOTEXIST);
216                 this.status.setStatus(PDPGroupStatus.Status.LOAD_ERRORS);
217             }
218         }
219         //
220         // Parse policies
221         //
222         this.loadPolicies(Paths.get(directory.toString(), PROPS_POLICY));
223         //
224         // Parse pip config
225         //
226         this.loadPIPConfig(Paths.get(directory.toString(), PROPS_PIP));
227     }
228
229     /**
230      * loadPolicies.
231      *
232      * @param file Path
233      * @throws PAPException PAPException
234      */
235     public void loadPolicies(Path file) throws PAPException {
236         //
237         // Read the Groups Policies
238         //
239         Properties policyProperties = new Properties();
240         if (!file.toFile().exists()) {
241             // need to create the properties file with default values
242             policyProperties.setProperty(XACMLProperties.PROP_ROOTPOLICIES, "");
243             policyProperties.setProperty(XACMLProperties.PROP_REFERENCEDPOLICIES, "");
244             // save properties to file
245             try (OutputStream os = Files.newOutputStream(file)) {
246                 policyProperties.store(os, "");
247             } catch (Exception e) {
248                 throw new PAPException("Failed to create new default policy properties file '" + file + "'", e);
249             }
250         } else {
251             // load previously existing file
252             try {
253                 //
254                 // Load the properties
255                 //
256                 try (InputStream is = Files.newInputStream(file)) {
257                     policyProperties.load(is);
258                 }
259                 //
260                 // Parse the policies
261                 //
262                 this.readPolicyProperties(directory, policyProperties);
263             } catch (IOException e) {
264                 logger.warn(MSG_LOADFAILURE + file, e);
265                 this.status.addLoadError("Not policy properties defined");
266                 this.status.setStatus(Status.LOAD_ERRORS);
267                 throw new PAPException(MSG_LOADFAILURE + file);
268             }
269         }
270     }
271
272     /**
273      * loadPIPConfig.
274      *
275      * @param file Path
276      * @throws PAPException PAPException
277      */
278     public void loadPIPConfig(Path file) throws PAPException {
279         //
280         // Read the Groups' PIP configuration
281         //
282         Properties pipProperties = new Properties();
283         if (!file.toFile().exists()) {
284             // need to create the properties file with no values
285             pipProperties = setPipProperties(pipProperties);
286             // save properties to file
287             try {
288                 try (OutputStream os = Files.newOutputStream(file)) {
289                     pipProperties.store(os, "");
290                 }
291             } catch (Exception e) {
292                 throw new PAPException("Failed to create new default pip properties file '" + file + "'", e);
293             }
294             // Even if we create a new pip file, we still need to parse and load the properties
295             try {
296                 this.readPipProperties(pipProperties);
297             } catch (Exception e) {
298                 throw new PAPException("Failed to load the new pip properties file", e);
299             }
300         } else {
301             try {
302                 //
303                 // Load the properties
304                 //
305                 try (InputStream is = Files.newInputStream(file)) {
306                     pipProperties.load(is);
307                 }
308                 // For all old PIP config's modify to the new PIP Configuration.
309                 // If PIP is empty add the new values and save it.
310                 if ("".equals(pipProperties.get(XACMLProperties.PROP_PIP_ENGINES).toString().trim())) {
311                     pipProperties = setPipProperties(pipProperties);
312                     try (OutputStream os = Files.newOutputStream(file)) {
313                         pipProperties.store(os, "");
314                     }
315                 }
316                 //
317                 // Parse the pips
318                 //
319                 this.readPipProperties(pipProperties);
320             } catch (IOException e) {
321                 logger.warn("Failed to open group PIP Config properties file: " + file, e);
322                 this.status.addLoadError("Not PIP config properties defined");
323                 this.status.setStatus(Status.LOAD_ERRORS);
324                 throw new PAPException(MSG_LOADFAILURE + file);
325
326             }
327         }
328     }
329
330     /**
331      * resetStatus.
332      */
333     public void resetStatus() {
334         //
335         // Reset our status object
336         //
337         this.status.reset();
338         //
339         // Determine our status
340         //
341         for (PDP pdp : this.pdps) {
342             switch (pdp.getStatus().getStatus()) {
343                 case OUT_OF_SYNCH:
344                     this.status.addOutOfSynchPDP(pdp);
345                     break;
346                 case LAST_UPDATE_FAILED:
347                     this.status.addLastUpdateFailedPDP(pdp);
348                     break;
349                 case LOAD_ERRORS:
350                     this.status.addFailedPDP(pdp);
351                     break;
352                 case UPDATING_CONFIGURATION:
353                     this.status.addUpdatingPDP(pdp);
354                     break;
355                 case UP_TO_DATE:
356                     this.status.addInSynchPDP(pdp);
357                     break;
358                 case UNKNOWN:
359                 case CANNOT_CONNECT:
360                 case NO_SUCH_HOST:
361                 default:
362                     this.status.addUnknownPDP(pdp);
363                     break;
364             }
365         }
366
367         // priority is worst-cast to best case
368         if (!this.status.getUnknownPDPs().isEmpty()) {
369             this.status.setStatus(Status.UNKNOWN);
370         } else if (!this.status.getFailedPDPs().isEmpty() || !this.status.getLastUpdateFailedPDPs().isEmpty()) {
371             this.status.setStatus(Status.LOAD_ERRORS);
372         } else if (!this.status.getOutOfSynchPDPs().isEmpty()) {
373             this.status.setStatus(Status.OUT_OF_SYNCH);
374         } else if (!this.status.getUpdatingPDPs().isEmpty()) {
375             this.status.setStatus(Status.UPDATING_CONFIGURATION);
376         } else {
377             this.status.setStatus(Status.OK);
378         }
379     }
380
381     @Override
382     public String getId() {
383         return this.id;
384     }
385
386     public void setId(String id) {
387         this.id = id;
388     }
389
390     @Override
391     public boolean isDefaultGroup() {
392         return this.isDefault;
393     }
394
395     /**
396      * setDefaultGroup.
397      *
398      * @param isDefault boolean
399      */
400     public void setDefaultGroup(boolean isDefault) {
401         this.isDefault = isDefault;
402         //
403         // Cannot fire this because 2 operations have
404         // to occur: 1) old default=false (don't want to fire) and
405         // then 2) new default=true (yes fire - but we'll have to do that
406         // elsewhere.
407     }
408
409     @Override
410     public String getName() {
411         return name;
412     }
413
414     @Override
415     public void setName(String groupName) {
416         this.name = groupName;
417         this.firePDPGroupChanged(this);
418     }
419
420     @Override
421     public String getDescription() {
422         return this.description;
423     }
424
425     @Override
426     public void setDescription(String groupDescription) {
427         this.description = groupDescription;
428         this.firePDPGroupChanged(this);
429     }
430
431     public Path getDirectory() {
432         return this.directory;
433     }
434
435     public void setDirectory(Path groupDirectory) {
436         this.directory = groupDirectory;
437         // this is used only for transmission on the RESTful interface, so no need to fire group changed?
438     }
439
440     @Override
441     public PDPGroupStatus getStatus() {
442         return this.status;
443     }
444
445     @Override
446     public Set<PDPPolicy> getSelectedPolicies() {
447         return this.selectedPolicies;
448     }
449
450     @Override
451     public String getOperation() {
452         return this.operation;
453     }
454
455     @Override
456     public Set<PDP> getPdps() {
457         return Collections.unmodifiableSet(pdps);
458     }
459
460     public void setOnapPdps(Set<OnapPDP> pdps) {
461         this.pdps = pdps;
462     }
463
464     @Override
465     public Set<OnapPDP> getOnapPdps() {
466         return Collections.unmodifiableSet(pdps);
467     }
468
469     public boolean addPDP(OnapPDP pdp) {
470         return this.pdps.add(pdp);
471     }
472
473     public boolean removePDP(PDP pdp) {
474         return this.pdps.remove(pdp);
475     }
476
477     @Override
478     public Set<PDPPolicy> getPolicies() {
479         return Collections.unmodifiableSet(this.policies);
480     }
481
482     @Override
483     public PDPPolicy getPolicy(String id) {
484         for (PDPPolicy policy : this.policies) {
485             if (policy.getId().equals(id)) {
486                 return policy;
487             }
488         }
489         return null;
490     }
491
492     @Override
493     public Properties getPolicyProperties() {
494         Properties properties = new Properties() {
495             private static final long serialVersionUID = 1L;
496
497             // For Debugging it is helpful for the file to be in a sorted order,
498             // any by returning the keys in the natural Alpha order for strings we get close enough.
499             // TreeSet is sorted, and this just overrides the normal Properties method to get the keys.
500             @Override
501             public synchronized Enumeration<Object> keys() {
502                 return Collections.enumeration(new TreeSet<Object>(super.keySet()));
503             }
504         };
505         List<String> roots = new ArrayList<>();
506         List<String> refs = new ArrayList<>();
507
508         for (PDPPolicy policy : this.policies) {
509             // for all policies need to tell PDP the "name", which is the base name for the file id
510             if (policy.getName() != null) {
511                 properties.setProperty(policy.getId() + STR_APPEND_NAME, policy.getName());
512             }
513             // put the policy on the correct list
514             if (policy.isRoot()) {
515                 roots.add(policy.getId());
516             } else {
517                 refs.add(policy.getId());
518             }
519         }
520
521         properties.setProperty(XACMLProperties.PROP_ROOTPOLICIES, Joiner.on(',').join(roots));
522         properties.setProperty(XACMLProperties.PROP_REFERENCEDPOLICIES, Joiner.on(',').join(refs));
523
524         return properties;
525     }
526
527     /**
528      * publishPolicy.
529      *
530      * @param id String
531      * @param name String
532      * @param isRoot boolean
533      * @param policy InputStream
534      * @return PDPPolicy
535      * @throws PAPException PAPException
536      */
537     public PDPPolicy publishPolicy(String id, String name, boolean isRoot, InputStream policy) throws PAPException {
538         //
539         // Does it exist already?
540         //
541         if (this.getPolicy(id) != null) {
542             throw new PAPException("Policy with id " + id + " already exists - unpublish it first.");
543         }
544         Path tempFile = null;
545         try {
546             //
547             // Copy the policy over
548             //
549             tempFile = Files.createFile(Paths.get(this.directory.toAbsolutePath().toString(), id));
550             long num;
551             try (OutputStream os = Files.newOutputStream(tempFile)) {
552                 num = ByteStreams.copy(policy, os);
553             }
554             logger.info("Copied " + num + " bytes for policy " + name);
555
556             StdPDPPolicy tempRootPolicy = new StdPDPPolicy(id, isRoot, name, tempFile.toUri());
557             if (!tempRootPolicy.isValid()) {
558                 try {
559                     Files.delete(tempFile);
560                 } catch (Exception ee) {
561                     PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, ee, STR_CLASS,
562                             "Policy was invalid, could NOT delete it.");
563                 }
564                 throw new PAPException("Policy is invalid");
565             }
566             //
567             // Add it in
568             //
569             this.policies.add(tempRootPolicy);
570             //
571             // We are changed
572             //
573             this.firePDPGroupChanged(this);
574             //
575             // Return our new object.
576             //
577             return tempRootPolicy;
578         } catch (IOException e) {
579             PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, STR_CLASS, "Failed to publishPolicy");
580         }
581         return null;
582     }
583
584     /**
585      * Copy one policy file into the Group's directory but do not change the configuration.
586      * This is one part of a multi-step process of publishing policies.
587      * There may be multiple changes in the group (adding multiple policies, deleting policies, changine
588      * root<->referenced)
589      * that must be done all at once, so we just copy the file in preparation for a later "update whole group"
590      * operation.
591      *
592      * @param id String
593      * @param policy InputStream
594      * @throws PAPException PAPException
595      */
596     public void copyPolicyToFile(String id, InputStream policy) throws PAPException {
597         copyPolicyToFile(id, this.name, policy);
598     }
599
600     /**
601      * Policy Engine API Copy one policy file into the Group's directory but do not change the configuration.
602      *
603      * @param id String
604      * @param fileName String
605      * @param policy InputStream
606      * @throws PAPException PAPException
607      */
608     public void copyPolicyToFile(String id, String fileName, InputStream policy) throws PAPException {
609         try {
610             //
611             // Copy the policy over
612             //
613             long num;
614             Path policyFilePath = Paths.get(this.directory.toAbsolutePath().toString(), id);
615
616             Path policyFile;
617             if (policyFilePath.toFile().exists()) {
618                 policyFile = policyFilePath;
619             } else {
620                 policyFile = Files.createFile(policyFilePath);
621             }
622
623             try (OutputStream os = Files.newOutputStream(policyFile)) {
624                 num = ByteStreams.copy(policy, os);
625             }
626
627             logger.info("Copied " + num + " bytes for policy " + fileName);
628             for (PDPPolicy p : policies) {
629                 if (p.getId().equals(id)) {
630                     // we just re-copied/refreshed/updated the policy file for a policy that already exists in this
631                     // group
632                     logger.info("Policy '" + id + "' already exists in group '" + getId() + "'");
633                     return;
634                 }
635             }
636
637             // policy is new to this group
638             StdPDPPolicy tempRootPolicy = new StdPDPPolicy(id, true, fileName, policyFile.toUri());
639             if (!tempRootPolicy.isValid()) {
640                 try {
641                     Files.delete(policyFile);
642                 } catch (Exception ee) {
643                     PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, ee, STR_CLASS,
644                             "Policy was invalid, could NOT delete it.");
645                 }
646                 throw new PAPException("Policy is invalid");
647             }
648             //
649             // Add it in
650             //
651             this.policies.add(tempRootPolicy);
652             //
653             // We are changed
654             //
655             this.firePDPGroupChanged(this);
656
657         } catch (IOException e) {
658             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Failed to copyPolicyToFile");
659             throw new PAPException("Failed to copy policy to file: " + e);
660         }
661     }
662
663     /**
664      * removePolicyFromGroup.
665      *
666      * @param policy PDPPolicy
667      * @return boolean
668      */
669     public boolean removePolicyFromGroup(PDPPolicy policy) {
670         PolicyLogger.info("policy: " + policy.getId());
671         PolicyLogger.info("Policy ID:" + policy.getPolicyId());
672         PolicyLogger.info("Policy Version: " + policy.getVersion());
673         PolicyLogger.info("StdPDPPolicy Class cast: " + this.getPolicy(policy.getId()).toString());
674         StdPDPPolicy currentPolicy = (StdPDPPolicy) this.getPolicy(policy.getId());
675         if (currentPolicy == null) {
676             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "Policy " + policy.getId() + " does not exist.");
677             return false;
678         }
679         try {
680             //
681             // Remove it from our list
682             //
683             this.policies.remove(currentPolicy);
684             //
685             // We are changed
686             //
687             this.firePDPGroupChanged(this);
688             return true;
689         } catch (Exception e) {
690             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Failed to delete policy");
691         }
692         return false;
693     }
694
695     /**
696      * removePolicy.
697      *
698      * @param policy PDPPolicy
699      * @return boolean
700      */
701     public boolean removePolicy(PDPPolicy policy) {
702         PDPPolicy currentPolicy = this.getPolicy(policy.getId());
703         if (currentPolicy == null) {
704             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "Policy " + policy.getId() + " does not exist.");
705             return false;
706         }
707         try {
708             //
709             // Delete it on disk
710             //
711             Files.delete(Paths.get(currentPolicy.getLocation()));
712             //
713             // Remove it from our list
714             //
715             this.policies.remove(currentPolicy);
716             //
717             // We are changed
718             //
719             this.firePDPGroupChanged(this);
720             return true;
721         } catch (Exception e) {
722             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Failed to delete policy " + policy);
723         }
724         return false;
725     }
726
727     @Override
728     public Set<PDPPIPConfig> getPipConfigs() {
729         return Collections.unmodifiableSet(this.pipConfigs);
730     }
731
732     @Override
733     public PDPPIPConfig getPipConfig(String id) {
734         for (PDPPIPConfig config : this.pipConfigs) {
735             if (config.getId().equals(id)) {
736                 return config;
737             }
738         }
739         return null;
740     }
741
742     public void setPipConfigs(Set<PDPPIPConfig> pipConfigs) {
743         this.pipConfigs = pipConfigs;
744         this.firePDPGroupChanged(this);
745     }
746
747     public void removeAllPIPConfigs() {
748         this.pipConfigs.clear();
749         this.firePDPGroupChanged(this);
750     }
751
752     @Override
753     public Properties getPipConfigProperties() {
754         Properties properties = new Properties();
755         List<String> configs = new ArrayList<>();
756
757         for (PDPPIPConfig config : this.pipConfigs) {
758             configs.add(config.getId());
759             properties.putAll(config.getConfiguration());
760         }
761
762         properties.setProperty(XACMLProperties.PROP_PIP_ENGINES, Joiner.on(',').join(configs));
763
764         return properties;
765     }
766
767     @Override
768     public void repair() {
769         //
770         // Reset the status object
771         //
772         this.status.reset();
773         //
774         // Validate our directory
775         //
776         boolean fire = false;
777         if (! directory.toFile().exists()) {
778             logger.warn("Group directory does NOT exist: " + directory.toString());
779             try {
780                 Files.createDirectory(directory);
781                 fire = true;
782                 this.status.addLoadWarning("Created missing group directory");
783             } catch (IOException e) {
784                 PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS,
785                         "Failed to create missing Group directory.");
786                 this.status.addLoadError("Failed to create missing Group directory.");
787                 this.status.setStatus(PDPGroupStatus.Status.LOAD_ERRORS);
788             }
789         }
790         //
791         // Validate our PIP config file
792         //
793         Path pipPropertiesFile = Paths.get(directory.toString(), PROPS_PIP);
794         if (! pipPropertiesFile.toFile().exists()) {
795             try {
796                 Files.createFile(pipPropertiesFile);
797                 fire = true;
798                 this.status.addLoadWarning("Created missing PIP properties file");
799             } catch (IOException e) {
800                 PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS,
801                         "Failed to create missing PIP properties file");
802                 this.status.addLoadError("Failed to create missing PIP properties file");
803                 this.status.setStatus(PDPGroupStatus.Status.LOAD_ERRORS);
804             }
805         }
806         //
807         // Valid our policy properties file
808         //
809         Path policyPropertiesFile = Paths.get(directory.toString(), PROPS_POLICY);
810         if (! policyPropertiesFile.toFile().exists()) {
811             try {
812                 Files.createFile(policyPropertiesFile);
813                 fire = true;
814                 this.status.addLoadWarning("Created missing Policy properties file");
815             } catch (IOException e) {
816                 PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS,
817                         "Failed to create missing Policy properties file");
818                 this.status.addLoadError("Failed to create missing Policy properties file");
819                 this.status.setStatus(PDPGroupStatus.Status.LOAD_ERRORS);
820             }
821         }
822         this.resetStatus();
823         if (fire) {
824             this.fireChanged();
825         }
826     }
827
828     private void readPolicyProperties(Path directory, Properties properties) {
829         //
830         // There are 2 property values that hold policies, root and referenced
831         //
832         String[] lists = new String[2];
833         lists[0] = properties.getProperty(XACMLProperties.PROP_ROOTPOLICIES);
834         lists[1] = properties.getProperty(XACMLProperties.PROP_REFERENCEDPOLICIES);
835         //
836         // Iterate each policy list
837         //
838         boolean isRoot = true;
839         for (String list : lists) {
840             //
841             // Was there actually a property?
842             //
843             if (list == null || list.length() == 0) {
844                 isRoot = false;
845                 continue;
846             }
847             //
848             // Parse it out
849             //
850             Iterable<String> policyList = Splitter.on(',').trimResults().omitEmptyStrings().split(list);
851             //
852             // Was there actually a list
853             //
854             if (policyList == null) {
855                 isRoot = false;
856                 continue;
857             }
858             for (String policyId : policyList) {
859                 //
860                 // Construct the policy filename
861                 //
862                 Path policyPath = Paths.get(directory.toString(), policyId);
863                 //
864                 // Create the Policy Object
865                 //
866                 StdPDPPolicy policy;
867                 try {
868                     policy = new StdPDPPolicy(id, isRoot, policyPath.toUri(), properties);
869                 } catch (IOException e) {
870                     PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS,
871                             "Failed to create policy object");
872                     policy = null;
873                 }
874                 //
875                 // Is it valid?
876                 //
877                 if (policy != null && policy.isValid()) {
878                     this.policies.add(policy);
879                     this.status.addLoadedPolicy(policy);
880                 } else {
881                     this.status.addFailedPolicy(policy);
882                     this.status.setStatus(Status.LOAD_ERRORS);
883                 }
884                 // force all policies to have a name
885                 if (policy != null && policy.getName() == null) {
886                     policy.setName(policy.getId());
887                 }
888             }
889             isRoot = false;
890         }
891     }
892
893     private void readPipProperties(Properties properties) {
894         String list = properties.getProperty(XACMLProperties.PROP_PIP_ENGINES);
895         if (list == null || list.length() == 0) {
896             return;
897         }
898         for (String pipId : list.split("[,]")) {
899             StdPDPPIPConfig config = new StdPDPPIPConfig(pipId, properties);
900             if (config.isConfigured()) {
901                 this.pipConfigs.add(config);
902                 this.status.addLoadedPipConfig(config);
903             } else {
904                 this.status.addFailedPipConfig(config);
905                 this.status.setStatus(Status.LOAD_ERRORS);
906             }
907         }
908     }
909
910     @Override
911     public void changed() {
912
913         // save the (changed) properties
914         try {
915             saveGroupConfiguration();
916         } catch (PAPException | IOException e) {
917             PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, STR_CLASS,
918                     "Unable to save group configuration change");
919             // don't notify other things of change if we cannot save it???
920             return;
921         }
922
923         this.firePDPGroupChanged(this);
924
925     }
926
927     @Override
928     public void groupChanged(OnapPDPGroup group) {
929         this.changed();
930     }
931
932     @Override
933     public void pdpChanged(OnapPDP pdp) {
934         //
935         // If one of the group's PDP's changed, then the group changed
936         //
937         this.changed();
938     }
939
940     public boolean isDefault() {
941         return isDefault;
942     }
943
944     public void setDefault(boolean isDefault) {
945         this.isDefault = isDefault;
946     }
947
948     public void setStatus(PDPGroupStatus status) {
949         this.status = new StdPDPGroupStatus(status);
950     }
951
952     public void setPolicies(Set<PDPPolicy> policies) {
953         this.policies = policies;
954     }
955
956     public void setSelectedPolicies(Set<PDPPolicy> selectedPolicies) {
957         this.selectedPolicies = selectedPolicies;
958     }
959
960     public void setOperation(String operation) {
961         this.operation = operation;
962     }
963
964     /**
965      * saveGroupConfiguration.
966      *
967      * @throws PAPException PAPException
968      * @throws IOException IOException
969      */
970     public void saveGroupConfiguration() throws PAPException, IOException {
971
972         // First save the Policy properties
973
974         // save the lists of policies
975         Properties policyProperties = this.getPolicyProperties();
976
977         // save info about each policy
978         for (PDPPolicy policy : this.policies) {
979             policyProperties.put(policy.getId() + STR_APPEND_NAME, policy.getName());
980         }
981
982         //
983         // Now we can save the file
984         //
985         Path file = Paths.get(this.directory.toString(), PROPS_POLICY);
986         try (OutputStream os = Files.newOutputStream(file)) {
987             policyProperties.store(os, "");
988         } catch (Exception e) {
989             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "STdPDPGroup", "Group Policies Config save failed");
990             throw new PAPException("Failed to save policy properties file '" + file + "'");
991         }
992
993         // Now save the PIP Config properties
994         Properties pipProperties = this.getPipConfigProperties();
995
996         //
997         // Now we can save the file
998         //
999         file = Paths.get(this.directory.toString(), PROPS_PIP);
1000         try (OutputStream os = Files.newOutputStream(file)) {
1001             pipProperties.store(os, "");
1002         } catch (Exception e) {
1003             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Group PIP Config save failed");
1004             throw new PAPException("Failed to save pip properties file '" + file + "'");
1005         }
1006     }
1007
1008     //
1009     // Comparable Interface
1010     //
1011     @Override
1012     public int compareTo(Object arg0) {
1013         if (arg0 == null) {
1014             return -1;
1015         }
1016         if (!(arg0 instanceof StdPDPGroup)) {
1017             return -1;
1018         }
1019         if (((StdPDPGroup) arg0).name == null) {
1020             return -1;
1021         }
1022         if (name == null) {
1023             return 1;
1024         }
1025
1026         return name.compareTo(((StdPDPGroup) arg0).name);
1027     }
1028
1029     // Adding Default PIP engine(s) while Loading initially. We don't want
1030     // Programmer intervention with the PIP engines.
1031     private Properties setPipProperties(Properties props) {
1032         props.setProperty("AAF.name", "AAFEngine");
1033         props.setProperty("AAF.description", "AAFEngine to communicate with AAF to take decisions");
1034         props.setProperty("AAF.classname", "org.onap.policy.xacml.std.pip.engines.aaf.AAFEngine");
1035         props.setProperty(XACMLProperties.PROP_PIP_ENGINES, "AAF");
1036         // read from PIP properties file.
1037         Path file = Paths.get(StdEngine.PIP_PROPERTY_FILE);
1038         if (file.toFile().exists()) {
1039             InputStream in;
1040             Properties prop = new Properties();
1041             try {
1042                 in = new FileInputStream(file.toFile());
1043                 prop.load(in);
1044             } catch (IOException e) {
1045                 PolicyLogger.error(
1046                         XACMLErrorConstants.ERROR_SYSTEM_ERROR + "can not load the pip properties from file" + e);
1047             }
1048             props = prop;
1049         }
1050         return props;
1051     }
1052
1053 }

© 2017 ONAP. Copyright © The Linux Foundation ®. All Rights Reserved.
The Linux Foundation has registered trademarks and uses trademarks.
For a list of trademarks of The Linux Foundation, please see our Trademark Usage page.
Linux is a registered trademark of Linus Torvalds.
Privacy Policy and Terms of Use